c programları

Web de Yenilik

2008-10-17T14:15:00.000-07:00

C programlama dili için yapılmış cdiliogren.blogspot.com sitesi acılmıştır ziyarecilere ve c ile ilgilenen yazılımcılara duyurulur

c de bir program kodu

2008-10-10T14:25:00.001-07:00

#include
#include
#include
#include
#include
#include

using namespace std;
int main(int argc,char *argv[])
{
system("TITLE EN BÜYÜK BEŞİK TAŞ KARA KARTAL");
//+++++++++++++++++++++++++++++++++++++++++++++++

// 1 - BİRİNCİ KOMUT AŞAMASI.

float s,h1,h2,sonuc;

geri:

system("color 9f");

cout<<" [X]"<>s;

// 2 - İKİNCİ KOMUT AŞAMASI.

if(s==1)
{

system("cls");

system("color 1f");

cout<<"\n\n\n\n\n\n\n"<>h1;

cout<<" +"<>h2;

sonuc=(h1+h2);

cout<<" ="<>h1;

cout<<" -"<>h2;

sonuc=(h1-h2);

cout<<" ="<>h1;

cout<<" *"<>h2;

sonuc=(h1*h2);

cout<<" ="<>h1;

cout<<" /"<>h2;

sonuc=(h1/h2);

cout<<" ="<5)||(s<0)||(s<=0))
{

system("cls");

system("color 0a");

Sleep(5000);

cout<<"\n\n\n\n\n\n\n\n\n\n"<
cout<<" !!! LUTFEN DOGRU BiR UYGULAMA GiRiNiZ !!!\n"<
cout<<" [1][2][3][4][5]"<
Sleep(5000);

system("cls");

goto geri;

}

// 7 - KOMUT AŞAMASI.

else if(s==5)
{

system("cls");

system("color f0");

Sleep(3000);
cout<<"\n\n\n\n\n\n\n"<cout<<" HESAP MAKiNESi PROGRAMI [ OuZ 1.2 ]\n"<
cout<<"EVET ARKADASLAR HESAP MAKiNESi PROGRAMI HAZIR.\n"<
Sleep(3000);

cout<<"ONCELiKLE EMEGE SAYGI LUTFEN...\n"<
Sleep(3000);

cout<<"BU PROGRAMLA iLGiLi GORUSLERiNiZ VE ONERiLERiNiZ\n"<
Sleep(3000);

cout<<"BENiM iCiN COK ONEMLi.VE SiZLERDENDE BU TARZ BASiT PROGRAMLAR VE OYUNLAR\n"<
Sleep(3000);

cout<<"YAPAN ARKADASLAR VARSA BANA EMAiL ADRESiMDEN ULASIRSANIZ SEViNiRiM.\n"<
Sleep(3000);

cout<<""<
Sleep(3000);

cout<<"SAYGILAR VE SEVGiLER HERKESE ( BY )\n"<
Sleep(3000);

cout<<"email adresim : ouzcpp@hotmail.com\n"<
Sleep(3000);

cout<<"email adresim : ouztek@hotmail.com\n"<
Sleep(4000);

system("cls");

cout<<"Windows ( calc ) HESAP MAKiNESi PROGRAMINA YONLENDiRiLiYORSUNUZ...\n"<
cout<<""<
cout<<"Lutfen Bekleyiniz...\n"<
Sleep(5000);

system("calc");

}

// 8 - KOMUT AŞAMASI.

else
{

system("cls");

system("color 0a");

Sleep(5000);

cout<<"\n\n\n\n\n\n\n\n\n\n"<
cout<<" !!! LUTFEN DOGRU BiR UYGULAMA GiRiNiZ !!!\n"<
cout<<" [1][2][3][4][5]"<
Sleep(5000);

system("cls");

cout<<" !!! HATALI BiR UYGULAMA GiRDiNiZ !!!\n"<
Sleep(4000);

cout<<"Windows ( calc ) HESAP MAKiNESi PROGRAMINA YONLENDiRiLiYORSUNUZ...\n"<
cout<<""<
cout<<"Lutfen Bekleyiniz...\n"<
Sleep(5000);

system("calc");

}

Eczane Programı

2008-09-12T14:12:00.000-07:00

eczane işlerini görebilecek bir program

#include
#include
#include
#include

typedef struct{
char ilac_ad[20];
char barkod[20];
char ilac_firmasi[50];
double ilac_tutari;
double kdv;
char ilac_turu[20];
int ilac_adedi;
} İlacT;

typedef struct{
char eleman_adi[20];
char eleman_soyadi[20];
char eleman_unvani[20];
int eleman_yasi;
char eleman_tel_no[20];
char tc_kimlik[15];
} ElemanT;

typedef struct{
char eczane_ismi[20];
ElemanT sahib;
} EczaneT;

typedef struct{
double gelir;
double gider;
double kâr;
} ButceT;

typedef struct{
double brut_maas_mik;
double sigorta_mik;
double net_maas_mik;
} MaasT;

void eczane_bil_gir(EczaneT* eczane)
{
char bos[2];
FILE *ptr;
ptr=fopen("eczane_bil.txt","w");
gets(bos);
printf("Eczane ismini giriniz...\t");
gets(eczane->eczane_ismi);

fputs(eczane->eczane_ismi,ptr);
fprintf(ptr,"\n");

printf("Eczane sahibinin ismini giriniz...\t");
gets(eczane->sahib.eleman_adi);

printf("Soyadini giriniz...\t");
gets(eczane->sahib.eleman_soyadi);

fputs(eczane->sahib.eleman_adi,ptr);
fprintf(ptr,"\n");
fputs(eczane->sahib.eleman_soyadi,ptr);

fclose(ptr);

if(ptr!=NULL)
{
printf("Bilgiler basariyla yuklendi...\n");
}
else{printf("Bilgiler yuklenirken bir hata olustu...\nLutfen tekrar giris yapiniz...\n");}
}
int eleman_bil_gir(ElemanT* eleman)
{
int secim;
FILE* ptr;
FILE* tptr;
char isim[20];
char tc[16];
char uzanti[6]=".txt";
char bos[2];

system("cls");

printf("Elemanin tc kimlik no sunu giriniz...\n");
scanf("%s", &eleman->tc_kimlik);

strcpy(tc,eleman->tc_kimlik);
strcat(tc,uzanti);

tptr=fopen(tc,"w");

printf("Eleman adini giriniz...\t");
gets(bos);

gets(eleman->eleman_adi);

strcpy(isim,eleman->eleman_adi);
strcat(isim,uzanti);

ptr=fopen(isim,"w");

fprintf(ptr,"Tc Kimlik:\t");
fputs(eleman->tc_kimlik,ptr);
fprintf(ptr,"\n");

fprintf(tptr,"Tc Kimlik:\t");
fputs(eleman->tc_kimlik,tptr);
fprintf(tptr,"\n");

fprintf(ptr,"Ad:\t");
fputs(eleman->eleman_adi,ptr);
fprintf(ptr,"\n");

fprintf(tptr,"Ad:\t");
fputs(eleman->eleman_adi,tptr);
fprintf(tptr,"\n");

printf("Soyadini giriniz...\t");
gets(eleman->eleman_soyadi);

fprintf(ptr,"Soyad:\t");
fputs(eleman->eleman_soyadi,ptr);
fprintf(ptr,"\n");

fprintf(tptr,"Soyad:\t");
fputs(eleman->eleman_soyadi,tptr);
fprintf(tptr,"\n");

printf("Unvanini giriniz...\t");
gets(eleman->eleman_unvani);
fprintf(ptr,"Unvani:\t");
fputs(eleman->eleman_unvani,ptr);
fprintf(ptr,"\n");

fprintf(tptr,"Unvani:\t");
fputs(eleman->eleman_unvani,tptr);
fprintf(tptr,"\n");

printf("Yasini giriniz...\t");
scanf("%d", &eleman->eleman_yasi);
fprintf(ptr,"Yas:\t");
fprintf(ptr,"%d\n",eleman->eleman_yasi);

fprintf(tptr,"Yas:\t");
fprintf(tptr,"%d\n",eleman->eleman_yasi);

printf("Telefon No sunu giriniz...\t");
scanf("%s",eleman->eleman_tel_no);
fprintf(ptr,"Tel-no:\t");
fputs(eleman->eleman_tel_no,ptr);

fprintf(tptr,"Tel-no:\t");
fputs(eleman->eleman_tel_no,tptr);

fclose(ptr);fclose(tptr);
if(ptr!=NULL){printf("Bilgileriniz basariyla yuklendi...\n");}else{printf("Bilgiler yuklenirken bir hata olustu lutfen tekrar deneyiniz...\n");}
if(tptr!=NULL){printf("Bilgiler yuklenirken bir hata olustu lutfen tekrar deneyiniz...\n");}

free(eleman);
do{
printf("\nYeni eleman eklemek icin (1) e basiniz\nYoksa herhangi bir tusa basiniz...\n");
scanf("%d", &secim);
if(secim!=1)
return 0;

eleman=(ElemanT*)malloc(sizeof ElemanT);
eleman_bil_gir(eleman);
}while(secim==1);
}
void eleman_maas_bil_gir()
{
MaasT maas;
char name[20];
char ek[5]=".txt";
char tc[16];
printf("Maas bilgilerini girmek istediginiz elemanin adini giriniz...\n");
scanf("%s", name);
printf("Maas bilgilerini girmek istedigininz elemanin tc kimlik no sungu iriniz\n");
scanf("%s",tc);
strcat(tc,ek);
strcat(name, ek);
FILE* tptr;
tptr=fopen(tc,"a");
FILE* ptr;
ptr=fopen(name,"a");

printf("Brut maas miktarini giriniz: ");
scanf("%lf", &maas.brut_maas_mik);
printf("Sigorta ucretini girini: ");
scanf("%lf", &maas.sigorta_mik);
maas.net_maas_mik=(maas.brut_maas_mik)-maas.sigorta_mik;
printf("Elemaninizin net maas miktari %.2lf YTL dir...\n", maas.net_maas_mik);

fprintf(ptr,"\nBrut maas tutari: %.2lf YTL", maas.brut_maas_mik);
fprintf(ptr,"\nSigorta tutari: %.2lf YTL", maas.sigorta_mik);
fprintf(ptr,"\nNet maas tutari: %.2lf YTL", maas.net_maas_mik);

fprintf(tptr,"\nBrut maas tutari: %.2lf YTL", maas.brut_maas_mik);
fprintf(tptr,"\nSigorta tutari: %.2lf YTL", maas.sigorta_mik);
fprintf(tptr,"\nNet maas tutari: %.2lf YTL", maas.net_maas_mik);

fclose(ptr);

if(ptr!=NULL){printf("Isleminiz basariyla gerceklestirildi...\n");}
else{printf("Isleminizde hata olustu kontrol edip tekrar deneyiniz...\n");
}
}

void ilac_bil_gir()
{
İlacT ilac;
FILE* ptr;
FILE* bptr;
char uzanti[5]=".txt";
char name[20];
char barkod[20];

char bos[2];
system("cls");
printf("Ilacin adini giriniz...\t");
gets(bos);
gets(ilac.ilac_ad);

printf("Ilacin turunu giriniz...\t");
gets(ilac.ilac_turu);

printf("Ilacin ait oldugu firmanin adinin giriniz...\t");
gets(ilac.ilac_firmasi);

printf("Ilacin barkodunu giriniz...\t");
gets(ilac.barkod);

printf("Ilacın tutarini giriniz...\t");
scanf("%lf", &ilac.ilac_tutari);

printf("Ilacin kdv sini giriniz...\t");
scanf("%lf", &ilac.kdv);

printf("Ilactan kac adet bulundugunu giriniz...\t");
scanf("%d", &ilac.ilac_adedi);

strcpy(name,ilac.ilac_ad);
strcat(name,uzanti);

strcpy(barkod,ilac.barkod);
strcat(barkod, uzanti);

ptr=fopen(name,"w");
bptr=fopen(barkod,"w");

fprintf(ptr,"Ilacin Barkodu:\t");
fputs(ilac.barkod,ptr);

fprintf(bptr,"Ilacin Barkodu:\t");
fputs(ilac.barkod,bptr);

fprintf(ptr,"\nIlacin Adi:\t");
fputs(ilac.ilac_ad,ptr);

fprintf(bptr,"\nIlacin Adi:\t");
fputs(ilac.ilac_ad,bptr);

fprintf(ptr,"\nIlacin Firmasi:\t");
fputs(ilac.ilac_firmasi,ptr);

fprintf(bptr,"\nIlacin Firmasi:\t");
fputs(ilac.ilac_firmasi,bptr);

fprintf(ptr,"\nIlacin turu:\t");
fputs(ilac.ilac_turu,ptr);

fprintf(bptr,"\nIlacin turu:\t");
fputs(ilac.ilac_turu,bptr);

fprintf(ptr,"\nIlacin Adedi:\t");
fprintf(ptr,"%d", ilac.ilac_adedi);

fprintf(bptr,"\nIlacin Adedi:\t");
fprintf(bptr,"%d", ilac.ilac_adedi);

fprintf(ptr,"\nIlacin Tutari:\t");
fprintf(ptr,"%.2lf YTL", ilac.ilac_tutari);

fprintf(bptr,"\nIlacin Tutari:\t");
fprintf(bptr,"%.2lf YTL", ilac.ilac_tutari);

fprintf(ptr,"\nIlacin kdv tutari:\t");
fprintf(ptr,"%.2lf YTL",ilac.kdv);

fprintf(bptr,"\nIlacin kdv tutari:\t");
fprintf(bptr,"%.2lf YTL",ilac.kdv);

fclose(ptr);
fclose(bptr);

if(ptr!=NULL){printf("Ilac bilgileri basariyla yuklendi...\n");}else{printf("Ilac bilgileri yuklenirken hata olustu lutfen tekrar deneyiniz...\n");}

}
void ilac_bil_sorgula()
{
FILE* ptr;
char barkod[20];
char bos[2];
char uzanti[5]=".txt";
char* alici;
alici=(char*)malloc(50*sizeof(char));

printf("Lutfen ilacin barkodunu giriniz...\t");

gets(bos);
gets(barkod);

strcat(barkod, uzanti);

ptr=fopen(barkod,"r");
system("cls");
while(!(feof(ptr)))
{
fgets(alici,50,ptr);

puts(alici);
}
free(alici);
}

void ilac_sat()
{
char string[15];
int basamak=0;
FILE* ptr;
int value;
int sonuc;
char barkod[20];
char bos[2];
char uzanti[5]=".txt";
char* alici;
char ek[20]="Ilacin Adedi: ";
alici=(char*)malloc(60*sizeof(char));
if(alici==NULL){printf("Hafiza tahsisi yapilamadi...\n");}
int al;
char null[20];

system("cls");
printf("Lutfen ilacin barkodunu giriniz...\t");

gets(bos);
gets(barkod);

strcpy(null,barkod);
strcat(barkod, uzanti);

ptr=fopen(barkod,"r+");

printf("Kac Adet bu ilactan satilacak:\t");
scanf("%d", &al);

while(!(feof(ptr)))
{
static int sayac=3;
fgets(alici,60,ptr);

while(sayac==0)
{
static int say=2;

if(say==0){
fscanf(ptr,"%d", &value);
value=value-al;
if(value<0){
printf("Hic ilac kalmamis,Lutfen ilac siparis ediniz...\n");break;}
else{
sonuc= value+ al;
do{
sonuc=sonuc/10;
basamak++;}while(sonuc!=0);

if(basamak>1){
fseek(ptr,-(basamak),1);
fprintf(ptr,"%d", value);
while(basamak!=0){
fprintf(ptr," ");basamak--;}
break;}
else{
fseek(ptr,-1,1);
fprintf(ptr,"%d", value);break;}
}
}
if((say>0)&&(say!=0))
{
fscanf(ptr,"%s",string);

}
say--;
}
sayac--;
if(sayac<0)
break;

}

printf("\nIlactan %d tane satilnistir...\n\n",al);
printf("%s barkodlu ilactan %d tane kalmistir...\n", null, value);
fclose(ptr);
}
void ilac_ekle()
{
char string[15];
int basamak=0;
int sayac;
FILE* ptr;
int value;
char barkod[20];
char bos[2];
char uzanti[5]=".txt";
char* alici;
char ek[20]="Ilacin Adedi: ";
alici=(char*)malloc(60*sizeof(char));
if(alici==NULL){printf("Hafiza tahsisi yapilamadi...\n");}
int al;
char null[20]="\0";

system("cls");
printf("Lutfen ilacin barkodunu giriniz...\t");

gets(bos);
gets(barkod);
strcpy(null,barkod);

strcat(barkod, uzanti);

ptr=fopen(barkod,"r+");

printf("Kac Adet bu ilactan eklenecek:\t");
scanf("%d", &al);

while(!(feof(ptr)))
{
static int sayac=3;
fgets(alici,60,ptr);

while(sayac==0)
{
static int say=2;

if(say==0){
fscanf(ptr,"%d", &value);
value=value+al;
if(value<0){
printf("Hic ilac kalmamis,Lutfen ilac siparis ediniz...\n");break;}
else{
sayac= value-al;
do{
sayac=sayac/10;
basamak++;}while(sayac!=0);

fseek(ptr,-basamak,1);
fprintf(ptr,"%d", value);break;
while(basamak!=0)
{
fprintf(ptr," ");
basamak--;
}
}
}
if((say>0)&&(say!=0))
{
fscanf(ptr,"%s",string);

}
say--;
}
sayac--;
if(sayac<0)
break;

}
if(value>0){
printf("\nIlactan %d tane eklenmistir...\n\n",al);

printf("%s barkodlu ilactan %d tane vardir...\n", null, value);}
fclose(ptr);
}

void eczane_bilancosu(ButceT);

void menu1()
{
char* name;
name=(char*)malloc(20*sizeof(char));
FILE* ptr;
ptr=fopen("eczane_bil.txt","r");
fgets(name,20,ptr);
printf("\t\t\t\t");
puts(name);
printf("\n");
printf("\t\t\t\t\tHOSGELDINIZ\n\n");
}
void menu()
{
system("color d");
printf("\t\tEczane Bilgileri girmek icin (1)\a\n");
printf("\t\tEleman Bilgileri girmek icin (2)\a\n");
printf("\t\tEleman Maas Bilgilerini girmek icin (3)\a\n");
printf("\t\tEleman Bilgileri isimle sorgulamak icin (4)\a\n");
printf("\t\tEleman Bilgilerinin tc kimlik no ile sorgulamak icin (5)\a\n");
printf("\t\tIlac bilgilerini girmek icin (6)\a\n");
printf("\t\tIlac bilgilerini sorgulamak icin (7)\a\n");
printf("\t\tIlac Satisi icin (8)\a\n");
printf("\t\tIlac eklemek icin (9)\a\n");
printf("\t\tYeni islem (10)\a\n");
printf("\t\tCikis icin (11)\a\n");
}
void eleman_bil_sorgula_tc()
{
char uzanti[5]=".txt";
char tc[16];
FILE* tptr;
printf("Tc Kimlik No yu Giriniz:\t");
scanf("%s", tc);
strcat(tc,uzanti);
tptr=fopen(tc,"r");
if(tptr==NULL){printf("Boyle Bir kayit bulunmamaktadir...\n");}
system("cls");
char* Name;
Name=(char*)malloc(40*sizeof(char));
while(!(feof(tptr)))
{

fgets(Name,40,tptr);
puts(Name);
}
fclose(tptr);
printf("\nSorguladiginiz kisinin Bilgileri yukaridadir...\n");
}

void eleman_bil_sorgula()
{
char bos[2];
FILE* ptr;
printf("Bilgilerine ulasmak istediginiz elemanin ismini ilk harfi buyuk olacak bıcımde giriniz\n");
char uzanti[5]=".txt";
char name[20];
char* Name;
Name=(char*)malloc(40*sizeof(char));
gets(bos);
gets(name);
strcat(name, uzanti);
ptr=fopen(name,"r");
if(ptr==NULL){printf("Boyle Bir kayit bulunmamaktadir...\n");}
system("cls");

while(!(feof(ptr)))
{

fgets(Name,40,ptr);
puts(Name);
}
fclose(ptr);
printf("\nSorguladiginiz kisinin Bilgileri yukaridadir...\n");

}
int main()
{
menu1();

menu();
int secim;
system("color 3");
printf("Seciminizi giriniz... ");
scanf("%d", &secim);

ElemanT* eleman;
eleman=(ElemanT*)malloc(sizeof ElemanT);
EczaneT* eczane;
eczane=(EczaneT*)malloc(sizeof EczaneT);
if(secim==1){
eczane_bil_gir(eczane);
system("pause");
system("cls");
return main();}
if(secim==2){
eleman_bil_gir(eleman);system("pause");
system("cls");
return main();}
if(secim==3){
eleman_maas_bil_gir();system("pause");
system("cls");
return main();}
if(secim==4){
eleman_bil_sorgula();system("pause");
system("cls");
return main();}
if(secim==5){
eleman_bil_sorgula_tc();system("pause");
system("cls");
return main();}
if(secim==6){
ilac_bil_gir();system("pause");
system("cls");
return main();}
if(secim==7){
ilac_bil_sorgula();system("pause");
system("cls");
return main();}
if(secim==8){
ilac_sat();system("pause");
system("cls");
return main();}
if(secim==9){
ilac_ekle();system("pause");
system("cls");
return main();}
if(secim==10){
system("cls");return main();}
if(secim==11)
return 0;

else{
return 0;}
return 0;
}

Word Listesi kodu

2008-07-20T14:42:00.000-07:00

#include
#include
main()
{
int i,j,k,l;
const char a[26]={'A','B','C','D','E','F','G','H','I','J','K','L', 'M','N','O','P','Q','R','S','T','U','V','W','X','Y ','Z'};
FILE *dosya;
dosya=fopen("Nedved.txt","w");
for(i=0;i<26;i++)
for(j=0;j<26;j++)
for(k=0;k<26;k++)
for(l=0;l<26;l++)
fprintf(dosya,"%c%c%c%c\n",a[i],a[j],a[k],a[l]);
fclose(dosya);
}

yılan oyunun kod c++ c-programlari

2008-02-12T12:43:00.001-08:00

Yılan oyunu..

Yılan oyunun hazır kodları

#include
#include
#include
#include

void acilisnotlari(void);
void seviyebelirle(void);
void duvarbelirle(void);
void yilankoordinatbelirle(void);
void yembelirle(void);

void kuyruksildegeraktar(void);
void hareketkontrol(void);
void duvarcarpmakontrol(void);
void kendinecarpmakontrol(void);
void yemekontrol(void);
void yilangoruntule(void);
void ozelyembelirle(void);
void yukari(void);
void asagi(void);
void saga(void);
void sola(void);
void sonnot(void);

static int yilan[100][2],yem[2][2];
static int x,y,dson,ozelpuan,verilecekpuan,yemX,yemY,puan,kon trol,yilankuyrukX,yilankuyrukY,kuyruk=6,seviye=110 ,baraj=25;
int ch,d=77,i,j,sec;
char ad[35]="030123003 - ™ZGšR BAYRAKTARO¦LU",olmadi;

void sonnot()
{
nosound();
getch();
clrscr();
gotoxy(22,12);
textcolor(RED);cprintf("@ ...DESIGNED BY ™ZGšR BAYRAKTARO¦LU... @");
delay(1500);
textcolor(7);
exit(0);
}
void acilisnotlari(void)
{
_setcursortype(_NOCURSOR);
textcolor(7);
x=14,y=14;
clrscr();
gotoxy(20,7);printf("ntt---€anakkale 18 Mart šniversitesi");
delay(500);
gotoxy(20,8);printf ("ntt---Bilgisayar ™§retmenli§i ve ™§retim Teknolojileri B”l?m?");
delay(500);
gotoxy(20,9);printf ("ntt---Programlama Dersi");
delay(500);
gotoxy(20,10);printf ("ntt---Vize Projesi:");
delay(500);
gotoxy(33,11);printf (" Nokia Y?lan Oyunu...n");
delay(500);
gotoxy(20,6);
textcolor(2);
for (i=0; i<31;i++)
{
cprintf("%c",ad[i]);
sound(4000);
delay(50);
nosound();
delay(70);
}
delay (500);
textcolor(BLUE);
for (y=14; y>4; y -= 9)
for (x=14;x<76;x++)
{
gotoxy(x,y); cprintf("%c",2);
delay(10);
}
for (x=14; x<76; x += 61)
for (y=6; y<15; y++)
{
gotoxy(x,y); cprintf("%c",2);
delay(15);
}
gotoxy(27,17);
textcolor(4+128);
cprintf("BaŸlamak icin herhangi bir tuŸa bas?n?z");
getch();
textcolor(7);
clrscr();
}
void seviyebelirle()
{
if (puan >= 150)
seviye = 50;
else if (puan>=125)
seviye = 60;
else if (puan>=100)
seviye = 70;
else if(puan>=75)
seviye = 80;
else if (puan>=50)
seviye = 90;
else if (puan>= 25)
seviye = 100;
}
void duvarbelirle()
{
textcolor(GREEN);
for (j=1;j<25;j=j+23)
for (i=1;i<=80;i++)
{
gotoxy (i,j);
cprintf ("%c", 219);
}
for (i=1;i<=80;i=i+79)
for (j=1;j<25;j++)
{
gotoxy(i,j);
cprintf ("%c", 219);
}
textbackground(2);
textcolor(0);
gotoxy(61,24);
cprintf("™zg?r Bayraktaro§lu");
textbackground(0);
textcolor(7);
}
void yilankoordinatbelirle()
{
randomize();
yilan[0][0] = random(60)+8;
yilan[0][1] = rand()%21+2;
for (i=1; i<7; i++)
{
gotoxy(yilan[i-1][0],yilan[i-1][1]);
if (i==1)
{
printf("%c",2);
}
else
{
printf("%c",219);
}
yilan[i][0] = yilan[0][0]-i;
yilan[i][1] = yilan[0][1];
}
gotoxy(yilan[kuyruk][0],yilan[kuyruk][1]);printf("%c",219);
}
void yembelirle()
{
yem[0][0] = rand()%77 + 2;
yem[0][1] = rand()%21 + 2;
for (i=0; i<=kuyruk; ++i)
{
if (yem[0][0] == yilan[i][0] && yem[0][1] == yilan[i][1])
yembelirle();
}
gotoxy(yem[0][0],yem[0][1]);
printf("%c",2);
}

void kuyruksildegeraktar()
{
yilankuyrukX = yilan[kuyruk][0];
yilankuyrukY = yilan[kuyruk][1];
for (i=kuyruk; i>=1; i--)
{
yilan[i][0] = yilan[i-1][0];
yilan[i][1] = yilan[i-1][1];
}
}
void hareketkontrol()
{
switch (d)
{
case 72:yukari();break;//yukari
case 80:asagi();break;//asagi
case 77:saga();break;//saga
case 75:sola();break;//sol
//case 'p':break;//pause
}
}
void yukari()
{
if (dson == 80)
{
yilan[0][1]++;
d=dson;
}
else
yilan[0][1]--;
}
void asagi()
{
if (dson == 72)
{
yilan[0][1]--;
d=dson;
}
else
yilan[0][1]++;
}
void saga()
{
if (dson == 75)
{
yilan[0][0]--;
d=dson;
}
else
yilan[0][0]++;
}
void sola()
{
if (dson == 77)
{
yilan[0][0]++;
d=dson;
}
else
yilan[0][0]--;
}
void duvarcarpmakontrol()
{
if ( yilan[0][0] > 79 || yilan[0][0] < 2 || yilan[0][1] >23 || yilan[0][1] < 2 )
{
sound(850);
gotoxy(30,25);printf(".......KENARA CARPTIN........");
delay(1000);
sonnot();
}
}
void kendinecarpmakontrol()
{
for (i=2;i{
if (yilan[0][0] == yilan[i][0] && yilan[0][1] == yilan[i][1])
{
sound(850);
gotoxy(35,25);printf("KENDi KENDiNE CARPTIN");
delay(1000);
sonnot();
}
}
}
void yemekontrol()
{
if (yem[0][0] == yilan[0][0] && yem[0][1] == yilan[0][1])
{
sound(400);
kuyruk++;
yilan[kuyruk][0] = yilankuyrukX;
yilan[kuyruk][1] = yilankuyrukY;
puan += 5;
gotoxy(1,25);
printf("PUAN: %d KUYRUK BOYU: %d",puan+verilecekpuan,kuyruk);
clreol();
if (puan == baraj)
{
seviyebelirle();
baraj += 25;
gotoxy(1,25);
printf("...OZEL YEM CIKTI CABUK YE...");
do
{
olmadi = 0;
yem[1][0] = rand()%77 + 2;
yem[1][1] = rand()%21 + 2;
yemX = yem[1][0];
yemY = yem[1][1];
for (i=0; i<=kuyruk; ++i)
{
if (yem[1][0] == yilan[i][0] && yem[1][1] == yilan[i][1])
olmadi = 1;
}
}
while(olmadi == 1);

gotoxy(yemX,yemY);
textcolor(RED);
cprintf("%c",3);
kontrol = 1;
verilecekpuan = 80;
textcolor(7);
}
yembelirle();
}
}

void yilangoruntule()
{
for (i=0; i<=kuyruk; ++i)
{
gotoxy(yilan[i][0],yilan[i][1]);
if (i==0)
{
textcolor(4);
cprintf("%c",2);
}
else
{
textcolor(i);
cprintf("%c",219);
}
}
gotoxy(yilankuyrukX,yilankuyrukY);
textcolor(7);
cprintf(" ");
delay(seviye);
nosound();
}
void ozelyembelirle()
{
verilecekpuan -= 1;
if (yemX == yilan[0][0] && yemY == yilan[0][1])
{
sound(4000);
kontrol = 0;
gotoxy(1,25);
printf("ALDIGIN OZEL PUAN: %d ",verilecekpuan);
clreol();
}
if (verilecekpuan == 0)
{
kontrol = 0;
gotoxy(yemX,yemY);
textcolor(7);
cprintf(" ");
gotoxy(1,25);
printf("OZEL YEMi ALAMADIN");
clreol();
}
}
void main()
{
clrscr();
acilisnotlari();
seviyebelirle();
duvarbelirle();
yilankoordinatbelirle();
yembelirle();
while (ch!=27)
{
dson = d;
while (!kbhit())
{
if (kontrol==1)
ozelyembelirle();
do
{
kuyruksildegeraktar();
hareketkontrol();
duvarcarpmakontrol();
kendinecarpmakontrol();
yemekontrol();
yilangoruntule();
}
while(1 == 2);
}
ch=getch();
if (ch==0) d=getch();
if (ch=='p')
getch();

if (kontrol==1)
ozelyembelirle();
do
{
kuyruksildegeraktar();
hareketkontrol();
duvarcarpmakontrol();
kendinecarpmakontrol();
yemekontrol();
yilangoruntule();
}
while(1 == 2);

}
sonnot();
}

c programlama pointer

2007-12-30T14:07:00.000-08:00

Bu yazıda eğer bilgisayar bölümünde değilseniz çoğunlukla okullarda göremeyeceğiniz ancak oldukça önem taşıyan bir konu olan pointerla aşınalık sağlayarak üzerinizdeki zor gibi görünen bu konudaki korkuyu atmaya çalışacağız.
Öncelikle, kısaca bahsetmek gerekirse bir integer değişkenin hafızada integer değeri tutması gibi, ya da bir double değişkenin ondalıklı sayılar tutması gibi pointer da adres değeri tutan değişkendir. Yani içinde tuttuğu adres başka bir değişkenin adresine point eder diyebiliriz.İsterseniz bir örnek üzerinde açıklayalım.
int *p;
int i;
int j=10;

komutu ile bir integer değişkenin adresini tutan p isimli bir pointer ve de i ve j isminde iki integer tanımlayıp dahası j’nin değerini tanımlanır tanımlanmaz 10’a eşitlemiş olduk.
Şimdi i=j; diyerek i’nin de 10 olmasını sağlayabildiğimiz gibi
p=&j; komutu ile p pointerının j değişkeninin adresini tutmasını sağlayabiliriz.
Ancak dikkat etmemiz gereken nasıl i=j; derken i’nin karşısına yine bir integer değer geliyorsa aynı şekilde adres tutan p pointerının karşısına da j’nin adresi olan &j’nin geliyor olması. Yani &j demek, j’nin memorydeki(hafızadaki) adresi demek oluyor. Bir de bunu tersi olan * işareti var ki *p de bize p pointerının gösterdiği adresin içeriğini veriyor.
Yani şu durumda cout<<*p; gibi bir satır ‘p pointerının gösterdiği adresin içinde ne varsa onu ekrana yaz’ demek olacağından 10 rakamını ekranda gösterecektir.
Diyebiliriz ki C++’da array(dizi) olarak bildiğiniz şey, aslında pointer yapısına sahip. Yani arrayin sıfırıncı elemanına point eden bir pointer var elimizde ve tüm diğer elemanlar da hafızada sıfırıncı elemanın yanına öylece dizilmiş haldeler. İşte array dediğimiz şey de bu yapıdan başka bir şey değil.
Örneğin;
int x[2][3]; komutu bize nasıl 2’ye 3 lük bir matris tanımlama imkanı veriyorsa ve onun (i,j)’inci elemanına x[2][3]; şeklinde ulaşıyorsak, bu aslında şunu yazmaktan farklı bir şey değil;
*(&x[0][0]+3i+j) burada &x[0][0] bize (0,0)ıncı elemanın adresini veriyor.
Bunu sütun sayısı olan 3 ile çarpıp j ile topladığınızda da (i,j)nci elemana ulaşmış oluyorsunuz.
Ufak ve şirin bir kısaltma olarak C++’da &x[0][0] yerine x kullanabiliyoruz.
Yani demek oluyor ki;
*(x+3i+j) ibaresi de (i,j)nci elemanı ifade etmemizi sağlıyor.
Şu an x[i][j] gibi kolay bir ifadeyi pointerlar ile ifade edip niye kalabalık yaptığımıza bir anlam verememeniz doğal. Ancak emin olun ki bazı durumlarda arraylarle uğraşmaktansa direkt pointer aritmetiği kullanarak işimizi çok daha kolay halledebileceğimizi ilerde anlayacaksınız.
Pointerlarin kullanıldığı en rahat anlaşılır ve etkin yerlereden biri dinamik hafıza kontrolüdür (dynamic memory management). Bir dahaki sefere uygulamalı olarak pointerların bize nasıl program ortasında değişken oluşturma ve yine istediğimiz anda ortadan kaldırma imkanı verdiğinden bahsedeceğiz. Bu defa sadece bilmeyenlerin pointerları kabaca tanımalarını ve varsa korkuyu üzerlerinden atmalarını amaçladım.
ALINTI
------------------
Gece gece böyle bi konu bulduk.(nerden bulduysam, eh insan oyun programcısıyla konuşursa gece gece bile kodlarla uğraşır )
Bende daha şu saatlerde karşılaştım bu pointer denilen şeyle aslında C++ ile ilgilenmem ama yeri gelmişken öyle bir kişiden pointer konusunu dinlemek hoş bişi Galiba bu kadar karıştırılan şeyi ben anladım (bide koda çevirebilsem tam olcak )
"int a = 5; //a değişkenini 5 yapttıkint* b = &a; //b pointerına anın adresini atadık*b = 10; // bnin gösterdiği adrese 10 yazdık
burdan sonra anın değeri ne olur?"
ben: "5*10 mu ?"
"hyr 10
int* b // b nin integer pointer ı olduunu ifade ediyo02:42 &a daki & anın adresini alıyo*b de bnin gösterdiği adresteki değer demek oluyo"
ben: "onu sil bunu yazmı diyo :S"
"Evet =) bu 3 olayı kavrayabilirsen data yapılarını çok rahat anlarsın .aslında çizerek göstermem lazım daha iyi olur ama şimdi kağıt kalem yok =) "
ben: "doğrudr bi an aklımda canlandırdım kutu kutu felan "
"evet aynen öyle =)"
ben: "kutuya Ayşe girerse erkekler onu çarpar dedim (5*10) baktım olmadı dedim Ali girer ayşe kaçar "
"hehehee pointer konusu c / c++ öğrenicilerinin en zorlandığı konudur bu yüzden genelde vb yada pascal gibi başka dillerle başlarlar ama sökersen bu konuyu gerisi çorap söküğü gibi gelir =). pointerın nasıl kullanabileceğini kavrayınca onu kullanarak yeni yapılar oluşturuyosun ağaçlar / yığıtlar falan =)""
ben: "yığıt :S"
"hmm şöyle düşün üstüste konmuş n tane tabak en tepeye tabak koyabiliyosun en tepeden tabak alabiliyosun.Tabaklarda da veri var"
ben: "çörek börek"
"evet =))"
ben: "Peki bunlara resim aktarabiliyonmu ? Sadece yazımı yoksa Yoksa yoksa ..."
"istediğini tut veri olarak.bak mesela şööle bi kullanımı var yığıtları "serkan" stringini ters çevirmek istiyoz mesela yığıyta sırayla "s" "e" "r" "k" "a" "n" ekliyosun. en tepedeki tabakta ne var şimdi? "
ben: "N var"
"üstüne E yi eklediküstüne R yi eklediküstüne K y eklediksoora sırayla alıyoz tabakları "
ben : "al gülüm ver gülüm O masadan diğer masaya geçirdin.En üstteki en alta geldi.bide bunu koda çevirebilsem çok şey yapcamda "
"hehehe"
Böylece konuyu reel yaptıkmı konuların nası kolay anlaşılacağını göstermiş olduk

c FONKSİYONLAR

2007-12-08T09:58:00.001-08:00

FONKSİYONLAR

C'de alt programlara fonksiyon denir. Fonksiyon sözcüğü burada matematiksel anlamıyla değil diğer programlama dillerinde kullanılan, "alt program", "prosedür", "subroutine" sözcüklerinin karşılığı olarak kullanılmaktadır.

Fonksiyonlar C dilinin temel yapı taşlarıdır. Çalıştırılabilen bir C programı en az bir C fonksiyonundan oluşur. Bir C programının oluşturulmasında fonksiyon sayısında bir kısıtlama yoktur.

Fonksiyonların onları çağıran fonksiyonlardan aldıkları girdileri ve yine onları çağıran fonksiyonlara gönderdikleri çıktıları vardır. Fonksiyonların girdilerine aktüel parametreler (actual parameters) ya da argumanlar (arguments) diyoruz. Fonksiyonların çıktılarına geri dönüş değeri (return value) diyoruz.

Bir fonksiyon iki farklı amaçla kullanılabilir :

1. Fonksiyon, icrası süresince belli amaçları gerçekleştirir. (Belli işlemleri yapar)
2. Fonksiyon icrası sonunda üreteceği bir değeri kendisini çağıran fonksiyona gönderebilir.
Fonksiyonların Tanımlanması ve Çağırılması
Bir fonksiyonun ne iş yapacağının ve bu işi nasıl yapacağının C dilinin sentaks kurallarına uygun olarak anlatılmasına o fonksiyonun tanımlanması (definition) denir. Fonksiyon tanımlamaları aşağıda inceleneceği gibi birtakım sentaks kurallarına tabidir.
Bir fonksiyonun çağırılması ise o fonksiyonun yapacağı işi icraya davet edilmesi anlamına gelir. Fonksiyon çağırma ifadesi karşılığında derleyici, programın akışını ilgili fonksiyonun kodunun bulunduğu bölgeye aktaracak şekilde bir kod üretir. Programın akışı fonksiyonun kodu içinde akıp bu kodu bitirdiğinde, yani fonksiyon icra edildiğinde, programın akışı yine fonksiyonun çağırıldığı noktaya geri dönecektir. Fonksiyon çağırmaya ilişkin sentaks da yine aşağıda açıklanacaktır.
Fonksiyonların Geri Dönüş Değerleri (return values)
Bir fonksiyonun yürütülmesi sonunda onu çağıran fonksiyona dönüşünde gönderdiği değere, fonksiyonun geri dönüş değeri (return value) denmektedir. Her fonksiyon bir geri dönüş değeri üretmek zorunda değildir. Fonksiyonların geri dönüş değerleri farklı amaçlar için kullanılabilir;
1. Bazı fonksiyonlar tek bir değer elde etmek amacıyla tasarlanmışlardır. Elde ettikleri değeri de kendilerini çağıran fonksiyonlara geri dönüş değeri olarak iletirler. Örneğin:

y = pow(2, 3);

pow fonksiyonu standart bir C fonksiyonudur. Birinci parametresiyle belirtilen sayının ikinci parametresiyle belirtilen kuvvetini hesaplayarak, hesapladığı sayıyı geri dönüş değeri olarak kendisini çağıran fonksiyona iletir. Yukarıdaki örnekte 2 sayısının 3. kuvveti bu fonksiyon yardımıyla hesaplanarak bulunan değer y değişkenine atanmıştır.

2. Bazı fonksiyonların geri dönüş değerleri fonksiyonun yürütülmesi sırasında yapılan işlemlerin başarısı hakkında bilgi verir. Yani bu tür fonksiyonların geri dönüş değerleri test amacıyla kullanılmaktadır. Geri dönüş değerleri yapılması istenen işlemin başarılı olup olmaması durumunu açıklar. Örneğin :

p = malloc(200);

ifadesiyle bellekte 200 byte uzunluğunda bir blok tahsis etmek isteyen programcı bu işlemin başarılı bir biçimde yerine getirilip getirilmediğini de test etmek zorundadır. Hemen arkasından p değişkeninin aldığı değeri kontrol edecek ve işlemin başarısı hakkında bir karara varacaktır. Dolayısıyla malloc fonksiyonunun geri dönüş değeri, fonksiyonun yapması gereken işin başarılı bir şekilde sonuçlanıp sonuçlanmadığını göstermektedir.

3. Bazı fonksiyonlar kendilerine gönderilen argumanları belirli bir kritere göre test ederler. Ürettikleri geri dönüş değerleri ise test sonucunu belirtir. Örneğin:

if (isalpha(ch)) {
...
}

Burada isalpha fonksiyonu arguman olarak gönderilen karakterin bir harf karakteri olup olmadığını test eder. Eğer harf karakteriyse, isalpha fonksiyonu 0 dışı bir değere geri dönecek, eğer harf karakteri değilse 0 değerine geri dönecektir. Çağıran fonksiyonda da geri dönüş değerine göre farklı işlemler yapılabilecektir.

4. Bazı fonksiyonlar hem belli bir amacı gerçekleştirirler hem de buna ek olarak amaçlarını tamamlayan bir geri dönüş değeri üretirler. Örneğin :

x = printf("Merhaba Dünya\n");

Burada printf fonksiyonu ekrana Merhaba Dünya yazısını yazmak için kullanılmıştır. Ancak ekrana yazdığı karakter sayısını da geri dönüş değeri olarak vermektedir.
Bir yazı içersinde bulunan belirli bir karakteri silecek bir fonksiyon tasarladığımızı düşünelim. Fonksiyon işini bitirdikten sonra yazıdan kaç karakter silmiş olduğunu geri dönüş değeri ile çağırıldığı yere bildirilebilir.

5. Bazen geri dönüş değerlerine ihtiyaç duyulmaz. Örneğin yalnızca ekranı silme amacıyla tasarlanmış olan bir fonksiyonun geri dönüş değerine sahip olması gereksizdir.

clrscr();

clrscr fonksiyonu yalnızca ekranı siler, böyle bir fonksiyonun geri dönüş değerine ihtiyacı yoktur.

Fonksiyonların geri dönüş değerlerinin de türleri söz konusudur. Fonksiyonların geri dönüş değerleri herhangi bir türden olabilir. Geri dönüş değerlerinin türleri fonksiyonların tanımlanması sırasında belirtilir.
Fonksiyonların Tanımlanması
Kendi yazdığımız fonksiyonlar için tanımlama (definition) terimini kullanıyoruz. C'de fonksiyon tanımlama işleminin genel biçimi şöyledir:

[Geri dönüş değerinin türü] ([parametreler])
{
...
...
}

Yukarıdaki gösterimde açısal parantez içinde belirtilen ifadeler zorunlu olarak bulunması gerekenleri köşeli parantez içinde belirtilen ifadeler ise bulunması zorunlu olmayan, isteğe bağlı (optional) ifadeleri göstermektedir. Tanımlanan fonksiyonlar en az bir blok içerirler. Bu bloğa fonksiyonun ana bloğu denir. Ana blok içinde istenildiği kadar içiçe blok yaratılabilir. Aşağıdaki fonksiyon tanımlamasından fonk1 fonksiyonunun parametre almadığını ve geri dönüş değerinin de double türden olduğunu anlıyoruz.

double fonk1()
{
...
... Fonksiyonun ana bloğu
...
}

void Anahtar Sözcüğü
Bir fonksiyonun parametre değişkeni ya da geri dönüş değeri olmak zorunda değildir. Bir fonksiyonun parametre değişkeni olmadığı iki şekilde belirtilebilir:

1. Fonksiyon parametre parantezinin içi boş bırakılır, yani buraya hiçbirşey yazılmaz.
2. Fonksiyon parametre parantezinin içine void anahtar sözcüğü yazılır.

fonk() fonk(void)
{ {
... ...
} }

Yukarıdaki tanımlamalar C'de aynı anlama gelmiyor. Fonksiyon prototipleri konusunu öğrenirken bu iki tanımlama arasındaki farkı da öğrenmiş olacağız. Şimdilik bu iki tanımlamanın aynı anlama geldiğini ve fonksiyonun parametre almadığını belirttiklerini varsayacağız.

Geri dönüş değerine ihtiyaç duyulmadığı durumlarda da geri dönüş değerinin türü yerine void anahtar sözcüğü yerleştirilir. Örneğin:

void sample(void)
{
...
}

Yukarıda tanımlanan sample fonksiyonu parametre almamakta ve bir geri dönüş değeri de üretmemektedir.

Fonksiyon tanımlarken geri dönüş değeri yazılmayabilir. Bu durum geri dönüş türünün olmadığı anlamına gelmez. Eğer geri dönüş değeri yazılmazsa, C derleyicileri tanımlanan fonksiyonun int türden bir geri dönüş değerine sahip olduğunu varsayarlar. Örneğin :

sample2()
{
...
}

Tanımlanan sample2 fonksiyonunun parametresi yoktur ama int türden bir geri dönüş değeri vardır.

C dilinde fonksiyon içinde fonksiyon tanımlanamaz!

Örneğin aşağıdaki durum error oluşturur, çünkü sample2 fonksiyonu sample1 fonksiyonunun içinde tanımlanmıştır:

double sample1()
{
...
int sample2() /* error */
{
...
}
...
}

tanımlamanın aşağıdaki şekilde yapılması gerekirdi :

double sample1()
{
...
}

int sample2()
{
...
}
Fonksiyonların Çağırılması (function calls)
C dilinde fonksiyon çağırma operatörü olarak () kullanılmaktadır. Bir fonksiyon çağırıldığı zaman programın akışı fonksiyonu icra etmek üzere bellekte fonksiyonun kodunun bulunduğu bölgeye atlar, fonksiyonun icra edilme işlemi bittikten sonra da akış tekrar çağıran fonksiyonun kalınan yerinden devam eder.

Bir fonksiyonun geri dönüş değeri varsa, fonksiyon çağırma ifadesi geri dönüş değerini üretir.
Geri dönüş değeri bir değişkene atanabileceği gibi doğrudan aritmetik işlemlerde de kullanılabilir. Örneğin:

sonuc = hesapla();

Burada hesapla fonksiyonunun çağırılma ifadesiyle üretilen geri dönüş değeri sonuc değişkenine atanmaktadır. Bir başka deyişle bir fonksiyon çağırma ifadesinin ürettiği değer, ilgili fonksiyonun ürettiği (eğer üretiyorsa) geri dönüş değeridir. Yukarıdaki örnekte önce hesapla() fonksiyonu çağırılacak daha sonra fonksiyonun icra edilmesiyle oluşan geri dönüş değeri sonuc değişkenine atanacaktır.

Fonksiyonların geri dönüş değerleri nesne değildir yani sol taraf değeri (L value) değildir. Yani C dilinde aşağıdaki gibi bir atama her zaman hata verecektir:

hesapla() = 5; /* hata (L value required) */

Fonksiyonların geri dönüş değerleri sağ taraf değeri (R value) dir.

sonuc = hesapla1() + hesapla2() + x + 10;

gibi bir ifade geçerlidir. çağırılmış olan hesapla1 ve hesapla2 fonksiyonları icra edilerek üretilen geri dönüş değerleri ile x değişkeni içindeki değer ve 10 sabiti toplanacaktır. İfadeden elde edilen değer sonuç değişkenine atanacaktır.

Fonksiyonlar ancak tanımlanmış fonskiyonların içerisinden çağırılabilirler. Blokların dışından fonksiyon çağırılamaz.

Çağıran fonksiyon ile çağırılan fonksiyonun her ikisi de aynı amaç kod içerisinde bulunmak zorunda değildir. Çağıran fonksiyon ile çağırılan fonksiyon farklı amaç kodlar içerisinde de bulunabilir. Çünkü derleme işlemi sırasında bir fonksiyonun çağırıldığını gören derleyici, amaç kod içerisine (yani .obj içine) çağırılan fonksiyonun adını ve çağırılış biçimini yazmaktadır. Çağıran fonksiyon ile çağırılan fonksiyon arasında bağlantı kurma işlemi, bağlama aşamasında, bağlayıcı program (linker) tarafından yapılır.

Bu nedenle tanımlanan bir fonksiyon içerisinde, var olmayan bir fonksiyon çağırılsa bile derleme aşamasında bir hata oluşmaz. Hata bağlama aşamasında oluşur. Çünkü bağlayıcı çağırılan fonksiyonu bulamayacaktır.

Bütün C programları çalışmaya main fonksiyonundan başlar. Programın başladığı nokta olma dışında main fonksiyonunun diğer fonksiyonlardan başka hiçbir farkı yoktur. main fonksiyonun icrası bitince program da sonlanır. Bir C programının çalışabilmesi için mutlaka bir main fonksiyonuna sahip olması gerekir. Eğer main fonksiyonu yoksa hata bağlama (linking) aşamasında bağlayıcı program tarafından bildirilecektir.

Standart C Fonksiyonları
Standard C fonksiyonları, C dilinin standarlaştırılmasından sonra, her derleyicide bulunması zorunlu hale getirilmiş fonksiyonlardır. Yani derleyicileri yazanlar mutlaka standard C fonksiyonlarını kendi derleyicilerinde tanımlamak zorundadırlar. Bu durum C dilinin taşınabilirliğini (portability) artıran ana faktörlerden biridir.

Bir fonksiyonun derleyiciyi yazanlar tarafından tanımlanmış ve derleyici paketine eklenmiş olması, o fonksiyonun standart C fonksiyonu olduğu anlamına gelmez. Derleyiciyi yazanlar programcının işini kolaylaştırmak için çok çeşitli fonksiyonları yazarak derleyici paketlerine eklerler. Ama bu tür fonksiyonların kullanılması durumunda, oluşturulan kaynak kodun başka bir derleyicide derlenebilmesi yönünde bir garanti yoktur, yani artık kaynak kodun taşınabilirliği azalır. Örneğin printf fonksiyonu standart bir C fonksiyonudur. Yani printf fonksiyonu her derleyici paketinde aynı isimle bulunmak zorundadır.

Standart C fonksiyonları özel kütüphanelerin içerisinde bulunurlar. Başlık dosyaları içinde, yani uzantısı .h biçiminde olan dosyaların içinde standart C fonksiyonlarının prototipleri bulunmaktadır. Fonksiyon prototipleri konusu ileride detaylı olarak incelenecektir.

Kütüphaneler (libraries) derlenmiş dosyalardan oluşur. DOS'da kütüphane dosyalarının uzantısı .lib, UNIX'de ise .a (archive) biçimindedir. WINDOWS altında uzantısı .dll biçiminde olan dinamik kütüphaneler de bulunmaktadır.

Derleyicileri yazanlar tarafından kaynak kodu yazılmış standart C fonksiyonları önce derlenerek .obj haline getirilirler ve daha sonra aynı gruptaki diğer fonksiyonların .obj halleriyle birlikte kütüphane dosyalarının içine yerleştirilirler. Standart C fonksiyonları bağlama aşamasında, bağlayıcı (linker) tarafından çalışabilir (.exe) kod içerisine yazılırlar. Entegre çalışan derleyicilerde bağlayıcılar amaç kod içerisinde bulamadıkları fonksiyonları, yerleri önceden belirlenmiş kütüphaneler içinde ararlar. Oysa komut satırlı uyarlamalarında (command line version) bağlayıcıların hangi kütüphanelere bakacağı komut satırında belirtilir.

Standart fonksiyonlarını kullanmak programların taşınabilirliğini artırdığı gibi proje geliştirme süresini de kısaltır. Bu yüzden iyi bir C programcısının C dilinin standart fonksiyonlarını çok iyi tanıması ve bu fonksiyonları yetkin bir şekilde kullanabilmesi gerekmektedir.
Fonksiyonların Geri Dönüş Değerlerinin Oluşturulması
C dilinde fonksiyonların geri dönüş değerleri return anahtar sözcüğü ile oluşturulur. return anahtar sözcüğünün bir başka işlevi de içinde bulunduğu fonksiyonu sonlandırmasıdır.

#include

int sample(void)
{
int x = 10; int y = 20;

return x * y;
}

int main()
{
int c;

c = sample();
printf("c = %d\n", c);

return 0;
}

Yukarıdaki örnekteki sample fonksiyonunda return anahtar sözcüğünün yanında yer alan x * y ifadesi sample fonksiyonunu sonlandırmakta ve sample fonksiyonunun geri dönüş değerini oluşturmaktadır. Fonksiyonun geri dönüş değeri, main fonksiyonu içinde c değişkenine atanmış ve daha sonra standart C fonksiyonu olan printf ile c fonksiyonunun değeri ekrana yazdırılmıştır. fonksiyonun geri dönüş değerini başka bir değişkene atamadan aşağıdaki ifade ile de doğrudan ekrana yazdırabilirdik :

printf("%d\n", sample());

Aynı örnekte main fonksiyonu içinde de bir return ifadesinin yer aldığı görülmektedir. main de bir fonksiyondur ve main fonksiyonunun da bir geri dönüş değeri olabilir. main fonksiyonun geri dönüş değeri programın icrası bittikten sonra işletim sistemine bildirilmektedir. main fonksiyonunun başına bir geri dönüş değer türü yazılmazsa derleyiciler main fonksiyonunun geri dönüş değerinin int türden olduğunu varsayarlar. Özellikle yeni derleyiciler, tanımlamalarında bir geri dönüş değeri üretecekleri belirtilen fonksiyonlarının, return anahtar sözcüğüyle geri dönüş değeri üretmemelerini bir uyarı (warning) mesajı ile bildirirler. Borland derleyicilerinde bu uyarı mesajı genellikle "warning : function should return a value..." şeklindedir. Bu uyarı mesajını kesmek için iki yol vardır:

1. main fonksiyonu da yukarıdaki örnekte olduğu gibi int türden bir geri dönüş değeri üretir. Geleneksel olarak bu değer 0 ise programın problemsiz bir şekilde sonlandırıldığı anlamına gelir.

2. main fonksiyonunun başına void anahtar sözcüğü yazılarak bu fonksiyonun bir geri dönüş değeri üretmeyeceği derleyiciye bildirilir. Bu durumda derleyici geri dönüş değeri beklemediği için bir uyarı mesajı göndermez.

return anahtar sözcüğünün kullanılması zorunlu değildir. Bir fonksiyon içinde return anahtar sözcüğü kullanılmamışsa fonksiyonun icrası, fonksiyonun ana bloğunun sonuna gelindiğinde otomatik olarak biter. Tabi bu tür bir fonksiyon anlamlı bir şekilde bir geri dönüş değeri üretemeyecektir. Bir geri dönüş değerine sahip olacak şekilde tanımlanmış fakat return ile geri dönüş değeri oluşturulmamış fonksiyonlar rastgele bir değer döndürürler.

return anahtar sözcüğünden sonra parantez kullanılabilir ama parantez kullanımı zorunlu değildir. Okunabilirlik açısından özellikle uzun return ifadelerinde parantez kullanımı tavsiye edilmektedir.

return (a * b - c * d);

return 5; /* return ifadesinin değişken içermesi bir zorunluluk değildir. Bir fonksiyon sabit bir değerle de geri dönebilir. */

return sample();

Bu örnekte return anahtar sözcüğünden sonra bir fonksiyon çağırma ifadesi yer almaktadır. Bu durumda önce çağırılan fonksiyon icra edilir, ve geri dönüş değeri elde edilir, daha sonra elde edilen geri dönüş değeri tanımlanması yapılan fonksiyonun da geri dönüş değeri yapılmaktadır.

Geri dönüş değeri olmayan fonksiyonlarda return anahtar sözcüğü yanında bir ifade olmaksızın tek başına da kullanılabilir :

return;

Bu durumda return içinde yer aldığı fonksiyonu geri dönüş değerini oluşturmadan sonlandırır.

C dilinde fonksiyonlar yalnızca bir geri dönüş değeri üretebilirler. Bu da fonksiyonların kendilerini çağıran fonksiyonlara ancak bir tane değeri geri gönderebilmeleri anlamına gelmektedir. Ancak, fonksiyonların birden fazla değeri ya da bilgiyi kendilerini çağıran fonksiyonlara iletmeleri gerekiyorsa, C dilinde bunu sağlayacak başka mekanizmalar vardır ve bu mekanizmalar ileride detaylı olarak incelenecektir.

Fonksiyonların ürettiği geri dönüş değerlerinin kullanılması yönünde bir zorunluluk yoktur. Örneğin fonk() fonksiyonu int türden bir değeri geri dönen bir fonksiyon olsun:

a = fonk();

yukarıdaki ifadese fonk fonksiyonunun geri dönüş değeri a değişkenine atanmaktadır. Dolayısıyla biz bu fonksiyonu bir kez çağırmamıza karşın artık geri dönüş değerini a değişkeninede tuttuğumuz için, bu geri dönüş değerine fonksiyonu tekrar çağırmadan istediğimiz zaman ulaşabiliriz. Ancak:

fonk();

şeklinde bir fonksiyon çağırma ifadesinde artık geri dönüş değeri bir değişkende saklanmamakatdır. Bu duruma geri dönüş değerinin kullanılmaması denir. (discarded return value).
Örneğin standart bir C fonksiyonu olan printf fonksiyonun da bir geri dönüş değeri vardır (printf fonksiyonu ekrana bastırılan toplam karakter sayısına geri döner) ama bu geri dönüş değeri nadiren kullanılır.

Fonksiyon Parametre Değişkenlerinin Tanımlanması
Bir fonksiyonun parametreleri ya da parametre değişkenleri fonksiyonların kendilerini çağıran fonksiyonlardan aldıkları girdileri tutan değişkenleridir. Bir fonksiyonun parametre sayısı ve bu parametrelerin türleri gibi bilgiler, fonksiyonların tanımlanması sıarsında derleyicilere bildirilirler.

C dilinde fonksiyonların tanımlanmasında kullanılan 2 temel biçim vardır. Bu biçimler birbirlerinden fonksiyon parametrelerinin derleyicilere tanıtılma şekli ile ayrılırlar. Bu biçimlerden birincisi eski biçim (old style) ikincisi ise yeni biçim (new style) olarak adlandırılır.

Artık eski biçim hemen hemen hiç kullanılmamaktadır, ama C standartlarına göre halen geçerliliğini korumaktadır. Kullanılması tavsiye edilen kesinlikle yeni biçimdir ancak eski kodların ya da eski kaynak kitapların incelenmesi durumunda bunların anlaşılabilmesi için eski biçimin de öğrenilmesi gerekmektedir.

Eski Biçim (old style)
Bu biçimde fonksiyonun parametre değişkenlerinin yalnızca ismi fonksiyon parantezleri içinde yazılır. (Eğer parametre değişkenleri birden fazla ise aralarına virgül koyulur. Daha sonra alt satıra geçilerek bu değişkenlerin bildirimi yapılır. Bu bildirimler daha önce öğrendiğimiz, C dilinin bildirim kurallarına uygun olarak yapılır. Örnek :

double alan(x, y)
int x, y;
{
return x * y;
}

Yukarıda tanımlanan alan fonksiyonunun iki parametre değişkeni vardır ve bu parametre değişkenlerinin isimleri x ve y'dir. Her iki parametre değişkeni de int türdendir.

int sample (a, b, c)
int a;
double b;
long c;
{
...
}

Bu örnekte ise sample fonksiyonu üç parametre almaktadır. Parametre değişkenlerinin isimleri a, b ve c'dir. İsmi a olan parametre değişkeni int türden, b olanı double türden ve ismi c olanı ise long türdendir.

Eski biçimin dezavantajı gereksiz yere uzun oluşudur. Çünkü fonksiyon parantezelerinin içinde parametre değişkenlerinin isimi yer almakta sonra tekrar bu isimler alt satırlarda yeniden kullanılarak bildirim yapılmaktadır.

Yeni Biçim (new style)
Yeni biçim eski biçime göre hem daha kısadır hem de okunabilmesi eski biçime göre çok daha kolaydır.

Yeni biçimde fonksiyon parametre değişkenlerinin bildirimi fonksiyon parantezelerinin içinde yalnızca bir kez yapılmaktadır. Bu biçimde fonksiyonun parantezlerinin içine parametre değişkenin türü ve yanına da ismi yazılır. Eğer birden fazla fonksiyon parametre değişkeni varsa bunlar virgüllerle ayrılır ancak her defasında tür bilgisi yeniden yazılır . Örnek :

int sample (int x, int y)
{
...
}

int fonk(double x, int y)
{
...
}

Bu biçimde dikkat edilmesi gereken önemli nokta, fonksiyon parametre değişkenleri aynı türden olsalar bile her defasında tür bilgisinin tekrar yazılması zorunluluğudur. Örneğin :

int sample (double x, y) /* error */
{
...
}

bildirimi hatalıdır. Doğru tanımlamanın aşağıdaki şekilde olması gerekir:

int sample (double x, double y)
{
...
}

Klavyeden Karakter Alan C Fonskiyonları
Sistemlerin hemen hemen hepsinde klavyeden karakter alan 3 ayrı C fonksiyonu bulunur. Bu fonksiyonların biri tam olarak standarttır ama diğer ikisi sistemlerin hemen hemen hepsinde bulunmasına karşın tam olarak standart değildir.

getchar Fonksiyonu
int getchar(void);

getchar standart bir C fonksiyonudur. Geri dönüş değeri klavyeden alınan karakterin ASCII tablosundaki sıra numarasını gösteren int türden bir sayıdır. getchar fonskiyonu klavyeden karakter almak için enter tuşuna ihtiyaç duyar.

Aşağıda yazılan programda önce klavyeden bir karakter alınmış daha sonra alınan karakter ve karakterin sayısal karşılıkları ekrana yazdırılmıştır. (getchar fonksiyonunun geri dönüş değeri klavyede basılan tuşa ilişkin karakterin sistemde kullanılan karakter seti tablosundaki sıra numarasıdır.)

#include

int main()
{
char ch;

ch = getchar();
printf("\nKarakter olarak ch = %c\nASCII numarası ch = %d\n", ch, ch);
return 0;
}

getchar derleyicilerin çoğunda stdio.h dosyasında bir makro olarak tanımlanmıştır. Makrolar konusunu daha ileride inceleyeceğiz.
getch Fonksiyonu
int getch(void);

getchar fonksiyonu gibi bu fonksiyonda klavyede basılan tuşun kullanılan karakter setindeki sıra numarasıyla geri döner. getchar fonksiyonundan iki farkı vardır.
1. Basılan tuş ekranda görünmez.
2. Enter tuşuna ihtiyaç duymaz.

Yukarıda verilen programda getchar yerine getch yazarak programı çalıştırırsanız farkı daha iyi görebilirsiniz.

Tam olarak standardize edilmemiştir ama neredeyse bütün sistemlerde bulunur. getch fonksiyonu özellikle tuş bekleme ya da onaylama amacıyla kullanılmaktadır:

....
printf("devam için herhangi bir tuşa basınız...\n");
getch();

Burada basılacak tuşun programcı açısından bir önemi olmadığı için fonksiyonun geri dönüş değeri kullanılmamıştır.

getche Fonksiyonu
int getche(void);

getche İngilizce get char echo sözcüklerinden gelmektedir. getche fonksiyonu da basılan tuşun karakter setindeki sıra numarasıyla geri döner ve enter tuşuna gereksinim duymaz. Ama basılan tuşa ilişkin karakter ekranda görünür.

getchar
enter tuşuna ihtiyaç duyar
alınan karakter ekranda görünür.
getch
enter tuşuna ihtiyaç duymaz
alınan karakter ekranda görünmez
getche
enter tuşuna ihtiyaç duymaz
alınan karakter ekranda görünür.

Ekrana Bir Karakterin Görüntüsünü Yazan C Fonksiyonları
C dilinde ekrana karakter yazamakta iki fonksiyonun kullanıldığı görülür :

putchar Fonksiyonu
int putchar(int ch);

putchar standart bir C fonksiyonudur. Bütün sistemlerde bulunması zorunludur. Parametresi olan karakteri ekranda imlecin bulunduğu yere yazar. Örneğin:

#include

main()
{
char ch;

ch = getchar();
putchar (ch);
return 0;
}

Burada putchar fonksiyonunun yaptığı işi printf fonksiyonuna da yaptırabilirdik;

printf("%c", ch);

putchar(ch) ile tamamen aynı işleve sahiptir.

putchar fonksiyonu ile '\n' karakterini yazdırdığımızda printf fonksiyonunda olduğu gibi imleç sonraki satırın başına geçer. putchar fonksiyonu ekrana yazılan karakterin ASCII karşılığı ile geri dönmektedir.

putchar fonksiyonu derleyicilerin çoğunda stdio.h dosyası içinde bir makro olarak tanımlanmıştır. Makrolar konusunu ileriki derslerde detaylı olarak öğreneceğiz.

putch Fonksiyonu
int putch(int ch);

putch standart bir C fonksiyonu değildir. Dolayısıyla sistemlerin hepsinde bulunmayabilir. Bu fonksiyonun putchar fonksiyonundan tek farkı '\n' karakterinin yazdırılması sırasında ortaya çıkar. putch, '\n" karakterine karşılık yalnızca LF(line feed) (ASCII 10) karakterini yazmaktadır. Bu durum imlecin bulunduğu kolonu değiştirmeksizin aşağı satıra geçmesine yol açar.

printf Fonksiyonu

Değişkenlerin içerisindeki değerler aslında bellekte ikilik sistemde tutulmaktadır. Bir değişkenin içerisindeki değerin ekrana, kaçlık sistemde ve nasıl yazdırılacağı programcının isteğine bağlıdır. Değişkenlerin içerisindeki değerlerin ekrana yazdırılmasında printf fonksiyonu kullanılır. printf standart bir C fonksiyonudur.

printf aslında çok ayrıntılı özelliklere sahip bir fonksiyondur. Burada yalnızca temel özellikleri görsel bir biçimde açıklanacaktır. printf iki tırnak içerisindeki karakterleri ekrana yazar. Ancak iki tırnak içinde gördüğü % karakterlerini ekrana yazmaz. printf fonksiyonu % karakterlerini yanındaki karakter ile birlikte format karakteri olarak yorumlar. Format karakterleri iki tırnaktan sonra yazılan parametrelerle birebir eşleştirilir. Örnek:

int x, y;

x = 125;
y = 200;
printf("x = %d\ny = %d\n", x, y);

printf fonksiyonunun yukarıdaki şekilde çağırılmasıyla x ve y değişkeni içindeki değerler ekrana onluk sistemde yazdırılacaktır.

Format karakterleri yerine eşlenen değişkenlerin içerisindeki değerler ekrana yazılır. Format karakterleri sayıların ekrana nasıl yazılacağını belirtmekte kullanılır.

format karakteri
Anlamı

%d
int türünü desimal sistemde yazar.
%ld
long türünü desimal sistemde yazar
%x
unsigned int türünü hexadecimal sistemde yazar.
%X
unsigned int türünü hexadecimal sistemde yazar.(semboller büyük harfle)
%lx
unsigned long türünü hexadecimal sistemde yazar.
%u
unsigned int türünü decimal sistemde yazar.
%o
unsigned int türünü oktal sistemde yazar.
%f
float ve double türlerini desimal sistemde yazar.
%lf
double türünü desimal sistemde yazar.
%e
gerçek sayıları üstel biçimde yazar.
%c
char veya int türünü karakter görüntüsü olarak yazdırır.
%s
string olarak yazdırır.
%lf
long double türünü desimal sistemde yazdırır.

Yukarıdaki tabloda görüldüğü gibi double türü hem %f format karakteri hem de %lf format karakteri ile yazdırılabilmektedir. Ama %lf (okunabiliriliği artırdığı için) daha çok tercih edilmektedir.

Yukarıdaki tabloya göre unsigned int türünden bir sayıyı aşağıdaki şekillerde yazdırabiliriz :

unsigned int u;

printf("%u", u); /* u sayısını 10'luk sistemde yazar */
printf("%o, u); /* u sayısını 8'lik sistemde yazar */
printf("%x, u); /* u sayısını 16'lık sistemde yazar */

short bir sayıyı yazarken d o u ya da x karakterlerinden önce h karakterini kullanıyoruz :

short int sh;

printf("%hd", sh); /* 10'luk sistemde yazar */

unsigned short int unsh;

printf("%hu", unsh); /* 10'luk sistemde yazar */
printf("%ho", unsh); /* 8'lik sistemde yazar */
printf("%hx", unsh); /* 16'lık sistemde yazar */

long bir sayıyı yazarken d o u ya da x karakterlerinden önce l karakterini kullanıyoruz :

long int lo;

printf("%ld", lo); /* 10'luk sistemde yazar */

unsigned long int unlo;

printf("%lu", unlo); /* 10'luk sistemde yazar */
printf("%lo", unlo); /* 8'lik sistemde yazar */
printf("%lx", unlo); /* 16'lık sistemde yazar */

Yukarıdaki bilgilerde unsigned bir tamsayıyı printf fonksiyonuyla 8'lik ya da 16'lık sistemde yazdırabileceğimizi gördük. Peki signed bir tamsayıyı 8'lik ya da 16'lık sistemde yazdıramaz mıyız? Yazdırırsak ne olur? Sözkonusu signed tamsayı pozitif olduğu sürece bir sorun olmaz. Sayının işaret biri 0 olduğu için sayının nicel büyüklüğünü etkilemez. Yani doğru sayı ekrana yazar, ama sayı negatifse işaret biti 1 demektir. Bu durumda ekrana yazılacak sayının işaret biti de nicel büyüklüğün bir parçası olarak değerlendirilerek yazılır. Yani yazılan değer doğru olmayacaktır.

% karakterinin yanında önceden belirlenmiş bir format karakteri yoksa , % karakterinin yanındaki karakter ekrana yazılır.

%% (%) karakterini yaz anlamına gelir.

scanf Fonksiyonu
scanf fonksiyonu klavyeden her türlü bilginin girişine olanak tanıyan standart bir C fonksiyonudur. scanf fonksiyonu da printf fonksiyonu gibi aslında çok detaylı, geniş kullanım özellikleri olan bir fonksiyondur. Ancak biz bu noktada scanf fonksiyonunu yüzeysel bir şekilde tanıyacağız.

scanf fonksiyonunun da birinci parametresi bir stringdir. Ancak bu string klavyeden alınacak bilgilere ilişkin format karakterlerini içerir. Bu format karakterleri önceden belirlenmiştir ve % karakterinin yanında yer alırlar. scanf fonksiyonunun kullandığı format karakterlerinin printf fonksiyonunda kullanılanlar ile aynı olduğunu söyleyebiliriz. Yalnızca gerçek sayılara ilişkin format karakterlerinde önemli bir farklılık vardır. printf fonksiyonu %f formatı ile hem float hem de double türden verileri ekrana yazabilirken scanf fonksiyonu %f format karakterini yalnızca float türden veriler için kullanır. double tür için scanf fonksiyonunun kullandığı format karakterleri %lf şeklindedir. scanf fonksiyonunun format kısmında format karakterlerinden başka bir şey olmamalıdır. printf fonksiyonu çift tırnak içindeki format karakterleri dışındaki karakterleri ekrana yazıyordu, ancak scanf fonksiyonu format karakterleri dışında string içine yazılan karakterleri ekrana basmaz, bu karakterler tamamen başka anlama gelecektir. Bu nedenle fonksiyonun nasıl çalıştığını öğrenmeden bu bölgeye format karakterlerinden başka bir şey koymayınız. Buraya konulacak bir boşluk bile farklı anlama gelmektedir.

int x, y;

scanf(“%d%d”, &x, &y);

Yukarıdaki örnekte x ve y sayıları için desimal sistemde klavyeden giriş yapılmaktadır. Giriş arasına istenildiği kadar boşluk karakteri konulabilir. Yani ilk sayıyı girdikten sonra ikinci sayıyı SPACE, TAB ya da ENTER tuşuna bastıktan sonra girebilirsiniz. Örneğin:

5 60

biçiminde bir giriş geçerli olacağı gibi;

5
60

biçiminde bir giriş de geçerlidir. scanf fonksiyonuna gönderilecek diğer argumanlar & operatörü ile kullanılmaktadır. & bir gösterici operatörüdür. Bu operatörü göstericiler konusunda öğreneceğiz.

scanf fonksiyonunun yalnızca giriş için kullanılır, ekrana yazmak için printf fonksiyonunu kullanmamız gerekir :

int number;

printf(“bir sayi giriniz : “);
scanf(“%d”, &number);

C++ dilinde bir fonksiyon tanımlanmasında fonksiyonun geri dönüş değerinin türü olarak void anahtar sözcüğü yazılmamışsa, fonksiyon return anahtar sözcüğü kullanılarak mutlaka bir geri dönüş değeri üretmelidir. Fonksiyonun geri dönüş değeri üretmemesi durumunda derleme zamanında hata oluşacaktır. Yani C dilinde olduğu gibi rasgele bir değer üretilmesi söz konusu değildir. Yine C++ dilinde geri dönüş değeri üretecek bir fonksiyonun tanımlanması içinde return anahtar sözcüğü yalın olarak kullanılamaz. return anahtar sözcüğünün yanında mutlaka bir ifade yer almalıdır.

c de dosyalar

2007-12-08T09:53:00.001-08:00

DOSYALAR

İkincil bellekte tanımlanmış bölgelere dosya denir. Her dosyanın bir ismi vardır. Ancak dosyaların isimlendirme kuralları sistemden sisteme göre değişebilmektedir. Dosya işlemleri tamamen işletim sisteminin kontrolü altındadır.

İşletim sistemi de ayrı ayrı yazılmış fonksiyonların birbirlerini çağırması biçiminde çalışır. Örneğin komut satırında ismi yazılmış olan bir programın çalıştırılması birkaç sistem fonksiyonunun çağırılması ile yapılmaktadır. Komut satırından yazıyı alan, diskte bir dosyayı arayan, bir dosyayı RAM’e yükleyen, RAM’deki programı çalıştıran fonksiyonlar düzenli olarak çağırılmaktadır.

İşletim sisteminin çalışması sırasında kendisinin de çağırdığı, sistem programcısının da dışarıdan çağırabildiği işletim sistemine ait fonksiyonlara sistem fonksiyonları denir. Bu tür fonksiyonlara Windows sisteminde API (Application Proggramming Interface) fonksiyonları, UNIX işletim sisteminde ise sistem çağırmaları (system calls) denir.
Aslında bütün dosya işlemleri, hangi programlama dili ile çalışılırsa çalışılsın, işletim sisteminin sistem fonksiyonları tarafından yapılır. Sistem fonksiyonlarının isimleri ve parametrik yapıları sistemden sisteme değişebilmektedir.
Dosyalara İlişkin Temel Kavramlar
Dosyanın Açılması
Bir dosya üzerinde işlem yapmadan önce dosya açılmalıdır. Dosya açabilmek için işletim sisteminin “dosya aç” isimli bir sistem fonksiyonu kullanılır. Dosyanın açılması sırasında dosya ile ilgili çeşitli ilk işlemler işletim sistemi tarafından yapılır.

Bir dosya açıldığında, dosya bilgileri, ismine “Dosya Tablosu” (File table) denilen ve işletim sisteminin içerisinde bulunan bir tabloya yazılır. Dosya tablosunun biçimi sistemden siteme değişebilir. Örneğin tipik bir dosya tablosu şağıdaki gibi olabilir :

Dosya tablosu (File table)
Sıra No
Dosya ismi
Dosyanın Diskteki Yeri
Dosyanın Özellikleri
Diğerleri
0

1

...

12
AUTOEXEC.BAT
...
...
...
...

Sistem fonksiyonlarının da parametreleri ve geri dönüş değerleri vardır. "Dosya aç" sistem fonksiyonunun parametresi açılacak dosyanın ismidir.Fonksiyon, dosya bilgilerinin yazıldığı sıra numarası ile geri döner ki bu değere "file handle" denir. Bu handle değeri diğer dosya fonksiyonlarına parametre olarak geçirilir. Dosyanın açılması sırasında buna ek olarak başka önemli işlemler de yapılmaktadır.
Dosyanın Kapatılması
Dosyanın kapatılması açılması sırasında yapılan işlemlerin geri alınmasını sağlar. Örneğin dosyanın kapatılması sırasında, işletim sisteminin dosya tablosunda bulunan bu dosyaya ilişkin bilgiler silinir. Açılan her dosya kapatılmalıdır. Kapatılmaması çeşitli problemlere yol açabilir.
Dosyaya Bilgi Yazılması ve Okunması
İşletim sistemlerinin dosyaya n byte veri yazan ve dosyadan n byte veri okuyan sistem fonksiyonları vardır. Yazma ve okuma işlemleri bu fonksiyonlar kullanılarak yapılır.
Dosya pozisyon göstericisi (file pointer)
Bir dosya byte’lardan oluşur. Dosyadaki her bir byte’a 0’dan başlayarak artan sırada bir sayı karşılık getirilmiştir. Bu sayıya ilgili byte’ın ofset numarası denir. Dosya pozisyon göstericisi long türden bir sayıdır ve bir ofset değeri belirtir. Dosyaya yazan ve dosyadan okuma yapan fonksiyonlar bu yazma ve okuma işlemlerini her zaman dosya pozisyon göstericisinin gösterdiği yerden yaparlar. Örneğin dosya göstericisinin gösterdiği yer 100 olsun. Dosyadan 10 byte bilgi okumak için sistem fonksiyonu çağırıldığında, 100. ofsetden itibaren 10 byte bilgi okunur. İşletim sisteminin dosya göstericisini konumlandıran bir sistem fonksiyonu vardır. Dosya ilk açıldığında dosya göstericisi 0. ofsetdedir. Örneğin bir dosyanın 100. Ofsetinden itibaren 10 byte okunmak istenirse sırası ile şu işlemlerin yapılması gerekir:

İlgili dosya açılır.
Dosya pozisyon göstericisi 100. Offsete konumlandırılır.
Dosyadan 10 byte okunur.
Dosya kapatılır.

C dilinde dosya işlemleri 2 biçimde yapılabilir :

1. İşletim sisteminin sistem fonksiyonları doğrudan çağırılarak.
2. Standart C fonksiyonları kullanılarak.

Prototipleri stdio.h içerisinde olan standart dosya fonksiyonlarının hepsinin ismi f ile başlar.Tabi standart C fonksiyonları da işlemlerini yapabilmek için aslında işletim sisteminin sistem fonksiyonlarını çağırmaktadır. İşletim sisteminin sistem fonksiyonları taşınabilir değildir. İsimleri ve parametrik yapıları sistemden sisteme değişebilir. Bu yüzden standart C fonksiyonlarının kullanılması tavsiye edilir.
fopen fonksiyonu
FILE *fopen (const char *fname, const char *mode)

Fonksiyonun 1. Parametresi açılacak dosyanın ismidir. 2. Parametre açış modudur. Dosya ismi path içerebilir. Dizin geçişleri için / de konulabilir. Açış modu şunlar olabilir :

Mode
Anlamı
"w"
Dosyayı yazmak için açar. Dosyadan okuma yapılamaz. Dosyanın mevcut olaması zorunlu değildir. Dosya mevcut değilse yaratılır. Dosya mevcut ise sıfırlanır.
"w+"
Dosyayı yazma ve okuma için açar. Dosyanın mevcut olaması zorunlu değildir. Dosya mevcut değilse yaratılır. Dosya mevcut ise sıfırlanır.
"r"
Dosyayı okuma için açar. Dosyaya yazma yapılamaz. Dosya mevcut değilse açılamaz.
"r+"
Dosyayı okuma ve yazma için açar. (Dosyanın pozisyon göstericisi dosyanın başındadır). Dosya mevcut değilse açılamaz.
"a"
Dosyayı sonuna ekleme için açar. Dosyadan okuma yapılamaz. Dosyanın mevcut olaması zorunlu değildir. Dosya mevcut değilse yaratılır.
"a+"
Dosyayı sonuna ekleme ve dosyadan okuma için açar. Dosyanın mevcut olaması zorunlu değildir. Dosya mevcut değilse yaratılır.

Fonksiyonun geri dönüş değerine ilişkin FILE yapısı stdio.h içerisinde bildirilmiştir. Fonskiyonun geri dönüş değeri FILE yapısı türünden bir adrestir. Bu yapının elemanları standart değildir. Sistemden sisteme değişiklik gösterebilir. Zaten programcı bu yapının elemanlarına gereksinim duymaz. fopen fonksiyonu işletim sisteminin dosya aç sistem fonksiyonunu çağırarak dosyayı açar ve dosyaya ilişkin bazı bilgileri bu FILE yapısı içerisine yazarak bu yapının başlangıç adresini geri döndürür. Örneğin "file handle" değeri de bu yapının içerisindedir. Tabi fopen fonksiyonunun geri verdiği FILE türünden adres güvenli bir adrestir. Dosya çeşitli sebeplerden dolayı açılamayabilir. Bu durumda fopen NULL gösterici döndürür. Fonksiyonun geri dönüş değeri kesinlikle kontrol edilmelidir. Tipik bir kontrol işlemi aşağıdaki gibi yapılabilir:

if ((f = fopen(“data”, “r”)) == NULL) {
printf(“cannot open file”...\n);
exit(1);}

Dosya ismi dosyanın yeri hakkında bilgi (sürücü, path gibi) içerebilir. Dosya ismi string ile veriliyorsa path bilgisi verirken dikkatli olmak gerekecektir. path bilgisi \ karakteri içerebilir. string içinde \ karakterinin kullanılması, \ karakterininin onu izleyen karakterle birlikte önceden belirlenmiş ters bölü karakter sabiti olarak yorunlanmasına yol açabilecektir. Örneğin :

fopen("C:\source\new.dat", "r");

fonksiyon çağırımında derleyici \n karakterini "newline" karakteri olarak yorumlayacak \s karakterini ise "undefined" kabul edecektir. Bu problemden sakınmak \ yerine \\ kullanılmasıyla mümkün olur:

fopen("C:\\source\\new.dat", "r");

Append modları ("a", "a+") çok kullanılan modlar değildir. Dosyaya yazma durumunda "w" modu ile "a" modu arasında farklılık vardır. "w" modunda dosyada olan ofsetin üzerine yazılabilir. "a" modunda ise dosya içeriği korunarak sadece dosyanın sonuna yazma işlemi yapılabilir. Bir dosyanın hem okuma hem de yazma amacıyla açılması durumunda (yani açış modunu belirten stringde '+' karakterinin kullanılması durumunda dikkatli olmak gerekir. Okuma ve yazma işlemleri arasında mutlaka ya dosya pozisyon göstericisinin konumlandırılması (mesela fseek fonksiyonu ile) ya da dosyaya ilişken tampon bellek alanının (buffer) tazelenmesi gerekecektir.

Bir dosyanın açılıp açılamayacağını aşağıdaki şekilde test edebiliri:

Program komut satırından

canopen dosya.dat

şeklinde çalıştırıldığında ekrana "xxxxx dosyası açılabilir" ya da "xxxxx dosyası açılamaz" yazacaktır.

#include

int main(int argc, char *argv[])
{
FILE *fp;

if (argc != 2) {
printf("usage: canopen filename\n");
return 2;
}
if ((fp = fopen(argv[1], "r")) == NULL) {
printf("%s dosyası açılamaz\n", argv[1]);
return 1;
}
printf("%s dosyası açılabilir\n", argv[1]);
fclose(fp);
return 0;
}
fclose fonksiyonu
int fclose(FILE *stream);
Bu fonksiyon açılmış olan bir dosyayı kapatır. Fonksiyon fopen ya da fropen fonksiyonundan elde edilen FILE yapısı türünden adresi parametre olarak alır ve açık olan dosyayı kapatır. Fonksiyonun geri dönüş değeri 0 ise dosya başarılı olarak kapatılmıştır. Fonksiyonun geri dönüş değeri EOF ise dosya kapatılamamıştır. EOF stdio.h içinde tanımlanan bir sembolik sabittir ve derleyicilerin çoğunda (-1) olarak tanımlanmıştır. Fonksiyonun başarısı ancak şüphe altında test edilmelidir. Normal şartlar altında dosyanın kapatılmaması için bir neden yoktur.

int main()
{
FILE *f;

if ((f = fopen(“data”, “w”)) ==NULL) {
printf(“cannot open file”...\n);
exit(1);
}
fclose(f);
return 0;
}

fgetc fonksiyonu
int fgetc(FILE *f);

İşletim sisteminin dolayısıyla C’nin yazma ve okuma yapan fonksiyonları yazılan ve okunan miktar kadar dosya göstericisini ilerletirler. fgetc fonksiyonu dosya göstericisinin gösterdiği yerdeki byte’ı okur ve geri dönüş değeri olarak verir. Fonksiyon başarısız olursa , stdio.h dosyası içerisinde sembolik sabit olarak tanımlanmış EOF değerine geri döner. Pek çok derleyici de EOF sembolik sabiti aşağıdaki gibi tanımlanmıştır.

#define EOF (-1)

fgetc fonksiyonunun geri dönüş değerini char türden bir değişkene atamak yanlış sonuç verebilir, bu konuda dikkatli olunmalı ve fonksiyonun geri dönüş değeri int türden bir değişkende saklanmalıdır.

char ch;
...
ch = fgetc(fp);

Yukarıda dosyadan okunan karakterin 255 numaralı ASCII karakteri (0x00FF) olduğunu düşünelim. Bu sayı char türden bir değişkene atandığında yüksek anlamlı byte'ı kaybedilecek ve ch değişkenine 0xFF değeri atanacaktır. Bu durumda ch değişkeni işaretli char türden olduğundan ch değişkeni içinde negatif bir sayının tutulduğu anlamı çıkar.

if (ch == EOF)

gibi bir karşılaştırma deyiminde, if parantezi içerisindeki karşılatırma işleminin yapılabilmesi için otomatik tür dönüşümü yapılır. Bu otomatik tür dönüşümünde işaretli int türüne çevrilecek ch değişkeni FF byte'ı ile beslenecektir. (negatif olduğu için). Bu durumda eşitlik karşılaştırması doğru netice verecek, yani dosyanın sonuna gelindiği (ya da başka nedenden dolayı okumanın yapılamadığı) yorumu yapılacaktır.

Oysa ch değişkeni int türden olsaydı, ch değişkenine atanan değer 0x00FF olacak ve bu durumda karşılaştırma yapıldığında ch değişkeni ile EOF değerinin (0xFFFF) eşit olmadığı sonucuna varılacaktır.

Bir dosyanın içeriğini ekrana yazdıran örnek program:

#include

int main()
{
FILE *f;
char fname[MAX_PATH];
int ch;

printf(“Dosya ismi : “);
gets(fname);
if (f = fopen(fname, “r”)) == NULL) {
printf(“cannot open file...\n”);
exit(1);
}
while (ch = fgetc(f)) != EOF)
putchar(ch);
fclose(f);
return 0;
}

not : maximum path uzunluğu DOS’da 80 UNIX ve WINDOWS’da 256 karakteri geçemez.
fputc Fonksiyonu
int fputc(int ch, FILE *p);
Bu fonksiyon dosya göstericisinin bulunduğu yere 1 byte bilgiyi yazar. Fonksiyonun 1. parametresi yazılacak karakter, 2. parametresi ise yazılacak dosyaya ilişkin FILE yapısı adresidir. Fonksiyonun geri dönüş değeri EOF ise işlem başarısızdır. Değilse fonksiyon yazılan karakter ile geri döner.

fgetc ve fputc fonksiyonları kullanılarak bir dosyayı kopyalayan örnek program:

#include
#include

#define MAX_PATH 80

int main()
{
FILE *fsource, *fdest;
char source[MAX_PATH], dest[MAX_PATH];
int ch;

printf(“kopyalanacak dosya : “);
gets(source);
printf(“kopya dosya : “);
gets (dest);
if ((fsource = fopen(source, “r”)) == NULL) {
printf(“cannot open file...\n”);
exit(EXIT_FAILURE);
}
if ((fdest = fopen(dest, “w”)) == NULL) {
printf(“cannot create file...\n”);
exit(EXIT_FAILURE);
}
while ((ch = fgetc(fsource)) != EOF)
fputc(ch, fdest);
fclose(fsource);
fclose(fdest);
printf(“1 file copied...\n”);
return 0;
}

fprintf Fonksiyonu
Bu fonksiyon tıpkı printf fonksiyonu gibidir. Ancak ilk parametresi yazma işleminin hangi dosyaya yapılacağını belirtir. Diğer parametreleri printf fonksiyonun da olduğu gibidir. Özetle printf fonksiyonu ekrana yazar ancak fprint fonksiyonu 1. parametre değişkeninde belirtilen dosyaya yazar.

#include
#include

#define MAX_PATH 80

int main()
{
FILE *f;
int i;

if ((f = fopen(“data”, “w”)) ==NULL) {
printf(“cannot open file...\n");
exit(1);
}
for (i = 0; i < 10; ++i)
fprintf(f, “sayi = %d\n”, i);
fclose(f);

return 0;
}

fgets fonksiyonu
char *fgets(char *buf, int n, FILE *f);

Bu fonksiyon dosya göstericisinin gösterdiği yerden 1 satırlık bilgiyi okur. Fonksiyon dosyadan '\n' karakterini okuyunca onu da birinci parametresinde verilen adrese yazarak işlemini sonlandırır.

Fonksiyonun 1. parametresi okunacak bilginin RAM'de yerleştirileceği yerin adresidir. 2. parametresi ise okunacak maksimum karakter sayısıdır. fgets en fazla n –1 karakteri okur. Okuduğu karakterlerin soonuna null karakteri ekler ve işlemini sonlandırır. Eğer satır üzerindeki karakter sayısı n- 1'den az ise tüm satırı okur ve işlemini sonlandırır. Örneğin bu parametreyi 10 olarak girdiğimizi düşünelim. Satır üzerinde 20 karakter olsun. Fonksiyon 9 karakteri okur, sonuna NULL karakteri ekler. Ancak satır üzerinde \n dahil olmak üzere 5 karakter olsaydı fonksiyon bu 5 karakteri de okuyarak sonuna da NULL karakter ekleyerek işlemini sonlandıracaktı. Bir döngü içerisinde fgets fonksiyonu sürekli olarak çağırılarak bütün dosya okunabilir.

Fonksiyonun geri dönüş değeri, en az 1 karakter okunmuş ise 1. parametresi ile belirtilen adresin aynısı, hiç okunmamışsa NULL adresidir.

Örnek : Bir dosyayı fgets fonksiyonu ile satır satır olarak ekrana yazan program:

#define MAX_PATH 80
#define MBUFSIZE 100

int main()
{
FILE *f;
char s[MAX_PATH];
char buf[BUFSIZE];

printf(“Dosya : “);
gets(s);
if ((f = fopen(s, “r”)) == NULL) {
printf(“cannot open file...\n”);
exit(1);
}
while (fgets(buf, BUFSIZE, f) != NULL)
printf(“%s”, buf);
fclose(f);
return 0;
}
Text ve Binary Dosya Kavramları
DOS VE WINDOWS işletim sistemlerinde bir dosya text ve binary modda açılabilir. Varsayılan açış modu textdir. Yani dosyanın hangi modda açıldığı açık bir şekilde belirtilmezse dosyanın text modda açıldığı varsayılacaktır. Dosyayı binary modda açabilmek için açış modunun sonuna b eklemek gerekir. Örneğin :

f = fopen(“data”, “r”) text modda
f = fopen(“data, “rb”) binary modda

DOS’da bir dosya type edildiğinde bir karakter aşağı satırın başında görünüyorsa bunu sağlamak için o karakterden önce CR (carriage return) ve LF (line feed) karakterlerinin bulunması gerekir. CR karakteri C’de ‘\r’ ile belirtilir. 13 numaralı ASCII karakteridir. LF karakteri C’de \n ile belirtilir. 10 numaralı ASCII karakteridir. Örneğin bir dosya type edildiğinde görüntü

a
b

şeklinde olsun. Dosyadaki durum a\r\nb şeklindedir. Oysa UNIX sistemlerinde aşağı satırın başına geçebilmek için sadece LF karakteri kullanılmaktadır. UNIX de

a
b

görüntüsünün dosya karşılığı

a\nb biçimindedir.

DOS’da LF karakteri bulunulan satırın aşağısına geç CR karakteri ise bulunulan satırın başına geç anlamındadır. Örneğin DOS da bir bir dosyanın içeriği a\nb biçiminde ise dosya type edildiğinde
a
b

görüntüsü elde edilir. Eğer dosyanın içeriği a\rb biçiminde ise dosya type edildiğinde
b
görüntüsü elde edilir.

printf fonksiyonunda \n ekranda aşağı satırın başına geçme amacıyla kullanılır. Aslında biz printf fonksiyonunun 1. parametresi olan stringin içine \n yerleştirdiğimizde UNIX'de yalnızca \ni DOS'da ise \r ve\n ile bu geçiş sağlanır.

Text dosyaları ile rahat çalışabilmek için dosyalar text ve binary olarak ikiye ayrılmıştır. Bir dosya text modunda açıldığında dosyaya \n karakteri yazılmak istendiğinde dosya fonksiyonları otomatik olarak \r ve \n karakterlerini dosyaya yazarlar. Benze r bir biçimde dosya text modda açılmışsa dosya göstericisi \r\n çiftini gösteriyorsa dosyadan yalnızca /n karakteri okunur. DOS işletim sisteminde text ve binary dosyalar arasındaki başka bir fark da, CTRL Z (26 numaralı ASCII karakterinin) dosyayı sonlandırdığının varsayılmasıdır. Oysa dosya binary modda açıldığında böyle bir varsayım yapılmaz.

UNIX işletim sisteminde text modu ile binary mod arasında hiçbir fark yoktur. Yani UNIX işletim sisteminde dosyanın binary mod yerine text modunda açılmasının bir sakıncası olmayacaktır. Ancak DOS altında text dosyası olmayan bir dosyanın binary mod yerine text modunda açılmasının sakıncaları olabilir. Örneğin DOS altında bir exe dosyanın binary mod yerine text modda açıldığını düşünelim. Bu dosyada 10 numaralı ve 13 numaralı ASCII karakterleri yanyana bulunduğunda dosyadan yalnızca 1 byte okunacaktır. Aynı şekilde dosyadan 26 numaralı ASCII karakteri okunduğunda dosyadan artık başka bir okuma yapılamayacaktır. (Dosyanın sonuna gelindiği varsayılacaktır.)

/*
textmode.c programı
DOS altında text modu ile binary mod arasındaki
farkı gösteren bir program
*/

#include
#include
#include

main()
{
FILE *fp;
int k, ch;

clrscr();
fp = fopen("deneme", "w");
if (fp == NULL) {
printf("dosya açılamıyor\n");
exit(EXIT_FAILURE);
}

/* dosyaya 5 tane \n karakteri yazdırılıyor */

for (k = 0; k < 5; ++k)
fputc('\n', fp);
fclose(fp);

printf("\ndosya binary modda açılarak yazdırılıyor\n");
fp = fopen("deneme", "rb");
if (fp == NULL) {
printf("dosya açılamıyor\n");
exit(EXIT_FAILURE);
}
while ((ch = fgetc(fp)) != EOF)
printf("%d ", ch);

/* ekran çıktısı
13 10 13 10 13 10 13 10 13 10
*/

fclose(fp);

printf("\ndosya kapatıldı. Şimdi dosya text modunda açılarak yazdırılıyor .\n");
fp = fopen("deneme", "r");
if (fp == NULL) {
printf("dosya açılamıyor\n");
exit(EXIT_FAILURE);
}
while ((ch = fgetc(fp)) != EOF)
printf("%d ", ch);

/* ekran çıktısı
10 10 10 10 10
*/

fclose(fp);

/* simdi '\x1A' karakterinin text modunda dosyayı sonlandırması özelliği
test ediliyor */

fp = fopen("deneme", "w");
if (fp == NULL) {
printf("dosya açılamıyor\n");
exit(EXIT_FAILURE);
}

/* dosyaya 5 tane 'A' karakteri yazdırılıyor */

for (k = 0; k < 5; ++k)
fputc('A', fp);

/* dosyaya '\x1A' karakteri yazdırılıyor */

fputc('\x1a', fp);

/* dosyaya 10 tane 'A' karakteri yazdırılıyor. */

for (k = 0; k < 5; ++k)
fputc('A', fp);

fclose(fp);
printf("\ndosya binary modda açılarak yazdırılıyor :\n");
fp = fopen("deneme", "rb");
if (fp == NULL) {
printf("dosya açılamıyor\n");
exit(EXIT_FAILURE);
}
while ((ch = fgetc(fp)) != EOF)
printf("%d ", ch);

/* ekran çıktısı
65 65 65 65 65 26 65 65 65 65 65
*/

printf("\ndosya kapatıldı, Şimdi dosya text modunda açılarak yazdırılıyor\n");
fp = fopen("deneme", "r");
if (fp == NULL) {
printf("dosya açılamıyor\n");
exit(EXIT_FAILURE);
}
while ((ch = fgetc(fp)) != EOF)
printf("%d ", ch);

/* ekran çıktısı
65 65 65 65 65 26 65 65 65 65 65
*/

fclose(fp);

return 0;
}

EOF (END OF FILE) DURUMU

Dosyanın sonunda hiçbir özel karakter yoktur. İşletim sistemi dosyanın sonuna gelinip gelinmediğini dosyanın uzunluğuna bakarak anlayabilir. EOF durumu dosya pozisyon göstericisinin dosyada olmayan son karakteri göstermesi durumudur. EOF durumunda dosya pozisyon göstericisinin offset değeri dosya uzunluğu ile aynı değerdedir. EOF durumunda dosyadan okuma yapılmak istenirse dosya fonksiyonları başarısız olur. Ancak açış modu uygunsa dosyaya yazma yapılabilir ve bu durumda dosyaya ekleme yapılır.
Daha önce söylendiği gibi C dilinde açılan bir dosya ile ilgili bilgiler FILE türünden bir yapı nesnesi içinde tutulur. Bu yapının her bir elemanı dosyanın bir özelliği hakkında bilgi vermektedir. C programcısı bu yapının elemanlarının değerleri ile doğrudan ilgilenmez, zira fopen fonksiyonunun geri dönüş değeri bu yapı nesnesini gösteren FILE yapısı türünden bir göstericidir ve C dilinin dosyalarla ilgili işlem yapan fonksiyonları çoğunlukla bu adresi parametre olarak alarak, istenilen dosyaya ulaşırlar.
Söz konusu FILE yapısının elemanlarından biri de flag olarak kullanılan EOF indikatörüdür. (aslında int türden bir flag'in yalnızca belirli bir bitidir.) C dilinin dosyalarla ilgili işlem yapan bazı fonksiyonları EOF indikatörünün değerini değiştirirler. (set ya da clear ederler. Set edilmesi bu indikatöre 1 değerinin atanması clear edilmesi ise 0 değerinin atanmasıdır. Bu indikatörün set edilmesi demek dosya pozisyon göstericisinin dosyanın sonunu göstermesi demektir.
Dosya açan fonksiyonlar FILE yapısındaki EOF indikatörünü sıfırlarlar. Bu fonksiyonlar dışında fseek fonksiyonu ve clearerr fonksiyonları da EOF indikatörünü sıfırlarlar. (clear ederler).

fseek fonksiyonu :

Bu fonksiyon dosya pozisyon göstericisini istenilen bir offsete konumlandırmak amacıyla kullanılır. Bu fonksiyonun kullanılmasıyla, açılmış bir dosyanın istenilen bir yerinden okuma yapmak ya da istenilen bir yerine yazmak mümkün hale gelir. Prototipi :

int fseek(FILE *f, long offset, int origin);

Fonksiyonun ikinci parametresi konumlandırma işleminin yapılacağı offset değeridir.
Fonksiyonun 3. parametresi 0, 1, veya 2 olabilir. Bu değerler stdio.h dosyasında

#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2

biçiminde sembolik sabitlerle tanımlanmıştır ve fseek fonksiyonun çağırılmasında daha çok bu sembolik sabitler kullanılmaktadır.

son parametre 0 ise, konumlandırma dosya başından itibaren yapılır. Bu durumda 2. parametre >= 0 olmalıdır. Örneğin:

fseek(f, 10L, 0);

ile dosya göstericisi 10. offsete konumlandırılır. Ya da

fseek(f, 0, 0);

ile dosya göstericisi dosyanın başına konumlandırılır. Dosya pozisyon göstericisinin dosyanın başına konumlandırılması için rewind fonksiyonu da kullanılabilir:

void rewind(FILE *fp);

rewind(f);

fonksiyonun 3. parametre değişkenine geçilen değer 1 ise (SEEK_CUR) , konumlandırma dosya göstericisinin en son bulunduğu yere göre yapılır. Bu durumda ikinci parametre pozitif ya da negatif değere sahip olabilir. Pozitif bir değer ileri, negatif bir değer geri anlamına gelecektir. Örneğin dosya göstericisi 10. offsette olsun.

fseek(f, -1, SEEK_CUR);

çağırması ile dosya göstericisi 9. offset'e konumlandırılır.

fonksiyonun 3. parametre değişkenine geçilen değer 2 ise (SEEK_END), konumlandırma EOF durumundan itibaren yani dosya sonunu referans alınarak yapılır. Bu durumda ikinci parametre <= 0 olmalıdır. Örneğin dosya göstericisini EOF durumuna çekmek için :

fseek(f, 0, SEEK_END);

çağırmasını yapmak gerekir. Ya da başka bir örnek:

fseek(f, -1, SEEK_END);

çağırması ile dosya göstericisi son karakterin offsetine çekilir. Fonksiyonun geri dönüş değeri işlemin başarısı hakkında bilgi verir. Geri dönüş değeri 0 ise işlem başarılıdır. Geri dönüş değeri 0 dışı bir değer ise işlem başarısızdır. Ancak problemli durumlarda geri dönüş değrinin test edilmesi tavsiye edilir.

Yazma ve okuma işlemleri arasında dosya göstericisinin fseek fonksiyonu ile konumlandırılması gerekir.Konumlandırma gerekirse boş bir fseek çağırması ile yapılabilir. Örneğin dosyadan bir karakter okunup , bir sonraki karaktere bu karakterin 1 fazlasını yazacak olalım.

ch = fgetc(f);
fputc(ch + 1, f);

işlemi hatalıdır. Yazmadan okumaya, okumadan yazmaya geçişte dosya göstericisi konumlandırılmalıdır.

feof fonskiyonu :

bu fonksiyon dosya göstericisinin EOF durumunda olup olmadığını (EOF indikatörünün set edilip edilmediğini) test etmek amacıyla kullanılır. Prototipi:

int feof(FILE *f);

Eğer dosya göstericisi dosya sonunda ise (EOF indikatörü set edilmişse) fonksiyon 0 dışı bir değere , değilse (EOF indikatörü set edilmemişse) 0 değeri ile geri döner.

Ancak feof fonksiyonunun 0 dışı bir değere geri dönebilmesi için dosya göstericisinin dosyanın sonunda olmasının yanı sıra en son yapılan okuma işleminin de başarısız olması gerekir. daha önce söylendiği gibi bazı fonksiyonlar (fopen, fseek, rewind, clearerr) EOF indikatorünü clear ederler, yani EOF indikatörünün 0 değerinde olması (clear edilmiş olması) dosyanın sonunda olunmadığının bir garantisi değildir.

fread ve fwrite fonksiyonları

Bu iki fonksiyon C dilinde en çok kullanılan dosya fonksiyonlarıdır. Genel olarak dosya ile RAM arasında transfer yaparlar. Her iki fonskiyonun da prototipleri aynıdır.

size_t fread(void *adr, size_t size, size_t n, FILE *);
size_t fwrite (const void *adr, size_t size, size_t n, FILE *);

size_t türünün derleyiciyi yazanlar tarafından unsigned int ya da unsigned long türünün typedef edilmiş yeni ismi olduğunu hatırlayalım.

fread fonskiyonu dosya pozisyon göstericisinin gösterdiği yerden, 2. ve 3. parametresine kopyalanan değerlerin çarpımı kadar byte'ı , RAM'de 1. parametresinin gösterdiği adresten başlayarak kopyalar. Geleneksel olarak fonksiyonun 2. parametresi veri yapısının bir elemanının uzunluğunu, 3. parametresi ile parça sayısı biçiminde girilir.

Bu fonksiyonlar sayesinde diziler ve yapılar tek hamlede dosyaya transfer edilebilirler. Örneğin 10 elemanlı bir dizi aşağıdaki gibi tek hamlede dosyaya yazılabilir.

int a[5] = {3, 4, 5, 7, 8};

fwrite (a, sizeof(int), 5, f);

Yukarıdaki örnekte, dizi ismi olan a int türden bir adres bilgisi olduğu için, fwrite fonksiyonuna 1. arguman olarak gönderilebilir. FILE türünden f göstericisi ile ilişkilendirilen dosyaya RAM'deki a adresinden toplam sizeof(int) * 5 byte yazılmaktadır.
Ancak tabi fwrite fonskiyonu sayıları bellekteki görüntüsü ile dosyaya yazar. (yani fprintf fonksiyonu gibi formatlı yazmaz.) Örneğin:

int i = 1535;

fwrite(&i, sizeof(int), 1, f);

Burada dosya type edilirse 2 byte uzunluğunda rasgele karakterler görünür. Çünkü DOS'da int türü 2 byte uzunluğundadır. Bizim gördüğümüz ise 1525'in rasgele olan bytelarıdır. Bilgileri ASCII karşılıkları ile dosyaya yazmak için fprintf fonksiyonu kullanılabilir..

fread ve fwrite fonksiyonları bellekteki bilgileri transfer ettiğine göre dosyaların da binary modda açılmış olması uygun olacaktır.

#include
#include

int main()
{
FILE *f;
int i;
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];

if ((f = fopen("data", w+b")) == NULL) {
printf("cannot open file...\n");
exit(EXIT_FAILURE);
}
fwrite (a, sizeof(int), 10, f);
fseek(f, 0, SEEK_SET);
fread(b, sizeof(int), 10, f);
for (i = 0; i < 10; ++i)
printf("%d\n", b[i]);
}

fread ve fwrite fonksiyonlarının geri dönüş değerleri 3. parametresi ile belirtilen okunan ya da yazılan parça sayısıdır. Örneğin

n = fread(a, sizeof(int), 10, f);

ifadesinde fonksiyon bütün sayıları okuyabildiyse 10 sayısına geri döner. Eğer dosyadaki kalan byte sayısı okunmak istenen sayıdan az ise fonksiyon bütün byte'ları okur ve geri dönüş değeri okunan byte sayısı 2. parametresi ile belirtilen sayı olur. Örneğin DOS altında çalışıyor olalım. Dosyada 10 byte bilgi kalmış olsun.

n = fread(a, sizeof(int), 10, f);

ile fonksiyon 5 sayısına geri dönecektir.

Aşağıdaki iki ifadeyi inceleyelim:

fread(str, 100, 1, f);
fread(str, 1, 100, f);

her iki fonksiyon çağırma ifadesi de RAM'deki str adresine FILE türünden f göstericisi ile ilişkilendirilen dosyadan 100 byte okumak amacıyla kullanılabilir. Ancak birinci çağırmada geri dönüş değeri ya 0 ya 1 olabilecekken, ikinci fonksiyon çağırmasında geri dönüş değeri 0 100(dahil) herhangi bir değer olabilecektir.

Blok blok kopyalama işlemi

Aşağıdaki örnekte bir grup byte fread fonskiyonu ile bir dosyadan okunmuş ve fwrite fonksiyonu ile diğer bir dosyaya yazılmıştır.

#define BLOCK_SIZE 1024
#define MAX_PATH 80

int main()
{
FILE *fs, *fd;
char s[MAX_PATH], d[MAX_PATH];
unsigned n;

printf("kaynak dosya : ");
gets(s);
printf("amaç dosya : ");
gets(d);
if ((fs = fopen(s, "rb")) == NULL) {
printf("cannot open file ...\n");
exit(EXIT_FAILURE);
}
if ((fd = fopen(d, "wb")) == NULL) {
printf("cannot open file ...\n");
fclose(fs);
exit(EXIT_FAILURE);
}
while ((n = fread(buf, 1, BLOCK_SIZE, fs)) > 0)
fwrite(buf, 1, n, fd);
fclose(fs);
fclose(fd);
printf("1 file copied...\n");
return 0;
}

remove fonksiyonu

Bu fonksiyon bir dosyayı silmek için kullanılır. Fonksiyonun prototipi :

int remove (const char *filename);

şeklindedir. Fonksiyona arguman olarak silinecek dosyanın ismi gönderilir. Fonksiyonun geri dönüş değeri, dosyanın başarılı bir şekilde silinebilmesi durumunda 0 aksi halde (yani dosya silinememişse) 0 dışı bir değerdir. Açık olan bir dosyanın silinmesi "implementation depended" (derleyiciye bağlı) olduğundan, yazılan kodun taşınabilirliği açısından, silinecek bir dosya açık ise önce kapatılmalıdır.

rename fonksiyonu

Bu fonksiyon bir dosyanın ismini değiştirmek için kullanılır. Fonksiyonun prototipi :

int rename (const char *old, const char *new);

şeklindedir.

Fonksiyona 1. arguman olarak dosyanın eski ismi ikinci arguman olarak ise dosyanın yeni ismi gönderilmelidir. Fonksiyonun geri dönüş değeri, isim değiştirmen işleminin başarılı olması durumunda 0, aksi halde (dosyanın ismi değiştirilemiyorsa 0 dışı bir değerdir. (Örneğin açık olan bir dosyanın isminin değiştirilmeye çalışılması başarılı olamayacağından fonksiyon bu durumda 0 dışı bir değere geri dönecektir.)

tmpfile fonksiyonu

Fonksiyon geçici bir dosya açmak amacıyla kullanılır. Fonksiyonun prototipi :

FILE * tmpfile(void);

tmpfile fonksiyonu açtığı geçici dosyayı "wb" modunda açar. Açılan dosya fclose fonksiyonu ile kapatıldığında ya da (kapatılmazsa), program sona erdiğinde otomatik olarak silinecektir. Fonksiyonu geri dönüş değeri, açılan geçici dosya ile ilişki kurulmasına yarayacak, FILE yapısı türünden bir adrestir. Herhangi bir nedenle dosya geçici dosya açılamıyorsa fonksiyon NULL adresine geri dönecektir.

tmpnam fonksiyonu

Geçici olarak kullanılacak bir dosya için bir isim üretilmesi amacıyla kullanılır. Fonksiyonun prototipi :

char *tmpnam(char *s);

şeklindedir. Fonksiyon ürettiği dosya ismini kendisine gönderilen char türden adrese yerleştirir. Eğer fonksiyona arguman olarak NULL adresi gönderilirse, fonksiyon üretilen dosya ismini statik bir dizi içinde tutarak bu dizinin adresiyle geri dönecektir. Fonksiyona char türden bir dizinin adresi gönderildiğinde bu dizinin boyutu ne kadar olmalıdır. Başka bir deyişle tmpnam fonksiyonu kaç karakter uzunluğunda bir dosya ismi üretecektir. İşte bu değer stdio.h dosyası içinde tanımlanan L_tmpnam sembolik sabitiyle belirtilmektedir.
tmpnam fonksiyonunun ürettiği dosya isminin daha önce kullanılmayan bir dosya ismi olması garanti altına alınmıştır. Yani üretilen dosya ismi tektir. (unique file name) Bir programda daha sonra silmek üzere bir dosya açacağımızı ve bu dosyaya birtakım bilgileri yazacağımız düşünelim. Bu durumda dosyayı yazma modunda açacağımıza göre, açacağımız dosyaya olan bir dosyanın ismini veremeyiz. Eğer verirsek , var olan dosya sıfırlanacağı için bu dosyayı kaybederiz. Bu riske girmemek için, geçici olarak kullanılacak dosya tmpfiel fonksiyonu kullanılarak açılmalıdır. Ancak tmpfile fonksiyonunun kullanılması durumunda, açılan dosya kalıcı hale getirilemez. Yani herhangi bir nedenden dolayı geçici dosyanın silinmemesini istersek, (dosyayı kalıcı hale getirmek istersek) dosyayı fopen fonksiyonuyla açmalıyız. İşte bu durumda geçici dosyayı başka bir dosyayı riske etmemek için tmpnam fonksiyonunun ürettiği isim ile açmalıyız. Peki tmpnam fonksiyonuyla en fazla kaç tane "unique file name " üretebiliriz. İşte bu sayı stdio.h içinde tanımlanan TMP_MAX sembolik sabiti ile belirlenmiştir.

C dilinde bazı giriş ve çıkış birimleri(klavye, ekran gibi) doğrudan bir dosya gibi ele alınırlar. C standartları herhangi bir giriş çıkış birimini "stream" olarak isimlendirmektedir. Bir stream bir dosya olabileceği gibi, dosya olarak ele alınan bir giriş çıkış birimi de olabilir. Örneğin küçük programlar genellikle girdilerini genellikle tek bir stream,den alıp (mesela klavye) çıktılarını da tek bir streame (mesela ekran) iletirler.

freopen fonksiyonu

freopen fonksiyonu daha önce açılmış bir dosyayı, fropen fonksiyonu ile açılan dosyaya yönlendirir. Fonksiyonun prototipi :

FILE *freopen(const char *filename, const char *mode, FILE *stream);
şeklindedir.

Uygulamalarda daha çok standart dosyaların (stdin, stdout, stderr) başka dosyalara yönlendirilmesinde kullanılır. Örneğin bir programın çıktılarının data.dat isimli dosyaya yazılmasını istersek :

if (freopen("data.dat", "w", stdout) == NULL) {
printf("data.dat dosyası açılamıyor\n");
exit(EXIT_FAILURE);}

yukarıdaki fonksiyon çağırımıyla stdout dosyasının yönlendirildiği dosya kapatılarak (bu yönlendirme işlemi komut satırından yapılmış olabileceği gibi, freopen fonksiyonunun daha önceki çağırımı ile de yapılmış olabilir.) stdout dosyasının data.dat dosyasına yönlendirilmesi sağlanır.

freopen fonksiyonunun geri dönüş değeri fonksiyona gönderilen üçüncü arguman olan FILE yapısı türünden göstericidir. freopen dosyası yönlendirmenin yapılacağı dosyayı açamazsa NULL adresine geri döner. Eğer yönlendirmenin yapıldığı eski dosya kapatılamıyorsa, freopen fonksiyonu bu durumda bir işaret vermez.

dosya buffer fonksiyonları

İkincil belleklerle (disket, hard disk vs.) yapılan işlemler RAM'de yapılan işlemlere göre çok yavaştır. Bu yüzden bir dosyadan bir karakterin okunması ya da bir dosyaya bir karakterin yazılması durumunda her defasında dosyaya doğrudan ulaşmak verimli bir yöntem değildir.
İşlemin performansı bufferlama yoluyla artırılmaktadır. Bir dosyaya yazılacak data ilk önce bellekteki bir buffer alanında saklanır. Bu buffer alanı dolduğunda ya da yazılmanın yapılacağı dosya kapatıldığında bufferdaki data alanında ne varsa dosyaya yazılır. Buna bufferin boşaltılması (to flush the buffer) denir.
Giriş dosyaları da benzer şekilde bufferlanabilir. Giriş biriminden alınan data (örneğin klavyeden) önce buffera yazılır.
dosyaların bufferlaması erimlilikte çok büyük bir artışa neden olur. Çünkü bufferdan (RAM'den) bir karakter okunması ya da buffera bir karakter yazılması ihmal edilecek kadar küçük bir zaman içinde yapılır. Buffer ile dosya arasındaki transfer şüphesiz yine vakit alacaktır ama bir defalık blok transferi, küçük küçük transferlerin toplamından çok daha kısa zaman alacaktır.

stdio.h başlık dosyası içinde prototipi bildirimi yapılan ve dosyalarla ilgili işlem yapan fonksiyonlar tamponlamayı otomatik olarak gerçekleştirirler. Yani dosyaların tamponlanması için bizim birşey yapmamıza gerek kalmadan bu iş geri planda bize sezdirilmeden yapılmaktadır. Ama bazı durumlarda tamponlama konusunda programcı belirleyici durumda olmak isteyebilir. İşte bu durumlarda programcı dosya tamponlama fonksiyonlarını (fflush, setbuf, setvbuf) kullanacaktır:

fflush fonksiyonu

Bir program çıktısını bir dosyaya yazarken (örneğin stdout dosyasına) yazılan dosya ilk önce RAM'deki tamponlama alanına gider. Dosya kapatıldığında ya da tamponlama alanı dolduğunda, tamponlama alanı boşaltılarak dosyaya yazılır. fflush fonksiyonunun kullanılmasıyla, dosyanın kapatılması ya da tamponlama alanının dolması beklenmeksizin, tamponlama alanı boşatılarak dosyaya yazılır. Bu işlem istenilen sıklıkta yapılabilir. Fonksiyonun prototipi :

int fflush (FILE *stream);

şeklindedir.

fflush(fp);

çağırımı ile FILE yapısı türünden fp göstericisi ile ilişkilendirilen dosyanın tamponlama alanı (buffer) boşaltılır. Eğer fflush fonksiyonuna NULL adresi gönderilirse, açık olan bütün dosyaların tamponlama alanları boşaltılacaktır.

Tamponlama alanının boşaltılması işlemi başarılı olursa fflush fonksiyonu 0 değerine geri dönecek aksi halde EOF değerine geri dönecektir.

setvbuf fonksiyonu

setvbuf fonksiyonu bir dosyanın tamponlanma şeklinin değiştirilmesi ve tampon alanının yerinin ve boyutunun değiştirilmesi amacıyla kullanılır. Fonksiyonun prototipi aşağıdaki şekildedir :

int setvbuf(FILE *stream, char *buf, int mode, size_t size);

Fonksiyona gönderilen üçüncü arguman tamponlama şeklini belirler. Üçüncü argumanın değeri stdio.h başlık dosyası içinde tanımlanan sembolik sabitlerle belirlenir.

_IOFBF (full buffering - tam tamponlama)
data dosyaya tamponlama alanı dolduğunda yazılır. Ya da giriş tamponlaması söz konusu ise dosyadan okuma tamponlama alanı boş olduğu zaman yapılır.

_IOLBF (line buffering - satır tamponlaması)
Tamponlama alanı ile dosya arasındaki okuma ya da yazma işlemi satır satır yapılır.

_IONBF (no buffering - tamponlama yok)
Dosyadan okuma ya da soyaya yazma tamponlama olmadan doğrudan yapılır.

setvbuf fonksiyonuna gönderilen ikinci arguman RAM'de tamponlamanın yapılacağı bloğun başlangıç adresidir. Tamponlamanın yapılacağı alan statik ya da dinamik ömürlü olabileceği gibi, dinamik bellek fonksiyonlarıyla da tahsis edilebilir.
Fonksiyona gönderilen son arguman tamponlama alanında tutulacak byteların sayısıdır.

setvbuf fonksiyonu dosya açıldıktan sonra, fakat dosya üzerinde herhangi biri işlem yapılmadan önce çağırılmalıdır. Fonksiyonun başarılı olması durumunda fonksiyon 0 değerine geri dönecektir. Fonksiyona gönderilen üçüncü argumanın geçersiz olması durumunda ya da fonksiyonun ilgili tamponlamayı yapamaması durumunda, geri dönüş değeri 0 dışı bir değer olacaktır.
Fonksiyona gönderilen buffer alanının geçerliliğinin bitmesinden önce (ömrünün tamamlanmasından önce) dosya kapatılmamalıdır.

dosya işlemleri ile ilgili örnek uygulamalar:

Uygulama 1 : Dosya üzerinde sıralı veri tabanı tutulması

#include
#include
#include
#include
/* symbolic constants */
#define MAX_PATH 80
#define ADDREC 1
#define LISTREC 2
#define FINDREC 3
#define DELREC 4
#define EDITREC 5
#define PACKRECS 6
#define SORTREC 7
#define EXITPROG 8
#define DELETED 0
#define NORMALREC 1
#define INVALID 0

/* structure declarations */

typedef struct _PERSON {
char name[30];
int no;
int delflag;
} PERSON;

/* function prototypes */

int GetOption(void);
void AddRec(void);
void ListRec(void);
void FindRec(void);
void DelRec(void);
void EditRec(void);
void SortRec(void);
void Pack(void);

/* global variables */

FILE *f;
char fname[MAX_PATH];

/* function definitions */

void AddRec(void)
{
PERSON per;

printf("Adı soyadı : ");
fflush(stdin);
gets(per.name);
printf("No : ");
scanf("%d", &per.no);
per.delflag = NORMALREC;
fseek(f, 0, SEEK_END);
fwrite(&per, sizeof(PERSON), 1, f);
}

void FindRec(void)
{
PERSON per;
char name[30];

printf("lütfen kayıt ismini giriniz :");
fflush(stdin);
gets(name);
fseek(f, 0, SEEK_SET);
while (fread(&per, sizeof(PERSON), 1, f) > 0) {
if (per.delflag != NORMALREC)
continue;
if (!stricmp(per.name, name)) {
printf("\n%s %d\n\n", per.name, per.no);
return;
}
}
printf("\nKayıt bulunamadı...\n\n");
}

void ListRec(void)
{
PERSON per;

putchar('\n');
fseek(f, 0L, SEEK_SET);
while (fread(&per, sizeof(PERSON), 1, f) > 0) {
printf("\n%20s %5d", per.name, per.no);
if (per.delflag == DELETED)
printf("\tDELETED");
}
putchar('\n\n');
}

void DelRec(void)
{
char name[30];
PERSON per;

printf("Silinecek kayıtın adı ve soyadı : ");
fflush(stdin);
gets(name);
fseek(f, 0, SEEK_SET);
while (fread(&per, sizeof(PERSON), 1, f) > 0) {
if (!stricmp(per.name, name)) {
per.delflag = DELETED;
fseek(f, -(long)sizeof(PERSON), 1);
fwrite(&per, sizeof(PERSON), 1, f);
printf("Record deleted!..\n");
return;
}
}
printf("silinecek kayıt bulunamadı");
}

void EditRec(void)
{
char name[30];
PERSON per;

printf("Değiştirilecek kayıtın adı ve soyadı : ");
fflush(stdin);
gets(name);
fseek(f, 0, SEEK_SET);
while (fread(&per, sizeof(PERSON), 1, f) > 0) {
if (per.delflag == NORMALREC && !stricmp(per.name, name)) {
printf("Adı soyadı : ");
fflush(stdin);
gets(per.name);
printf("No : ");
scanf("%d", &per.no);
fseek(f, -(long)sizeof(PERSON), 1);
fwrite(&per, sizeof(PERSON), 1, f);
printf("Record updated!..\n");
return;
}
}
printf("değiştirilecek kayıt bulunamadı\n");

}

int GetOption(void)
{
int option;

printf("\n1) Kayıt Ekle\n");
printf("2) Kayıt Listele\n");
printf("3) Kayıt Bul\n");
printf("4) Kayıt Sil\n");
printf("5) Kayıt değiştir\n");
printf("6) Pack\n");
printf("7) Sırala\n");
printf("8) Çık\n");
printf("\nSeçiminiz :");
scanf("%d", &option);
if (option <> 8)
return INVALID;
return option;
}

void SortRec(void)
{
PERSON per[2], tmp;
int i, count, chgFlag;

fseek(f, 0, SEEK_END);
count = ftell(f) / sizeof(PERSON);

do {
chgFlag = 0;
for (i = 0; i < count - 1; ++i) {
fseek(f, (long)i * sizeof(PERSON), SEEK_SET);
if (fread(per, sizeof(PERSON), 2, f) != 2) {
printf("cannot read from the file!..\n");
exit(EXIT_FAILURE);
}
if (per[0].no > per[1].no) {
chgFlag = 1;

tmp = per[0];
per[0] = per[1];
per[1] = tmp;

fseek(f, (long)i * sizeof(PERSON), SEEK_SET);
if (fwrite(per, sizeof(PERSON), 2, f) != 2) {
printf("cannot read from the file!..\n");
exit(EXIT_FAILURE);
}
}
}
} while (chgFlag);
}

void Pack(void)
{
FILE *fnew;
PERSON per;

if ((fnew = fopen("temp", "wb")) == NULL) {
printf("cannot create temporary file!..\n");
exit(EXIT_FAILURE);
}
fseek(f, 0l, SEEK_SET);
while (fread(&per, sizeof(PERSON), 1, f) > 0) {
if (per.delflag == NORMALREC)
fwrite(&per, sizeof(PERSON), 1, fnew);
}
fclose(fnew);
fclose(f);
if (unlink(fname)) {
printf("Fatal Error : Cannot open database file!..\n");
exit(EXIT_FAILURE);
}
if (rename("temp", fname)) {
printf("fatal Error: cannot delete database file!..\n");
exit(EXIT_FAILURE);
}
if ((f = fopen(fname, "r+b")) == NULL) {
printf("Fatal Error : Cannot open database file!..\n");
exit(EXIT_FAILURE);
}
printf("Pack operation succesfully completed!..\n");
}

void main()
{
char dfname[MAX_PATH];
int option;

printf("Data File : ");
gets(dfname);
if ((f = fopen(dfname, "r+b")) == NULL)
if ((f = fopen(dfname, "w+b")) == NULL) {
printf("Cannot open database file!..\n");
exit(EXIT_FAILURE);
}
strcpy(fname, dfname);
for (;;) {
option = GetOption();
switch (option) {
case ADDREC : AddRec(); break;
case LISTREC : ListRec(); break;
case FINDREC : FindRec(); break;
case DELREC : DelRec(); break;
case EDITREC : EditRec(); break;
case PACKRECS : Pack(); break;
case SORTREC : SortRec(); break;
case EXITPROG : goto EXIT;
case INVALID : printf("Geçersiz Seçenek!..\n");
}
}
EXIT:
fclose(f);
}

Uygulama 2: developer's back up programı (G. Aslan)

#include
#include
#include
#include
#include

#define GOOD 0
#define FAIL (-1)

#define FBUFSIZ (63*512) /* Buffer size */

char *Buffer, *in_buf, *out_buf;
char CmpFile[128], OutFile[128];

int filecmp(FILE *fi, FILE *fo)
{
int c1, c2;
long l1, l2;

l1 = filelength(fileno(fi));
l2 = filelength(fileno(fo));
if (l1 != l2)
return FAIL;

rewind(fi);
rewind(fo);
for (;;) {
c1 = getc(fi);
c2 = getc(fo);

if (c1 != c2) {
return FAIL;
}

if (c1 == EOF)
break;
}

return GOOD;
}

int filecopy(FILE *fi, FILE *fo)
{
int c, nbytes;

rewind(fi);
rewind(fo);
for (;;) {
c = fread(Buffer, 1, FBUFSIZ, fi);
if (c == 0) {
break;
}

nbytes = fwrite(Buffer, 1, c, fo);
if (nbytes != c) {
return FAIL;
}
}
return GOOD;
}

int main(int argc, char *argv[])
{
FILE *fi, *fo;
char *ptr;
int i;

printf("*GA Developer's Backup Utility. Version 1.0\n"
"(C) *GA, 1995\n\n");

if (argc != 2) {
fprintf(stderr, "Usage: BK \n");
return 1;
}

if ((Buffer = malloc(FBUFSIZ)) == NULL
(in_buf = malloc(FBUFSIZ)) == NULL
(out_buf = malloc(FBUFSIZ)) == NULL) {
fprintf(stderr, "Not enough memory\n");
return 2;
}

if ((fi = fopen(argv[1], "rb")) == NULL) {
ptr = argv[1];
OPN_ERR:
fprintf(stderr, "File could not be opened: '%s'\n", ptr);
return 3;
}
setvbuf(fi, in_buf, _IOFBF, FBUFSIZ);

strcpy(CmpFile, argv[1]);
ptr = strchr(CmpFile, '.');
if (ptr == NULL)
ptr = strchr(CmpFile, '\0');

for (i = 1; i <= 999; ++i) {
sprintf(ptr, ".%03d", i);
if (access(CmpFile, 0))
break;
}

if (i == 1000) {
fprintf(stderr, "Backup operation failed: File limit!\n");
return 3;
}

strcpy(OutFile, CmpFile);

if (i > 1) {
sprintf(ptr, ".%03d", i-1);

if ((fo = fopen(CmpFile, "rb")) == NULL) {
ptr = CmpFile;
goto OPN_ERR;
}
setvbuf(fo, out_buf, _IOFBF, FBUFSIZ);

if (!filecmp(fi, fo)) {
printf("No differences encountered: '%s'\n", CmpFile);
return 0;
}
fclose(fo);
}

printf("File being copied: %s ---> %s\n", argv[1], OutFile);

if ((fo = fopen(OutFile, "wb")) == NULL) {
ptr = OutFile;
goto OPN_ERR;
}
setvbuf(fo, out_buf, _IOFBF, FBUFSIZ);

if (filecopy(fi, fo)) {
fprintf(stderr, "File copy error!\n");
return 4;
}

fcloseall();

return 0;
}

Uygulama 3 : bol.c ve bir.c programları :

bir dosyanın belirkli byte büyüklüğünde n kadar sayıda dosyaya bölünmesi ve daha sonra başka bir programla bu dosyaların tekrar birleştirilmesi.

/*******bol.c *******************/

#include
#include
#include

#define MAX_LEN 80

int main(int argc, char **argv)
{
FILE *fs, *fd;
char fsname[MAX_LEN];
char fdname[MAX_LEN] = "dos0001.xxx";
int chunk;
long no_of_chars = 0L;
int no_of_files = 0;
int ch;

if (argc != 3) {
printf("bolunecek dosyanin ismini giriniz : ");
gets(fsname);
printf("kac byte'lik parcalara bolmek istiyorsunuz?");
scanf("%d", &chunk);
}
else {
strcpy(fsname, argv[1]);
chunk = atoi(argv[2]);
}

printf("%s dosyasi %d uzunlugunda dosyalara bolunecek!\n", fsname, chunk);

fs = fopen(fsname, "rb");
if (fs == NULL) {
printf("%s dosyasi acilamiyor!\n", fsname);
exit(EXIT_FAILURE);
}
fd = NULL;

while ((ch = fgetc(fs)) != EOF) {
if (fd == NULL) {
fd = fopen(fdname, "wb");
if (fd == NULL) {
printf(" %s dosyasi yaratilamiyor!\n", fdname);
exit(EXIT_FAILURE);
}
no_of_files++;
printf("%s dosyasi yaratildi!\n", fdname);
}
fputc(ch, fd);
no_of_chars++;
if (no_of_chars % chunk == 0) {
fclose(fd);
printf("%s dosyasi kapatildi!\n", fdname);
fd = NULL;
sprintf(fdname, "dos%04d.xxx", no_of_files + 1);
}
}
fclose(fs);
if (no_of_chars % chunk != 0) {
fclose(fd);
printf("%s dosyasi kapatildi!\n", fdname);
}

printf("%ld uzunlugunda %s dosyasi %d uzunlugunda %d adet dosyaya bolundu!\n",
no_of_chars, fsname, chunk, no_of_files);

return 0;
}

/*******bir.c *******************/

#include
#include
#include

#define MAX_LEN 80

int main(int argc, char **argv)
{
FILE *fs, *fd;
char fdname[MAX_LEN];
char fsname[MAX_LEN] = "dos0001.xxx";
int ch;
int no_of_files = 0;
long no_of_chars = 0L;
int k;

if (argc != 2) {
printf("birlestirilecek dosyanin ismini giriniz : ");
gets(fdname);
}
else {
strcpy(fdname, argv[1]);
}

fd = fopen(fdname, "wb");
if (fd == NULL) {
printf("%s dosyasi yaratilamiyor!\n", fdname);
exit(EXIT_FAILURE);
}

printf("%s dosyasi yaratildi!\n", fdname);
while (fs = fopen(fsname, "rb")) {
no_of_files++;
printf("%s dosyasi acildi!\n", fsname);

while ((ch = fgetc(fs)) != EOF) {
fputc(ch, fd);
no_of_chars++;
}
fclose(fs);
printf("%s dosyasi kapatildi!\n", fsname);
sprintf(fsname, "dos%04d.xxx", no_of_files + 1);
}
fclose(fd);
printf("%s dosyasi kapatildi!\n", fdname);
printf("%d adet dosya %ld uzunlugunda %s ismli dosya altinda\ birlestirildi!\n", no_of_files, no_of_chars, fdname);

for (k = 1; k <= no_of_files; ++k) {
sprintf(fsname, "dos%04d.xxx", k);
remove(fsname);
printf("%s dosyasi silindi!\n", fsname);
}

return 0;
}

2007-12-08T09:53:00.000-08:00

DOSYALAR

İkincil bellekte tanımlanmış bölgelere dosya denir. Her dosyanın bir ismi vardır. Ancak dosyaların isimlendirme kuralları sistemden sisteme göre değişebilmektedir. Dosya işlemleri tamamen işletim sisteminin kontrolü altındadır.

İşletim sistemi de ayrı ayrı yazılmış fonksiyonların birbirlerini çağırması biçiminde çalışır. Örneğin komut satırında ismi yazılmış olan bir programın çalıştırılması birkaç sistem fonksiyonunun çağırılması ile yapılmaktadır. Komut satırından yazıyı alan, diskte bir dosyayı arayan, bir dosyayı RAM’e yükleyen, RAM’deki programı çalıştıran fonksiyonlar düzenli olarak çağırılmaktadır.

İşletim sisteminin çalışması sırasında kendisinin de çağırdığı, sistem programcısının da dışarıdan çağırabildiği işletim sistemine ait fonksiyonlara sistem fonksiyonları denir. Bu tür fonksiyonlara Windows sisteminde API (Application Proggramming Interface) fonksiyonları, UNIX işletim sisteminde ise sistem çağırmaları (system calls) denir.
Aslında bütün dosya işlemleri, hangi programlama dili ile çalışılırsa çalışılsın, işletim sisteminin sistem fonksiyonları tarafından yapılır. Sistem fonksiyonlarının isimleri ve parametrik yapıları sistemden sisteme değişebilmektedir.
Dosyalara İlişkin Temel Kavramlar
Dosyanın Açılması
Bir dosya üzerinde işlem yapmadan önce dosya açılmalıdır. Dosya açabilmek için işletim sisteminin “dosya aç” isimli bir sistem fonksiyonu kullanılır. Dosyanın açılması sırasında dosya ile ilgili çeşitli ilk işlemler işletim sistemi tarafından yapılır.

Bir dosya açıldığında, dosya bilgileri, ismine “Dosya Tablosu” (File table) denilen ve işletim sisteminin içerisinde bulunan bir tabloya yazılır. Dosya tablosunun biçimi sistemden siteme değişebilir. Örneğin tipik bir dosya tablosu şağıdaki gibi olabilir :

Dosya tablosu (File table)
Sıra No
Dosya ismi
Dosyanın Diskteki Yeri
Dosyanın Özellikleri
Diğerleri
0

1

...

12
AUTOEXEC.BAT
...
...
...
...

Sistem fonksiyonlarının da parametreleri ve geri dönüş değerleri vardır. "Dosya aç" sistem fonksiyonunun parametresi açılacak dosyanın ismidir.Fonksiyon, dosya bilgilerinin yazıldığı sıra numarası ile geri döner ki bu değere "file handle" denir. Bu handle değeri diğer dosya fonksiyonlarına parametre olarak geçirilir. Dosyanın açılması sırasında buna ek olarak başka önemli işlemler de yapılmaktadır.
Dosyanın Kapatılması
Dosyanın kapatılması açılması sırasında yapılan işlemlerin geri alınmasını sağlar. Örneğin dosyanın kapatılması sırasında, işletim sisteminin dosya tablosunda bulunan bu dosyaya ilişkin bilgiler silinir. Açılan her dosya kapatılmalıdır. Kapatılmaması çeşitli problemlere yol açabilir.
Dosyaya Bilgi Yazılması ve Okunması
İşletim sistemlerinin dosyaya n byte veri yazan ve dosyadan n byte veri okuyan sistem fonksiyonları vardır. Yazma ve okuma işlemleri bu fonksiyonlar kullanılarak yapılır.
Dosya pozisyon göstericisi (file pointer)
Bir dosya byte’lardan oluşur. Dosyadaki her bir byte’a 0’dan başlayarak artan sırada bir sayı karşılık getirilmiştir. Bu sayıya ilgili byte’ın ofset numarası denir. Dosya pozisyon göstericisi long türden bir sayıdır ve bir ofset değeri belirtir. Dosyaya yazan ve dosyadan okuma yapan fonksiyonlar bu yazma ve okuma işlemlerini her zaman dosya pozisyon göstericisinin gösterdiği yerden yaparlar. Örneğin dosya göstericisinin gösterdiği yer 100 olsun. Dosyadan 10 byte bilgi okumak için sistem fonksiyonu çağırıldığında, 100. ofsetden itibaren 10 byte bilgi okunur. İşletim sisteminin dosya göstericisini konumlandıran bir sistem fonksiyonu vardır. Dosya ilk açıldığında dosya göstericisi 0. ofsetdedir. Örneğin bir dosyanın 100. Ofsetinden itibaren 10 byte okunmak istenirse sırası ile şu işlemlerin yapılması gerekir:

İlgili dosya açılır.
Dosya pozisyon göstericisi 100. Offsete konumlandırılır.
Dosyadan 10 byte okunur.
Dosya kapatılır.

C dilinde dosya işlemleri 2 biçimde yapılabilir :

1. İşletim sisteminin sistem fonksiyonları doğrudan çağırılarak.
2. Standart C fonksiyonları kullanılarak.

Prototipleri stdio.h içerisinde olan standart dosya fonksiyonlarının hepsinin ismi f ile başlar.Tabi standart C fonksiyonları da işlemlerini yapabilmek için aslında işletim sisteminin sistem fonksiyonlarını çağırmaktadır. İşletim sisteminin sistem fonksiyonları taşınabilir değildir. İsimleri ve parametrik yapıları sistemden sisteme değişebilir. Bu yüzden standart C fonksiyonlarının kullanılması tavsiye edilir.
fopen fonksiyonu
FILE *fopen (const char *fname, const char *mode)

Fonksiyonun 1. Parametresi açılacak dosyanın ismidir. 2. Parametre açış modudur. Dosya ismi path içerebilir. Dizin geçişleri için / de konulabilir. Açış modu şunlar olabilir :

Mode
Anlamı
"w"
Dosyayı yazmak için açar. Dosyadan okuma yapılamaz. Dosyanın mevcut olaması zorunlu değildir. Dosya mevcut değilse yaratılır. Dosya mevcut ise sıfırlanır.
"w+"
Dosyayı yazma ve okuma için açar. Dosyanın mevcut olaması zorunlu değildir. Dosya mevcut değilse yaratılır. Dosya mevcut ise sıfırlanır.
"r"
Dosyayı okuma için açar. Dosyaya yazma yapılamaz. Dosya mevcut değilse açılamaz.
"r+"
Dosyayı okuma ve yazma için açar. (Dosyanın pozisyon göstericisi dosyanın başındadır). Dosya mevcut değilse açılamaz.
"a"
Dosyayı sonuna ekleme için açar. Dosyadan okuma yapılamaz. Dosyanın mevcut olaması zorunlu değildir. Dosya mevcut değilse yaratılır.
"a+"
Dosyayı sonuna ekleme ve dosyadan okuma için açar. Dosyanın mevcut olaması zorunlu değildir. Dosya mevcut değilse yaratılır.

Fonksiyonun geri dönüş değerine ilişkin FILE yapısı stdio.h içerisinde bildirilmiştir. Fonskiyonun geri dönüş değeri FILE yapısı türünden bir adrestir. Bu yapının elemanları standart değildir. Sistemden sisteme değişiklik gösterebilir. Zaten programcı bu yapının elemanlarına gereksinim duymaz. fopen fonksiyonu işletim sisteminin dosya aç sistem fonksiyonunu çağırarak dosyayı açar ve dosyaya ilişkin bazı bilgileri bu FILE yapısı içerisine yazarak bu yapının başlangıç adresini geri döndürür. Örneğin "file handle" değeri de bu yapının içerisindedir. Tabi fopen fonksiyonunun geri verdiği FILE türünden adres güvenli bir adrestir. Dosya çeşitli sebeplerden dolayı açılamayabilir. Bu durumda fopen NULL gösterici döndürür. Fonksiyonun geri dönüş değeri kesinlikle kontrol edilmelidir. Tipik bir kontrol işlemi aşağıdaki gibi yapılabilir:

if ((f = fopen(“data”, “r”)) == NULL) {
printf(“cannot open file”...\n);
exit(1);}

Dosya ismi dosyanın yeri hakkında bilgi (sürücü, path gibi) içerebilir. Dosya ismi string ile veriliyorsa path bilgisi verirken dikkatli olmak gerekecektir. path bilgisi \ karakteri içerebilir. string içinde \ karakterinin kullanılması, \ karakterininin onu izleyen karakterle birlikte önceden belirlenmiş ters bölü karakter sabiti olarak yorunlanmasına yol açabilecektir. Örneğin :

fopen("C:\source\new.dat", "r");

fonksiyon çağırımında derleyici \n karakterini "newline" karakteri olarak yorumlayacak \s karakterini ise "undefined" kabul edecektir. Bu problemden sakınmak \ yerine \\ kullanılmasıyla mümkün olur:

fopen("C:\\source\\new.dat", "r");

Append modları ("a", "a+") çok kullanılan modlar değildir. Dosyaya yazma durumunda "w" modu ile "a" modu arasında farklılık vardır. "w" modunda dosyada olan ofsetin üzerine yazılabilir. "a" modunda ise dosya içeriği korunarak sadece dosyanın sonuna yazma işlemi yapılabilir. Bir dosyanın hem okuma hem de yazma amacıyla açılması durumunda (yani açış modunu belirten stringde '+' karakterinin kullanılması durumunda dikkatli olmak gerekir. Okuma ve yazma işlemleri arasında mutlaka ya dosya pozisyon göstericisinin konumlandırılması (mesela fseek fonksiyonu ile) ya da dosyaya ilişken tampon bellek alanının (buffer) tazelenmesi gerekecektir.

Bir dosyanın açılıp açılamayacağını aşağıdaki şekilde test edebiliri:

Program komut satırından

canopen dosya.dat

şeklinde çalıştırıldığında ekrana "xxxxx dosyası açılabilir" ya da "xxxxx dosyası açılamaz" yazacaktır.

#include

int main(int argc, char *argv[])
{
FILE *fp;

if (argc != 2) {
printf("usage: canopen filename\n");
return 2;
}
if ((fp = fopen(argv[1], "r")) == NULL) {
printf("%s dosyası açılamaz\n", argv[1]);
return 1;
}
printf("%s dosyası açılabilir\n", argv[1]);
fclose(fp);
return 0;
}
fclose fonksiyonu
int fclose(FILE *stream);
Bu fonksiyon açılmış olan bir dosyayı kapatır. Fonksiyon fopen ya da fropen fonksiyonundan elde edilen FILE yapısı türünden adresi parametre olarak alır ve açık olan dosyayı kapatır. Fonksiyonun geri dönüş değeri 0 ise dosya başarılı olarak kapatılmıştır. Fonksiyonun geri dönüş değeri EOF ise dosya kapatılamamıştır. EOF stdio.h içinde tanımlanan bir sembolik sabittir ve derleyicilerin çoğunda (-1) olarak tanımlanmıştır. Fonksiyonun başarısı ancak şüphe altında test edilmelidir. Normal şartlar altında dosyanın kapatılmaması için bir neden yoktur.

int main()
{
FILE *f;

if ((f = fopen(“data”, “w”)) ==NULL) {
printf(“cannot open file”...\n);
exit(1);
}
fclose(f);
return 0;
}

fgetc fonksiyonu
int fgetc(FILE *f);

İşletim sisteminin dolayısıyla C’nin yazma ve okuma yapan fonksiyonları yazılan ve okunan miktar kadar dosya göstericisini ilerletirler. fgetc fonksiyonu dosya göstericisinin gösterdiği yerdeki byte’ı okur ve geri dönüş değeri olarak verir. Fonksiyon başarısız olursa , stdio.h dosyası içerisinde sembolik sabit olarak tanımlanmış EOF değerine geri döner. Pek çok derleyici de EOF sembolik sabiti aşağıdaki gibi tanımlanmıştır.

#define EOF (-1)

fgetc fonksiyonunun geri dönüş değerini char türden bir değişkene atamak yanlış sonuç verebilir, bu konuda dikkatli olunmalı ve fonksiyonun geri dönüş değeri int türden bir değişkende saklanmalıdır.

char ch;
...
ch = fgetc(fp);

Yukarıda dosyadan okunan karakterin 255 numaralı ASCII karakteri (0x00FF) olduğunu düşünelim. Bu sayı char türden bir değişkene atandığında yüksek anlamlı byte'ı kaybedilecek ve ch değişkenine 0xFF değeri atanacaktır. Bu durumda ch değişkeni işaretli char türden olduğundan ch değişkeni içinde negatif bir sayının tutulduğu anlamı çıkar.

if (ch == EOF)

gibi bir karşılaştırma deyiminde, if parantezi içerisindeki karşılatırma işleminin yapılabilmesi için otomatik tür dönüşümü yapılır. Bu otomatik tür dönüşümünde işaretli int türüne çevrilecek ch değişkeni FF byte'ı ile beslenecektir. (negatif olduğu için). Bu durumda eşitlik karşılaştırması doğru netice verecek, yani dosyanın sonuna gelindiği (ya da başka nedenden dolayı okumanın yapılamadığı) yorumu yapılacaktır.

Oysa ch değişkeni int türden olsaydı, ch değişkenine atanan değer 0x00FF olacak ve bu durumda karşılaştırma yapıldığında ch değişkeni ile EOF değerinin (0xFFFF) eşit olmadığı sonucuna varılacaktır.

Bir dosyanın içeriğini ekrana yazdıran örnek program:

#include

int main()
{
FILE *f;
char fname[MAX_PATH];
int ch;

printf(“Dosya ismi : “);
gets(fname);
if (f = fopen(fname, “r”)) == NULL) {
printf(“cannot open file...\n”);
exit(1);
}
while (ch = fgetc(f)) != EOF)
putchar(ch);
fclose(f);
return 0;
}

not : maximum path uzunluğu DOS’da 80 UNIX ve WINDOWS’da 256 karakteri geçemez.
fputc Fonksiyonu
int fputc(int ch, FILE *p);
Bu fonksiyon dosya göstericisinin bulunduğu yere 1 byte bilgiyi yazar. Fonksiyonun 1. parametresi yazılacak karakter, 2. parametresi ise yazılacak dosyaya ilişkin FILE yapısı adresidir. Fonksiyonun geri dönüş değeri EOF ise işlem başarısızdır. Değilse fonksiyon yazılan karakter ile geri döner.

fgetc ve fputc fonksiyonları kullanılarak bir dosyayı kopyalayan örnek program:

#include
#include

#define MAX_PATH 80

int main()
{
FILE *fsource, *fdest;
char source[MAX_PATH], dest[MAX_PATH];
int ch;

printf(“kopyalanacak dosya : “);
gets(source);
printf(“kopya dosya : “);
gets (dest);
if ((fsource = fopen(source, “r”)) == NULL) {
printf(“cannot open file...\n”);
exit(EXIT_FAILURE);
}
if ((fdest = fopen(dest, “w”)) == NULL) {
printf(“cannot create file...\n”);
exit(EXIT_FAILURE);
}
while ((ch = fgetc(fsource)) != EOF)
fputc(ch, fdest);
fclose(fsource);
fclose(fdest);
printf(“1 file copied...\n”);
return 0;
}

fprintf Fonksiyonu
Bu fonksiyon tıpkı printf fonksiyonu gibidir. Ancak ilk parametresi yazma işleminin hangi dosyaya yapılacağını belirtir. Diğer parametreleri printf fonksiyonun da olduğu gibidir. Özetle printf fonksiyonu ekrana yazar ancak fprint fonksiyonu 1. parametre değişkeninde belirtilen dosyaya yazar.

#include
#include

#define MAX_PATH 80

int main()
{
FILE *f;
int i;

if ((f = fopen(“data”, “w”)) ==NULL) {
printf(“cannot open file...\n");
exit(1);
}
for (i = 0; i < 10; ++i)fprintf(f, “sayi = %d\n”, i);fclose(f);return 0;}fgets fonksiyonuchar *fgets(char *buf, int n, FILE *f);Bu fonksiyon dosya göstericisinin gösterdiği yerden 1 satırlık bilgiyi okur. Fonksiyon dosyadan '\n' karakterini okuyunca onu da birinci parametresinde verilen adrese yazarak işlemini sonlandırır.Fonksiyonun 1. parametresi okunacak bilginin RAM'de yerleştirileceği yerin adresidir. 2. parametresi ise okunacak maksimum karakter sayısıdır. fgets en fazla n –1 karakteri okur. Okuduğu karakterlerin soonuna null karakteri ekler ve işlemini sonlandırır. Eğer satır üzerindeki karakter sayısı n- 1'den az ise tüm satırı okur ve işlemini sonlandırır. Örneğin bu parametreyi 10 olarak girdiğimizi düşünelim. Satır üzerinde 20 karakter olsun. Fonksiyon 9 karakteri okur, sonuna NULL karakteri ekler. Ancak satır üzerinde \n dahil olmak üzere 5 karakter olsaydı fonksiyon bu 5 karakteri de okuyarak sonuna da NULL karakter ekleyerek işlemini sonlandıracaktı. Bir döngü içerisinde fgets fonksiyonu sürekli olarak çağırılarak bütün dosya okunabilir.Fonksiyonun geri dönüş değeri, en az 1 karakter okunmuş ise 1. parametresi ile belirtilen adresin aynısı, hiç okunmamışsa NULL adresidir.Örnek : Bir dosyayı fgets fonksiyonu ile satır satır olarak ekrana yazan program:#define MAX_PATH 80#define MBUFSIZE 100int main(){FILE *f;char s[MAX_PATH];char buf[BUFSIZE];printf(“Dosya : “);gets(s);if ((f = fopen(s, “r”)) == NULL) {printf(“cannot open file...\n”);exit(1);}while (fgets(buf, BUFSIZE, f) != NULL)printf(“%s”, buf);fclose(f);return 0;}Text ve Binary Dosya KavramlarıDOS VE WINDOWS işletim sistemlerinde bir dosya text ve binary modda açılabilir. Varsayılan açış modu textdir. Yani dosyanın hangi modda açıldığı açık bir şekilde belirtilmezse dosyanın text modda açıldığı varsayılacaktır. Dosyayı binary modda açabilmek için açış modunun sonuna b eklemek gerekir. Örneğin :f = fopen(“data”, “r”) text moddaf = fopen(“data, “rb”) binary moddaDOS’da bir dosya type edildiğinde bir karakter aşağı satırın başında görünüyorsa bunu sağlamak için o karakterden önce CR (carriage return) ve LF (line feed) karakterlerinin bulunması gerekir. CR karakteri C’de ‘\r’ ile belirtilir. 13 numaralı ASCII karakteridir. LF karakteri C’de \n ile belirtilir. 10 numaralı ASCII karakteridir. Örneğin bir dosya type edildiğinde görüntüabşeklinde olsun. Dosyadaki durum a\r\nb şeklindedir. Oysa UNIX sistemlerinde aşağı satırın başına geçebilmek için sadece LF karakteri kullanılmaktadır. UNIX deabgörüntüsünün dosya karşılığıa\nb biçimindedir.DOS’da LF karakteri bulunulan satırın aşağısına geç CR karakteri ise bulunulan satırın başına geç anlamındadır. Örneğin DOS da bir bir dosyanın içeriği a\nb biçiminde ise dosya type edildiğindeabgörüntüsü elde edilir. Eğer dosyanın içeriği a\rb biçiminde ise dosya type edildiğindebgörüntüsü elde edilir.printf fonksiyonunda \n ekranda aşağı satırın başına geçme amacıyla kullanılır. Aslında biz printf fonksiyonunun 1. parametresi olan stringin içine \n yerleştirdiğimizde UNIX'de yalnızca \ni DOS'da ise \r ve\n ile bu geçiş sağlanır.Text dosyaları ile rahat çalışabilmek için dosyalar text ve binary olarak ikiye ayrılmıştır. Bir dosya text modunda açıldığında dosyaya \n karakteri yazılmak istendiğinde dosya fonksiyonları otomatik olarak \r ve \n karakterlerini dosyaya yazarlar. Benze r bir biçimde dosya text modda açılmışsa dosya göstericisi \r\n çiftini gösteriyorsa dosyadan yalnızca /n karakteri okunur. DOS işletim sisteminde text ve binary dosyalar arasındaki başka bir fark da, CTRL Z (26 numaralı ASCII karakterinin) dosyayı sonlandırdığının varsayılmasıdır. Oysa dosya binary modda açıldığında böyle bir varsayım yapılmaz.UNIX işletim sisteminde text modu ile binary mod arasında hiçbir fark yoktur. Yani UNIX işletim sisteminde dosyanın binary mod yerine text modunda açılmasının bir sakıncası olmayacaktır. Ancak DOS altında text dosyası olmayan bir dosyanın binary mod yerine text modunda açılmasının sakıncaları olabilir. Örneğin DOS altında bir exe dosyanın binary mod yerine text modda açıldığını düşünelim. Bu dosyada 10 numaralı ve 13 numaralı ASCII karakterleri yanyana bulunduğunda dosyadan yalnızca 1 byte okunacaktır. Aynı şekilde dosyadan 26 numaralı ASCII karakteri okunduğunda dosyadan artık başka bir okuma yapılamayacaktır. (Dosyanın sonuna gelindiği varsayılacaktır.)/*textmode.c programıDOS altında text modu ile binary mod arasındakifarkı gösteren bir program*/#include #include #include main(){FILE *fp;int k, ch;clrscr();fp = fopen("deneme", "w");if (fp == NULL) {printf("dosya açılamıyor\n");exit(EXIT_FAILURE);}/* dosyaya 5 tane \n karakteri yazdırılıyor */for (k = 0; k < 5; ++k)fputc('\n', fp);fclose(fp);printf("\ndosya binary modda açılarak yazdırılıyor\n");fp = fopen("deneme", "rb");if (fp == NULL) {printf("dosya açılamıyor\n");exit(EXIT_FAILURE);}while ((ch = fgetc(fp)) != EOF)printf("%d ", ch);/* ekran çıktısı13 10 13 10 13 10 13 10 13 10*/fclose(fp);printf("\ndosya kapatıldı. Şimdi dosya text modunda açılarak yazdırılıyor .\n");fp = fopen("deneme", "r");if (fp == NULL) {printf("dosya açılamıyor\n");exit(EXIT_FAILURE);}while ((ch = fgetc(fp)) != EOF)printf("%d ", ch);/* ekran çıktısı10 10 10 10 10*/fclose(fp);/* simdi '\x1A' karakterinin text modunda dosyayı sonlandırması özelliğitest ediliyor */fp = fopen("deneme", "w");if (fp == NULL) {printf("dosya açılamıyor\n");exit(EXIT_FAILURE);}/* dosyaya 5 tane 'A' karakteri yazdırılıyor */for (k = 0; k < 5; ++k)fputc('A', fp);/* dosyaya '\x1A' karakteri yazdırılıyor */fputc('\x1a', fp);/* dosyaya 10 tane 'A' karakteri yazdırılıyor. */for (k = 0; k < 5; ++k)fputc('A', fp);fclose(fp);printf("\ndosya binary modda açılarak yazdırılıyor :\n");fp = fopen("deneme", "rb");if (fp == NULL) {printf("dosya açılamıyor\n");exit(EXIT_FAILURE);}while ((ch = fgetc(fp)) != EOF)printf("%d ", ch);/* ekran çıktısı65 65 65 65 65 26 65 65 65 65 65*/printf("\ndosya kapatıldı, Şimdi dosya text modunda açılarak yazdırılıyor\n");fp = fopen("deneme", "r");if (fp == NULL) {printf("dosya açılamıyor\n");exit(EXIT_FAILURE);}while ((ch = fgetc(fp)) != EOF)printf("%d ", ch);/* ekran çıktısı65 65 65 65 65 26 65 65 65 65 65*/fclose(fp);return 0;}EOF (END OF FILE) DURUMUDosyanın sonunda hiçbir özel karakter yoktur. İşletim sistemi dosyanın sonuna gelinip gelinmediğini dosyanın uzunluğuna bakarak anlayabilir. EOF durumu dosya pozisyon göstericisinin dosyada olmayan son karakteri göstermesi durumudur. EOF durumunda dosya pozisyon göstericisinin offset değeri dosya uzunluğu ile aynı değerdedir. EOF durumunda dosyadan okuma yapılmak istenirse dosya fonksiyonları başarısız olur. Ancak açış modu uygunsa dosyaya yazma yapılabilir ve bu durumda dosyaya ekleme yapılır.Daha önce söylendiği gibi C dilinde açılan bir dosya ile ilgili bilgiler FILE türünden bir yapı nesnesi içinde tutulur. Bu yapının her bir elemanı dosyanın bir özelliği hakkında bilgi vermektedir. C programcısı bu yapının elemanlarının değerleri ile doğrudan ilgilenmez, zira fopen fonksiyonunun geri dönüş değeri bu yapı nesnesini gösteren FILE yapısı türünden bir göstericidir ve C dilinin dosyalarla ilgili işlem yapan fonksiyonları çoğunlukla bu adresi parametre olarak alarak, istenilen dosyaya ulaşırlar.Söz konusu FILE yapısının elemanlarından biri de flag olarak kullanılan EOF indikatörüdür. (aslında int türden bir flag'in yalnızca belirli bir bitidir.) C dilinin dosyalarla ilgili işlem yapan bazı fonksiyonları EOF indikatörünün değerini değiştirirler. (set ya da clear ederler. Set edilmesi bu indikatöre 1 değerinin atanması clear edilmesi ise 0 değerinin atanmasıdır. Bu indikatörün set edilmesi demek dosya pozisyon göstericisinin dosyanın sonunu göstermesi demektir.Dosya açan fonksiyonlar FILE yapısındaki EOF indikatörünü sıfırlarlar. Bu fonksiyonlar dışında fseek fonksiyonu ve clearerr fonksiyonları da EOF indikatörünü sıfırlarlar. (clear ederler).fseek fonksiyonu :Bu fonksiyon dosya pozisyon göstericisini istenilen bir offsete konumlandırmak amacıyla kullanılır. Bu fonksiyonun kullanılmasıyla, açılmış bir dosyanın istenilen bir yerinden okuma yapmak ya da istenilen bir yerine yazmak mümkün hale gelir. Prototipi :int fseek(FILE *f, long offset, int origin);Fonksiyonun ikinci parametresi konumlandırma işleminin yapılacağı offset değeridir.Fonksiyonun 3. parametresi 0, 1, veya 2 olabilir. Bu değerler stdio.h dosyasında#define SEEK_SET 0#define SEEK_CUR 1#define SEEK_END 2biçiminde sembolik sabitlerle tanımlanmıştır ve fseek fonksiyonun çağırılmasında daha çok bu sembolik sabitler kullanılmaktadır.son parametre 0 ise, konumlandırma dosya başından itibaren yapılır. Bu durumda 2. parametre >= 0 olmalıdır. Örneğin:

fseek(f, 10L, 0);

ile dosya göstericisi 10. offsete konumlandırılır. Ya da

fseek(f, 0, 0);

ile dosya göstericisi dosyanın başına konumlandırılır. Dosya pozisyon göstericisinin dosyanın başına konumlandırılması için rewind fonksiyonu da kullanılabilir:

void rewind(FILE *fp);

rewind(f);

fonksiyonun 3. parametre değişkenine geçilen değer 1 ise (SEEK_CUR) , konumlandırma dosya göstericisinin en son bulunduğu yere göre yapılır. Bu durumda ikinci parametre pozitif ya da negatif değere sahip olabilir. Pozitif bir değer ileri, negatif bir değer geri anlamına gelecektir. Örneğin dosya göstericisi 10. offsette olsun.

fseek(f, -1, SEEK_CUR);

çağırması ile dosya göstericisi 9. offset'e konumlandırılır.

fonksiyonun 3. parametre değişkenine geçilen değer 2 ise (SEEK_END), konumlandırma EOF durumundan itibaren yani dosya sonunu referans alınarak yapılır. Bu durumda ikinci parametre <= 0 olmalıdır. Örneğin dosya göstericisini EOF durumuna çekmek için :fseek(f, 0, SEEK_END);çağırmasını yapmak gerekir. Ya da başka bir örnek:fseek(f, -1, SEEK_END);çağırması ile dosya göstericisi son karakterin offsetine çekilir. Fonksiyonun geri dönüş değeri işlemin başarısı hakkında bilgi verir. Geri dönüş değeri 0 ise işlem başarılıdır. Geri dönüş değeri 0 dışı bir değer ise işlem başarısızdır. Ancak problemli durumlarda geri dönüş değrinin test edilmesi tavsiye edilir.Yazma ve okuma işlemleri arasında dosya göstericisinin fseek fonksiyonu ile konumlandırılması gerekir.Konumlandırma gerekirse boş bir fseek çağırması ile yapılabilir. Örneğin dosyadan bir karakter okunup , bir sonraki karaktere bu karakterin 1 fazlasını yazacak olalım.ch = fgetc(f);fputc(ch + 1, f);işlemi hatalıdır. Yazmadan okumaya, okumadan yazmaya geçişte dosya göstericisi konumlandırılmalıdır.feof fonskiyonu :bu fonksiyon dosya göstericisinin EOF durumunda olup olmadığını (EOF indikatörünün set edilip edilmediğini) test etmek amacıyla kullanılır. Prototipi:int feof(FILE *f);Eğer dosya göstericisi dosya sonunda ise (EOF indikatörü set edilmişse) fonksiyon 0 dışı bir değere , değilse (EOF indikatörü set edilmemişse) 0 değeri ile geri döner.Ancak feof fonksiyonunun 0 dışı bir değere geri dönebilmesi için dosya göstericisinin dosyanın sonunda olmasının yanı sıra en son yapılan okuma işleminin de başarısız olması gerekir. daha önce söylendiği gibi bazı fonksiyonlar (fopen, fseek, rewind, clearerr) EOF indikatorünü clear ederler, yani EOF indikatörünün 0 değerinde olması (clear edilmiş olması) dosyanın sonunda olunmadığının bir garantisi değildir.fread ve fwrite fonksiyonlarıBu iki fonksiyon C dilinde en çok kullanılan dosya fonksiyonlarıdır. Genel olarak dosya ile RAM arasında transfer yaparlar. Her iki fonskiyonun da prototipleri aynıdır.size_t fread(void *adr, size_t size, size_t n, FILE *);size_t fwrite (const void *adr, size_t size, size_t n, FILE *);size_t türünün derleyiciyi yazanlar tarafından unsigned int ya da unsigned long türünün typedef edilmiş yeni ismi olduğunu hatırlayalım.fread fonskiyonu dosya pozisyon göstericisinin gösterdiği yerden, 2. ve 3. parametresine kopyalanan değerlerin çarpımı kadar byte'ı , RAM'de 1. parametresinin gösterdiği adresten başlayarak kopyalar. Geleneksel olarak fonksiyonun 2. parametresi veri yapısının bir elemanının uzunluğunu, 3. parametresi ile parça sayısı biçiminde girilir.Bu fonksiyonlar sayesinde diziler ve yapılar tek hamlede dosyaya transfer edilebilirler. Örneğin 10 elemanlı bir dizi aşağıdaki gibi tek hamlede dosyaya yazılabilir.int a[5] = {3, 4, 5, 7, 8};fwrite (a, sizeof(int), 5, f);Yukarıdaki örnekte, dizi ismi olan a int türden bir adres bilgisi olduğu için, fwrite fonksiyonuna 1. arguman olarak gönderilebilir. FILE türünden f göstericisi ile ilişkilendirilen dosyaya RAM'deki a adresinden toplam sizeof(int) * 5 byte yazılmaktadır.Ancak tabi fwrite fonskiyonu sayıları bellekteki görüntüsü ile dosyaya yazar. (yani fprintf fonksiyonu gibi formatlı yazmaz.) Örneğin:int i = 1535;fwrite(&i, sizeof(int), 1, f);Burada dosya type edilirse 2 byte uzunluğunda rasgele karakterler görünür. Çünkü DOS'da int türü 2 byte uzunluğundadır. Bizim gördüğümüz ise 1525'in rasgele olan bytelarıdır. Bilgileri ASCII karşılıkları ile dosyaya yazmak için fprintf fonksiyonu kullanılabilir..fread ve fwrite fonksiyonları bellekteki bilgileri transfer ettiğine göre dosyaların da binary modda açılmış olması uygun olacaktır.#include #include int main(){FILE *f;int i;int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};int b[10];if ((f = fopen("data", w+b")) == NULL) {printf("cannot open file...\n");exit(EXIT_FAILURE);}fwrite (a, sizeof(int), 10, f);fseek(f, 0, SEEK_SET);fread(b, sizeof(int), 10, f);for (i = 0; i < 10; ++i)printf("%d\n", b[i]);}fread ve fwrite fonksiyonlarının geri dönüş değerleri 3. parametresi ile belirtilen okunan ya da yazılan parça sayısıdır. Örneğinn = fread(a, sizeof(int), 10, f);ifadesinde fonksiyon bütün sayıları okuyabildiyse 10 sayısına geri döner. Eğer dosyadaki kalan byte sayısı okunmak istenen sayıdan az ise fonksiyon bütün byte'ları okur ve geri dönüş değeri okunan byte sayısı 2. parametresi ile belirtilen sayı olur. Örneğin DOS altında çalışıyor olalım. Dosyada 10 byte bilgi kalmış olsun.n = fread(a, sizeof(int), 10, f);ile fonksiyon 5 sayısına geri dönecektir.Aşağıdaki iki ifadeyi inceleyelim:fread(str, 100, 1, f);fread(str, 1, 100, f);her iki fonksiyon çağırma ifadesi de RAM'deki str adresine FILE türünden f göstericisi ile ilişkilendirilen dosyadan 100 byte okumak amacıyla kullanılabilir. Ancak birinci çağırmada geri dönüş değeri ya 0 ya 1 olabilecekken, ikinci fonksiyon çağırmasında geri dönüş değeri 0 100(dahil) herhangi bir değer olabilecektir.Blok blok kopyalama işlemiAşağıdaki örnekte bir grup byte fread fonskiyonu ile bir dosyadan okunmuş ve fwrite fonksiyonu ile diğer bir dosyaya yazılmıştır.#define BLOCK_SIZE 1024#define MAX_PATH 80int main(){FILE *fs, *fd;char s[MAX_PATH], d[MAX_PATH];unsigned n;printf("kaynak dosya : ");gets(s);printf("amaç dosya : ");gets(d);if ((fs = fopen(s, "rb")) == NULL) {printf("cannot open file ...\n");exit(EXIT_FAILURE);}if ((fd = fopen(d, "wb")) == NULL) {printf("cannot open file ...\n");fclose(fs);exit(EXIT_FAILURE);}while ((n = fread(buf, 1, BLOCK_SIZE, fs)) > 0)
fwrite(buf, 1, n, fd);
fclose(fs);
fclose(fd);
printf("1 file copied...\n");
return 0;
}

remove fonksiyonu

Bu fonksiyon bir dosyayı silmek için kullanılır. Fonksiyonun prototipi :

int remove (const char *filename);

şeklindedir. Fonksiyona arguman olarak silinecek dosyanın ismi gönderilir. Fonksiyonun geri dönüş değeri, dosyanın başarılı bir şekilde silinebilmesi durumunda 0 aksi halde (yani dosya silinememişse) 0 dışı bir değerdir. Açık olan bir dosyanın silinmesi "implementation depended" (derleyiciye bağlı) olduğundan, yazılan kodun taşınabilirliği açısından, silinecek bir dosya açık ise önce kapatılmalıdır.

rename fonksiyonu

Bu fonksiyon bir dosyanın ismini değiştirmek için kullanılır. Fonksiyonun prototipi :

int rename (const char *old, const char *new);

şeklindedir.

Fonksiyona 1. arguman olarak dosyanın eski ismi ikinci arguman olarak ise dosyanın yeni ismi gönderilmelidir. Fonksiyonun geri dönüş değeri, isim değiştirmen işleminin başarılı olması durumunda 0, aksi halde (dosyanın ismi değiştirilemiyorsa 0 dışı bir değerdir. (Örneğin açık olan bir dosyanın isminin değiştirilmeye çalışılması başarılı olamayacağından fonksiyon bu durumda 0 dışı bir değere geri dönecektir.)

tmpfile fonksiyonu

Fonksiyon geçici bir dosya açmak amacıyla kullanılır. Fonksiyonun prototipi :

FILE * tmpfile(void);

tmpfile fonksiyonu açtığı geçici dosyayı "wb" modunda açar. Açılan dosya fclose fonksiyonu ile kapatıldığında ya da (kapatılmazsa), program sona erdiğinde otomatik olarak silinecektir. Fonksiyonu geri dönüş değeri, açılan geçici dosya ile ilişki kurulmasına yarayacak, FILE yapısı türünden bir adrestir. Herhangi bir nedenle dosya geçici dosya açılamıyorsa fonksiyon NULL adresine geri dönecektir.

tmpnam fonksiyonu

Geçici olarak kullanılacak bir dosya için bir isim üretilmesi amacıyla kullanılır. Fonksiyonun prototipi :

char *tmpnam(char *s);

şeklindedir. Fonksiyon ürettiği dosya ismini kendisine gönderilen char türden adrese yerleştirir. Eğer fonksiyona arguman olarak NULL adresi gönderilirse, fonksiyon üretilen dosya ismini statik bir dizi içinde tutarak bu dizinin adresiyle geri dönecektir. Fonksiyona char türden bir dizinin adresi gönderildiğinde bu dizinin boyutu ne kadar olmalıdır. Başka bir deyişle tmpnam fonksiyonu kaç karakter uzunluğunda bir dosya ismi üretecektir. İşte bu değer stdio.h dosyası içinde tanımlanan L_tmpnam sembolik sabitiyle belirtilmektedir.
tmpnam fonksiyonunun ürettiği dosya isminin daha önce kullanılmayan bir dosya ismi olması garanti altına alınmıştır. Yani üretilen dosya ismi tektir. (unique file name) Bir programda daha sonra silmek üzere bir dosya açacağımızı ve bu dosyaya birtakım bilgileri yazacağımız düşünelim. Bu durumda dosyayı yazma modunda açacağımıza göre, açacağımız dosyaya olan bir dosyanın ismini veremeyiz. Eğer verirsek , var olan dosya sıfırlanacağı için bu dosyayı kaybederiz. Bu riske girmemek için, geçici olarak kullanılacak dosya tmpfiel fonksiyonu kullanılarak açılmalıdır. Ancak tmpfile fonksiyonunun kullanılması durumunda, açılan dosya kalıcı hale getirilemez. Yani herhangi bir nedenden dolayı geçici dosyanın silinmemesini istersek, (dosyayı kalıcı hale getirmek istersek) dosyayı fopen fonksiyonuyla açmalıyız. İşte bu durumda geçici dosyayı başka bir dosyayı riske etmemek için tmpnam fonksiyonunun ürettiği isim ile açmalıyız. Peki tmpnam fonksiyonuyla en fazla kaç tane "unique file name " üretebiliriz. İşte bu sayı stdio.h içinde tanımlanan TMP_MAX sembolik sabiti ile belirlenmiştir.

C dilinde bazı giriş ve çıkış birimleri(klavye, ekran gibi) doğrudan bir dosya gibi ele alınırlar. C standartları herhangi bir giriş çıkış birimini "stream" olarak isimlendirmektedir. Bir stream bir dosya olabileceği gibi, dosya olarak ele alınan bir giriş çıkış birimi de olabilir. Örneğin küçük programlar genellikle girdilerini genellikle tek bir stream,den alıp (mesela klavye) çıktılarını da tek bir streame (mesela ekran) iletirler.

freopen fonksiyonu

freopen fonksiyonu daha önce açılmış bir dosyayı, fropen fonksiyonu ile açılan dosyaya yönlendirir. Fonksiyonun prototipi :

FILE *freopen(const char *filename, const char *mode, FILE *stream);
şeklindedir.

Uygulamalarda daha çok standart dosyaların (stdin, stdout, stderr) başka dosyalara yönlendirilmesinde kullanılır. Örneğin bir programın çıktılarının data.dat isimli dosyaya yazılmasını istersek :

if (freopen("data.dat", "w", stdout) == NULL) {
printf("data.dat dosyası açılamıyor\n");
exit(EXIT_FAILURE);}

yukarıdaki fonksiyon çağırımıyla stdout dosyasının yönlendirildiği dosya kapatılarak (bu yönlendirme işlemi komut satırından yapılmış olabileceği gibi, freopen fonksiyonunun daha önceki çağırımı ile de yapılmış olabilir.) stdout dosyasının data.dat dosyasına yönlendirilmesi sağlanır.

freopen fonksiyonunun geri dönüş değeri fonksiyona gönderilen üçüncü arguman olan FILE yapısı türünden göstericidir. freopen dosyası yönlendirmenin yapılacağı dosyayı açamazsa NULL adresine geri döner. Eğer yönlendirmenin yapıldığı eski dosya kapatılamıyorsa, freopen fonksiyonu bu durumda bir işaret vermez.

dosya buffer fonksiyonları

İkincil belleklerle (disket, hard disk vs.) yapılan işlemler RAM'de yapılan işlemlere göre çok yavaştır. Bu yüzden bir dosyadan bir karakterin okunması ya da bir dosyaya bir karakterin yazılması durumunda her defasında dosyaya doğrudan ulaşmak verimli bir yöntem değildir.
İşlemin performansı bufferlama yoluyla artırılmaktadır. Bir dosyaya yazılacak data ilk önce bellekteki bir buffer alanında saklanır. Bu buffer alanı dolduğunda ya da yazılmanın yapılacağı dosya kapatıldığında bufferdaki data alanında ne varsa dosyaya yazılır. Buna bufferin boşaltılması (to flush the buffer) denir.
Giriş dosyaları da benzer şekilde bufferlanabilir. Giriş biriminden alınan data (örneğin klavyeden) önce buffera yazılır.
dosyaların bufferlaması erimlilikte çok büyük bir artışa neden olur. Çünkü bufferdan (RAM'den) bir karakter okunması ya da buffera bir karakter yazılması ihmal edilecek kadar küçük bir zaman içinde yapılır. Buffer ile dosya arasındaki transfer şüphesiz yine vakit alacaktır ama bir defalık blok transferi, küçük küçük transferlerin toplamından çok daha kısa zaman alacaktır.

stdio.h başlık dosyası içinde prototipi bildirimi yapılan ve dosyalarla ilgili işlem yapan fonksiyonlar tamponlamayı otomatik olarak gerçekleştirirler. Yani dosyaların tamponlanması için bizim birşey yapmamıza gerek kalmadan bu iş geri planda bize sezdirilmeden yapılmaktadır. Ama bazı durumlarda tamponlama konusunda programcı belirleyici durumda olmak isteyebilir. İşte bu durumlarda programcı dosya tamponlama fonksiyonlarını (fflush, setbuf, setvbuf) kullanacaktır:

fflush fonksiyonu

Bir program çıktısını bir dosyaya yazarken (örneğin stdout dosyasına) yazılan dosya ilk önce RAM'deki tamponlama alanına gider. Dosya kapatıldığında ya da tamponlama alanı dolduğunda, tamponlama alanı boşaltılarak dosyaya yazılır. fflush fonksiyonunun kullanılmasıyla, dosyanın kapatılması ya da tamponlama alanının dolması beklenmeksizin, tamponlama alanı boşatılarak dosyaya yazılır. Bu işlem istenilen sıklıkta yapılabilir. Fonksiyonun prototipi :

int fflush (FILE *stream);

şeklindedir.

fflush(fp);

çağırımı ile FILE yapısı türünden fp göstericisi ile ilişkilendirilen dosyanın tamponlama alanı (buffer) boşaltılır. Eğer fflush fonksiyonuna NULL adresi gönderilirse, açık olan bütün dosyaların tamponlama alanları boşaltılacaktır.

Tamponlama alanının boşaltılması işlemi başarılı olursa fflush fonksiyonu 0 değerine geri dönecek aksi halde EOF değerine geri dönecektir.

setvbuf fonksiyonu

setvbuf fonksiyonu bir dosyanın tamponlanma şeklinin değiştirilmesi ve tampon alanının yerinin ve boyutunun değiştirilmesi amacıyla kullanılır. Fonksiyonun prototipi aşağıdaki şekildedir :

int setvbuf(FILE *stream, char *buf, int mode, size_t size);

Fonksiyona gönderilen üçüncü arguman tamponlama şeklini belirler. Üçüncü argumanın değeri stdio.h başlık dosyası içinde tanımlanan sembolik sabitlerle belirlenir.

_IOFBF (full buffering - tam tamponlama)
data dosyaya tamponlama alanı dolduğunda yazılır. Ya da giriş tamponlaması söz konusu ise dosyadan okuma tamponlama alanı boş olduğu zaman yapılır.

_IOLBF (line buffering - satır tamponlaması)
Tamponlama alanı ile dosya arasındaki okuma ya da yazma işlemi satır satır yapılır.

_IONBF (no buffering - tamponlama yok)
Dosyadan okuma ya da soyaya yazma tamponlama olmadan doğrudan yapılır.

setvbuf fonksiyonuna gönderilen ikinci arguman RAM'de tamponlamanın yapılacağı bloğun başlangıç adresidir. Tamponlamanın yapılacağı alan statik ya da dinamik ömürlü olabileceği gibi, dinamik bellek fonksiyonlarıyla da tahsis edilebilir.
Fonksiyona gönderilen son arguman tamponlama alanında tutulacak byteların sayısıdır.

setvbuf fonksiyonu dosya açıldıktan sonra, fakat dosya üzerinde herhangi biri işlem yapılmadan önce çağırılmalıdır. Fonksiyonun başarılı olması durumunda fonksiyon 0 değerine geri dönecektir. Fonksiyona gönderilen üçüncü argumanın geçersiz olması durumunda ya da fonksiyonun ilgili tamponlamayı yapamaması durumunda, geri dönüş değeri 0 dışı bir değer olacaktır.
Fonksiyona gönderilen buffer alanının geçerliliğinin bitmesinden önce (ömrünün tamamlanmasından önce) dosya kapatılmamalıdır.

dosya işlemleri ile ilgili örnek uygulamalar:

Uygulama 1 : Dosya üzerinde sıralı veri tabanı tutulması

#include
#include
#include
#include
/* symbolic constants */
#define MAX_PATH 80
#define ADDREC 1
#define LISTREC 2
#define FINDREC 3
#define DELREC 4
#define EDITREC 5
#define PACKRECS 6
#define SORTREC 7
#define EXITPROG 8
#define DELETED 0
#define NORMALREC 1
#define INVALID 0

/* structure declarations */

typedef struct _PERSON {
char name[30];
int no;
int delflag;
} PERSON;

/* function prototypes */

int GetOption(void);
void AddRec(void);
void ListRec(void);
void FindRec(void);
void DelRec(void);
void EditRec(void);
void SortRec(void);
void Pack(void);

/* global variables */

FILE *f;
char fname[MAX_PATH];

/* function definitions */

void AddRec(void)
{
PERSON per;

printf("Adı soyadı : ");
fflush(stdin);
gets(per.name);
printf("No : ");
scanf("%d", &per.no);
per.delflag = NORMALREC;
fseek(f, 0, SEEK_END);
fwrite(&per, sizeof(PERSON), 1, f);
}

void FindRec(void)
{
PERSON per;
char name[30];

printf("lütfen kayıt ismini giriniz :");
fflush(stdin);
gets(name);
fseek(f, 0, SEEK_SET);
while (fread(&per, sizeof(PERSON), 1, f) > 0) {
if (per.delflag != NORMALREC)
continue;
if (!stricmp(per.name, name)) {
printf("\n%s %d\n\n", per.name, per.no);
return;
}
}
printf("\nKayıt bulunamadı...\n\n");
}

void ListRec(void)
{
PERSON per;

putchar('\n');
fseek(f, 0L, SEEK_SET);
while (fread(&per, sizeof(PERSON), 1, f) > 0) {
printf("\n%20s %5d", per.name, per.no);
if (per.delflag == DELETED)
printf("\tDELETED");
}
putchar('\n\n');
}

void DelRec(void)
{
char name[30];
PERSON per;

printf("Silinecek kayıtın adı ve soyadı : ");
fflush(stdin);
gets(name);
fseek(f, 0, SEEK_SET);
while (fread(&per, sizeof(PERSON), 1, f) > 0) {
if (!stricmp(per.name, name)) {
per.delflag = DELETED;
fseek(f, -(long)sizeof(PERSON), 1);
fwrite(&per, sizeof(PERSON), 1, f);
printf("Record deleted!..\n");
return;
}
}
printf("silinecek kayıt bulunamadı");
}

void EditRec(void)
{
char name[30];
PERSON per;

printf("Değiştirilecek kayıtın adı ve soyadı : ");
fflush(stdin);
gets(name);
fseek(f, 0, SEEK_SET);
while (fread(&per, sizeof(PERSON), 1, f) > 0) {
if (per.delflag == NORMALREC && !stricmp(per.name, name)) {
printf("Adı soyadı : ");
fflush(stdin);
gets(per.name);
printf("No : ");
scanf("%d", &per.no);
fseek(f, -(long)sizeof(PERSON), 1);
fwrite(&per, sizeof(PERSON), 1, f);
printf("Record updated!..\n");
return;
}
}
printf("değiştirilecek kayıt bulunamadı\n");

}

int GetOption(void)
{
int option;

printf("\n1) Kayıt Ekle\n");
printf("2) Kayıt Listele\n");
printf("3) Kayıt Bul\n");
printf("4) Kayıt Sil\n");
printf("5) Kayıt değiştir\n");
printf("6) Pack\n");
printf("7) Sırala\n");
printf("8) Çık\n");
printf("\nSeçiminiz :");
scanf("%d", &option);
if (option <> 8)
return INVALID;
return option;
}

void SortRec(void)
{
PERSON per[2], tmp;
int i, count, chgFlag;

fseek(f, 0, SEEK_END);
count = ftell(f) / sizeof(PERSON);

do {
chgFlag = 0;
for (i = 0; i < count - 1; ++i) {fseek(f, (long)i * sizeof(PERSON), SEEK_SET);if (fread(per, sizeof(PERSON), 2, f) != 2) {printf("cannot read from the file!..\n");exit(EXIT_FAILURE);}if (per[0].no > per[1].no) {
chgFlag = 1;

tmp = per[0];
per[0] = per[1];
per[1] = tmp;

fseek(f, (long)i * sizeof(PERSON), SEEK_SET);
if (fwrite(per, sizeof(PERSON), 2, f) != 2) {
printf("cannot read from the file!..\n");
exit(EXIT_FAILURE);
}
}
}
} while (chgFlag);
}

void Pack(void)
{
FILE *fnew;
PERSON per;

if ((fnew = fopen("temp", "wb")) == NULL) {
printf("cannot create temporary file!..\n");
exit(EXIT_FAILURE);
}
fseek(f, 0l, SEEK_SET);
while (fread(&per, sizeof(PERSON), 1, f) > 0) {
if (per.delflag == NORMALREC)
fwrite(&per, sizeof(PERSON), 1, fnew);
}
fclose(fnew);
fclose(f);
if (unlink(fname)) {
printf("Fatal Error : Cannot open database file!..\n");
exit(EXIT_FAILURE);
}
if (rename("temp", fname)) {
printf("fatal Error: cannot delete database file!..\n");
exit(EXIT_FAILURE);
}
if ((f = fopen(fname, "r+b")) == NULL) {
printf("Fatal Error : Cannot open database file!..\n");
exit(EXIT_FAILURE);
}
printf("Pack operation succesfully completed!..\n");
}

void main()
{
char dfname[MAX_PATH];
int option;

printf("Data File : ");
gets(dfname);
if ((f = fopen(dfname, "r+b")) == NULL)
if ((f = fopen(dfname, "w+b")) == NULL) {
printf("Cannot open database file!..\n");
exit(EXIT_FAILURE);
}
strcpy(fname, dfname);
for (;;) {
option = GetOption();
switch (option) {
case ADDREC : AddRec(); break;
case LISTREC : ListRec(); break;
case FINDREC : FindRec(); break;
case DELREC : DelRec(); break;
case EDITREC : EditRec(); break;
case PACKRECS : Pack(); break;
case SORTREC : SortRec(); break;
case EXITPROG : goto EXIT;
case INVALID : printf("Geçersiz Seçenek!..\n");
}
}
EXIT:
fclose(f);
}

Uygulama 2: developer's back up programı (G. Aslan)

#include
#include
#include
#include
#include

#define GOOD 0
#define FAIL (-1)

#define FBUFSIZ (63*512) /* Buffer size */

char *Buffer, *in_buf, *out_buf;
char CmpFile[128], OutFile[128];

int filecmp(FILE *fi, FILE *fo)
{
int c1, c2;
long l1, l2;

l1 = filelength(fileno(fi));
l2 = filelength(fileno(fo));
if (l1 != l2)
return FAIL;

rewind(fi);
rewind(fo);
for (;;) {
c1 = getc(fi);
c2 = getc(fo);

if (c1 != c2) {
return FAIL;
}

if (c1 == EOF)
break;
}

return GOOD;
}

int filecopy(FILE *fi, FILE *fo)
{
int c, nbytes;

rewind(fi);
rewind(fo);
for (;;) {
c = fread(Buffer, 1, FBUFSIZ, fi);
if (c == 0) {
break;
}

nbytes = fwrite(Buffer, 1, c, fo);
if (nbytes != c) {
return FAIL;
}
}
return GOOD;
}

int main(int argc, char *argv[])
{
FILE *fi, *fo;
char *ptr;
int i;

printf("*GA Developer's Backup Utility. Version 1.0\n"
"(C) *GA, 1995\n\n");

if (argc != 2) {
fprintf(stderr, "Usage: BK \n");
return 1;
}

if ((Buffer = malloc(FBUFSIZ)) == NULL
(in_buf = malloc(FBUFSIZ)) == NULL
(out_buf = malloc(FBUFSIZ)) == NULL) {
fprintf(stderr, "Not enough memory\n");
return 2;
}

if ((fi = fopen(argv[1], "rb")) == NULL) {
ptr = argv[1];
OPN_ERR:
fprintf(stderr, "File could not be opened: '%s'\n", ptr);
return 3;
}
setvbuf(fi, in_buf, _IOFBF, FBUFSIZ);

strcpy(CmpFile, argv[1]);
ptr = strchr(CmpFile, '.');
if (ptr == NULL)
ptr = strchr(CmpFile, '\0');

for (i = 1; i <= 999; ++i) {sprintf(ptr, ".%03d", i);if (access(CmpFile, 0))break;} if (i == 1000) {fprintf(stderr, "Backup operation failed: File limit!\n");return 3;}strcpy(OutFile, CmpFile); if (i > 1) {
sprintf(ptr, ".%03d", i-1);

if ((fo = fopen(CmpFile, "rb")) == NULL) {
ptr = CmpFile;
goto OPN_ERR;
}
setvbuf(fo, out_buf, _IOFBF, FBUFSIZ);

if (!filecmp(fi, fo)) {
printf("No differences encountered: '%s'\n", CmpFile);
return 0;
}
fclose(fo);
}

printf("File being copied: %s ---> %s\n", argv[1], OutFile);

if ((fo = fopen(OutFile, "wb")) == NULL) {
ptr = OutFile;
goto OPN_ERR;
}
setvbuf(fo, out_buf, _IOFBF, FBUFSIZ);

if (filecopy(fi, fo)) {
fprintf(stderr, "File copy error!\n");
return 4;
}

fcloseall();

return 0;
}

Uygulama 3 : bol.c ve bir.c programları :

bir dosyanın belirkli byte büyüklüğünde n kadar sayıda dosyaya bölünmesi ve daha sonra başka bir programla bu dosyaların tekrar birleştirilmesi.

/*******bol.c *******************/

#include
#include
#include

#define MAX_LEN 80

int main(int argc, char **argv)
{
FILE *fs, *fd;
char fsname[MAX_LEN];
char fdname[MAX_LEN] = "dos0001.xxx";
int chunk;
long no_of_chars = 0L;
int no_of_files = 0;
int ch;

if (argc != 3) {
printf("bolunecek dosyanin ismini giriniz : ");
gets(fsname);
printf("kac byte'lik parcalara bolmek istiyorsunuz?");
scanf("%d", &chunk);
}
else {
strcpy(fsname, argv[1]);
chunk = atoi(argv[2]);
}

printf("%s dosyasi %d uzunlugunda dosyalara bolunecek!\n", fsname, chunk);

fs = fopen(fsname, "rb");
if (fs == NULL) {
printf("%s dosyasi acilamiyor!\n", fsname);
exit(EXIT_FAILURE);
}
fd = NULL;

while ((ch = fgetc(fs)) != EOF) {
if (fd == NULL) {
fd = fopen(fdname, "wb");
if (fd == NULL) {
printf(" %s dosyasi yaratilamiyor!\n", fdname);
exit(EXIT_FAILURE);
}
no_of_files++;
printf("%s dosyasi yaratildi!\n", fdname);
}
fputc(ch, fd);
no_of_chars++;
if (no_of_chars % chunk == 0) {
fclose(fd);
printf("%s dosyasi kapatildi!\n", fdname);
fd = NULL;
sprintf(fdname, "dos%04d.xxx", no_of_files + 1);
}
}
fclose(fs);
if (no_of_chars % chunk != 0) {
fclose(fd);
printf("%s dosyasi kapatildi!\n", fdname);
}

printf("%ld uzunlugunda %s dosyasi %d uzunlugunda %d adet dosyaya bolundu!\n",
no_of_chars, fsname, chunk, no_of_files);

return 0;
}

/*******bir.c *******************/

#include
#include
#include

#define MAX_LEN 80

int main(int argc, char **argv)
{
FILE *fs, *fd;
char fdname[MAX_LEN];
char fsname[MAX_LEN] = "dos0001.xxx";
int ch;
int no_of_files = 0;
long no_of_chars = 0L;
int k;

if (argc != 2) {
printf("birlestirilecek dosyanin ismini giriniz : ");
gets(fdname);
}
else {
strcpy(fdname, argv[1]);
}

fd = fopen(fdname, "wb");
if (fd == NULL) {
printf("%s dosyasi yaratilamiyor!\n", fdname);
exit(EXIT_FAILURE);
}

printf("%s dosyasi yaratildi!\n", fdname);
while (fs = fopen(fsname, "rb")) {
no_of_files++;
printf("%s dosyasi acildi!\n", fsname);

while ((ch = fgetc(fs)) != EOF) {
fputc(ch, fd);
no_of_chars++;
}
fclose(fs);
printf("%s dosyasi kapatildi!\n", fsname);
sprintf(fsname, "dos%04d.xxx", no_of_files + 1);
}
fclose(fd);
printf("%s dosyasi kapatildi!\n", fdname);
printf("%d adet dosya %ld uzunlugunda %s ismli dosya altinda\ birlestirildi!\n", no_of_files, no_of_chars, fdname);

for (k = 1; k <= no_of_files; ++k) {
sprintf(fsname, "dos%04d.xxx", k);
remove(fsname);
printf("%s dosyasi silindi!\n", fsname);
}

return 0;
}

C ye giris yapalım

2007-12-08T09:44:00.000-08:00

GiRiŞ

Bilgisayar, verileri saklayan , bunlar üzerinde çok hızlı işlem yapan ve istenen verileri sunan bir aygıttır.
Donanım (hardware) ve yazılım(software) diye iki bölüme ayrlır. Donanım bilgisayarın fiziksel bileşenleridir. Yazılım ise donanımı oluşturan bileşenlerin çalışmasını ve işlevlerini yerine getirmesini sağlayan programlardır.

İşlemci

Denetim Aritmetik Girdi
Birimi Mantık Çıktı
Birimi Ana Bellek
Yan Bellek

Girdi birimleri : Veri ve program girilmesini sağlar. Klavye, fare, kart okuyucu ...
Çıktı birimleri : İstenen verilerin kullanıcıya sunulduğu ortam. Ekran, yazıcı...
Ana Bellek : Programların ve işlenen verilerin geçici olarak saklandığı birim.
Yan bellek : Bilgilerin (veri, program) kalıcı olarak saklandığı ortamlar. Disket, disk, manyetik şerit.

Bilgisayar broşuründe olan kavramlar, bit, byte, ... RAM, ROM...

n Bu günkü anlamda ilk bilgisayar ENIAC [Electronic Numeric integrator and computer]
30 ton, kablolar ile programlama
n 1842, Charles Babbag , analitik makine tasarlıyor. Programlanabilir bir cihaz Öncesi Hesap Makinesi. Ada Agusta programcısı.

Bilgisayarlar :
1. Kusak 39 - 58 Vakum tüp ile çalışıyor
2. Kusak 58 - 64 Transistör
3. Kusak 64 - 75 Entegre
4. Kusak 75 - --- Yüksek ölçekli entegre

n Micro computer ( PC ) ( bu gün 50 - MIPS)
n Workstation
n Mini Computer
n Main Frame (50 lerde 50 IPS)
n Super Computer
Bilgisayarın yapısı
n Bellek (...., birimi byte bit)
n CPU ( Bilgiyi işleyen kısım bellekten okur - yazar)
n Denetim Birimi ( Hangi işlem, ne zaman yapılacak, belirler (gerekli işaretleri üretir))
n Giriş/Çıkış : klavye (veya benzer)
: ekran (veya benzer)
n İkincil ( yardımcı ) bellek (Kütük olarak saklı bilgiler.)
n Hardware - Software

Bilgisayarlar kendisine sorulan sorulara hemen cevap veren, bir sürü problemi çözen bir aygıt değildir. Bilgisayarda yapılan her tür iş, ilk önce insan aklının süzgecinden geçiyor, insanlar tarafından etraflıca tasarlanıyor, planlanıp programlanıyor [1].

ilk yapılan bilgisayarın karşına geçip hemen
en eski soruyu sormuşlar "Tanrı var mı".
Bilgisayar kısa bir düşünmeden sonra "Evet artık var".

Bu nedenle, önce bilgisayara problemin çözümü öğretilmelidir. Fakat bunun için bizim problemi çözmemiz gerekir. Ve daha sonra bir programlama dili ile bu çözüm bilgisayara aktarılmalıdır.

1- Problem Çözme ve Algoritmalar
1.1 Problem Çözme
Problem çözmede, soruna hemen girişmek yerine, dikkatli ve sistematik yaklaşım ilke olmalıdır. Problem iyice anlaşılmalı ve mümkün olduğu kadar küçük parçalara ayırılmaladır.
Descartes tarafından "Discourse on Method" isimli kitabında anlatılan problem çözme teknikleri;[2]

1. Doğruluğu kesin olarak kanıtlanmadıkça, hiçbir şeyi doğru olarak kabul etmeyin; tahmin ve önyargılardan kaçının.
2. Karşılaştığınız her güçlüğü mümkün olduğu kadar çok parçaya bölün.
3. Düzenli bir biçimde düşünün; anlaşılması en kolay olan şeylerle başlayıp yavaş yavaş daha zor ve karmaşık olanlara doğru ilerleyiniz.
4. Olaya bakışınız çok genel, hazırladığınız ayrıntılı liste ise hiçbir şeyi dışarıda bırakmayacak kadar kusursuz ve eksiksiz olsun.

1.2 Algoritmalar
Belirli bir görevi yerine getiren sonlu sayıdaki işlemler dizisidir.
İ.S. 9.yy da İranlı Musaoğlu Horzumlu Mehmet
(Alharezmi adını araplar takmıştır) problemlerin çözümü için genel kurallar oluşturdu. Algoritma Alharezmi'nin Latince okunuşu.
Her algoritma aşağıdaki kriterleri sağlamalıdır.
1. Girdi: Sıfır veya daha fazla değer dışarıdan verilmeli.
2. Çıktı: En azından bir değer üretilmeli.
3. Açıklık: Her işlem (komut) açık olmalı ve farklı anlamlar içermemeli.
4. Sonluluk: Her türlü olasılık için algoritma sonlu adımda bitmeli.
5. Etkinlik: Her komut kişinin kalem ve kağıt ile yürütebileceği kadar basit olmalıdır.
Not: Bir program için 4. özellik geçerli değil. işletim sistemleri gibi program sonsuza dek çalışırlar .

Örnek 1.2.1 : 1'den 100'e kadar olan sayıların toplamını veren algoritma.
1. Toplam T, sayılar da i diye çağırılsın.
2. Başlangıçta T'nin değeri 0 ve i'nin değeri 1 olsun.
3. i'nin değerini T'ye ekle.
4. i'nin değerini 1 arttır.
5. Eğer i'nin değeri 100'den büyük değil ise 3. adıma git.
6. T'nin değerini yaz.
Algoritmaların yazım dili değişik olabilir. Günlük konuşma diline yakın bir dil olabileceği gibi simgelere dayalı da olabilir. Akış şeması eskiden beri kullanıla gelen bir yapıdır. Algoritmayı yazarken farklı anlamlar taşıyan değişik şekildeki kutulardan yararlanılır. Yine aynı amaç için kullanılan programlama diline yakın bir (sözde kod = pseudo code) dil , bu kendimize özgü de olabilir, kullanılabilir.

Aynı algoritmayı aşağıdaki gibi yazabiliriz.
1. T=0 ve i=0
2. i'nin değerini T'ye ekle.
3. i'yi 1 arttır.
4. i<101 ise 2.adıma git.
5. T'nin değerini yaz.

Algoritmayı bir de akış şeması ile gerçekleyelim.

T=0
İ=0

İ’nin Değrini T’ye ekle

İ’yi bir arttır

İ<101

T’yi yaz

Örnek 1.2.2 : ax2+bx+c=0 tipi bir denklemin köklerini veren algoritma.
Girdi : a, b ve c katsayıları Çıktı : denklemin kökleri
1. a, b ve c katsayılarını al.
2. D = b2-4ac değerini hesapla.
3. D<0 ise gerçel kök yok. 7. adıma git.
4.
5 .
6. değerlerini yaz.
7. Dur.
Döngü Gösterimi
Tekrarlanan adımlar
n. Koşul sağlandığı sürece
n.1 ...
n.2 ... tekrarlanan adımlar
n.3 ...

Örnek 1.2.3 : İki tamsayının çarpma işlemini sadece toplama işlemi kullanarak gerçekleyin.
Girdi : iki tamsayı
Çıktı : sayıların çarpımı
1. a ve b sayılarını oku
2. c =0
3. b>0 olduğu sürece tekrarla
.3.1. c=c + a
3.2. b = b-1
4. c değerini yaz ve dur

Örnek 1.2.4 : Bir tamsayının faktoriyelini hesaplayınız.
Girdi : Bir tamsayı
Çıktı : sayının faktoriyel
İlgili formul: Faktoriyel(n)=1*2*...*n
1. n değerini oku
2. F=1
3. n >1 olduğu sürece tekrarla
.3.1. F=F*n
3.2. n= n-1
4. F değerini yaz
Örnek 1.2.5 : İki tamsayının bölme işlemini sadece çıkarma işlemi kullanarak gerçekleyin. Bölüm ve kalanın ne olduğu bulunacak.
1. a ve b değerlerini oku
2. m=0
3. a>=b olduğu sürece tekrarla
3.1 a=a-b
3.2 m = m + 1
4. kalan a ve bölüm m 'yi yaz

Örnek 1.2.6 : 100 tane sayıyı okuyup, ortalamasını bul
1. T=0, i=0
2. i<101 olduğu sürece tekrarla
2.1 m değerini oku
2.2 T = T + m
2.3 i = i + 1
3. T = T / 100
4. Ortalama T ‘yi yaz
5. Dur

Örnek 1.2.7 : Bir sınava giren öğrencilerin not ortalamasının hesaplanması
1. Tüm sınav kağıtlarını inceleyip notların toplamını hesapla
2. Ortalamayı notların toplamını incelenen sınav kağıdına bölerek hesapla
3. Ortalamayı yaz.

1. Notların toplamını ve incelenen sınav kağıdı sayısını sıfır kabul et
2. Sıradaki sınav kağıdının notunu notların toplamına ekle
3. İncelenen sınav kağıdı sayısını Bir arttır
4. İncelenecek sınav kağıdı var ise 2. Adıma git
5. Ortalamayı notların toplamını incelenen sınav kağıdına bölerek hasapla
6. Ortalamayı yaz

1. Notların toplamını ve incelenen sınav kağıdı sayısını sıfır kabul et
2. Her bir sınav kağıdı için
2.1. Sıradaki sınav kağıdının notunu notların toplamına ekle
2.2. İncelenen sınav kağıdı sayısını bir arttır
3. Ortalamayı notların toplamını incelenen sınav kağıdına bölerek hesapla
4. Ortalamayı yaz

Koşul Gösterimi

n. Koşul doğru ise
n.D.1
n.D.2 doğru olduğunda işlenen adımlar
n.D.3
aksi halde
n.Y.1
n.Y.2 yanlış olduğunda işlenen adımlar
n.Y.3

Kök bulma örneğinde 3. Adımı tekrar yazarsak
3. D>=0 ise
3.D.1
3.D.2
aksi halde
3.Y.1 Reel kök yoktur

Sorular:
* Girilen üç sayıdan en büyüğünü bulan algoritmayı yazınız.
* Tamsayılarda üs alma işlemini gerçekleştiren algoritmayı yazınız ( ab ).
* 1-100 arasında tutulan bir sayıyı tahmin eden algoritmayı yazınız.

Örnek 1.2.8 : Aracın otopark ücretinin hesaplanması. Araçların en fazla 24 saat kaldığını varsayın.
0 - 2 saat 150 bin
2 - 8 saat 300 bin
8-24 saat 500 bin

1. Aracın kaç saat kaldığını öğren ( t olsun ).
2. t <= 2 ise
2.D.1. ücret = 150 bin
Aksi halde
2.Y.1. t<=8 ise
2.Y.1.D.1. ücret = 300 bin
Aksi halde
2.Y.1.Y.1. ücret = 500 bin

3. ücreti yaz
4. Dur

Örnek 1.2.9: Sınavdaki en büyük notun bulan algoritma.

1. En büyük = ilk sınav kağıdındaki not (ya da olabilecek en düşük değer kabul edilebilir).
2. İncelenecek sınav kağıdı var ise
2.1 Sınav kağıdındaki not > En büyük ise En büyük = Sınav kağıdındaki not

3. En büyük değerini yaz.
4. Dur

Algoritmanın yazımı daha simgesel olabilir. Ni i. Öğrencinin notu olsun.

1. EB = N1
2. i = 2
3. İncelenecek sınav kağıdı var ise
3.1 Ni>EB => EB = Ni
3.2 i = i + 1

4. EB’ yi yaz.
5. Dur

Örnek 1.2.10 : Programın C dili ile yazılıp çalışır hale getirilmesi.

1. Programı bilgisayara gir
2. Kaynak dosya olarak kaydet
3. Kaynak dosyayı derle ( compile)
4. Derleme sonucunda hata var ise
4.1 Hataları düzelt
4.2 3. Adıma git
5. Oluşan amaç dosyasına diğer dosyaları bağla (link)
6. Bağlama sonucunda hata var ise
6.1. Hataları düzelt
6.2. Hatalar kaynak dosya ile ilgili ise 2. adıma aksi halde 5. adıma git
7. Program çalıştırılmaya hazır

2- Programlamaya Giriş

Program : Belirli bir problemi çözmek için bir bilgisayar dili kullanılarak yazılmış deyimler dizisi.
Önceki bölümde bir problemin çözümü ile ilgili teknikler sunmuştuk. Bir problemi bilgisayar ile çözmek için geliştireceğimiz programın yazımında izleyeceğimiz adımlar:

i) Problemin ne olduğunu kavra. Çözüm için gereksinimleri belirle.
ii) Problemin girdilerini, çıktılarını ve diğer kısıtlama ve gereksinimleri belirle ( bilgilerin giriş ve çıkış biçimlerinin nasıl olacağına kadar).
iii) Problemin çözümünü veren algoritmayı yaz.
iv) Algoritmayı bir programla dili ile yaz.
v) Programın doğru çalışıp çalışmadığını test et. Bu testi değişik veriler (girdiler) için tekrarla.

2.1 İlk Program Örneği
#include Kullanılan işlevler ile ilgili başlık dosyası
main()
{
int i ; Değişken tanımı
scanf("%d",&i); Programın gövdesi
i:=i*i;
printf("%d",i);
}

BCPL à B (1967 Ken Thompson) à C (Denis Ritchie unix i yazmak için)
az sayıda saklı sözcük
kısa ve etkin program
çok sayıda işleç
assembler e yakın kod
taşınabilir kod
kullanıcıya bırakılan kontroller (dizinin boyutu gibi )
düşük okunabilirlik

source -----> compiler -----> object -----> link
kaynak derleyeci amaç bağlama
kaynak kod : C dili ile yazılmış olan program.
derleyeci : Kaynak kodu makina koduna çevirir
amaç kodu : Kaynak kodun makina dilindeki karşılığı
bağlama : Birden fazla amaç kodu dosyasının tek dosyada birleştirilmesi
2.2 Veri Tipleri

Veri tiplerini vermeden önce yazılan bir programın geçtiği aşamalara göz atalım.

2.2.1 Int Tip
Integer = Tamsayı
Tamsayıları içerir. Bellekte 2 Byte tutar.
5 , -19 , 25000 gibi
Minimum : -231 = -32768
Maksimum : 231-1 = 32767

2.2.2 Gerçel Tipler (Float, Double)
Gerçel sayıları içerirler.
float : Bellekte 4 Byte yer tutar. 3.4E-38 ile 3.4E+38 aralığında değer alır. Hassasiyet 7-8 basamaktır.
double : Bellekte 8 Byte ter tutar. 1.7E-308 ile 1.7E308 aralığında değer alır. Hassasiyet 15-16 basamaktır.

218.1 , -5.2 , 4.0

Bilimsel gösterim biçimi 2.5*103 = 2.5E3 2.5*10-3 = 2.5E-3

2.2.3 Char Tip
Char : Karakter : Alfanumerik karakterleri içerir.
'5' , '*' , 'K'

2.3 Sabitler (CONST)

#include
main()
{
const float PI=3.14; Tanımlama kısmı
float r, Alan;
scanf("%f",r);
alan := PI*r*r;
printf(('Alan = %f', alan);
}
CONST (sabit) : Değeri programın çalışması boyunca değiştirilemez. Kullanım biçimi
const tip Belirleyici=değeri;
const float PI=3.14;
Tip belirtilmez ise tamsayı kabul edilir.

2.4 Değişkenler
Değeri programın çalışması boyunca değiştirilekir. Kullanım biçimi:
Tip Belirleyici [,Belirleyici] ;
int i;
float alan;

2.5 Belirleyiciler (Identifier)
Bileşenlere isim verme. (Sabit, değişken, altprogram, etiket, tipler (kullanıcı tanımlı)).

2.5.1 Kısıtlamalar
. İlk karakteri rakam olamaz
. Sadece harfler, rakamlar ve _ (underscore) karakterinin birleşiminden oluşabilir.
. C diline ait saklı (reserved) sözcükler kullanılamaz.
. En fazla 31 karakter olabilir.
. Küçük - büyük harf ayırımı vardır.

2.5.2 isimlerin Seçimi
. Belirleyicinin kullanım amacına uygun anlamlı isim seçin. (Hungarian notation)
. Ne fazla kısa ne de fazla uzun olsun. 3 - 10 karakter uzunluğunda olmasını alışkanlı edinin.
2.6 Matematiksel ifadeler
Matematiksel ifadeleri günlük hayattaki biçimde bilgisayarda yazamadığımız için belli bir kurallar uymamız gerekir. Kullandığımız matematiksel işlemler ve anlamları şöyledir:
+ , - , * , / toplama, çıkarma, çarpma, bölme
% tamsayı bölme sonucundaki kalanı verir (modulus)
7. / 2 ---> 3.5 (nokta sayının gerçel yorumlanmasını sağlar)
7 / 2 ---> 3 (sayılar int kabul edilip sonuçta int tipine dönüştürülür)
7 % 2 ---> 1
2 % 7 ---> 2
2 / 7 ---> 0
Matematiksel ifadeler hesaplanırken izlenen adımlar:
1. Önce parantez içindeki ifadeler hesaplanır. İçiçe parantezler var ise hesaplamaya en içteki parantezden başlanır.
2. ilk önce * , / ve % işlemleri daha sonra + ve - işlemleri yapılır.
3. Öncelik sırası aynı olan işlemlerde hesaplama soldan sağa doğru yapılır. 5./2*3 --> 7.5

Bir C Programının Genel Yapısı

başlık dosyaları. Kullanılan deyimler ile ilgili
main()
{
sabitler ; sabitlerin tanımlama bölümü
değişkenler; değişkenleri tanımlama bölümü
deyimler; Program gövdesi
}

2.7 Atama Deyimi (Assignment)
Bir değişkene bir değer(sabit, değişken, ifade) vermek.
DeğişkenAdı = değer;
x = 8 ;
y = x + 15 ;
y = (8 - x) / (2 - x) ;

Örnek 2.7.1: 5x2+2 fonksiyonunun x=4.8 noktasındaki değerini
main()
{
float x, y ;
x = 4.8;
y = 5 * x * x + 2;
}

Örnek 2.7.2: Vize ve final notlarınından geçme notu
main()
{
float vize, final, ort;
vize = 50;
final = 60;
ort = vize * 0.4 + final * 0.6;
}

Örnek 2.7.3: 1998 yılına kadar geçen gün sayısı
main()
{
float gun;
int yil = 1996;
gun = 365 * (yil - 1);
gun = gun + (yil -1 ) / 4;
}

2.8 printf işlevi
Program içinde istenen değerleri çıktı birimlerine göndermek için kullanılır. Normal kullanımında çıktı birimi olarak ekran kabul edilir. Kullanım biçimi:

prinf( kontrol, )
ile belirtilen bilgiye göre parametreleri yazar. Kontrol metini iki kısımdan oluşur.
o sıradan karakterler: doğrudan yazılırlar.
o dönüşüm/biçim belirleyici karakterler: Değerlerin nasıl yazılacağı bildirilir.

printf(" sonuç = %d", k);
--- integer değer yazılacaktır
--------- ekrana aynen aktarılır

Dönüşüm belirlemek için önce % karakteri ve ardından dönüşümün nasıl
olacağını belirten karakter verilir. Bu karakterlerden bazıları:

d : decimal (integer)
u : unsigned decimal
c : char (tek karakter)
s : string
e : float/double sayıyı bilimsel gösterimde yaz
f : float/double sayıyı [-] mmm.nnnnn biçiminde yaz
ld : long integer
lu : unsigned long integer
Le,Lf : long double

ESC dizileri : \n : satır başı, \a : zil , \t : tab, \b : bir karakter geri

program parçası ekranda görünen / imleçin konumu
i = 5 ;
printf("%d",i) ; 5
printf("'i=%d",i) ; i=5
printf("i=") ;
printf("%d",i) ; i=5 -

printf("i=\n") ; i=
printf("%d",i) ; 5 alt satıra geçer

printf('i=%d\n",i) ; i=5 alt satıra geçer

printf("%d - %d",i, 5*i); 5 - 25

Biçimli yazdırma
% karakteri ile dönüşüm karakteri arasına aşağıdaki karakterler de kullanılabilir.

- : sola dayalı yaz
m : yazılacak değer için ayırılan alan
n : değerin kaç karekteri yazılacağı

s = "ABCDEF"
printf("%10s ",s); . . . . A B C D E F

printf("%10.3s ",s); . . . . . . . A B C

x = 128.5 ;
printf("%7.2f",x) ; # 128.50

x = 85.47 ;
printf("%6.3f",x) ; 85.470

printf("%6.1f",x) ; ## 85.5

Örnek 2.8.1 : Yarıçapı belli dairenin alanını hesaplayan programı yazınız. (ilk yazılan program)
#include
main()
{
const float PI=3.14;
float r, alan;
r = 7;
alan := PI*r*r;
printf(('Alan = %f', alan);
}

Örnek 2.8.2 : En fazla dört basamak olabilen sayının basamak değerlerini yazdır. % ve / işlemlerinin kullanımı.
#include
main()
{
int i,y;

y=1985;
i= y / 1000;
printf("%d",i);
y= y-i*1000;
i= y / 100;
printf(" %d",i);
y = y-i*100;
i= y / 10;
printf(" %d",i);
y = y-i*10;
printf(" %d\n",y);
i = 1985;
printf("%d ",i / 1000);
printf("%d ",(i / 100) % 10);
printf("%d ",(i / 10) % 10);
printf("%d\n",i % 10);
}

Örnek 2.8.3: ax2+bx+c=0 tipi bir denklemin köklerini veren programı yazınız.
Girdi : a, b ve c katsayıları
Çıktı : denklemim kökleri
Algoritma :
1. a, b ve c katsayılarını oku.
2. Delta= değerini hesapla.
3. x1 ve x2 değerlerini hesapla.
4. Kökleri yaz.

Programın kodlanması:

#include /* printf işlevi için */
#include /* sqrt işlevi için */
main()
{
float a, b, c;
float x1, x2;
float d;

a = 1;
b = -3;
c = 2;
d = b * b - 4 * a * c;
x1 = (-b + sqrt(d)) / (2 * a);
x2 = (-b - sqrt(d)) / (2 * a);

printf("Kökler = %f , %f",x1, x2);
}
C dilinde karekök almak için bir deyim yoktur. Örnekte bunu yerine getiren C diline eklenmiş olan sqrt() fonksiyonu kullanılmştır. Aşağıda buna benzer artık C derleyecilerinde standart olmuş bazı fonksiyonlar verilmiştir. Bu işlevler math.h başlık dosyasında tanımlıdır.
Fonksiyon x ,y Sonuç
abs(x) int int x'in mutlak değeri
fabs(x) double double x'in mutlak değeri
pow(x, y) double double xy
sqrt(x) double double x'in karekökü
exp(x) double double ex değeri
log(x) double double ln(x) değeri
log10(x) double double log10(x) değeri
ceil(x) double double x ten büyük ilk tamsayı
floor(x) double double x ten küçük ilk tamsayı

Örnekler:
ceil(5) 5
ceil(5.2) 6
ceil(-5.2) -5
floor(5) 5
floor(5.2) 5
floor(-5.2) -6

2.9 scanf İşlevi
Klavyeden veri okumak için kullanılır. Yapı olarak printf işlevi ile hemen hemen aynıdır. Kullanım biçimi:

scanf( kontrol, )

Girilen karakterler metininde belirtilen biçimlere göre değişkenlere aktarılır.
Değişkenler işaretçi tipinde olmalıdır. Yani parametre olarak değişkenin adresi gönderilmelidir.
Ayırıcılar boşluk, tab, enter

scanf("%f %f %f ", &a, &b, &c);

scanf işlevinin değeri
0 ise hiçbir değişkene değer atanmamış
>0 ise başarılı bir şekilde değer atanan değişken sayısı
int a,b,c;
float m,n;
scanf("%d", &a); Klavyeden tamsayı okur. Girilen değer a değişkenine aktarılır.
scanf("%d %d",&a,&b) Klavyeden girilen ilk değer a değişkenine, ikinci değer b değişkenine aktarılır.
scanf("%f %d", &m, &a); Klavyeden ilki gerçel, ikincisi tamsayı olmak üzere iki değer okur.

İkinci dereceden denklem çözümünün yapıldığı örnekte katsayıları klavyeden okutmak istersek

scanf("%f %f %f ", &a, &b, &c);

Farklı kullanıcı arayüzünde yazarsak

printf(“Katsayıları sırasıyla giriniz (a b c) :” ); scanf("%f %f %f ", &a, &b, &c);

printf(“a katsayısını giriniz : “); scanf(“%f”, &a);
printf(“b katsayısını giriniz : “); scanf(“%f”, &b);
printf(“c katsayısını giriniz : “); scanf(“%f”, &c);

Örnek 2.9.1: Vize ve final notlarınından ortalamayı hesaplayan programda değerlerin klavyeden okunmuş hali.
main()
{
float vize, final, ort;
printf(“Vize notunu giriniz “); scanf(“%f”, &vize);
printf(“Final notunu giriniz “); scanf(“%f”, &final);
ort = vize * 0.4 + final * 0.6;
printf(“Ortalaması = &f\n”, ort);
}

2.10 Mantıksal ifadeler
Sonucu Doğru veya Yanlış olan ifadelerdir. Sonuç sıfır ise yanlış aksi halde doğru kabul edilir.
İlişkisel işleçler(operatör) : iki değer arasındaki ilişkiyi test etmek için kullanılır.
işleç anlamı
> büyük
>= büyük - eşit
== eşit
< küçük
<= küçük - eşit
!= eşit değil

x=8, y=5 için
x > y Doğru
x < y Yanlış
x !=y Doğru

Mantıksal işleçler : İki mantıksal ifade arasındaki ilişki üzerindeki ilişkide kullanılır.
! DEĞİL (NOT)
&& VE (AND)
VEYA (OR)

(X>0) && (X>Y)
(X>0) (Y>0)

İfadelerde işleçlerin yürütülme sırası
işleç Önceliği
( ) en yüksek (ilk yürütülür)
!
*, /, %
+, -
<, <=, >=, >
==, !=
&&,
= en düşük (son yürütülür)
= işleci sağdan sola, diğerleri soldan sağa doğru yürütülür.
Görüldüğü gibi ifadelerde matematiksel ve mantıksal işlemler bittikten sonra ilişki test edilir.
X=50, Y=80, Z=45 için
( ( X / 4 + Y / 4 + Z / 2 ) >= 50 ) && ( Z >= 50 )

3 - Döngü ve Koşul Deyimleri

Programlar (algoritmalar) üç temel blok kullanılarak gerçekleştirilebilirler. Bunlar; ardarda, bir koşula bağlı olarak ve sonlu sayıda yineleme (döngü) dir.

3.1 Koşul Deyimleri

Birkaç seçenekten birini seçmek veya bir deyimin bir koşula bağlı olarak işlemek için kulanılır.

3.1.1 if-then-else Deyimi

if ()
blok_doğru;
else
blok_yanlış;

Mantıksal ifade doğru ise blok_doğru, yanlış ise else sözcüğünden sonraki blok_yanlış yürütülür. else kısmı seçimlidir, gerekmiyorsa kullanılmayabilir.

Örnek 3.1. 1.1 Girilen sayının tek/çift olduğunu yazan program
#include
main()
{
int i;
scanf("%d", &i);
if ( i % 2 == 1)
printf("Tek");
else
printf("Çift");
}

Bileşik (Compound) Deyimler

{ ve } karakterleri ile sınırlandırılmış bir dizi deyimden oluşur.
{
i = 5;
j = i/2;
k = i+1;
}

Eğer bloklarda birden fazla deyim kullanmak gerektiğinde bileşik deyim kullanılır.

if (yil % 4 == 0) {
subat =29;
gunyil = 366;
}
else {
subat =28;
gunyil = 365;
}
Örnek 3.1.1.2 : İkinci dereceden denklemin köklerinin bulunması.

if (delta<0)
printf("Gerçel kök yoktur.\n");
else
{
x1 = (-b + sqrt(delta)) / (2 * a);
x2 = (-b - sqrt(delta)) / (2 * a);
printf("Birinci kök = %f\n" , x1);
printf("ikinci kök = %f\n" , x2);
}

Örnek 3. 1.1.3 : Klavyeden girilen karakterin rakam olduğunun tesbiti.

char c;
c = getch();
if ((c>='0') && (c<='9')
printf("Rakam girdiniz.");

Örnek 3. 1.1.4 : Girilen üç sayıdan en küçüğünün bulunması (İçiçe IF kullanımı).

scanf("%d%d%d", &s1, &s2, &s3);
if ((s1
ek =s1;
else
if (s2
ek =s2;
else
ek = s3;
printf('En küçük olanı = %f", ek);

II. yol :
scanf("%d%d%d", &s1, &s2, &s3);
ek = s1;
if (ek>s2)
ek =s2;
if (ek>s3)
ek =s3;
printf('En küçük olanı = %f", ek);

Örnek 3. 1.1.5: Fonksiyonun girilen t değeri için aldığı değeri hesaplayıp yazan program.

main()
{
float y, x;

printf(“x değerini giriniz”);
scanf(“%f”, &x);
if (x > -1 && x<2)
y = 2/3 * (x + 1);
else
if (x>2 && x<=3)
y = 2;
else
y = 0;

printf(“Fonksiyonun değeri = &f”, y);
}

Örnek 3. 1.1.6: Vergi iadesini hesaplan programı yazınız. (elseif yapısı)
(0-60 bin : %10, 60-120 bin : %,120-200 bin : %12,>200 bin : %5)

main()
{
float fat_top, vergi_iade;
printf("Fatura toplamlarını giriniz ");
scanf("%f", &fat_top);
if (fat_top < 60000)
vergi_iade = fat_top * 0.10;
else if (fat_top < 120000)
vergi_iade = 6000 + (fat_top - 60000) * 0.20;
else if(fat_top < 200000)
vergi_iade = 18000 + (fat_top - 120000) * 0.12;
else
vergi_iade = 27600 + (fat_top - 200000) * 0.05;

printf("Ödenecek vergi iadesi = %f\n", vergi_iade);

}

Örnek 3. 1.1.7: Girilen tarihteki günün adını veren programı yazınız.

#include
main ( )
{
int gun, ay, yıl ;
long gt ;
printf(“Tarihi gir”) ; scanf ( “%d %d %d “,&gun)

/* oncekı yıllardakı gun sayısını hesapla */

gt=( yıl*1)*365 + yıl/4;

/* bu yildaki aylardaki gunleri ekle */

if (ay==2)
gt = gt + 31 ;
else if (ay ==3)
gt = gt + 31 + 28 ;
else if (ay ==4)
gt = gt + 31 + 28 +31;
else if (ay ==5)
gt = gt + 31 + 28 +31+ 30 ;
else if (ay ==6)
gt = gt + 31 + 28 +31+ 30 +31;
else if (ay ==7)
gt = gt + 31 + 28 +31+ 30 +31+ 30 ;
else if (ay ==8)
gt = gt + 31 + 28 +31+ 30 +31+ 30 + 31 ;
else if (ay ==9)
gt = gt + 31 + 28 +31+ 30 +31+ 30 + 31+30 ;
else if (ay ==10)
gt = gt + 31 + 28 +31+ 30 +31+ 30 + 31+30 + 31;
else if (ay ==11)
gt = gt + 31 + 28 +31+ 30 +31+ 30 + 31+30 + 31+ 30 ;
else if (ay ==12)
gt = gt + 31 + 28 +31+ 30 +31+ 30 + 31+30 + 31+ 30 +31;

/*Bu ayı ekle */
gt = gt+ gun;
if(yıl%4==0 && ay>2),
gt =gt+1;
gt=gt %7,
if(gt==1)
printf(“Pazar”);
else if(gt==2)
printf(“Pazartesi”);
else if(gt==3)
printf(“Salı”);
else if(gt==4)
printf(“Carsamba”);
else if(gt==5)
printf(“Persembe”);
else if(gt==6)
printf(“Cuma”);
else if(gt==7)
printf(“Cumartesi”);
}

2007-12-02T06:57:00.000-08:00

c de Kütüklerin Kullanımı

2007-12-02T06:36:00.000-08:00

Kütüklerin Kullanımı

Bir kütüğü kullanmadan önce iki işlemim yapılması germektedir. Kütük ile ilgili işaretçinin tanımlanması ve kütüğün açılması.

Tanımlı FILE tipinde işaretçi değişken tanımlayarak ilk işlem gerçekleştirilir.
FILE *kp; /*FILE yapısı stdio.h içerisinde tanımlı */

İkinci aşamada kütük açma deyimi kullanılır.
kp = fopen(kütük adı, mod)

kütük adı : açmak istediğimiz kütüğün adı (string). Büyük - küçük harf ayrımı yok.
mod : kullanım amacı (string). Okuma, yazma değişiklik ...

r : okumak için
w : yazmak için. Kütük yok ise oluşturulur, var ise içeriği silinir.

a : eklemek için. Kütük yok ise oluşturulur , var ise sondan itibaren yazılır
r+ : Var olan bir kütüğü okumak ve yazmak için
w+ : Okumak ve yazmak için yeni bir kütük oluştur. Dosya var ise içeriği silinir.
a+ : Eklemek için. Okuma ve yazma yapılabilir. . Dosya yok ise oluşturulur..

Örnek 12.1.1 : Kütüğe yazma
#include
main()
{
FILE *kp;
char *s;
int i;

kp = fopen("dene", "w"); /* NULL ise işlem başarısız */
if (kp == NULL)
exit(1);

for (i=0; i<5; i++) {
gets(s);
fprintf(kp, "%s\n", s);
}
getch();
fclose(kp); /* kütüğü kapatır. Program sona erdiğinde otomatik kapatılır */
/* fcloseall() hepsini kapatır. Dönen , kapanan kütük sayısı. Hata var ise EOF döner
*/
}

Yazarken kullanılan fprintf deyiminin çalışması printf gibidir. Sadece ilk parametre olarak kütük değişkenini vermek gerekir.

Benzer kütük işlevleri

int fgetc(FILE *stream);
int fputc(int c, FILE *stream);
char *fgets(char *s, int n, FILE *stream); n-1 karakter veya satır sonuna kadar okur
int fputs(const char *s, FILE *stream); satır sonu bilgisini ayrıca yazmak gerekir

Örnek 12.1.2: Kütükten okuma

#include
main()
{
FILE *kp;
char *s;
int i;

kp = fopen("dene", "r");
if (kp == NULL)
exit(1);

clrscr();
for (i=0; i<5; i++) {
fscanf(kp, "%s", s);
printf("%s\n", s);
}

/* Kütükteki kayıt sayısı bilimiyor ise */
rewind(kp);
/* fseek(stream, 0L, SEEK_SET)
SEEK_SET 0 baştan
SEEK_CUR 1 bulunulan yerden
SEEK_END 2 sondan
*/
fscanf(kp, "%s", s);
while (!feof(kp)) {
printf("%s\n", s);
fscanf(kp, "%s", s);
}
getch();
}

int feof(FILE *) : kütüğün sonuna erişilmiş ise sıfırdan farklı bir değer alır. Aksi halde sıfırdır.
rewind(FILE *) : kütük işaretçisinin (kütükteki hangı kayıdın okunacağı bilgisi) kütüğün başını göstermesini sağlar.

Örnek 12.1.3: Ekleme ve okuma

a+ modunda kütük aç. + eklenmez ise kütük işaretçisi kütük başına taşınmıyor

#include
main()
{
FILE *kp;
char *s;
int i;

kp = fopen("dene", "a+");
if (kp == NULL)
exit(1);

clrscr();
for (i=0; i<2; i++) {
gets(s);
fprintf(kp, "%s\n", s);
}
rewind(kp);
fscanf(kp, "%s", s);
while (!feof(kp)) {
printf("%s\n", s);
fscanf(kp, "%s", s);
getch();
}
getch();
}

Örnek 12.1.4: Matrisin elemanlarının değerlerinin kütükten öğrenilmesi.
kütüğün ismi matrisa.dat
matris elemanları double
boyut 4x3

#define SAT 4
#define SUT 3
#include
main()
{
FILE *kp;
double a[SAT][SUT];
int i, j;

kp = fopen("matrisa.dat", "r");
if (kp == NULL)
exit(1);

for (i=0; i for (j=0; j fscanf(kp, "%lf", &a[i][j]);

clrscr();

for (i=0; i for (j=0; j printf("%8.1f", a[i][j]);
printf("\n");
}

getch();
}

Örnek 12.1.5: Hesaplanan değerlerin kütüğe yazdırılması.
1-exp(-x) fonksiyonu 0-10 aralığında 0.02 adımlarla hesaplanıp kütüğe yazılıyor

#include
#include

#define ADIM 0.02
#define T0 0
#define TS 10

main()
{
FILE *kp;
double f, t;

kp = fopen("sonuc.dat", "w");
if (kp == NULL)
exit(1);
for (t=T0; t f = 1 - exp(-t);
fprintf(kp, "%6.3f %12.8f\n", t, f);
printf("%6.3f %12.8f\n",t, f);
}
getch();
}

12.1.1 Text Kütükte Değişiklik

Kütük işaretçisi değişiklik yapılacak kaydı göstermelidir. Ayrıca yeni bilgi eski bilgi ile aynı olmalıdır. Bu nedenle text kütüklerde değişiklik başvural bir şey değil. Gerektiği durumlarda kayıtlar geçici olarak başka bir kütüğe yazılır.

int remove(const char *k_adi) : kütüğü siler
int rename(const char *eski, const char *yeni) : kütüğün ismi değiştirilir

Örnek 12.1.6: Girilen dosyada herbir harfin kaçdefa geçtiğini bulup, çoktan aza doğru yazar.

#include
#include

void degistir(int *, int *);

main(int argc, char *argv[])
{

char dosyaadi[64];
FILE *fp;
char c;

long toplam = 0;
int frek[2][26] = {0,};
int i, j, k;

for (i=0; i<26; i++)
frek[0][i] = 65 + i;

if (argc<2) {
printf("Dosya adını belitmediniz\n");
exit(1);
}
else
strcpy(dosyaadi, argv[1]);

fp = fopen(dosyaadi, "r");

while (!feof(fp)) {
c = toupper(fgetc(fp));
if (c >= 'A' & c <='Z' )
frek[1][c - 'A']++;
}

for (i = 0; i < 26; i++)
toplam = toplam + frek[1][i];

clrscr();
printf("İncelenen Dosya : %s\n", dosyaadi);
printf("Toplam harf : %ld", toplam);

/* Çoktan aza doğru sırala */
do {
k = 0; /* bayrak */
for (i=0; i < 25; i++)
if (frek[1][i] < frek[1][i+1] ) {
k = 1;
degistir(&frek[0][i], &frek[0][i+1]);
degistir(&frek[1][i], &frek[1][i+1]);
}
} while (k == 1);

for (i = 0; i < 26; i++) {
if (i<13)
gotoxy(1, 5+ i);
else
gotoxy(40, 5 + i - 13);

printf("%c: %6d %5.3f",frek[0][i] , frek[1][i], (float)frek[1][i]/toplam);
}

getch();
}

void degistir(int *a, int *b)
{
int c;
c = *a;
*a = *b;
*b = c;
}

Örnek çıktı: (frekans classics.txt)

İncelenen Dosya : classics.txt
Toplam harf : 122850

E: 14657 0.119 M: 2870 0.023
T: 10449 0.085 F: 2630 0.021
A: 9902 0.081 P: 2440 0.020
I: 9889 0.080 Y: 2292 0.019
S: 9504 0.077 W: 2257 0.018
O: 9492 0.077 G: 2172 0.018
N: 8521 0.069 B: 1779 0.014
R: 7706 0.063 V: 1279 0.010
H: 6215 0.051 K: 1260 0.010
L: 5333 0.043 Z: 288 0.002
D: 4463 0.036 J: 236 0.002
C: 3760 0.031 X: 218 0.002
U: 3121 0.025 Q: 117 0.001

C DOSYALAMA

C nin dosyalama ile ilgili bir kac örnek

/*1-exp(-x) fonksiyonu 0-10 aralığında 0.002 adımlarla hesaplanıp kütüğe yazılması*/
#include
#include
#include
#include
#define adim 0.002
#define T0 0
#define TS 10
main(){
FILE *fp;
double f,t;

if ((fp=fopen("sonuc.dat","w"))==NULL){
printf("Dosya a‡lamad\n");
exit(1);
}
clrscr();
for(t=T0;t f=1-exp(-t);
fprintf(fp,"%6.3f %12.8f\n",t,f);
printf("%6.3f %12.8f\n",t,f);
}
getch();
fclose(fp);
}

--------------------------------------------------------------------------------
d_getch ile örnek

#include
#include
#include
#include
#define size 10
main(){
FILE *fp;
int i;
char a;
char *s;
if ((fp=fopen("data","r"))==NULL){
printf("Dosya kopyalanmadı\n");
exit(1);
}
clrscr();
printf("Okunacak hafiza noyu girin=");
scanf ("%d\n",&i);
fseek(fp,i,0);
i=fgetc(fp);
printf("%c\n",i);
fclose(fp);

getch();
}
--------------------------------------------------------------------

#include
#include
#include
#include
#define MAX_LINE 126
#define T0 0
#define TS 10

void main(){
FILE *fp;
char *s[80];
int t;
if ((fp=fopen("test","w"))==NULL){
printf("dosya a‡lamad..\n");
exit(1);
}
clrscr();
printf("bir string ve intger de§er girin\n");
scanf("%s %d",s,&t);
fprintf(fp,"%s %d",s,t);
fclose(fp);
if((fp=fopen("test","r"))==NULL){
printf("ktk a‡lamad");
exit(1);
}
fscanf(fp,"%s %d",s,&t);
printf("%s %d",s,t);
fclose(fp);
getch();
}

--------------------------------------------------------------------------

#include
#include
#include
#include
#define size 10
main(){
int p[size]={10,2,56,80,-2,23,80,21,-4,40};
FILE *fp;
int max,k,i;
if ((fp=fopen("data","w"))==NULL){
printf("Dosya a‡lamad\n");
exit(1);
}
clrscr();
fprintf(fp,"sayilar:\n");
for(k=0;k fprintf(fp,"%d\n",p[k]);
max=p[0];
for (k=1;k if (p[k]>max)
max=p[k];
}
fprintf(fp,"enbyk say:%d\n",max);

fclose(fp);

getch();
}

-----------------------------------------------------------------------------

#include
#include
#include
#include
#define size 10
main(){
FILE *fp;
char *s;
int i;
if ((fp=fopen("data","r"))==NULL){
printf("Dosya a‡lamad\n");
exit(1);
}
clrscr();

for(i=0;i<13;i++) {
fscanf(fp,"%s",s);
printf("%s\n",s);
}
fclose(fp);

getch();
}

---------------------------------------------------------------------------
Örnek:dosya ekleme

#include
#include
#include
#include
#define size 10
main(){
FILE *fp;
int i;
char *s;
if ((fp=fopen("data","a+"))==NULL){
printf("Dosya a‡lamad\n");
exit(1);
}
clrscr();
for(i=0;i<2;i++){
gets(s);
fprintf(fp,"%s\n",s);
}
rewind(fp);
fscanf(fp,"%s",s);
while(!feof(fp)){
printf("%s\n",s);
fscanf(fp,"%s",s);
getch();
}
fclose(fp);

getch();
}
-------------------------------------------------------------------------
Örnek: fgets ve puts ile ilgili örnek

#include
#include
#include
#include
#define MAX_LINE 126
#define T0 0
#define TS 10

void main(){
FILE *fp;
char s[80];
int t;
if ((fp=fopen("test","w"))==NULL){
printf("dosya a‡lamad..\n");
exit(1);
}
clrscr();
scanf("%s ",s);
fputs(s,fp);
/* fprintf(fp,"%s %d",s,t);*/
fclose(fp);
if((fp=fopen("test","r"))==NULL){
printf("ktk a‡lamad");
exit(1);
}
fgets(s,3,fp);
printf("%s ",s);
fclose(fp);
getch();
}

----------------------------------------------------------------------
Örnek:random atama

#include
#include
#include
#include
#include
#define MAX 10
typedef struct{
char no[11];
int notu;
}ogryapi;

FILE *kp;
ogryapi ogr;

void giris(void) ;
void liste(void);

void main(){
int i;
char c;
kp=fopen("ogr.dat","r+");
if (kp==NULL){
printf("dosya a‡lamad..\n");
kp=fopen("dizi.dat","w+");
}
do{
clrscr();
fseek(kp,0,2);
printf("dosya uzunlugu %ld\n" ,ftell(kp));
printf("Kayt says %d\n\n", ftell(kp)/sizeof(ogryapi));

printf("1-giris\n2-liste\n3-cikis\n");
c=getch();
switch(c){
case '1': giris(); break;
case '2':liste(); break;
case '3':exit(0);
};
}while(1);
}
void giris(void){
int i;
clrscr();
printf("™grenci no:"); scanf("%s",ogr.no);
printf("Notu :"); scanf("%d",&ogr.notu);
i=atoi(ogr.no);/*string tipi degiskenin tipini tam sayisal tipe d”nstrr*/
fseek(kp,(i-1)*sizeof(ogryapi),0);
fwrite(&ogr,sizeof(ogryapi),1,kp);
fflush(kp); /* *int fflush(FILE*) tampon bellektekileri diske yazar*/

}
void liste(void){
clrscr();
fseek(kp,0,0);
fread(&ogr,sizeof(ogryapi),1,kp);
while(!feof(kp)){
/*fseek(kp,0,0);*/
printf("%s %d\n",ogr.no,ogr.notu);
fread(&ogr,sizeof(ogryapi),1,kp);
/*printf("%s %d\n",ogr.no,ogr.notu);*/
}
getch();

}
--------------------------------------------------------------------------
Örnek: random 2 atama örnek
#include
#include
#include
#include
#define MAX 10

FILE *kp;
int a[MAX];

void giris(void) ;
void liste(void);

void main(){
int i;
char c;
kp=fopen("dizi.dat","r+");
if (kp==NULL){
printf("dosya a‡lamad..\n");
kp=fopen("dizi.dat","w+");
}
do{
clrscr();
fseek(kp,0,2);
printf("dosya uzunlugu %ld\n" ,ftell(kp));
printf("1-giris\n2-liste\n3-cikis\n");
c=getch();
switch(c){
case '1': giris(); break;
case '2':liste(); break;
case '3':exit(0);
};
}while(1);
}
void giris(void){
int i;
clrscr();
for(i=0;i a[i]=rand()%100;
fseek(kp,0,0);
fwrite(a,sizeof(int),MAX,kp);
}
void liste(void){
int i;
clrscr();
fseek(kp,0,0);
fread(a,sizeof(int),MAX,kp);
for (i=0;i printf("%d\n ", a[i]);
printf("\n");
getch();
}