ILK C PROGRAMINIZ

En basit C programi:

main()

{

}

Bu bir programdir, ve bunu kisaltmanin, basitlestirmenin bir yolu yoktur. Isin kotu tarafi, bu program birsey yapmaz. Buradaki en onemli kelime,

BIRSEYLER YAPAN BIR PROGRAM:

Daha ilginc bir program:

main()

{

printf("Bu bir satirlik yazidir.");

}

Bu programin, ayni diger program gibi, main, ve kume isaretleri vardir. Icinde yer alan fonksiyonun, bir satiri ekrana getirmesi icin, satiri " "

isaretleri arasina aliyoruz. Ayrica fonksiyonun parametresi oldugunu belirtmek icin de, cevresine parantez koyuyoruz. Satirin sonundaki noktali virgule dikkatinizi

 cekerim: Bir satirin bittigini derleyiciye bildirmek icin, C dilinde ; noktali virgul kullanilir.

DAHA COK SEY YAZAN BIR PROGRAM

main()

{

printf("Bu bir satirlik yazidir.\n");

printf("Bu bir baska ");

printf(" satirdir.\n");

printf("Bu ucuncu satirdir.\n");

}

Bu programda, 4 tane islenecek komut vardir. Satirlar bu sirada islenir. Ilk satirin sonundaki tuhaf ters bolu isareti, ondan sonra gelecek

karakterin bir kontrol karakteri oldugunu belirtiyor. Bu durumda n harfi, yeni bir satir istegini belirtir. Yani, cursor, ekranin sol basina, ve birsatir asagiya kayar.

 Katarin herhangi bir yerinde yeni bir satir isteyince, "\n" komutunu verebilirsiniz. Hatta bir kelimenin ortasina bile koyup, kelimeyi iki satira bolebilirsiniz.

Ilk komut, metini ekrana yazar, ve bir satir asagi iner. Ikinci komut, yazdiktan sonra, yeni satir yapmadan, ucuncu komutun icindekileri ekrana yazar. Bu komutun

 sonunda, yeni satira gecilir. Dorduncu komut ise, ucuncu satiri yazar, ve bir return karakteri sunar.

 RAKAMLAR YAZALIM

main()

{

int index;

index = 13;

printf("Indexin degeri simdi %d\n",index);

index = 27;

printf("Indexin degeri simdi %d\n",index);

index = 10;

printf("Indexin degeri simdi %d\n",index);

}

Bu programda ise, ilk defa olarak bir degisken kullaniyoruz. main() ve { isaretlerine artik alismis olmalisiniz. Bunun altinda "int index" diye bir

satir yer aliyor. Bu satir, "index" isimli bir tamsayi degiskenini tanimliyor. Cogu mikrobilgisayarlar icin, 'int' tipi bir degiskenin alabilecegi degerler, -32768 ila 32767 dir.

 'index' ismi ise, TANIMLAYICILAR da bahsettigimiz kurallara uyan herhangi birsey olabilir. Bu satirin sonunda da, satirin bittigini belirten ; noktali virgul yer alir.

Bir satirda birden fazla tam sayi tanimlanabilir, fakat henuz biz bununla ortaligi karistirmayacagiz. Programi incelerken, uc tane atama satiri oldugunu, ve bu satirlarin

altinda da degerlerin yazildigini goruyoruz. Once 13 atanir, ve ekranayazilir, sonra 27 ve 10. RAKAMLARI NASIL YAZARIZ Sozumuze sadik kalmak icin,

geciren tanidik \n isaretini goruyoruz. Den-denler arasinda kalan butun harfler, printf komutu ile ekrana cikacaklari tanimlar. Bundan sonraki virgul ve "index"

 sozcugu yer alir. printf komutu buradan degiskenin degerlerini okur. Daha fazla %d ekleyerek ,ve bunlari yine virgul ile birbirine ekleyerek, birden fazla degiskenin

de bu komut ile goruntulenmesini saglayabiliriz. Hatirlamaniz gereken onemli bir nokta, saha tanimlayici %d ile gecirdiginiz degisken miktari, ayni kalmalidir, yoksa

 bir runtime hatasi verir.

BILGI SATIRLARI NASIL EKLENIR

/* Bu satiri, derleyici kullanmaz */

main() /* Bir satir daha */

{

printf("Bilgi satirlarinin nasil eklenecegini ");

/* Bilgi satirlari,

bir satirdan uzun olabilir.

*/

printf("goruyoruz.\n");

}

/* Ve programin sonu... */

Programa aciklik katmak icin, eklenebilecek bilgiler, derleyici tarafindan uzerinden atlanir. Lutfen yukaridaki programi, iyi bir ornek olarak

almayin. Son derece daginik bir sekilde katilmis bilgi satirlari, sadece kullanimini gostermek amaci iledir. Bilgi satirlari, /* isaretleri ile baslar, ve */ isareti ile sona erir.

IYI SAYFA DIZIMI

Yazdiginiz bir program, kolay anlasilir olmalidir. Bunun icin, duzgun bir sekilde programlamak cok onemlidir. C derleyicileri, komutlar arasindaki

bosluklari goz onune almaz, ve bu nedenle de programlariniza aciklik katmak icin, dilediginiz gibi bosluk ve bos satir birakabilirsiniz. Su iki programi karsilastiralim:

main() /* Program buradan basliyor */

{

printf("iyi yazis,");

printf ("programin anlasilmasini kolaylastirir\n");

}

ve:

main() /* Program buradan basliyor */ {printf("iyi yazis,"); printf

("programin anlasilmasini kolaylastirir\n");}

Odev:

1. Ekrana kendi isminizi yazacak bir program yazin.

2. Programa ayri satirlarda, iki "printf" satiri daha ekleyerek,

adresinizi ve telefon numaranizi da yazdirin.

'WHILE' DONGUSU

C dilinde, bircok tip dongu vardir. While dongusu, herhangi bir test, dogru kaldigi surece, bir program parcasini tekrarlar. Bu testin sonucu

yalnis cikarsa, while dongusu sona erer, ve program normal akisina devam eder.

main() /* while dongusunun bir ornegi */

{

int count;

count = 0;

while (count<6)

{

printf("count'un degeri: %d oldu. ",count);

count = count + 1;

}

}

Bu programda, count isimli bir degiskeni tanimliyoruz, ve sifira esitliyoruz. while dongusunun kullanimi, gorundugu gibi, 'while' sozcugu,

ve parantez icinde bir test'den olusur. Parantezlerin icindeki deyim dogru kaldigi surece, bu program tekrarlar. Bu programda, degiskenin degeri teker teker

 arttirildigindan, eninde sonunda degeri altiya varacaktir, ve bu durumda program donguden cikacaktir. Parantezlerin icinde yer alan deyimleri, bundan sonraki

 konuda isleyecegiz. O zamana kadar, bunlarin dusundugunuz seyleri yaptigini kabul ediniz.

Birkac onemli nokta:

                                                              1. Sayet 'count' un baslangic degeri 5 den buyuk birseye atanmis olsa idi, dongunun icindekiler hic yapilmayacakti.

                   2. Eger 'count = count + 1' komutu ile degerini  bir arttirmasa idik, bu program hic durmazdi.

3. Son olarak, eger dongude tek bir komut varsa, kume isaretlerine gerek yoktur.

DO-WHILE DONGUSU

Buna benzeyen bir baska komut ise, 'do-while' komutudur. Su program, daha once gordugumuz programa cok benzer:

main() /* Do-While dongusu ornegi */

{

int i;

i=0;

do

{

printf("I nin degeri simdi: %d oldu.\n",i);

i = i + 1;

} while (i<5);

}

Yegane farkin, dongunun bir 'do' komutu ile yapilmasi ve denkligin kontrolunun sona birakilmasidir. Bu durumda, parantezlerin arasinda deyim

dogru kaldigi surece, dongu tekrarlanir. Burada onemli noktalar: Kontrol, dongunun sonunda yapildigindan, kume isaretlerinin arasindaki deyimler daima en

 az bir kere islenir. Ayrica yine, sayet i nin degeri degismez ise, program donguden cikmaz. Son olarak, sayet dongunun icinde bir tek komut varsa, kume

For dongusu, yeni birsey degildir. Sadece, 'while' dongusunun bir baska seklidir:

main() /* Bir for dongusu */

{

int index;

for(index=0;index<6;index = index + 1)

printf("index'in degeri simdi %d oldu.\n",index);

}

'For' dongusu, uc parcadan olusmustur. Her kesim birbirinden ; ile ayrilir. Ilk kesimi, baslangic kesimi (initalization) dir. Burada bulunan

islemler, dongu baslamadan once, ve bir kere yapilir. Aslinda buraya yazilacak seyler icin bir sinir yoktur, fakat basit tutmakta fayda vardir. Bu kesime birden

fazla islem yazilabilir, bunlari da birbirinden ',' virgul ile ayirmak gerekir. Ikinci kesimde, "index<6" diyen parcada, bu dongunun her turunda kontrol edilmesi gereken

 deyim yer alir. Bu deyim dogru oldugu surece, dongu devam eder. Dogru yada yalnis sonuc veren herhangi bir deyim, bu kesimde yer alabilir. Ucuncu kesimde

 yer alan islemler ise, yine dongunun her turunda yapilir, fakat isleme baslamasi, dongunun icinde yer alan komutlarin islenmesinden sonra yapilir. 'For' komutundan

 sonra, ya tek bir komut gelir, yada kume isaretleri icinde, bir komut bloku.. C de hemen heryerde, tek bir komut yerine, bir komut bloku koymaniz  mumkundur.

/* Bu, if-else komutunun bir ornegidir */

main()

{

int data;

for (data=0;data<10;data = data + 1)

{

if (data==2)

printf("Data simdi %d ye esit.\n",data);

if (data<5)

printf("Data simdi %d. Bu da, 5 den azdir. \n",data);

else

printf("Data simdi %d. Bu da, 4 den buyuktur.\n",data);

}

}

Bu programda, ilk once, icinde iki tane if komutu olan bir for dongusu gorunuyor. Bu dongunun on kere tekrarlanacagi, acik bir sekilde goruluyor.

Ilk if satirina bakin: "if" kelimesi ile basliyor, ve sonra bir parantez icinde, sarti goruluyor. Sayet bu parantezin icindeki islemin sonucu dogru (evet) ise, if'den hemen

 sonra gelen satir islenir. Sayet cevap yalnis ise, if'den sonra gelen komut, atlanir. Burada da, tek bir komut, kume isaretleri ile, bir komut bloku haline getirilebilir.

Burada data==2 islemi, data degiskeninin degerinin ikiye esit olup olmadigini kontrol eder. (Sayet data = 2 olsa idi, tumuyle ayri birsey gerceklesirdi.)

Ikinci "if", yine birincisine benziyor. Fakat, ek olarak "else" isimli bir kesimi de iceriyor. Bu da, sayet parantezlerin icindeki islem dogru (EVET)

sonuc verirse, "if" den sonra gelen satir islenecektir, sayet yalnis (HAYIR) sonucu verirse, "else" den sonra gelen komut islenecektir. Bu nedenle, iki satirdan biri

 muhakkak islenecektir.

main()

{

int xx;

for (xx=5;xx<15; xx=xx+1)

{

if (xx==8)

break;

printf("Break dongusunun icinde, xx in degeri simdi %d\n",xx);

}

for (xx=5;xx<15;xx=xx+1)

{

if (xx==8)

continue;

printf("Continue dongusunun icinde, xx in degeri simdi %d\n",xx);

}

}

Bu programda gordugunuz gibi, sayet xx in degeri 8 e esit ise, break isimli komutu cagiran bir if komutu goruyorsunuz. Break komutu, bizi

donguden cikarip, programi dongunun hemen altindaki satirdan devam etmesini saglar. Bu komut, ornegin dongunun icinde hesaplanan bir degere gore, donguden

cikmak istediginizde cok ise yarar. Ornekte, xx in degeri sekize ulasinca, program donguden cikar, ve ekrana yazilmis en son deger, yedi olur. Programin ikinci

 parcasindaki dongude ise, Continue komutunu goruyoruz. Burada ise, deger 8 e ulasinca, program donguden cikmaz, fakat program dongunun en son satirina

atlayip, aradaki printf satirini islemez.

SWITCH

main()

{

int kamyon;

for (kamyon = 3;kamyon<13;kamyon = kamyon + 1)

switch (kamyon)

{

case 3: printf("Degeri simdi uc.\n");

break;

case 4: printf("Degeri simdi dort.\n");

break;

case 5:

case 6:

case 7:

case 8: printf("Degeri simdi 5 le 8 arasinda.\n");

break;

case 11:printf("Degeri simdi onbir.\n");

break;

default:printf("Tanimsiz degerlerden biri.\n");

break;

}

}

}

Simdiye kadar gordugumuz en buyuk komut olan "switch", aslinda kullanimi kolaydir. Ilk once, "switch" kelimesi ile baslar. Bunun arkasindan,

parantez icinde bir deyim gelir. Bundan sonra, dilediginiz kadar 'case' komutlari, kume isaretleri arasinda yer alir. Her degeri sembolize eden 'case' satirlari, degiskenin

 degeri, iki nokta ust uste, ve bununla ilgili komutlardan olusur. Bizim ornegimizde, "kamyon" degiskeninin degeri 3 oldugunda, printf satiri, 'Degeri simdi uc' satirinin

ekrana yazilmasini, saglar. Daha sonra yer alan 'break' komutu ise, switch in icinde yer alan diger komutlari islenmeden, switch den cikilmasini saglar.

Bir giris noktasi bulunduktan sonra, satirlar bir 'break' komutuna rastlayincaya kadar, yada switch'in son kume isaretine varincaya kadar komutlar siradan islenir.

"Kamyon" un degeri 5 e esit ise, program, case 5,6,7 den gecerek 8'de bulunan printf ve break komutlarini isler. Break komutu da, programi son kume isaretine getirir.

 Sayet degiskenin bir degerine karsilik gelen bir case yoksa, 'default:' isimli secenek secilir.

GOTO KOMUTU

main()

{

goto leave

printf("Bu satir hic yazilmayacak.\n");

leave:

}

Goto komutunu kullanmak icin, "goto" isminin yanina, atlamak istediginiz yerin sembolik ismini yazmaniz yeterlidir. "goto" ile bir dongunun icine

atlamaniza izin yoktur, fakat bir dongunun disina atlayabilirsiniz. Ayrica bir fonksiyondan otekine de "goto" ile gecemezsiniz. Bazi kimseler, goto nun hicbir yerde

 kullanilmamasi gerektigini belirtiyorlar. Sayet, goto kullanimi ile, diger metodlara gore daha anlasilir bir program olusacaksa, goto yu kullanmaktan cekinmeyin.

SONUNDA - ISE YARAYAN BIR PROGRAM

main() /* Santigrad'dan Fahrenheite */

{

int count; /* for degiskeni */

int fahr; /* fahrenheit degerini tutar */

int cen; /* Santigrat degerini tutar */

printf("Santigrad -> Fahrenheit karsilik tablosu\n ");

for (count=-2;count<=12;count=count+1)

{

cen = 10 * count;

fahr = 32 + (cen * 9) / 5;

printf(" C = %4d F = %4d ",cen,fahr);

if (cen == 0)

printf(" Suyun donma noktasi");

if (cen == 100)

printf(" Suyun kaynama noktasi");

printf("\n");

}

}

Bu program, santigrad ve fahrenheit derecelerin tablosunu yaratmaktadir. Birden fazla degisken kullanilan ilk programimizdir bu. Degisken

taniminda, uc ayri satir kullanilmasi sayesinde, degiskenlerin yanina ne ise yaradiklarini da yazabiliriz.

Odev:

1. Isminizi ekrana 10 kere yazan bir program yaziniz. Bu programi 3 kere

yaziniz. Her seferinde ayri bir dongu metodu kullanarak..

2. Birden ona kadar sayan ve bu degerleri her satira bir tane olmak uzere

ekranda gosteren bir program yazin. Bu deger 3 e ve 7 ye esit olunca,

dilediginiz bir mesaji yazsin.

KARETOPL.C:

================================================================

int toplam; /* Global degisken */

main()

{

int index;

baslik(); /* Baslik isimli fonksiyonu cagirir */

for (index = 1;index <= 7;index++)

kare(index); /* Bu, kare fonksiyonunu cagirir. */

bitis(); /* Bu da, bitis isimli fonksiyonu cagirir */

}

baslik() /* Bu fonksiyonun tanimidir */

{

toplam = 0; /* "Toplam" isimli degiskene 0 degeri atanir.. */

printf("Bu, kare programinin basligidir\n ");

}

kare(rakam) /* Bu, kare fonksiyonunun baslangicidir */

int rakam;

{

int karesi; /* Yerel degisken tanimlaniyor */

karesi = rakam * rakam ; /* Karesini olusturuyor. */

toplam += karesi; /* Bulunan deger, toplama ekleniyor */

printf("%d nin karesi %d dir.\n",rakam,karesi);

}

bitis() /* Bitis fonksiyonu tanimlaniyor. */

{

printf("\nKarelerin toplami: %d dir.. ",toplam);

}

================================================================

KARETOPL.C isimli programa bir bakin. Bu program, fonksiyonlu ilk programimiz. Goreceginiz gibi C de fonksiyon tanimlamak o kadar kolaydir

ki, programlarin fonksiyonlara parcalanmasi neredeyse istemeden olur. Aslinda, biz fonksiyonlari kullanip duruyorduk, ornegin kullandigimiz printf komutu, bir

 fonksiyondur. Printf fonksiyonu, derleyici ile gelen fonksiyon kutuphanesinin bir parcasidir. Bu programin calisan kismina bir bakin. baslik() isimli bir satir ile

basliyor. Iste C de, herhangi bir fonksiyon, bu sekilde cagirilir: ismi, parantez, ve sayet varsa bu fonksiyona gonderilmesi istenen degerler yazilir. Programin calismasi

bu  satira gelince, baslik isimli fonksiyona atlanir, ve buradaki islemler yapilir. Bitince, program geri doner, ve ana programda kaldigi yerden isleme devam eder,

 ve "for" dongusune gelir. Burada, yedi kere "kare" isimli bir fonksiyonu cagirir, daha sonra "bitis" fonksiyonunu cagirir ve program sona erer.

FONKSIYONUN TANIMLANMASI

main'den sonra ayni main'in ozelliklerini tasayan bir program goreceksiniz. Sadece bunun ismi "baslik()" olarak tanimlanmistir. Bu basligin ilk satirinda "toplam"

degiskeninin degeri 0 a atanir, ve bir baslik satiri yazilir. Dikkat ederseniz, "toplam" degiskenini, fonksiyonlarin disinda, programin basinda tanimlamistik. Bu sekilde

tanimlanan bir degisken, o programdaki herhangi bir fonksiyondan cagirilabilir. Bu tip degiskenlere "global" denir. Bu iki satiri main() in icine de koymamiz mumkundur.

 Bu ornek sadece fonksiyonlarin kullanimini gostermektedir.

FONKSIYONA DEGER GECIRMEK

Ana programda, "for" dongusunde, "index++" deyimini goruyorsunuz. Ilk olarak gecen konuda ogrendigimiz birer birer arttirma metoduna alismaya

bakin, cunku C programlarinda cok karsilasacaksiniz. "kare" isimli fonksiyonu cagirirken, bir yenilik kattik. Yani, parantez icindeki "index" deyimini. Bu da derleyiciye,

 o fonksiyona gidince, "index" in o andaki degerini de beraberimizde goturmek istedigimizi belirtir. "Kare" isimli fonksiyonun basligina baktigimizda ise, parantezler

 icinde bir baska degisken ismi goruyoruz: "rakam." Ana programdan "kare(index)" dedigimizde gelen index'in degerine, bu fonksiyon icinde 'rakam' diyecegimizi

belirtiyoruz. Buna rakam demek yerine istedigimiz herhangi bir ismi verebilirdik - C nin degisken isim kurallarina uymasi sarti ile. Fonksiyon, ona ne tip bir deger

gecirilecegini bilmesi icinde, hemen alt satirda, "int rakam" diyerek, gelecek bu degerin bir integer olacagini belirtiyoruz. Kume isaretinden sonra, "int karesi" deyimi

ile,  sadece bu fonksiyonun icinde tanimli olan bir degisken daha tanimlandigini goruyoruz. Bundan sonra, "karesi" degiskenine 'rakam' in karesini atiyoruz, ve

BIR FONKSIYONA DEGER ATAMA HAKKINDA DAHA BILGI

Aslinda "index" in degerini fonksiyona gecirdigimizde, anlattigimdan biraz daha fazla sey oldu. Gercekte, "index" in degerini gecirmedik bu

bahsetmistik, bu konu icersinde, daha da bahsedecegiz. Programa devam ederek, bitis() isimli bir fonksiyonun cagirilisina geliyoruz. Bu cagirma da, hicbir yerel

UFAK BIR YALANI ITIRAF ETME ZAMANI

Biraz once size bir fonksiyondan bir deger dondurmek icin yegane yolun global degiskenler ile olabilecegini soylemistim. Fakat bir baska metod

daha var. Lutfen KARELER.C isimli programa bakin...

KARELER.C:

=====================================================================

main() /* Ana program burada. */

{

int x,y;

for(x = 0;x <= 7;x++) {

y = squ(x); /* x*x i hesaplayalim.. */

printf("%d nin karesi %d dir...\n",x,y);

}

for (x = 0;x <= 7;++x)

printf("%d nin karesi %d dir...\n",x,squ(x));

}

squ(in) /* Bir rakamin karesini bulan fonksiyon */

int in;

{

int kare;

kare = in * in;

return(kare); /* Yeni buldugumuz deger donduruluyor.. */

}

=====================================================================

Bu program, tek bir deger dondurmenin kolay oldugunu gosteriyor. Fakat,

birden fazla deger dondurmek icin, baska metodlara gerek oldugunu

hatirlamanizda fayda var.

ana programda, iki tane tamsayi degiskeni tanimliyoruz, ve 8 kere islenen

bir "for" dongusu baslatiyoruz. Dongudeki ilk satir, "y = squ(x);", yeni

ve tuhaf gorunuslu bir satir. Onceki programlarda gordugumuz gibi, squ(x)

kisimi, squ isimli fonksiyonu, x parametresi ile cagirmaktadir. Fonksiyona

baktigimizda, bu gecen degiskenin orada 'in' isminde oldugunu, ve kare

ismindeki yerel degiskene, gecirdigimiz degerin karesinin atandigini

goruyoruz. Daha sonra, yeni "return" komutunu goruyoruz. Parantezler

icindeki bu deger, fonksiyonun kendisine atanir, ve ana programa bu deger

dondurulur. Yani, "squ(x)" fonksiyonu, x in karesine atanir, ve bu deger,

ana programa atanir. Ornegin, x in degeri 4 ise, y nin degeri, "y=squ(x)"

satirindan sonra 16 olacaktir.

Bir baska dusunme sekli de, "squ(x)" sozcugunu, "x" in karesi degerinde bir

degisken olarak dusunmektir. Bu yeni degisken de, degiskenlerin

kullanildigi herhangi bir yerde kullanilabilir. Baska bir degisken olarak

gormeye bir ornek olarak bu programda ikinci bir dongu vardir. Burada,

y degiskenine atamak yerine, printf'in icinde, bu fonksiyonu cagiriyoruz.

Bir fonksiyondan donecek degiskenin tipi, derleyiciye bildirilmelidir.

Fakat, bizim yaptigimiz gibi sayet belirtmezsek, derleyici donecek degerin

tam sayi (integer) olacagini kabul edecektir. Baska tiplerin tanimlanmasini

ise, bundan sonraki programda gorecegiz..

KAYAR NOKTA FONKSIYONLARI

KAYARKAR.C:

================================================================

float z; /* Bu bir global degiskendir */

main()

{

int index;

float x,y,sqr(),glsqr();

for (index = 0;index <= 7;index++){

x = index; /* int'i float yapalim */

y = sqr(x); /* x'in karesini alalim.. */

printf("%d in karesi %10.4f dir.\n",index,y);

}

for (index = 0; index <= 7;index++) {

z = index;

y = glsqr();

printf("%d in karesi %10.4f dir.\n",index,y);

}

}

float sqr(deger) /* float'in karesini al, float dondur. */

float deger;

{

float karesi;

karesi = deger * deger;

return(karesi);

}

float glsqr() /* float'in karesini al, float dondur. */

{

return(z*z);

}

================================================================

KAYARKAR.C isimli programa bir bakin. Ilk once daha sonra kullanacagimiz

bir global degisken tanimlamak ile basliyor. Programin "main" kisiminda,

bir tamsayi degiskeni tanimlaniyor. Bunun altinda, iki tani tamsayi

degiskeni, iki tane de tuhaf gorunuslu tanimlamalar var. "sqr()" ve

"glsqr()" isimli iki fonksiyon gibi gorunuyorlar, ve oyleler. Bu, C

dilinde "int" yani tamsayi dan baska birsey dondurecek bir fonksiyonun

(float mesela) resmi sekilde tanimlanmasidir. Bu derleyiciye, bu iki

fonksiyondan bir deger donunce, bu degerin float olacagini bildiriyor.

Simdi programin ortasinda yer alan "sqr" fonksiyonuna bir bakin. Burada

fonksiyonun isminin basinda bir "float" sozcugu goreceksiniz. Bu

derleyiciye herhangi bir yerden bu fonksiyon cagirilinca, donecek degerin

float olacagini bildiriyor. Simdi bu fonksiyon, ana programdaki cagirma

ile uyumludur. Bunun altinda, "float deger" satirini goruyorsunuz. Bu da,

bu fonksiyona, cagiran tarafindan gecirilecek degerin, bir "float" yani

kayar nokta olacagini bildirir.

Bundan sonraki fonksiyon "glsqr" da, bir kayar nokta donduruyor, fakat o,

input icin global bir degikeni (z degiskenini) kullaniyor. Ayrica, yeni

bir degisken tanimlamadan, karesini almayi "return" komutunun icinde

yapiyor.

DEGISKENLERIN ALANI

ALAN.C:

================================================================

int say; /* Bu bir global degiskendir. */

main()

{

register int index; /* Bu degisken sadece "main" icinde kullanilabilir */

baslik_1();

baslik_2();

baslik_3();

/* bu programin ana "for" dongusu */

for (index = 8;index > 0;index--)

{

int birsey; /* Bu degisken sadece bu kume isaretleri arasinda tanimli */

for (birsey = 0;birsey <= 6;birsey++)

printf("%d ",birsey);

printf(" index simdi: %d oldu.\n",index);

}

}

int sayac; /* Bu degisken bu noktadan sonra kullanilabilir. */

baslik_1()

{

int index; /* Bu degisken sadece baslik_1 icinde tanimli */

index = 23;

printf("Baslik_1 deki degeri %d\n",index);

}

baslik_2()

{

int say; /* Bu degisken sadece baslik_2 icinde gecerli */

/* ayni isimli global degiskenin yerini alir.. */

say = 53;

printf("Baslik_2 deki degeri %d\n",say);

sayac = 77;

}

baslik_3()

{

printf("Baslik_3 deki degeri ise %d\n",sayac);

}

================================================================

Ilk tanimlanan degisken "say", butun fonksiyonlardan once tanimlandigi

icin, herhangi biri tarafindan cagirilabilir, ve daima erisilebilir. Daha

sonra, "sayac" isimli bir degisken tanimliyoruz. Bu da global bir

degiskendir, fakat ana programdan sonra tanimlandigi icin, ana program

tarafindan kullanilamaz. Global bir degisken, fonksiyonlarin disinda

tanimlanan degiskenlere denir. Bu tip degiskenlere dissal degiskenler adi

da verilebilir.

Ana programa geri donerek, "index" isimli degiskenin tanimina bakalim. Su

an icin "register" sozcugunu goz onune almayin. Bu degisken "otomatik" bir

degiskendir, yani o fonksiyon cagirildiginda olusur, ve fonksiyondan

cikinca kaybolur. Ana program baska fonksiyonlari cagirdiginda bile daima

calisir oldugundan, burada pek manasi yoktur. Tanimlanan diger bir

degisken de, "birsey" degiskenidir. Bu degisken, sadece "for" dongusunun

icinde tanimlidir, ve baska bir yerden erisilemez. Herhangi bir kume

dongusunun basina, degisken tanimlamalari konulabilir. Kumeden cikinca, bu

degisken tanimsiz olacaktir.

OTOMATIK DEGISKENLER HAKKINDA...

Baslik_1'e bir bakin. "index" isimli bir degisken kullaniyor. Bu

degiskenin ana programdaki "index" ile arasinda, ikisinin de otomatik

degisken olmasi disinda hicbir bag yoktur. Program, bu fonksiyonu

islemezken, bu degisken yoktur bile. Baslik_1 cagirildiginda, bu degisken

yaratilir, ve baslik_1 bitince de bu degisken silinir. Fakat bu, ana

programdaki ayni isimli degiskenin degerini hic etkilemez, cunku ayri

nesnelerdir.

Yani otomatik degiskenler, gerektiginde yaratilirlar, ve isleri bitince de

silinirler. Hatirlamaniz gereken bir nokta da, bir fonksiyon birden fazla

kere cagirildiginda, otomatik degiskenlerin eski degerleri saklanmaz, yeni

bastan deger atanmalari gerekir.

STATIK DEGISKENLER ?

Bir baska degisken tipi ise, statik degiskenlerdir. Degiskeni tanimlarken

basina "static" sozcugunu koyarak, o degisken yada degiskenler,

fonksiyonun tekrar tekrar cagirilmasinda, eski degerlerini tutarlar.

Ayni sozcugu bir global degiskenin onune koyarak, o degiskenin sadece o

kutuk icindeki fonksiyonlara tanimli olmasini saglayabiliriz. Bundanda

anlayacaginiz gibi, birkac parcadan olusan kutukler arasinda global

degiskenlerin tanimlanmasi mumkundur. Bunu 14. konuda daha iyi gorecegiz.

AYNI ISMI TEKRAR KULLANMAK

baslik_2 ye bir bakin. Burada "say" isimli degiskenin tekrar

tanimlandigini ve 53 degerini aldigini goruyoruz. Global olarak

tanimlanmasina karsin, ayni isimde bir otomatik degisken tanimlamak

mumkundur. Bu degisken tumuyle yeni bir degiskendir, ve global olarak,

programin basinda tanimlanan "say" ile arasinda hicbir baglanti yoktur. Bu

sayede kafanizda "acaba global isimlerle karisirmi" sorusu olmadan

fonksiyon yazabilirsiniz.

REGISTER DEGISKENLERI NEDIR

Sozumu tutarak, register degiskenine donelim. Bir bilgisayar bilgiyi

hafizada yada registerlerde tutabilir. Register sahasina erisim, hafizaya

erisimden cok daha hizlidir, fakat programcinin kullanabilecegi az sayida

register vardir. Bazi degiskenlerin program tarafindan cok kullanilacagini

dusunuyorsaniz, o degiskeni "register" olarak tanimlayabilirsiniz.

Bilgisayar ve derleyici tipinize gore, bir yada birkac degiskeni bu

sekilde tanimlayabilirsiniz. Cogu derleyicilerin hic register degiskenleri

yoktur, ve "register" sozcugunu goz onune almadan derleme yaparlar.

Register degiskenleri, sadece tamsayi ve karakter tipi degiskenler ile

kullanilabilir. Sectiginiz derleyiciye gore, unsigned, long yada short

tipleride register olabilir.

DEGISKENLERI NEREDE TANIMLAYALIM

Bir fonksiyona parametre olarak gecirilmis degiskenler varsa, bunlarin

tanimi, fonksiyon isminden sonra, ve acik kume isaretinden once

yapilmalidir. Fonksiyonda kullanilan diger degiskenler ise, fonksiyonun

basinda, hemen acik kume isaretinden sonra tanimlanir.

STANDART FONKSIYON KUTUPHANESI

Her derleyici, icinde bircok fonksiyon olan bir kutuphane ile birlikte

gelir. Bunlar genellikle giris/cikis islemleri, karakter ve katar isleme,

ve matemetiksel fonksiyonlari icerir. Bunlarin cogunu sonraki konularda

gorecegiz.

Bunun disinda, cogu derleyicinin, standart olmayan, ve kullandiginiz

bilgisayarin ozelliklerini kullanan, ilave fonksiyonlari vardir. Ornegin,

IBM-PC ve uyumlular icin, BIOS servislerini kullanan fonksiyonlar

sayesinde, isletim sistemine komutlar vermeyi, yada ekrana direk yazmayi

saglayan fonksiyonlar olabilir.

RECURSION NEDIR ?

RECURS.C:

================================================================

main()

{

int index;

index = 8;

geri_say(index);

}

geri_say(rakam)

int rakam;

{

rakam--;

printf("rakam degeri %d dir.\n",rakam);

if (rakam > 0)

geri_say(rakam);

printf("Simdi rakam %d oldu..\n",rakam);

}

================================================================

Recursion, ilk karsilasildiginda cok korkutucu gorunen bir kavramdir.

Fakat RECURS.C isimli programa bakarsaniz, recursion'un butun zorlugunu

yenebiliriz. Aslinda fazla basit ve dolayisi ile aptal olan bu program,

bize recursion'un kullanimini gostermesi bakimindan cok yararlidir.

Recursion, kendini cagiran bir fonksiyondan baska birsey degildir. Yani,

bitmek icin bir kontrol mekanizmasina ihtiyaci olan bir dongudur.

Karsinizdaki programda "index" degiskeni 8 e atanir, ve "geri_say"

fonksiyonunun parametresi olarak kullanilir. Bu fonksiyon da, bu

degiskenin degerini teker teker azaltir, ve bize bu degeri gosterir. Sonra

tekrar kendisini cagirir, degeri bir kez daha azalir, tekrar, tekrar..

Sonunda deger sifira ulasir, ve dongu artik kendini cagirmaz. Bunun

yerine, daha onceki cagirmada kaldigi yere geri doner, tekrar geri doner,

en sonunda ana programa geri doner, ve program sona erer.

NE OLDU ?

Fonksiyon kendisini cagirdiginda, butun degiskenlerini,ve cagirilan

fonksiyonun islemesi bittiginde donmesi gereken yeri hafizaya sakladi.

Bir dahaki sefere kendinin tekrar cagirdiginda, yine ayni seyi yapti, ta

ki kendisini tekrar cagirmasi bitene kadar. Daha sonra tekrar bu

bilgileri, ayni koyus sirasi ile geri okudu.

Hatirlamaniz gereken nokta, recursion'un bir noktada bitmesi gerektigidir,

sayet sonsuz bir donguye girerseniz, bilgisayarin hafizasi bitecek ve bir

hata mesaji cikacaktir.

ODEVLER

1. Daha once yazdigimiz Santigrad'dan Fahrenheit'a karsilik tablosundaki

derece hesaplamasini bir fonksiyona geciriniz.

2. Ekrana isminizi 10 kere yazan bir program yaziniz. Yazma isini yapmak

icin bir fonksiyon cagiriniz. Daha sonra bu fonksiyonu main() in basina

alarak, derleyicinin bunu kabul edip etmedigini kontrol ediniz.

C Dili - 6. Konu

================================================================

#define BASLA 0 /* Dongunun baslangic noktasi */

#define BITIR 9 /* Dongunun bitis noktasi */

#define MAX(A,B) ((A)>(B)?(A):(B)) /* Max makro tanimlanmasi */

#define MIN(A,B) ((A)>(B)?(B):(A)) /* Min makro tanimlanmasi */

main()

{

int index,mn,mx;

int sayac = 5;

for (index = BASLA;index <= BITIR;index++) {

mx = MAX(index,sayac);

mn = MIN(index,sayac);

printf("Max simdi %d ve min de %d ..\n",mx,mn);

}

}

================================================================

Bu programda, ilk defa define lara ve makrolarla tanisacaksiniz. Ilk dort

satirdaki "#define" sozcuklerine dikkat edin. Butun makrolar ve define'lar

bu sekilde baslar. Derleme baslamadan, on-derleyici (preprocessor) bu

tanimlari alir, ve programda bu sembolleri gercek degerleri ile

degistirir. Ornegin, BASLA sembolunu heryerde sifir ile degistirir.

Derleyicinin kendisi, bu BASLA yada BITIR sembollerini gormez bile.

Boyle ufak bir programda bu sekilde semboller tanimlamak luzumsuzdur,

fakat ikibin satirlik bir programda, yirmiyedi yerde BASLA olsa idi,

sayede #define'i degistirmek, programdaki rakamlari degistirmekten daha

kolay olurdu.

Ayni sekilde on-derleyici, BITIS sembolu gordugu heryere 9 rakamini

koyar.

C de alisilmis bir teknik de, BASLA yada BITIR gibi sembolik sabitlerin

buyuk harfle, ve degisken isimlerinin de kucuk harfle yazilmasidir.

MAKRO NEDIR ?

Makro, bir #define satirindan baska birsey degildir. Fakat icinde islemler

yapabildigi icin, ona ozel bir isim verilmistir. Ornegin ucuncu satirda,

iki rakamin hangisi buyukse onu donduren MAX isimli bir makro

tanimliyoruz. Bundan sonra on-derleyici ne zaman MAX termini ve arkasindan

parantezi gorurse, bu parantezlerin arasinda iki tane deger bulacagini

farz eder, ve tanimda bulunan deyimi, buraya koyar. Ornegin, onikinci

satira gelindiginde, "A" yerine "index" ve "B" yerine de "sayac" konur.

Ayni sekilde "MIN" isimli makro da kendisine gecirilen iki rakamin

hangisi daha kucukse, o degeri dondurur.

Bu makrolarda bir suru fazlalik parantez goreceksiniz. Bunlarin nedeni,

bir sonraki programda anlasilacak..

YALNIS BIR MAKRO

================================================================

#define HATALI(A) A*A*A /* Kup icin hatali makro */

#define KUP(A) (A)*(A)*(A) /* Dogusu ... */

#define KARE(A) (A)*(A) /* Karesi icin dogru makro */

#define START 1

#define STOP 9

main()

{

int i,offset;

offset = 5;

for (i = START;i <= STOP;i++) {

printf("%3d in karesi %4d dir, ve kubu ise %6d dir..\n",

i+offset,KARE(i+offset),KUP(i+offset));

printf("%3d in HATALIsi ise %6d dir.\n",i+offset,HATALI(i+offset));

}

}

================================================================

Ilk satira baktiginiza, HATALI isimli makronun bir rakamin kubunu

aldigini goruyoruz. Gercektende, bu makro bazen dogru calismaktadir.

Programin kendisinde,i+offset 'in KUP unun hesaplandigi yeri

inceleyelim. Sayet i 1 ise, offset de 5 olduguna gore, 1+5 = 6 olacaktir.

KUP isimli makroyu kullanirken, degerler:

(1+5)*(1+5)*(1+5) = 6*6*6 = 216

olacaktir. Halbuki, HATALI yi kullanirsak, carpmanin onceligi, toplamadan

fazla oldugundan, degerleri:

1+5*1+5*1+5 = 1+5+5+5 = 16

seklinde buluyoruz. Yani, parantezler, degiskenleri dogru bir sekilde

birbirinden ayrimak icin gereklidir.

Programin gerisi basittir, ve sizin incelemenize birakilmistir..

ODEV:

1. 7 den -5 e dogru sayan bir program yaziniz.

C Dili - 7. Konu

KELIME KATARI (STRING) NEDIR?

Bir katar, genellikle harflerden olusan karakterler dizisidir. Ciktinizin

guzel ve manali gorunmesi icin, icinde isimler ve adresler olabilmesi

icin, programlarinizin katarlar kullanmasi sarttir. C dilinde tam tanimi,

"char" tipi bilgilerin, NULL karakter (yani sifir) ile sonlandirilmasidir.

C bir katari karsilastiracagi, kopyalayacagi yada ekrana yansitacagi

zaman, bunlari gerceklestiren fonksiyonlar, NULL gorunene dek bu islemi

yapmak uzere programlanmistir.

ARRAY (dizi) NEDIR?

dizi, ayni tip verilerin birbiri arkasina tanimlanmasidir. Kelime katari,

bir cins dizidir.

CHRSTRG.C:

================================================================

main()

{

char isim[7]; /* Bir karakter dizisi tanimlayalim */

isim[0] = 'T';

isim[1] = 'u';

isim[2] = 'r';

isim[3] = 'g';

isim[4] = 'u';

isim[5] = 't';

isim[6] = 0; /* Bos karakter - katarin sonu */

printf("Isim %s dur. \n",isim);

printf("Icinden bir karakter: %c\n",isim[2]);

printf("Ismin bir parcasi: %s \n",&isim[3]);

}

================================================================

Bu programda, ilk once, "char" tipi bir tanimlama goruyoruz. Koseli

parantezler icinde, kac hanelik bir dizi tanimlanacagini belirtiyoruz. C

dilinde butun diziler sifirdan basladigi icin, bu tanimlama ile

kullanabilecegimiz en yuksek index degeri 6 dir.

KATAR NASIL KULLANILIR

Demek ki, "isim" degiskeni, icinde 7 tane karakter tutabilir. Fakat en son

karakterin sifir olmasi zorunlugu oldugu icin, kullanilabilecek olan alan

6 karakterliktir. Bu katarin icine manali birsey yuklemek icin, yedi tane

komut veriyoruz - her biri, katara bir karakter atamaktadir. En sonunda

da, katarin sonunu belirten sifir rakamini koyuyoruz. (Bir "#define" ile

NULL karakteri, programin basinda sifir olarak tanimlayabiliriz.)

printf komutundaki %s isareti, printf'e "isim" isimli katardan, sifira

rastlayincaya kadar ekrana yazmasini belirtir. Dikkat etmeniz gereken bir

nokta, "isim" degiskeninin indexinin yazilmasinin gerekmedigidir.

KATARIN BIR KISMININ YAZILMASI

Ikinci printf komutu ise %c ile, katarin icinden sadece bir karakter

(harf) yazilmasini gosterir. Istedigimiz karakterin index numarasini da,

"isim" degiskeninin yanina, koseli parantezler arasinda gosterebiliriz.

Son printf komutunda ise, katarin 4. karakterinden itibaren yazmanin bir

ornegidir. "isim" degiskeninin onundeki & (ampersand) isareti, isim[3]'un

hafizada saklandigi adresin printf'e gecirilmesini belirtir. Adresleri 8.

konuda gorecegiz, fakat ufak bir ornek ile size bizleri nelerin

bekledigini gostermek istedim.

BAZI KATAR FONKSIYONLARI

KATAR.C

================================================================

main()

{

char isim1[12],isim2[12],karisik[25];

char baslik[20];

strcpy(isim1,"Rosalinda");

strcpy(isim2,"Zeke");

strcpy(baslik,"Bu bir basliktir.");

printf(" %s\n ",baslik);

printf("isim 1: %s \n",isim1);

printf("isim 2: %s \n",isim2);

if(strcmp(isim1,isim2)>0) /* sayet isim1 > isim2 ise, 1 dondurur */

strcpy(karisik,isim1);

else

strcpy(karisik,isim2);

printf("Alfabetik olarak en buyuk isim %s dir.\n",karisik);

strcpy(karisik,isim1);

strcat(karisik," ");

strcat(karisik,isim2);

printf("Iki isim birden %s\n",karisik);

}

================================================================

Ilk once 4 tane katar tanimliyoruz. Daha sonra, "strcpy" isimli cok pratik

bir fonksiyona geliyoruz. Yaptigi is, bir katari, bir digerine, ta ki

sifir bulunana kadar kopyalamak. Hangi katarin hangisine kopyalancagini

hatirlamak icin, bir atama komutunu dusunun ("x=23" gibi). Veri,

sagdakinden, soldakine kopyalanir. Bu komutun yapilmasindan sonra, isim1

in icinde, "Rosalinda" olacaktir - den-densiz olarak. Den-denler,

derleyicinin sizin bir katar tanimladiginizi anlamasi icin gereklidir.

KATARLARIN ALFABETIK OLARAK SIRAYA KONMASI

Ilginizi cekebilecek diger bir fonksiyonda, "strcmp" dur. Sayet kendisine

gecirilen birinci katar ikinciden daha buyukse, 1 dondurur, ayni ise 0, ve

ikinci daha buyukse -1 dondurur. "Zeke" katarinin kazanmasi, sizi herhalde

sasirtmaz. Burada katarin boyu onemli degildir, sadece icindeki

karakterler. Ayrica harflerin buyuk yada kucuk harf olmasi da fark

ettirir. C de bir katarin butun harflerini kucuk yada buyuge ceviren

fonksiyonlar da vardir. Bunlari daha ileri kullanacagiz.

KATARLARI BIRBIRINE EKLEMEK

En son satirda, "strcat" isimli yeni bir fonksiyon goreceksiniz. Gorevi,

bir katarin sonuna diger katari eklemektir. Bunu yaparken NULL karakterin

de yerli yerinde olmasini saglar. Burada, "isim1", "karisik" 'a

kopyalanir, daha sonra "karisik" a iki bosluk ve "isim2" eklenir.

Katarlar zor degildir, ve son derece faydalidirlar. Onlari kullanmayi

iyice ogrenmenizde fayda vardir.

BIR TAMSAYI DIZISI

INTDIZIN.C:

================================================================

main()

{

int degerler[12];

int index;

for (index = 0;index < 12;index++)

degerler[index] = 2 * (index + 4);

for (index = 0;index < 12;index++)

printf("Index = %2d deki degeri %3d dir..\n",index,degerler[index]);

}

================================================================

Bu programda, bir tamsayi dizisi tanimliyoruz. Gordugunuz gibi, ayni katar

tanimlama gibi.. Bu sayede, index degiskeni haric oniki tane degiskenimiz

oluyor. Bu degiskenlerin isimleri "degerler[0]" , "degerler[1]" ,vs. dir.

Ilk "for" dongusunde, bunlara deger atiyoruz, ikincisi ise, index

degiskeni ve "degerler" dizisinin icindekileri ekrana yaziyor.

BIR KAYAR NOKTA DIZINI

BUYUKDIZ.C:

================================================================

char isim1[] = "Birinci Program basligi";

main()

{

int index;

int ivir[12];

float tuhaf[12];

static char isim2[] = "Ikinci Program Basligi";

for (index = 0;index < 12;index++) {

ivir[index] = index + 10;

tuhaf[index] = 12.0 * (index + 7);

}

printf("%s\n",isim1);

printf("%s\n ",isim2);

for (index = 0;index < 12;index++)

printf("%5d %5d %10.3f\n",index,ivir[index],tuhaf[index]);

}

================================================================

Burada, "float" olarak tanimli bir kayar nokta dizisi goruyorsunuz.

Ayrica bu program, katarlara nasil baslangic degeri atanabilecegini

gosteriyor. Koseli parantezlerin icini bos birakarak, derleyicinin o

veriyi saklamak icin yeteri kadar yer ayarlamasini sagladik. Programin

icinde, bir katar daha ilk degerini veriyoruz. Burada onune "static"

koymak zorunlugumuz var. Baska yeni birsey yok bu programda. Degiskenler

rastgele degerlere atanir, ve sonra da bu degerler ekrana yazdirilir.

BIR FONKSIYONDAN DEGER DONDURME

GERIDOND.C:

================================================================

main()

{

int index;

int matrix[20];

for (index = 0;index < 20;index++) /* veriyi uretelim */

matrix[index] = index + 1;

for (index = 0;index < 5;index++) /* orjinal veriyi, ekrana. */

printf("Baslangic matrix[%d] = %d\n",index,matrix[index]);

yapbirsey(matrix); /* fonksiyona gidip, deger degistirme */

for (index = 0;index < 5;index++) /* degismis matrix i yazalim */

printf("Geri donen matrix[%d] = %d\n",index,matrix[index]);

}

yapbirsey(list) /* Veri donusunu gosterir */

int list[];

{

int i;

for (i = 0;i < 5;i++) /* print original matrix */

printf("Onceki matrix[%d] = %d\n",i,list[i]);

for (i = 0;i < 20;i++) /* add 10 to all values */

list[i] += 10;

for (i = 0;i < 5;i++) /* print modified matrix */

printf("Sonraki matrix[%d] = %d\n",i,list[i]);

}

================================================================

Bir fonksiyondan deger dondurmenin bir yolu da, diziler kullanmaktir.

Buradam 20 hanelik bir dizi tanimladiktan sonra, icine degerler atiyoruz,

bu degerlerin ilk besini ekrana yazdiktan sonra, "yapbirsey" isimli

fonksiyona atliyoruz. Burada goreceginiz gibi, bu fonksiyon "matrix"

isimli diziye "list" demeyi tercih ediyor. Fonksiyona, ne cins bir dizi

gececegini bildirmek icin, "int" olarak "list"i tanimliyoruz. Fonksiyona

kac elemanlik bir dizi gecegini soylememize luzum yok, fakat istenirse

belirtilebilir. Bu nedenle bos koseli parantezler kullaniyoruz.

Bu fonksiyon da, kendisine gecen degerleri gosterdikten sonra, bu

degerlere 10 ekliyor, ve yeni degerleri gosterip, ana programa geri

donuyor. Ana programda goruyoruz ki, fonksiyonun yaptigi degisiklikler,

"matrix" degerlerini de degistirmis.

Dizilerin, normal degiskenlerin aksine, fonksiyondaki degerleri degisince,

cagiran programdaki dizinin degerlerinin degismesini garipsiyebilirsiniz.

Pointerlar konusuna gelince butun bunlar daha manali olacaktir.

BIRDEN FAZLA BOYUTLU DIZILER

COKLUDIZ.C:

================================================================

main()

{

int i,j;

int buyuk[8][8],dev[25][12];

for (i = 0;i < 8;i++)

for (j = 0;j < 8;j++)

buyuk[i][j] = i * j; /* Bu bir carpim tablosudur */

for (i = 0;i < 25;i++)

for (j = 0;j < 12;j++)

dev[i][j] = i + j; /* Bu da bir toplama tablosudur */

buyuk[2][6] = dev[24][10]*22;

buyuk[2][2] = 5;

buyuk[buyuk[2][2]][buyuk[2][2]] = 177; /* bu, buyuk[5][5] = 177; demek */

for (i = 0;i < 8;i++) {

for (j = 0;j < 8;j++)

printf("%5d ",buyuk[i][j]);

printf("\n"); /* Her i nin degeri artinca, bir RETURN */

}

}

================================================================

Burada iki tane iki boyutlu dizi kullaniyoruz. "buyuk" adli 8 e 8 lik

dizinin elemanlari [0][0] dan [7][7] ye kadar, toplam 64 tanedir. Diger

tanimli "dev" dizi ise, kare degildir, fakat dizinin kare olmasinin sart

olmadigini gosteren bir ornektir.

Iki dizi de biri carpim tablosu, digeri de toplama tablosu ile doldurulur.

Dizi elemanlarinin tek tek degistirilebilecegini gostermek icin, once

"buyuk" un elemanlarinda birine, "dev" in bir elemani ile, 22 ile

carpildiktan sonra atanir. Ikinci atamada ise, "buyuk[2][2]" elemani 5

degerine atanir. Herhangi bir islemin index olarak kullanilabilecegini

gosteren ucuncu atama ise, aslinda "big[5][5] = 177;" dir.

ODEVLER

1. Herbiri yaklasik 6 karakter uzunlugunda uc kisa katarin icine "strcpy"

ile iclerine "bir", "iki" ve "dort" kelimelerini kopyalayan bir program

yazin. Daha sonra, bu katarlari, daha buyuk bir katarin icine, uc kelimeyi

bir araya getirerek yerlestirin. Cikan sonucu on kere ekrana yazdirin.

2. Herbiri 10 elemanli olan "dizi1" ve "dizi2" isimli iki tamsayi dizisi

tanimlayin, ve iclerine bir dongu ile, ivir zivir bilgi doldurun. Daha

sonra her bir elemanini, ayni boydaki bir baska diziye ekleyin. Bu cikan

sonucu da "diziler" isimli 3. bir diziye atayin. Sonuclari ekrana

yazdirin:

1 2 + 10 = 12

2 4 + 20 = 34

3 6 + 30 = 36 gibi..

Ipucu: printf komutu soyle gorunecek:

printf("%4d %4d + %4d = %4d\n",index,dizi1[index],dizi2[index],

diziler[index]);

C Dili - 8. Konu

POINTER NEDIR?

Basitce, pointer, bir adrestir. Bir degisken olmak yerine, bir degiskenin

hafizadaki adresini tasiyan bir 'ok isareti'dir.

================================================================

main() /* Pointer kullanimi ornegi */

{

int index,*pt1,*pt2;

index = 39; /* herhangi bir deger */

pt1 = &index; /* 'index' in adresi */

pt2 = pt1;

printf("Deger simdi %d %d %d dir.\n",index,*pt1,*pt2);

*pt1 = 13; /* 'index' in degerine degisiklik yapalim */

printf("Degistikten sonra ise %d %d %d\n",index,*pt1,*pt2);

}

================================================================

Su an icin, programin index degiskenini ve iki tane astrisk ile baslayan

terimlerin tanimlandigi yere bakmayin. Aslinda astrisk denilen bu isarete,

biz simdilik 'yildiz' diyelim.

Programda ilk once, index degiskenine 39 degerini atiyoruz. Bunun

altindaki satirda ise, pt1'e tuhaf bir deger atanmasini goruyoruz - index

degiskeni, ve onunde bir & ampersand isareti ile. Bu ornekte, pt1 ve pt2

pointer dir, ve index de basit bir degiskendir. Simdi bir problemle karsi

karsiyayiz. Bu programda pointer kullaniliyor, fakat nasil kullanilacagini

ogrenmedik.

Bu gorecekleriniz biraz aklinizi karistiracak, fakat bunlari anlamadan

gecmeyin.

IKI ONEMLI KURAL

1. Onune ampersand isareti konmus bir degisken, o degiskenin adresini

belirtir. Yani altinci satir, soyle okunabilir: "pt1, index isimli

degiskenin adresini alir."

2. Onune yildiz konmus bir pointer, kendisinin tuttugu adreste bulunan

degeri gosterir. Programin dokuzuncu satiri, soyle okunabilir: "pt1

pointer'inin gosterdigi yere, 13 degeri atandi."

HAFIZA YARDIMCISI

1. & 'i bir adres olarak dusunun.

2. * 'i adresteki deger olarak dusunun.

pt1 ve pt2 pointer olarak, kendileri bir deger tasimazlar, fakat

bellekteki bir adresi gosterirler. Bu programda, 'index' degiskenini

gosteren pointer'lar oldugu icin, degiskenin degerini hem index ile, hemde

onun adresini tasiyan pointer'lar ile degistirebiliriz.

Dokuzuncu satirda, index degiskeninin degeri, pt1 pointer'i ile

degistiriliyor. Program icinde 'index' i kullandigimiz herhangi biryerde,

(pt1 baska birseye atanincaya kadar), '*pt1' i de kullanmamiz

mumkundur, cunku pt1, index'in adresini tasimaktadir.

BIR BASKA POINTER

Programa degisklik katmak icin, birbaska pointer daha tanimladim. "pt2"

isimli bu pointer, yedinci satirda "pt1"'in tasidigi adresi almaktadir. Bu

atamadan once, ayni henuz deger atanmamis degiskenler gibi icinde rastgele

bilgiler vardir. Bundan sonra, "pt2" de "index" degiskeninin adresini

tasimaktadir. Ornegin, dokuzuncu satirda "*pt1" i "*pt2" ile degistirsek

de, sonuc ayni olacaktir - cunku iki pointer da ayni adresi tasimaktadir.

SADECE BIR DEGISKEN

Bu programda uc tane degisken var gibi gorunse de, aslinda bir tane

degisken tanimlidir. Iki pointer ise, bu degiskenin adresini tutmaktadir.

Bu durum, "printf" komutunun hep 13 degerini yazmasindan da anlasilabilir.

Bu gercekten anlamasi zor bir kavramdir, fakat en kucuk C programlari

disinda hepsi tarafindan kullanildigi icin, ogrenmeniz gereklidir.

POINTER NASIL TANIMLANIR

Programin ucuncu satirinda, ilk once "index" isimli degisken tanimlanir,

daha sonra da iki tane pointer tanimlamasi goreceksiniz. Ikinci tanim, su

sekilde okunabilir: "pt1'in gosterecegi adres, bir tamsayi degiskenine ait

olacak." Yani, "pt1", tamsayi bir degiskeninin pointer'i olur. Ayni

sekilde, "pt2" de, yine bir tamsayi degiskeninin pointer'i olur.

Bir pointer, bir degiskenin adresini tasimak icin tanimlanir.

Tanimlandigindan baska bir degisken tipi icin kullanimi "uyumsuz veri

tipi" hatasinin olusmasina sebep olur. Ornegin, "float" tipi bir pointer,

"int" tipli bir degiskenin adresini alamaz.

POINTER'LI IKINCI PROGRAMIMIZ

POINTER2.C:

================================================================

main()

{

char katar[40],*orada,bir,iki;

int *pt,list[100],index;

strcpy(katar,"Bu bir karakter kataridir.");

bir = katar[0]; /* bir ve iki ayni degeri tasirlar */

iki = *katar;

printf("Ilk cikti %c %c\n",bir,iki);

bir = katar[8]; /* bir ve iki ayni degeri tasirlar */

iki = *(katar+8);

printf("Ikinci cikti %c %c\n",bir,iki);

orada = katar+10; /* katar+10 ve katar[10] aynidir. */

printf("Ucuncu cikti %c\n",katar[10]);

printf("Dorduncu cikti %c\n",*orada);

for (index = 0;index < 100;index++)

list[index] = index + 100;

pt = list + 27;

printf("Besinci cikti %d\n",list[27]);

printf("Altinci cikti %d\n",*pt);

}

================================================================

Bu programda, iki tane pointer, iki tane dizi ve uc tane degisken

tanimliyoruz. "orada" isimli pointer, karakter tipi, ve "pt" ise, tamsayi

tipindedir.

BIR KATAR DEGISKENI ASLINDA BIR POINTER DIR

C programlama dilinde, bir katar degiskeni, o katarin baslangicini

gosteren bir pointer olarak tanimlanmistir. Programda bir bakin: once

"katar" isimli diziye sabit bir katar atiyoruz. Daha sonra, "bir" isimli

degiskene, "katar" in ilk harfini atiyoruz. Sonra, "iki" isimli degiskene,

ayni degeri atiyoruz. Ikinci satirda "*katar[0]" yazmak yalnis olurdu,

cunku yildiz isareti, koseli parantezlerin yerini almaktadir.

"katar" i neredeyse tam bir pointer gibi kullanabilirsiniz, yegane farki,

tuttugu adres degistirilemez, ve daima o katarin baslangic adresini

gosterir.

Onkinci satira gelince, katarin dokuzuncu karakterinin (sifirdan

basladigimiz icin), iki ayri sekilde "bir" ve "iki" isimli degiskenlere

atandigini goruyoruz.

C programlama dili, pointer'in tipine gore, index ayarlamasini

otomatik olarak yapar. Bu durumda, "katar" bir "char" olarak tanimlandigi

icin, baslangic adresine 8 eklenir. Sayet "katar" "int" (tamsayi) olarak

tanimlanmis olsa idi, index iki ile carpilip, "katar" in baslangic

adresine eklenirdi.

"orada" bir pointer oldugu icin, 16. satirda "katar" in 11. elemaninin

adresini tasiyabilir. "orada" gercek bir pointer oldugu icin, herhangi bir

karakter degiskeninin adresini gosterebilir.

POINTER VE ARITMETIK

Her cesit islemler, pointer'lar ile mumkun degildir. Pointer bir adres

oldugundan, ona bir sabit rakam ekleyip, daha ilerideki bir adrese

erismek mumkundur. Ayni sekilde, pointer'in adresinde bir rakam cikartip,

daha onceki hafiza bolgelerine erismek mumkundur. Iki pointer'i toplamak

pek mantikli degildir, cunku bilgisayardaki adresler sabit degildir.

Cikacak rakamin tuhaf olacagi icin pointer ile carpma da yapilamaz. Ne

yaptiginizi dusunurseniz, yapabilecekleriniz ve yapamayacaklariniz kendini

belli edecektir.

TAMSAYI POINTER'I

"list" isimli tamsayi dizisine, 100 den 199 a kadar degerler verilir. Daha

sonra, 28. elemanin adresini, "pt" isimli pointer'a atiyoruz. Daha sonra

ekrana yazdigimizda, gercektende, o degeri aldigini goruyoruz.

Daha onceki konularda, bir fonksiyondan veri degerlerini dondurmek icin

iki metod oldugunu soylemistim. Ilki, bir dizi kullanarakti. Ikincisini

herhalde tahmin edersiniz. Sayet tahmininiz "pointer sayesinde" idiyse,

tebrikler.

CIFTYON.C:

================================================================

main()

{

int cevizler,elmalar;

cevizler = 100;

elmalar = 101;

printf("Baslangic degerleri %d %d\n",cevizler,elmalar);

/* "degistir" i cagirinca, */

degistir(cevizler,&elmalar); /* cevizlerin DEGERI ve, */

/* elmalarin adresini geciriyoruz */

printf("Bitis degerleri ise, %d %d dir..\n",cevizler,elmalar);

}

degistir(kuru_yemis,meyvalar) /* kuru_yemis tamsayidir */

int kuru_yemis,*meyvalar; /* meyvalar bir tamsayi pointer'idir */

{

printf("Degerler %d %d\n",kuru_yemis,*meyvalar);

kuru_yemis = 135;

*meyvalar = 172;

printf("Sonraki degerler %d %d\n",kuru_yemis,*meyvalar);

}

================================================================

Burada, iki tane tamsayi degiskeni (pointer degil) tanimliyoruz:

"cevizler" ve "elmalar". Once bunlara birer deger atiyoruz, ve "degistir"

isimli fonksiyonu cagiriyoruz. Cagirirken, "cevizler" in degeri (100), ve

"elmalar" degiskeninin adresini geciriyoruz. Fakat, fonksiyona da, bir

deger ve bir adres gelecegini haber vermemiz gereklidir. Bunun icin,

fonksiyonun parametreleri tanimlanirken, bir adres tasiyacak olan sembolun

basina bir yildiz koymamiz yeterlidir.

Fonksiyonun icinde, bu iki degeri degistirip, eski ve yeni degerleri

ekrana yaziyoruz. Bu program calistiginda, ana programdaki "cevizler" in

degerinin ayni kaldigini fakat "elmalar" in yeni degerlerini aldigini

goreceksiniz.

"cevizler" in degerinin ayni kalmasinin nedeni, fonksiyona bir

deger gecirildiginde, C dilinin o degerin bir kopyasini fonksiyona

gecirmesi yuzundendir. Programa geri dondugunuzde, degerin bir kopyasini

kullandigimiz icin asil degerin degismedigini goreceksiniz.

"elmalar" in degerinin degismesi ise, yine fonksiyona "elmalar"

degiskeninin adresinin bir kopyasi gecirildigi halde, bu adres ana

programdaki "elmalar" a karsilik geldigi icin, fonksiyonda bu adresteki

degeri degistirir degistirmez, "elmalar" in da degeri degismis olur.

ODEV

1. Bir karakter katari tanimlayin, ve icine "strcpy" ile bilgi koyun. Bir

dongu ve pointer ile katari harf-harf (teker teker) ekrana yazin.

Programin basinda pointer'i katarin ilk elemanina atayin, daha sonra cift

arti isareti ile pointer'in degerini arttirin. Ayri bir tamsayi degiskeni

ile kac karakter yazilacagini kontrol edin..

2. 1. deki programi, pointeri katarin sonuna atayip, cift eksi isaretini

kullanarak sondan basa dogru yazmasi icin degistiriniz.

C Dili - 9. Konu

Standart Input/Output

BASITIO.C:

================================================================

#include <stdio.h> /* input/output icin standard header */

main()

{

char c;

printf("Herhangi bir tusa basin. X = Programi durdurur. ");

do {

c = getchar(); /* klavyeden bir tus okuyalim */

putchar(c); /* ekranda gosterelim. */

} while (c != 'X'); /* ta ki okunan bir X oluncaya dek... */

printf("sonu.");

}

================================================================

Standart I/O deyimi, verinin girildigi ve ciktigi en normal yerleri,

klavyeyi ve ekrani kast eder. Bu kutuge ilk baktiginizda, "#include

<stdio.h>" komutunu goreceksiniz. Bu komut on-derleyiciye, kucuktur ve

buyuktur isaretleri arasinda yer alan kutuk isminin programa eklenmesini

soyler. Bazen, < > isaretleri yerine den-den " " isaretleri de

gorebilirsiniz. Aralarindaki fark, <> isaretlerinin on-derleyiciye, su

anda calistiginiz diskte / dizinde degil de, bu tip kutuklerin konuldugu

yerde aramasini bildirir. Halbuki den-den isaretleri ile belirlenmis bir

kutuk ismi, sizin su anda bulundugunuz disk / dizinde aranir. Genellikle,

"bu tip kutuklerin konuldugu yer", derleyiciye daha onceden belirtilir.

Ornegin, Quick C derleyicisinde, derleyiciye girmeden once:

SET INCLUDE=C:

yazmak, derleyicinin bundan sonra butun 'include' edilecek, yani eklenecek

kutuklerin C: diskinin dizininde aranmasini belirtir.

Sonu .h ile biten kutuklerin, ozel bir fonksiyonu vardir. Bunlara header

yada baslik kutukleri denir. Genellikle iclerinde, bazi fonksiyonlari

kullanmak icin gereken tanimlamalar yer alir. Bu kullandigimiz "stdio.h"

kutugu ise, bir suru "#define" komutundan olusur.

C DE INPUT/OUTPUT ISLEMLERI

C dilinde lisanin bir parcasi olarak tanimlanmis input/output komutlari

yoktur, bu nedenle bu fonksiyonlarin kullanici tarafindan yazilmasi

gereklidir. Her C kullanan kisi, kendi input/output komutlarini yazmak

istemediginden, derleyici yazarlari bu konuda calisma yapmislar, ve bize

bir suru input/output fonksiyonlari saglamislardir. Bu fonksiyonlar

standart hale gelmislerdir, ve hemen her C derleyicisinde ayni

input/output komutlarini bulabilirsiniz. C nin lisan tanimi, Kernigan ve

Richie tarafindan yazilmis bir kitaptir, ve onlar bu gorecegimiz

input/output fonksiyonlari bu kitaba katmislardir.

Bu "stdio.h" isimli kutugu incelemenizde fayda vardir. Icinde bircok

anlamadiginiz nokta olacaktir, fakat bazi kisimlar tanidik olacaktir.

DIGER INCLUDE KUTUKLERI

C de buyuk programlar yazmaya basladiginizda, programlari ufak parcalara

ayirip ayri ayri derlemek isteyebilirsiniz. Bu degisik parcalarin ortak

kisimlarini tek bir kutukte toplayip, bir degisiklik gerektiginde sadece o

ortak kutukten yapmayi isteyebilirsiniz (ornegin global degisken

tanimlari.) Bu gibi durumlarda "#include" kutukleri cok faydali olacaktir.

"BASITIO" YA GERI DONELIM

"c" isimli degisken tanimlanir, ve ekrana mesaj yazilir. Daha sonra,

kendimizi "c", buyuk harf X e esit olmadigi surece devam eden bir dongunun

icinde buluyoruz. Bu programdaki iki yeni fonksiyon, su an icin ilgi

noktamiz. Bunlar klavyeden bir tus okumak, ve ekrana bir karakter yazmayi

saglarlar.

"getchar()" isimli fonksiyon, klavyeden okudugu tusu dondurur, bu deger

"c" ye atanir. "putchar()" fonksiyonu ise, bu degeri ekrana yansitir.

Bu programi derleyip calistirdiginizda, bir surpriz ile karsilasacaksiniz.

Klavyeden yazdiginizda, ekrana herseyin iyi bir sekilde yansitildigini

goreceksiniz. RETURN tusuna bastiginizda ise, butun satirin tekrar ekrana

yazildigini goreceksiniz. Her karakteri teker teker ekrana getirmesini

soyledigimiz halde, programimiz sanki butun satiri sakliyor gibi.

DOS BIZE YARDIMCI OLUYOR (YADA ISE KARISIYOR)

Bu durumu anlayabilmek icin, DOS un nasil calistigini anlamamiz

gereklidir. Klavyeden tuslar DOS kontrolu ile okundugu zaman, RETURN tusu

basilana dek, basilan tuslar bir sahada saklanir. RETURN basilinca da,

butun satir programa dondurulur. Tuslara basilirken, karakterler ekrana da

yansitilir. Bu duruma da "eko" ismi verilir.

Simdi anlatilanlari goz onunde bulundurarak, programimiz calisirken ekrana

eko edilenlerin, DOS tarafindan yapildigini anlayabilirsiniz. Siz RETURN e

basinca da, bu saklanan tuslar, programa gonderilir. Bunu daha iyi anlamak

icin, icinde buyuk harf X olan bir satir yazin. DOS, buyuk X in ozel bir

tus oldugundan habersiz, siz RETURN e basana kadar tuslari kabul etmeye

devam eder. RETURN e basinca ise, bu katar programa gecirilir, ve program

X e rastlayincaya kadar ekrana karakterleri birer birer yazar.

Isletim sisteminin bu tuhafliklari karsisinda yilmayin. Bazi

programlarinizda, bu ozellik isinize yarayabilir. Fakat simdi biz, az once

yazdigimiz programin, dusundugumuz gibi calismasini saglayalim.

TEKIO.C:

================================================================

#include <stdio.h>

main()

{

char c;

printf("Herhangi bir tusa basin. X = Programi durdurur. ");

do {

c = getch(); /* bir tus oku */

putchar(c); /* basilan tusu goster */

} while (c != 'X'); /* ta ki c == 'X' olana dek */

printf("sonu.");

}

================================================================

Bu programdaki yegane degisiklik olan yeni fonksiyon "getch()", yine

klavyeden tek bir karakter okur. Farki, "getchar" gibi DOS'a

takilmamasidir. Bir karakter okur, ve ekrana yansitmadan bu tusu programa

dondurur.

Bu programi calistirdiginizda, bir oncekindeki gibi tekrarlanan satirlar

olmadigini goreceksiniz. Ayrica program artik 'X' e basar basmaz

durmaktadir. Burada baska bir problemimiz var. RETURN'e basinca cursor,

ekranin soluna gitmektedir, ama bir alt satira inmemektedir.

SATIR ATLAMAMIZ LAZIM

Cogu uygulama programi siz RETURN e basinca, program o RETURN e ek olarak

bir de "Line Feed" yani satir atlama karakteri ilave eder. Satir atlama

otomatik olarak yapilmaz. Bundan sonraki programda, bu sorunu da halletmis

olacagiz.

IYIIO.C:

================================================================

#include "stdio.h"

#define CR 13 /* CR sembolunu 13 olarak tanimlar */

#define LF 10 /* LF sembolunu 10 olarak tanimlar */

main()

{

char c;

printf("Tuslara basin. Durmak icin X e basin.");

do {

c = getch(); /* Bir karakter oku */

putchar(c); /* basilan tusu ekrana yaz */

if (c == CR) putchar(LF); /* sayet basilan RETURN tusu ise,

bir SATIR ATLAMA karakteri yolla */

} while (c != 'X');

printf("sonu.");

}

================================================================

Programin ilk basinda CR 'nin artik 13 e esit oldugunu ve LF nin de 10

oldugunu belirtiyoruz. Sayet ASCII tablosundan bakarsaniz, RETURN tusuna

karsilik gelen kodun 13 oldugunu gorursunuz. Ayni tabloda, satir atlama

kodu da 10 dur.

Ekrana basilan tusu yazdiktan sonra, sayet bu tus RETURN tusu ise, bir

satir atlayabilmemiz icin, satir atlama kodunu ekrana yaziyoruz.

Programin basindaki "#define" lar yerine "if (c == 13) putchar(10);"

diyebilirdik, fakat ne yapmak istedigimiz pek belirgin olmazdi.

HANGI METOD DAHA IYI?

Burada ekrandan bir harf okumanin iki yolunu inceledik. Her ikisinin de

avantajlari ve dezavantajlari var. Bunlara bir bakalim.

Ilk metodda, butun isi DOS ustlenmektedir. Programimiz baska islerle

ugrasirken, DOS bizim icin satiri hazirlayabilir, ve RETURN'e basilinca bu

satiri programa dondurebilir. Fakat, bu metodda karakterleri basildiklari

anda fark etmemiz imkansizdir.

Ikinci metodda, tuslari teker teker fark etmemiz mumkundur. Fakat,

program bu okuma sirasinda butun zamanini okumaya harcar ve baska bir is

yapamaz, ve bilgisayarin tum zamanini bu isle almis oluruz.

Hangi metodun uzerinde calistiginiz program icin daha uygun oldugunu

programci olarak siz karar vereceksiniz.

Burada, "getch()" fonksiyonun tersi olan "ungetch()" isimli bir fonksiyon

daha oldugunu da belirtmeliyim. Sayet bir karakteri "getch()" le okuduktan

sonra fazla okudugunuzu fark ederseniz, bu fonksiyon ile okunan tusu geri

koyabilirsiniz. Bu bazi programlarin yazilimini kolaylastirmaktadir cunku

bir tusu istemediginizi onu okuyuncaya kadar bilemezsiniz. Sadece bir tek

tusu "ungetch" edebilirsiniz, fakat genellikle bu yeterlidir.

BIRAZ TAMSAYI OKUYALIM

TAMOKU.C:

================================================================

#include <stdio.h>

main()

{

int deger;

printf("0 ila 32767 arasinda bir rakam yazin, durmak icin 100 girin.");

do {

scanf("%d",&deger); /* bir tamsayi oku (adresi ile) */

printf("Okunan deger %d idi. ",deger);

} while (deger != 100);

printf("Programin sonu");

}

================================================================

Alistigimiz tip bir program olan TAMOKU'da, "scanf" isimli yeni bir

fonksiyon goruyoruz. Cok kullandigimiz "printf" fonksiyonuna cok benzeyen

bu fonksiyonun gorevi, istenilen tip verileri okuyup, degiskenlere atamak.

"printf" den en buyuk farki, "scanf" in degisken degerleri yerine,

adreslerini kullanmasidir. Hatirlayacaginiz gibi, bir fonksiyonun

parametrelerinin degerlerini degistirebilmesi icin, degiskenin adresine

ihtiyaci vardir. "scanf" fonksiyonuna adres yerine deger gecirmek, C

dilinde en SIK rastlanan hatalardan biridir.

"scanf" fonksiyonu, girilen satiri, satirdaki bosluklara bakmadan, ve bu

sekilde kullanildiginda, rakam olmayan bir karakter bulana kadar bir

tamsayi okur.

Sayet 32766 den buyuk bir rakam girerseniz, programin hata yaptigini

gorursunuz. Ornegin 65536 girerseniz, programin 0 degerini dondurdugunu

gorursunuz. Buna sebep, tamsayilarin hafizada saklanisinda onlara 16

bitlik bir saha ayrilmasindandir. Programinizda daha buyuk rakamlar

kullanacaksaniz, 'long' yada 'float' tiplerini secebilirsiniz.

KARAKTER KATARI GIRISI

KATARIN.C:

================================================================

#include <stdio.h>

main()

{

char big[25];

printf("Karakter katari girin, en fazla 25 karakter.");

printf("Birinci kolonda X yazarak programi bitirin.");

do {

scanf("%s",big);

printf("Yazdiginiz katar -> %s",big);

} while (big[0] != 'X');

printf("Programin sonu.");

}

================================================================

Bu program bir oncekine cok benzer, fakat bu sefer bir kelime katari

giriyoruz. 25 elemanli bir dizi tanimlanmistir, fakat en son deger bir '0'

olmasi gerektiginden, kullanilabilen kisimi 24 dur. "scanf" deki

degiskenin onune & ampersand isareti gerekmez cunku, koseli parantezleri

olmayan bir dizi degiskeni, C dilinde o dizinin baslangicini gosteren

bir adrestir.

Calistiginizda, sizi bir supriz bekliyor. Yazdiginiz cumleyi, program ayri

satirlarda gosterir. Bunun sebebi, "scanf" bir katar okurken, satirin

sonuna yada bir bosluga rastlayincaya kadar okumasina devam eder. Bir

dongu icinde oldugumuzdan, program tekrar tekrar "scanf" i cagirarak,

DOS'un giris sahasinda kalan butun karakterleri okur. Cumleleri kelimelere

boldugunden, X ile baslayan herhangi bir kelimeye rastlayinca, bu program

durur.

24 karakterden daha fazlasini girmeye calisin. Ne olduguna bakin. Size bir

hata mesaji verebilir, yada programiniz aleti kilitleyebilir. Gercek bir

programda, boyle seylerin sorumlulugu sizlerin omuzlarinizdadir. C dilinde

yazdiginiza size cok sey duser, fakat ayni zamanda bircok kolaylik da

saglar.

C DE INPUT/OUTPUT PROGRAMLAMA

C dili cok miktarda input/output yapan programlar icin degil de, bir

bircok icsel islemler yapan sistem programlari icin yazilmistir.

Klavye'den bilgi alma rutinleri cok kullanislidir, fakat C size az

yardimci olur. Yani, yapmaniz gereken I/O islemlerinde sorun cikmasini

onlemek icin detaylarla sizin ugrasmaniz lazimdir. Fakat genellikle

herhangi bir program icin bu tip fonksiyonlari bir defa tanimlamaniz

yeterlidir.

HAFIZADA.C:

================================================================

main()

{

int rakam[5], sonuc[5], index;

char satir[80];

rakam[0] = 5;

rakam[1] = 10;

rakam[2] = 15;

rakam[3] = 20;

rakam[4] = 25;

sprintf(satir,"%d %d %d %d %d",rakam[0],rakam[1],

rakam[2],rakam[3],rakam[4]);

printf("%s",satir);

sscanf(satir,"%d %d %d %d %d",&sonuc[4],&sonuc[3],

(sonuc+2),(sonuc+1),sonuc);

for (index = 0;index < 5;index++)

printf("Sonuc %d dir. ",sonuc[index]);

}

================================================================

Bu programda, birkac tane degisken tanimliyoruz, ve "rakamlar" isimli

diziye de, "sprintf" fonksiyonunu incelemek icin rastgele sayilar

atiyoruz. Bu fonksiyon, "printf" e cok benzer. Yegane farki, ciktisini

ekrana yazmak yerine, bir karakter dizisine yazmasidir. Bunu da, ilk

parametresi olarak veriyoruz. Yani program bu fonksiyondan dondukten

sonra, "satir" dizisinin icinde, bes tane rakam olacaktir. Ikinci ile

ucuncu rakamlar arasindaki bosluk, "sscanf" fonksiyonunun bunlarin

uzerinden atlamasini gormek icindir.

Bunun altinda "printf" i kullanarak bu hazirladigimiz satiri yaziyoruz.

Daha sonra gordugunuz, "sscanf" fonksiyonu ise, "scanf" gibi ekrandan

okumak yerine, bizim "satir" dizimizden degerleri okur. Gordugunuz gibi,

"sscanf" e rakamlarin konacagi dizinin adreslerini cok degisik sekillerde

verebiliyoruz. Ilk ikisi, sadece dizideki 5. ve 4. elemanlarin adreslerini

index vererek tanimliyorlar, sonraki ikisi ise, dizinin baslangic adresine

bir offset (bir rakam) ekleyerek buluyorlar. Sonuncusu ise, koseli

parantezi olmayan bir dizinin, o dizinin baslangic elemaninin adresini

gostereceginden, hicbir sey gerektirmiyor.

Bazen, bir programin ciktilarini, standart ciktidan (ekrandan), bir baska

kutuge yoneltmek istenir. Fakat, hata mesajlarini gibi bazi mesajlari hala

ekrana yollamak isteyebilirsiniz:

OZEL.C:

================================================================

#include <stdio.h>

main()

{

int index;

for (index = 0;index < 6;index++) {

printf("Bu satir, standart ciktiya gidiyor.");

fprintf(stderr,"Bu satir ise standart hataya gidiyor.");

}

exit(4); /* Bu komut, DOS 'un ERRORLEVEL komutu ile bir batch file'da

(yigit kutugunde) kontrol edilebilir. Bu programin

d”nd£rd£g£ deger, soyle kontrol edilebilir:

 VE NiHAYET C ANLATIMIMIZ BiTTi. GERiSi SiNiZ ÇABALARINIZA VE ARASTIRMACI RUHUNUZA KALMIS.!!!!!!!