Web de Yenilik

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

#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ı

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

#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

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

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

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.