glClearColor () Fonksiyonu : Penceremizin arka planın rengini ayarlamamızı sağlar.^ tane parametre alır. “1.0,1.0,1.0,0.0″ parametresi bizim beyaz yapmamızı sağlıyor.Diğer renk tonajlarınıda yukarıdaki gibi oranları değiştirerek ayarlayabilirsiniz.

glutInitWindowSize(int x , int y) : Penceremizin boyutunu ayarlamamızı sağlar.İki parametre alır ilk parametre genişlik ikinci parametre ise yüksekliğini belirler.

glutInitWindowPosition(int x, int y): Penceremizin pozisyonunu belirlememize yarar.
glutInitWindowSize fonksiyonu gibi iki parametre alır ilk parametre sağa sola göre konumu ikinci parametre ise yukarı aşşağı konumudur.(0,0) sol alt köşedir.

Bu üç fonksiyonumuzun özeti olan kodumuzu inceleyelim;

Gördüğünüz üzere boyut istediğimiz gibi oldu.Ben ekran görüntüsü almak için pozisyonu değiştirdim ama istediğimiz pozisyonda çıktı penceremiz.

2 ve 3 Boyutlu Grafikler

Şekilde gördüğünüz gibi uzay üç boyutludur.Ancak bizim çizdiğimiz üçgen iki boyutlu olduğu için üçüncü kordinat numaraları 0.0 dır.Çünkü üçüncü boyut olan z ekseninde herhangi bir nokta çizmedik sadece x ve y eksenlerini kullandık.

Şekildeki üçgeni çizen programı yazalım ;

Kamera İle Görüntüleme

Fotoğrafların 2 boyutlu videolarında üç boyutlu olduğunu biliriz.Eğer animasyonlar yapmak istiyorsak üç boyutlu OpenGL projeleri yapmalıyız.Yanlız dikkat etmemiz gereken bir nokta var 3 boyutlu bir çizim yapacakken bir kamera kullanmalıyız kamera kullanırken şu üç adımı izlemeliyiz ;

Adım bir : İlk başta gluLookAt(); fonksiyonu ile kamera yönü ve konumu belirlenir.

Adım iki : Nasıl bir projeksiyon oluşturcağımızı  ilk başta belirlemeliyiz.İki tür projeksiyon çeşidimiz var ; Ortografik projeksiyon ve perspekti projeksion.Ortografik projeksiyon oluşturacağımız zaman glOrtho() fonksiyonunu kullanırız ancak perspektif projeksiyon kullancağımız zamanda gluPerspective() fonksiyonunu kullanırız.

Adım üç : Final adımımızda ise kameranın ekranımızda nasıl görüntüleneceğini ve bizim nasıl göreceğimizi ayarlarız.Bunun için glViewport()  fonksiyonu kullanılır.

Standart olarak OpenGl programlarımızda kameramız  dönüşüm matrixlerini kullanır.

OpenGL de modelview matrix,M; ve projeksiyon matrix,P olmak üzere iki tür matrix vardır.Yukarıda adımlardan bahsetmiştik.İşte ilk adımda modelview matrix ikinci adımda ise projeksiyon matrix kullanılır.Modelview matrix kamerayı kullanırken dünya kordinatlarını kullanır.

Kameraları hareketli bir biçimde kullandığımız için kordinatları değiştireceğimiz zaman bazı ayarlamalar yapmamız gerekecek.Bu sırada işte modelview ve projeksiyon matrixler arasında bazı değişimler meydana gelecek bu gibi durumlar için  bir formül geçerli ;

Çizime başlanan kordinat : c
modelview matrix : M
projeksiyon matrix : P
Yeni kordinat : c’

Formülümüz ise ;

Teknik ayrıntıları bilmeden yeni şeyleri yapamyacağımız için bu konu önemlidir dikaktli okuyup anlamadığınız yerleri internette araştırmanızı yada yorumla belirtmenizi öneririm.

glClear () Fonksiyonu : glClear sayesinde penceremizin içini temizleyebiliriz.Geçen uygulamamızda penceremizin içinnde değişik renkli bir yapı vardı ancak bu kod sayesinde temiz bir pencere elde edebiliriz.glClear bir çok parametre alabiliyor ancak bizim için şimdilik GL_COLOR_BUFFER_BIT parametresi yeterli.

glFlush() Fonksiyonu : glClear gibi pencerenin görünümünü değiştirecek olan fonksiyonların çalışmasını ekranın güncellenmesini sağlar.

Hemen ufak bir örnek yapalım;

glutKeyboardFunc () Fonksiyonu : Geçen dersimizde glutMainLoop () fonksiyonu klavye ve mouseden gelecek eventleri dinler gibi bir kelime söylemiştim işte glutKeyboardFunc bu cümlemi anlatmak için tam ideal bir fonksiyon.Bu fonksiyon sayesinde klavyeden girilecek olan tuşları dinleyebilecek girilen tuşa göre işlemler yapabileceğiz tek yapmamız gerek yukarıda fonksiyonunu oluşturmak ve programımızda çağırmak.

örneğimizi yapalım ;

Hangi tuşa basarsak o tuşu yazdı konsolumuz.Eğer esc tuşunada basarsak kendisini kapatacaktır.

Şimdi Linux makinamıza Open Gl kurulumunu anlatacağım.Bize lazım olan Mesa;

ftp://ftp.freedesktop.org/pub/mesa/ sitesinden sürüm nosu çift olanlardan bir tanesini indiriniz.Hem Mesalib hemde MesaDemos dosyalarını indiriniz

ardından kurulum için;
root olduktan sonra ;(root olmak için komut penceresinde su yazıp root şifrenizi girebilirsiniz.)

tabi bu işlemleri yapmadan önce o dizine gitmeyi unutmayın

# tar xzfv MesaLib.tar.gz
# tar xzfv MesaDemos.tar.gz
# cd Mesa-sürümno/
# ./configure
# make
# make install

mesaLib.tar.gz yerine indirdiğiniz dosyanın adını yazınız.Örneğin ; MesaDemos-7.5.2.tar.gz gibi.

Derleme İşlemi

Derlerken standratların dışında bazı bayrakları vermemiz gerekecek.Örneğin ilk.c adlı kodumuzu şöyle derliyebiliriz

gcc ilk.c -o ilk -lGL -lGLU -lglut

Bu bayraklar tabi kullandığınız headerlere göre değişecektir.Ama standart olarak bunu kullanacağız.

İlk Uygulama

Sonuç

Linuxda Görsel Programlamaya Giriş

C dili ile linux altında görsel programlama konularını inceleyeceğiz ben openGL kullanacağım ancak diğer platformlarıda size tanıtmak istiyorum;

GTK+

GTK+ Linux,BeOS ve Win32 sistemleri altında GPL olarak dağıtılabilen,programcıların serbest kullanımına sunulmuş bir kütüphanedir.
GTK+ linux altında çizim yapılabilen GIMP programının tasarım aşamasında kullanılan C kütüphanesidir.Yukarıdada bahsettiğimiz gibi bir çok sistemde kullanılabilmesi ona platform özgürlüğü getirir.

GTK+ kütüphanesi bileşen tabanlı bir yapıya sahiptir.Bu bizim ne işimize yarar dersenizde bu sayede GTK+ C dili ile yazılmış olmasına rağmen Ada95,C++,Objective C,Pascal,Perl,Phyton vs. gibi birçok programlama dilinide desteklemektedir.

GTK+ kurulumu için gerekli paketler gtk+.rpm ve gtk+-devel.rpm paketleridir.Piyasada şuanda bulunan bütün dağıtımlarda nerdeyse bu paketler bulunmaktadır.Olmayan dağıtımlarda ise şu kodlarla kurulabilir;

rpm -i gtk+.rpm
rpm -i gtk+-devel.rpm

Kütüphanenin resmi web sitesi : www.gtk.org

GNOME

Eğer ubuntu kullanıyorsanız şu an kullandığınız pencere sisteminin ismi gnomedir.Gnome bir linux arayüzüdür.Gnomede gtk+ gibi bir grafik kütüphanesidir.Gnome arayüzü işte bu gnome kütüphanesi kullanılarak oluşturulmuştur.

Türkiye Web Sitesi : http://www.gnome.org.tr

OpenGL

OpenGL (İngilizce: Open Graphics Library, Türkçe: Açık Grafik Kütüphanesi), gelişmiş donanım desteğini kullanarak hem iki hem de üç boyutlu grafikleri ekrana çizmek için kullanılan ücretsiz bir grafik uygulama geliştirme arabirimidir. Windows, Linux, MacOS ve Solaris gibi birçok işletim sisteminde yaygın olarak ve Playstation 3 başta olmak üzere bazı oyun konsollarınca desteklenir. Donanım tarafında ise SGI, ATI, Nvidia veya Intel  gibi büyük üreticiler her ekran kartında OpenGL desteği sunar.

1992 yılında ilk taslağı yaratılmış olan bu standart, günümüzde 4.0 sürümüne ulaşmıştır ve 250′nin üzerinde fonksiyona sahiptir. Çoklu platform desteği içeren uygulamalar ve özellikle de deneysel ve bilimsel araçlarda açık arayla önde ve standart olarak kullanılmakta olan platform OpenGL’dir.

Soket Programlama 2

Soket programlama 1 konusunun devamıdır.Kodlarımızı yazmaya başlayalım;

ilk başta bir port numaramızı belirtmeliyiz ;

#define PORT 3333

şimdi bir soket oluşturalım

int soketmaygun ;//Bildiğiniz gibi soketler bir tamsayıdır

soketmaygun = socket(AF_INET,SOCK_STREAM,0);//Soketimizi socket() fonksiyonu ile oluşturuyoruz
if (maygun < 0)//Eğeer bir değer atanmamışsa programımızı kapatıyoruz
{
printf(“Soket oluşurken bir hata oluştu “);
exit (1);
}
// Fonksiyonumuzdaki parametleri tanımıyoruz tanıştırayım sizi

İlk parametre protokol türünübelirler hazırda 5 protkol vardır

/*
AF_UNIX (UNIX internal protocols)
AF_INET (ARPA Internet protocols)
AF_ISO (ISO protocols)
AF_NS (Xerox Network Systems protocols)
AF_IMPLINK (IMP “host at IMP” link layer)
*/

http://www.google.com.tr/

Tabi bu kadar fonksiyon kullanıyoruz bunlar standart kütüphanelerde yok

<sys/types.h> ve <sys/socket.h> kütüphaneleri kullanacağız.

if(bind(soketmaygun,(struct sockaddr *)& my_addr,size of(struct sockaddr))== -1)
{
printf(“bind”);
exit(1);
}
//bind() fonksiyonu soketi, verilen socket ismi ile ilişkilendirip yerel adres atamasını yapar.

if (listen(soketmaygun, BACKLOG) == -1)
{
perror(“listen”);
exit(1);
}

/*listen() fonksiyonu ile oluşturduğumuz soketi dinlemeye geçeriz. Artık istemciden bağlantı olunca accept() fonksiyonunu çağıracağıznci parametre kaç tane bağlantıyı kuyrukta tutacağımızı belirler. Tamsayı bir değerdir.*/

Program gerekiği sunucunun çalıştığı bilgisayarın adresi veya sunucuya bağlanan istmcilerin adresleri gerekli olabilir. Bu durunda hazır olarak verilen sockaddr_in yapısı kullanılır.

#define PORT 2222

struct sockaddr_in server_addr; /* Server adres bilgisi */

server_addr.sin_family = AF_INET; /* Adres ailesi */
server_addr.sin_port = htons(PORT); /* PORT numarasi */
server_addr.sin_addr.s_addr = INADDR_ANY; /* IP numarasi */

//Bu kodlar kendi adres bilgilerimizi elde etmek içindir. Şu an yazdığımız programın sunucu olduğuna dikkat edin.

Şimdide sunucumuza bağlanan kişinin adresini tespit edelim ;

int accept(int s, struct sockaddr *addr, int *addrlen);

Bağlantının Kabul Edilmesi

//Bizim programla bağlantı kurulduğunda bağlantıyı kabul etmemiz için accept() fonksiyonunu çağırmamız gerekir.

int fd, client_size;

struct sockaddr_in client_addr; /* Client adres bilgisi */

client_size = sizeof(struct sockaddr_in);
fd = accept(soketmaygun, (struct sockaddr *)&client_addr, &client_size));
printf(“%s sunucumuza baglandi…\n”,inet_ntoa(client_addr.sin_addr));

/*accept()’ in ilk argumenti daha önce socket() ile oluşturduğumuz, bind() ile adresini atadığımız ve listen() ile dinlemeye geçtiğimiz soketin ismidir. İkinci parametre karşı tarafın adresinin atanacağı değişken, üçüncü parametre ise adres bilgisinin toplam uzunluğudur.*/

Veri Gönderme

Bir soketten istemciye veri göndermek için send() veya write() fonksiyonları kullanılır.Ben kodlarda send() i kullandım.

int send(int s, const void *msg, int len, unsigned int flags);

Kullanım şekli şöyledir ;
send(fd,mesaj,sizeof(mesaj), 0);

Tüm kodlar ise şöyle olacak ;

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>

#define PORT 3333 /* PORT numarasi */

main(int argc, char *argv[])
{
int ssoketmaygun, fd;
struct sockaddr_in server_addr, client_addr;
int client_size;
char mesaj[32];

printf(“%s %d portu uzerinde calismaya basladi…\n”,argv[0],PORT);

if ((soketmaygun = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
printf(“Error : socket”);
exit(1);
}

server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);
server_addr.sin_addr.s_addr = INADDR_ANY;

if (bind(soketmaygun, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
{
printf(“Error : bind”);
exit(1);
}

if (listen(soketmaygun, 1) == -1)
{
printf(“Error : listen”);
exit(1);
}

while(1)
{
client_size = sizeof(struct sockaddr_in);
if ((fd = accept(soketmaygun, (struct sockaddr *)&client_addr, &client_size)) == -1)
{
printf(“Error : accept”);
continue;
}

printf(“%s sunucumuza baglandi…\n”,inet_ntoa(client_addr.sin_addr));

strcpy(mesaj,”Sunucuma baglantiniz yapildi…\n”);

if (!fork())
{
if (send(fd,mesaj,sizeof(mesaj), 0) == -1) perror(“Error : send”);
close(fd);
exit(0);
}

close(fd);

while ( waitpid(-1,NULL,WNOHANG) > 0);
}
} //Derlendi sorunsuzca çalışıyor foruma eklerken bazı hatalr oluşabilir düzenleyiniz

Şimdiye kadar hep sunucumuzu tasarladık sırada istemci(client)i oluşturmada;

Fonksiyonlar tamamen farklı çünkü biri istemci biri sunucu

#define PORT 2222
// Portumuzu tanımlıyoruz

int main(int argc, char *argv[])
{
if (argc != 2) {
printf(“Kullanimi : %s hostname\n”,argv[0]);
exit(1);
}

//Sunucunun çalıştığı bilgisayar istemciye parametre olarak verilecek

struct hostent *h_name;

if(argc > 1)
{
h_name = gethostbyname(argv[1]);
}
else
{
printf(“Kullanimi: %s hostname\n”,argv[0]);
exit(1);
}

bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = *(u_long *) h_name->h_addr;
serv_addr.sin_port = htons(PORT);

printf(“Sunucu adresi: %s\n”,inet_ntoa(serv_addr.sin_addr));

//Parametre olarak alınan host ismini çözümlüyoruz. Adres yapısında olan server_addr değişkeninin PORT numarasını ve IP adresini atıyoruz.

struct hostent *h_name;

if(argc > 1)
{
h_name = gethostbyname(argv[1]);
}
else
{
printf(“Kullanimi: %s hostname\n”,argv[0]);
exit(1);
}

bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = *(u_long *) h_name->h_addr;
serv_addr.sin_port = htons(PORT);

printf(“Sunucu adresi: %s\n”,inet_ntoa(serv_addr.sin_addr));

//Artık hizmetkarımıza, yani sunucumuza bağlanıp selam verme vakti geldi.

if( (soketmaygun = socket(AF_INET, SOCK_STREAM, 0)) < 0) perror(“Hata: soket acilamadi!\n”);

if(connect(soketmaygun, (struct sockaddr *) &serv_addr, sizeof(serv_addr))< 0)
printf(“Hata: sunucuya baglanilamadi!\n”);

while(1)
{
printf(“\n==========================================\n”);
printf(“Mesajinizi girin veya \\”quit\\” yazarak cikin: “);
gets(buf);
printf(“\n”);

if(strcmp(buf,”quit”)==0) break;

if( (send(soketmaygun, buf, sizeof(buf), 0)) <= 0)
printf(“Client: Send error\n”);

strcpy(buf, “”);
if( (recv(sockfd, buf, sizeof(buf), 0)) <= 0)
printf(“Hata: paket alirken bir hata olustu!\n”);
if(buf[0] != 4)
{
printf(“Sunucu’dan gelen mesaj: %s”, buf);
}
else
{
break;
}
}
shutdown(sockfd, 2);
close(sockfd);

/*Aynen sunucu programda olduğu gibi soket açtık. Soket türümüz yine SOCK_STREAM. Sonra connect()fonksiyonunu kullanarak açtığımız soket üzerinden bir bağlantı yaptık. connect() fonksiyonu sys/types.h başlık dosyasında aşağıdaki gibi tanımlanmıştır:

int connect(int s, const void *addr, int addrlen);
lk parametre soket tanımlayıcısı, ikinci parametre bağlantı kurulacak sunucunun adres bilgilerini içeren server_addr yapısı, son parametre ise adres yapısının boyutudur.
*/

/* sunucumuzla aramızda stream bir soket bağlantısı kurmuş olduk. İstemci tarafında connect() yapıldığı zaman, sunucu tarafında accept() yapılır. Yani yapılan bağlantı kabul edilir. Daha önce yazdığımız sunucu programdaki accept() işlemi, telnet programının connect() isteğini karşılıyordu. Şimdi bizim istemimiz bu isteği gönderecek. Dikkat ederseniz ilkel bir telnet programı yazıyoruz.*/

Sunucuya Bilgi Gönderme

. Ekrandan bir mesaj alıp bunu send() fonksiyonu ile sunucuya gönderiyoruz. Bu fonksiyon, dosyalara yazmak için kullandığımız write() fonksiyonu gibidir. send() ile sokete veri gönderiyoruz. Soket sunucu ile bağlantılı olduğundan veri, sunucuya ulaşır. Sunucu ise her send() isteğine recv() ile karşılık verir. send() yada recv() işlemleri her iki tarafta da yapılabilir. Sunucudan gelen her send() isteğine karşı da istemci de bir recv() vardır. Örneğin ftp programında karşılık send() ve recv() işlemleri vardır. Siz önce istemci tarafından ’get dosya’ komutunu göndererek dosya isteğinizi belirtiyorsunuz. Sunucu bu komutu okuyup yorumluyor ve size dosyayı ftp protokolune uygun paketler halinde gönderiyor. Artık siz okumaya başlıyorsunuz. Paketleri alıp birleştirip yerel diske yazıyorsunuz. Bu aşamadan sonra istediğinizi yaptırabilirsiniz.

Socket(Soket) Programlama

C dili çok geniş bir uygulama alanına sahiptir.Networkta bu uygulamalar arasında önemli bir yer tutar.Bu makalemde de network işlemlerinin temel yapısı olan soket programlama konusu hakkında bilgiler vermeye çalışacağım.ilk başta networkun elemanlarını nelerden oluştuğunu nasıl çalıştığını incelemeye başlıyalım ;

İlk başta temel oluşumdan bahsedeyim.Bir client birde server vardır.client bir isteğini servere yollar serverde bu isteğe bir cevap verir.Arada bazı protokoller vardır.TCP/ıp gibi.Biz tarayıcımızı açıp www.xxx.com a bastığımızda direk olarak bu protokolü kabul etmiş olacağız.

Bu terimler kafanızı biraz karıştırmış olabilir tek tek terimlerin açıklamalarını yapalım ;

İstemci (Client) :Hizmet istiyen soket programlara denir.Sorguyu gönderende diyebiliriz.İstediğimiz zaman sunucuya bağlatır istediğimizi yaptırır ve kapatırız.

Sunucu (Server) :Hizmet vern soket programdır.Client(istemci)den gelen sorgulara yanıt verir.Client gibi istediğimiz zaman açıp kapatamayız.Çünkü istemcinin ne zaman sorgu göndereceği belli değildir. Linuxta bulunan bazı sunucular ;
in.telnetd,wu.ftpd,nfsd,httpd ….

Port : Bir bilgisayarda birden çok soket bulunabilir.Soketleri birbirinden ayırmak ve istemci-sunucu ikilisini buluşturabilmek için her soketin bir numarası vardır.Öğretmenin öğenciyle ilişki kurarken kullandığı okul numarası gibi.Örneğin ftp nin port numarası 21 dir.Linuxta 1-1024 arasındaki portlar standarttır ve sadece root olanlar kullanabilirler.Eğer normal kullanıcılar kullanmaya kalkarsalar yetkisizlik hatası üretir.

IP : Bilgisayarlar bir sunucu başka bir bilgisayar veya başka birşeyle iletişim kurarken Ip numarasını kullanarak haberleşir.TC no muza benzetebiliriz.Sınıf numarası ile karıştırmayalım aynı okulda olmayanların sınıf numaraları farklı olabilir ancak aynı tc ye sahip olamazlar.Port ile Ip kavramını karıştırmamak lazım.Bir istemci programı önce IP sını kullanarak sunucunun bulunduğu bilgisayara bağlanır sonra Port numarasını kullanarak hizmet istediği sunucu program ile temasa geçer.

Bu kavramlar soket programlama ve networkun temel konularıdır.
Aşşagıdaki resimde öğrendiklerimizi özetliyecektir

Soket Türleri
Bir çok soket türü bulunmaktadır ancak bizim ilgileneceğimiz iki üt soket türü vardır.”Stream Soketler” ve “Datagram Soketler”.Bunlar programlarda SOCK_STREAM ve SOCK_DGRAM isimleri ile kullanılırlar.

Stream soketlere bağlantı yönelimli (connection oriented) soketler,Datagram soketlere ise bağlantısız(connectionless) soketler denir.

İkisi arasındaki farklı güzel iki örnekle açıklayayım.Mail atmak ve online olarak konuşmak Mail attığınızda karşı tarafın müsait olmasına yada açık olmasına gerek yoktur.Yolarsınız istediği zaman bakar.Bu bağlantısız Datagram soketlere örnektir.Ancak online olarak her iki tarafında açık olması gereken görüşmeler içinde Stream soketlere örnek verebiliriz.Kullanılan tüm internet programları soket programlama mantığı ile yazılmıştır.Başka örnek olarakta ICQ ile IRC yi örnek verebiliriz.ICQ da mesajı yazıp gönderiyorruz.Tek taraflı bir bağlantı oluyor.Ancak IRC de ise sürekli olarak iki tarafta aktif rol alıyor.

Strea soketler TCP/IP protokolünün TCP özelliğini kullanırlar.Ancak Datagram soketler ie UDP protokolünü kullanırlar.

Bu iki soket ve protokoller araındaki farkları incelersek ;

- Stream soketler verileri sıralı gönderir, datagram soketleri sıralı göndermeyebilir.

- Stream soketler güvenlidir, Datagram soketler güvensizdir.Bunun sebebi TCP deki acknowledgement denetimidir.Yeni bir paket yollandığında karşı tarafa ulaşmadan hedefini bitirmiş olmaz karşı taraftan cevap gelene kadar yollamaya devam eder ancak UDP de böle bişe yoktur.

-Stream soketler, işlem bitene kadar kesintisiz bir bağlantı kurar. Datagram soketler ise bağlantı kurmaz. Sadece veri göndereceği zaman bağlantı kurar ve işi bitince bağlantıyı kapatır.

UDP ;

TCP ;

Bu kadar dezavantaja rağmen neden datagram soket ve UDP kullanılıyor diyorsanızda
el cevap
TCP de 6×32 kadar veri kullanılırken UDP 64 bit veri kullanır.UDDP yi kullanmanın kısaca en önemli nedeni az protokol yüküdür.Video paylaşımı gibi uygulamalarda TCP çok fazla veri tüketeceğinden baız hatalar oluşabilir kısaca veri tasarrufu yapmak için UDP kullanılır.O kadar güvensiz dedikte soket programlamada yazılımcı isterse UDP paketinide güvenli bir şekile dönüştürebilir.Bu konuyla alakalı son olarakta ’telnet’ programı Stream soket, ’tftp’ programı ise Datagram sokettir diyorum.

Break ve Continue Komutu

Konuları inceledim ve ufak gözden kaçan iki eksikliği gördüm.Eklemek istedim.İlk
başta Break komutundan başlayalım ;

break

Break komutunu normalde switch yapılarında görmüştük.Normal for,while,do while
döngülerinde kullanımı göstereceğim.Break’ın anlamı zaten durdurmak gibi birşeydir.
Bir şart sağlandığında döngünün sonlanmasını istediğimizde breakı kullanırız.

Mesala bir örnek kod üzerinde göstereyim ;

/*
0 ile 99 arasında tesadüfi sayılar üreten
bir programın, kaçıncı seferde 55 sayısını
bulacağını yazan program aşağıdadır.
*/
#include<stdio.h>
int main( void )
{
int i,rastgelesayi;
int deneme_sayisi = 0;
//while içinde 1 olduğundan sonsuza kadar döngü çalışır.
while( 1 )
{
//rastgele değişkenine, 0 ile 99 arasında
//her seferinde farklı bir sayı atanır.
rastgelesayi = rand() % 100;//bu komutu öncedende görmüştük 0-99 arası rastgle sayı üretecek
//Döngünün kaç defa çalıştığını deneme_sayisi
//değişkeniyle buluruz.
deneme_sayisi++;
//Eğer tesadufi sayı 55’e eşit olursa,
//döngü kırılıp, sonlandırılır.
if( tesadufi_sayi == 55) break;
}
printf(“Toplam deneme sayısı: %d\n”,deneme_sayisi);
return 0;
}

continue

Continue de devam etmek anlamındadır.Break döngüyü durdurur.Ancak continue sayesinde
döngü durmaz.O adım atlanarak devam edilir.Mesala 0-10 arasındaki çift sayıları
belirleyen bir kod yazalım ;

#include<stdio.h>
int main( void )
{
int i;
for( i = 0; i < 10; i++ ) {
//i değişkeninin 2’ye göre modu
//0 sonucunu veriyorsa, bu onun
//bir çift sayı olduğunu gösterir.
//! ifadesi sayesinde tersi olduğunda
//yani tek olması durumunda atlayacak
//Bu durumda ekrana yazdırılmaması
//için döngü bir sonraki adıma geçer.
if( !i%2 == 0 ) continue;
printf(“%2d\\n”,i);
}
return 0;
}

Gcc Derleyicisinde Başarım inceleme
Artık köşede kuytuda konular buldukça öğrendiklerimi aktarmaya çalışıyorum.Başarımızı incelemek için gcc derleyicisinde bir raporlama hizmeti vardır.gprof deniliyor bu araca.
-pg komutu ile bu istediğimizi yapabiliyoruz yanlız hem derleme hemde bağlanma aşamalrında -pg komutunu vermeliyiz.
ör :
gcc -pg program.c
gcc program.o -o program
bu komutlarla derlenip program çalıştırılır.gmon.out diye bir dosya oluşur biz programımız kullandıktan sonra.

gprof program gmon.out diyip raporumuzu inceleyebiliriz.Hangi fonksiyonların ne kadar kullanıldığı ne kadar zorladığını vs görebiliriz.

Dosya Yönetimi( I/O İŞLEMLERİ )

Dosya Açma ve Kapama

Bir dosyanın üzerinde işlem yapmak,yada görüntülemek için ilk başta o dosyayı açmak gerekir.İlk başta bir dosya göstergecisi(pointers) oluşturmak gerekir.Dosyayı açmak için fopen(),kapatmak için fclose() fonksiyonları kullanılır.Bu fonksiyonlar stdio.h kütüphanesinde tanımlandığından ek kütüphane eklememize gerek yoktur.
Genel olarak şematize edecek olursakta ;

FILE *dosyaismi;
yaz = fopen(const char dosya_adı,const char mod);
…..
dosya işlemleri
…..
fclose(dosya);

const char mod diye belirtilen dosyanın nasıl açılacağıdır.Benim bulabildiklerim şunlarİ

“r” :Salt okunur (read only). Dosyanın açılabilmesi için önceden oluştrulmuş olması gerekir. Bu modda açılmş olan bir dosyaya yazma yapılamaz.

“w” :Yalnızca yazma (write only). Dosya diskte kayıtlı olsun veya olamsın dosya yeniden oluşturulur. Bu modda açılmış olan bir dosyadan okuma yapılamaz.
“a” : Ekleme (append). Kayıtlı bir dosyanın sonuna veri eklemek için açılır. Bu modda açılmış olan bir dosyadan okuma yapılamaz.
“r+” :Okuma ve yazma. Bu modda açılmış olan bir dosyanın daha önce varolması gerekir.
“w+” :Okuma ve yazma. Bu modda açılmış olan bir dosya var olsun veya olmasın dosya yeniden oluşturulur.
“a+ ” : Okuma ve yazma. Kayıtlı bir dosyanın sonuna veri eklemek için açılır.

Ufak bir örnekle giriş yapalım istiyorsanız ;
Yanlız kodlarımızı yazarken şuna dikkat etmeliyiz,üzerinde çalışacağımız dosya ile ana programın aynı dizinde olması önemlidir.

#include<stdio.h>
#include<stdlib.h>
int main()
{
FILE *dg;//pointerimizi tanımladık
const int n = 5;
char ad[10];
int no,Not,i = 0;

dg = fopen(“ogrenci.txt”,”w”);//dosyamızı oluşturduk ve açtık
if (dg == NULL)//Pointer bellekte yer kaplayamazsa uyarı verecek bize
printf(“ogrenci.txt dosyası açılamadı. \n”),exit(1);

printf (“5 ogrenciye ait bilgileri girin : \n”);

while(i++<n)
{
printf(“%d. ogrencinin numarasi: “,i); scanf(“%d”,&no);
printf(“%d. ogrencinin adi     : “,i); scanf(“%s”,ad);
printf(“%d. ogrencinin notu    : “,i); scanf(“%d”,&Not);
printf(“\n”);

fprintf(dg,”%5d %10s %3d\\n”,no,ad,Not);
//fprintf fonksiyonumuzla istediğmiz veriyi yazdırttık
}
fclose(dg);//Ve en sonda kapattırdık.
printf(“Bilgiler kaydedildi \n”);

return 0 ;
/oluşturduğumuz dosyayı görüntülemek içinde terminale *$ edit ogrenci.txt komutunu verebiliriz*/

}

Aşşağıda dosya işlemlerinde kullanılan bazı fonksiyonlar var ;

fopen()      Dosya oluşturur, açar
fclose()      Dosyayı kapatır
putc()              Dosyaya bir karakter yazar
getc()              Dosyadan bir karakter okur
feof()              Dosya sonuna gelindiğini sorgular
fprintf()      Dosyaya formatlı veri yazar
fscanf()      Dosyadan formatlı veri okur
fputs()      Dosyaya katar yazar
fgets()      Dosyadan katar okur
fwrite()      Dosyaya dizi yazar
fread()      Dosyadan dizi okur

Dosyadan okuma,değiştirme türü işlemleri içeren ufak bir örnek daha yapalım;

/*
kelvin.sck dosyasındaki 100 tane kelvin sıcaklığını derece.sck dosyasına celciusa çevirip yolluyacaz
*/

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
/* dosya göstericileri */
FILE *oku, *yaz;

/* Dosya adları */
char *kaynak_dosya = “kelvin.sck”;
char *hedef_dosya = “derece.sck”;

float K,D;
int   i=0, n=100;

/* Dosylara erişim mümkün mü ? */
if( (oku=fopen(kaynak_dosya, “r”)) == NULL )
{
printf(“%s dosyası acilmadi.\n”, kaynak_dosya);
exit(1);
}
if( (yaz=fopen(hedef_dosya, “w”)) == NULL )
{
printf(“%s acilmadi.\n”, hedef_dosya);
exit(2);
}

for(i=0; i<n; i++)
{
fscanf(oku,”%f”,&K);        /* ’kelvin.sck’dan verileri oku     */
D = K – 273.0;               /* dönüşüm denklemi */
fprintf(yaz,”%8.2f\n”,D);    /* verileri ’derece.sck’ya yaz     */
}

/* Dosyaları kapat */
fclose(oku);
fclose(yaz);

printf(“%s > %s\n”, kaynak_dosya, hedef_dosya);
puts(“cevirme islemi tamamlandi.”);

return 0;
}

Kendi kendinize değişik örnekler yapabilirsiniz.

Standart Dosyalar
C Programlama Dili’nde bilgisayarın sahip olduğu ekran, klavye ve portlar birer dosya olarak tanımlanmıştır. Bu dosyalara standart dosyalar denir. Program çalışmaya başladığında beş adet standart dosya otomatik olarak açılır. C, stdio.h başlık dosyasında tanımlanan bütün bu standart dosyalara bazı isimler vermiştir.Aşşağıdaki lisede bunları görebilirsiniz.

stdout : Standart çıkış ortamı (ekran)
stderr : Standart hata çıkış ortamı (ekran)
stdin : Standart giriş ortamı (klavye)

bunların dışında derleyiciye özel olarak tanımlanmış dosya isimleride vardır.

Basit bir kod verecek olursakta ;

#include <stdio.h>

int main()
{
fprintf(stdout,”Bu mesaj *ekrana*   yazilacak …\n”);
fprintf(stdprn,”Bu mesaj *yaziciya* yazilacak …\n”);
return 0;
}
/*
stdprn Turbo C de bulunan bir dosya ismiymiş.İnternette gezerken gördüm paylaşayım dedim.
Yazıcı bağlı değilse işletim sistemi hata verecektir
*/