C NEDIR ?
C programlama dili Dennis Ritchie tarafindan Bell laboratuarlarinda
yaratilmistir. PDP-11 ile Unix altinda calismak icin yaratilmis olmasina
ragmen ilgi uzerine MS-DOS altinda calisacak hale getirilmistir.
Basitligi olusan kodun kucuklugu ve her cesit programlamada
kullanilabilmesi C yi populer bir dil yapmistir.

C cok kestirme olmasi nedeni ile yeni bilgisayarlara baslayanlar icin
ogrenmesi zordur. Bir programci C ile ust seviyelerden assebly'ye
yaklasan alt seviyelere kadar programlama yapabilir. C nin sagladigi bu
rahatligin yaninda tehlikeleride de vardir. Ornegin makineyi
kilitleyebilecek bir program yazmak Pascal yada BASIC de yazmaktan cok
daha kolaydir. Bir Pascal derleyicisinin fark edip uyaracagi bir hatayi C
derleyicileri fark etmeyebilir. C de kendi basinizasiniz..

NIYE C?

Bu gun IBM-PC icin yazilan piyasadaki yeni programlarin yuzde 75'i C ile
yaziliyor. MicroSoft Macro Assembler 4.0 i cikardiktan sonra onu C ile
yazdiklarini acikladi. Herhalde icinde birkac assembler rutin vardir ama
cogunlugu C ile yazilmistir.

C bir komite degilde bir kisi tarafindan yazilmis oldugundan cok
kullanisli bir lisandir fakat cok iyi tanimlanmamistir. C icin bir
standart yoktur ama ANSI grubu bu konuda calismaktadir. Isin ilgincligi
bir standart olmamasina ragmen degisiklikleri cok azdir. Halbuki iyi
tanimi olan Pascal dilinin derleyicileri birbirinden cok farklidir ve
bir Pascal programini bir bilgisayardan digerine gecirmek zordur..

C nin Tasinabilirlik referanslari iyi olmasina ragmen derleyiciler
arasinda farkliliklar vardir. Bu degisiklikler genellikle BIOS
fonksiyonlari gibi standart olmayan seyler kullanildiginda kendini
gosterir.


TANIMLAYICI ISIMLERI

Fonksiyon ve degisken isimleri harfler ve rakkamlardan olusabilir. Ilk
harf ya bir harf yada alt-cizgi karakteri olmak zorundadir. geri kalanlar
ise harf rakkam yada alt cizgi olabilir. Iki nokta onemlidir:

(1) Buyuk ve kucuk harfler farklidir. Bir programda "ISIM" "iSiM" ve
"isim" degisik tanimlayicilardir.

(2) C'de en fazla sekiz karakter onemlidir. Bir tanimlayici 8 karakterden
uzun olabilir fakat ilk sekizi sayilir. Bu derleyiciniz icin boyle
olmayabilir.

DERLEYICI

Bu derste bircok ornek program sunacagim. Bunlari istediginiz herhangi bir
derleyici ile derleyebilirsiniz fakat kullanim kolayligi bakimindan
QuickC derleyicisini tercih etmenizi tavsiye ederim.


c++ dersleri 2.bölüm

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
main() sozcugudur. Her programda olmasi gereken bu sozcuk daha sonra
gorecegimiz gibi ilk satirda olmak zorunda degildir fakat bir giris
noktasi saglamasi nedeni ile gereklidir. Bunu takiben iki tane paranaaa
vardir. Bunlar da main'in bir fonksiyon oldugunu belirtir. (Bir
fonksiyonun tam olarak nelerden olustugunu daha sonra gorecegiz)
Programin kendisi ise iki kume isareti arasinda yer alir.

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 paranaaa 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 bir
satir 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 %dn"index);
index = 27;
printf("Indexin degeri simdi %dn"index);
index = 10;
printf("Indexin degeri simdi %dn"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 ekrana
yazilir sonra 27 ve 10.

RAKAMLARI NASIL YAZARIZ

Sozumuze sadik kalmak icin tekrar printf komutuna donelim ve nasil
calistigini gorelim. Gordugunuz gibi butun satirlar birbiri ile ayni ve
diger orneklerden farki icindeki % isareti. Bu harf printf'e ekrana
yazmayi durdurup ozel birsey yapmasini soyler. % isaretinden sonra gelen
harf d bir tamsayi yazilacagini belirtir. Bundan sonra yeni satira
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.

Dikkat etmeniz gereken bir nokta birkac satirdan olusan bilgi
satirlarinda bulunan program komutlarinin isleme konmayacagidir.

Bilgi satirlari programin nasil calistigini gostermesi bakimindan cok
onemlidir. Yazdiginiz bir programin bir baskasi tarafindan okunabilmesi
yada siz nasil calistigini unuttuktan sonra hatirlayabilmeniz icin mumkun
oldugu kadar cok bilgi satiri eklemekte fayda vardir.

Bazi derleyiciler ic ice bilgi satirlarini kabul ederler fakat genelde
ic ice bilgi satirlari kabul edilmez.

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 kolaylastirirn");
}

ve:

main() /* Program buradan basliyor */ {printf("iyi yazis"); printf
("programin anlasilmasini kolaylastirirn");}


Odev bence aaaa her zaman gereklidir bunları yapmaya çalışın yaparsanız kKENDİ KENDİNİZE az da olsa c++'da ilerlemiş olacaksınız)

1. Ekrana kendi isminizi yazacak bir program yazin.
2. Programa ayri satirlarda iki "printf" satiri daha ekleyerek
adresinizi ve telefon numaranizi da yazdirin.


c++ dersleri 3.bölüm

TAM SAYI ATAMA

TAMSAYI.C:
================================================== ==
main()
{
int abc;

a = 12;
b = 3;

c = a+b;
c = a-b;
c = a*b;
c = a/b;
c = a%b;

c = 12*a+b/2-a*b*2/(a*c+b*2);

a = a + 1; /* arttirma islemleri */
b = b * 5;

a = b = c = 20; /* Coklu atamalar */
a = b = c = 12*13/4;
}
================================================== =

Bu programda uc tam sayi degiskeni tanimliyoruz (abc) ve bunlara
degerler atiyoruz. Ilk iki satirda a ve b ye sayisal degerler veriyoruz.
Daha sonraki dort satirda basit islemler goruyorsunuz.

Besinci satirda ise modulo operatorunu goruyorsunuz. Modulo iki degisken
birbirine bolundugunde kalan degeri verir. Modulo sadece integer ve char
degisken tipleri ile kullanilabilir.

Daha sonra gelen iki arttirma islemleri ise bu sekilde derleyici
tarafindan kabul edilir fakat bunlari yazmanin daha kestirme bir sekli
vardir - bunu daha sonra gorecegiz.

Son iki satira gelince bunlar cok tuhaf gorunebilir goze. C derleyicisi
atama satirlarini sagdan sola dogru okur. Bunun sayesinde coklu atamalar
gibi cok faydali islemler yapilabilir. Bu ornekte derleyici yirmiyi
alip c ye atiyor. Sola dogru devam ederken b yi gorup en son elde
edilen sonucu (20) b ye atiyor. Ayni sekilde a ya da b nin degeri
veriliyor.

Bu programi derleyip calistirmak son derece SIKICI olabilir. Bu programin
hicbir ciktisi yoktur. Dilerseniz ogrendiginiz printf fonksiyonu ile
programin yaptiklarini daha yakindan inceleyebilirsiniz.

C de veri tanimlari program bloku icinde islenecek komutlardan once
gelir. Sayet tanimlari programin ortasina yerlestirmeye calisirsaniz
derleyici bir hata verecektir.

VERI TIPLERI

main()
{
int abc; /* -32767 den 32767 ye - tamsayi olarak */
char xyz; /* 0 dan 255 e - tamsayi olarak */
float numtoything; /* 10e-38 den 10e+38 e - ondalikli olarak */

a = b = c = -27;
x = y = z = 'A';
num = toy = thing = 3.6792;

a = y; /* a nin degeri simdi 65 (karakter A) */
x = b; /* x simdi tuhaf bir sayi olacak */
num = b; /* num simdi -27.00 olacak */
a = toy /* a simdi 3 olacak */
}

Gordugunuz gibi birkac integer daha tanimladik. Fakat bundan baska iki
yeni tip daha kattik. "Char" ve "float".

"Char" tipi nerdeyse integer ile ayni manada. Fakat sadece 0 ila 255
arasindaki sayilari alabilir ve genellikle hafizada bir bytelik bir yerde
saklanir. Bu tip veri genellikle kelime katarlari saklamak icin
kullanilir.

DATA TIPLERININ KARISTIRILMASI

Bu anda C nin "int" ve "char" i nasil kullandigini gormenin tam zamani. C
deki "int" tipi ile calisan cogu fonksiyonlar karakter tip veri ile de
ayni sekilde calisabilir cunku karakter tipi bir cins integer'dir.
"char" ve "int" tiplerini neredeyse istediginiz gibi karistirmak
mumkundur. Derleyicinin akli karismaz ama sizin karisabilir. Bunun icin
dogru tip veriyi kullanmakta fayda vardir.

FLOAT

Ikinci yeni tip veri "float" tipidir. Kayar nokta da denilen bu tipin
sinirlari cok genistir. Cogu bilgisayarlarda float tipi 10e-38 den 10e+38
e kadardir.

YENI VERI TIPLERINI NASIL KULLANALIM

Bu programin ilk uc satirinda dokuz tane degiskene deger ataniyor.

* Daha once gordugumuz gibi "char" tipi aslinda bir "integer" tipi
oldugundan bir "char" in "int" e cevrilmesinde hicbir sorun yoktur.
* Fakat bir integer'i "char" a cevirmek icin bir standart yoktur. Bu
nedenle sayet tamsayi degiskeninin degeri "char" sahasindan buyukse
cikan sonuc cok sasirtici olabilir.
* Ucuncu satirda ise bir tamsayiyi "float" a atiyoruz. Bu durumda
derleyici bu ceviriyi bizim icin yapar.
* Fakat tersini yapmak ise biraz daha karisiktir. Derleyici sayet varsa
degiskenin ondalik degerini ne yapacagina karar vermek zorundadir.
Genellikle de ondalik kesimi gozardi eder.

Bu programin da hicbir ciktisi yok. Hem zaten karakter ve float tiplerinin
nasil ekrana yazilabilecegini gormedik.. Bundan sonraki programa kadar
sabir..

COKVERI.C:
================================================== =

main()
{
int a; /* basit tamsayi tipi */
long int b; /* uzun tamsayi tipi */
short int c; /* kisa tamsayi tipi */
unsigned int d; /* isaretsiz (+ - siz) tamsayi */
char e; /* karakter tipi */
float f; /* kayar nokta tipi */
double g; /* cift hassasiyet kayar nokta */

a = 1023;
b = 2222;
c = 123;
d = 1234;
e = 'X';
f = 3.14159;
g = 3.1415926535898;

printf("a = %dn"a); /* desimal */
printf("a = %on"a); /* oktal */
printf("a = %xn"a); /* heksadesimal */
printf("b = %ldn"b); /* uzun desimal */
printf("c = %dn"c); /* kisa desimal */
printf("d = %un"d); /* isaretsiz */
printf("e = %cn"e); /* karakter */
printf("f = %fn"f); /* kayar nokta */
printf("g = %fn"g); /* cift hassasiyet k.n */
printf("n");
printf("a = %dn"a); /* basit 'int' cikti */
printf("a = %7dn"a); /* 7 uzunlukta bir saha kullan*/
printf("a = %-7dn"a); /* sola dayali 7 lik saha */
printf("n");
printf("f = %fn"f); /* basit kayan nokta */
printf("f = %12fn"f); /* 12 lik bir saha kullan*/
printf("f = %12.3fn"f); /* noktadan sonra 3 hane */
printf("f = %12.5fn"f); /* noktadan sonra 5 hane */
printf("f = %-12.5fn"f); /* sola yapisik 12 hane */
}

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

Bu program C dilinde bulunan butun standart basit veri tiplerini
kapsiyor. Baska tiplerde var fakat bunlar basit tiplerin bir araya
gelmesi ile olusurlar. Bunlardan daha sonra bahsedecegiz.

Programi inceleyin. Ilk once basit 'int' sonra 'long int' ve 'short int'
gorunuyor. 'unsigned' tipi yine integer kadar bir sahada saklanir fakat
arti yada eksi isareti tasimadigindan genellikle siniri 0 - 65535 dir.
(Sayet long short yada unsigned deyimi kullanilmissa sonuna 'int'
yazilmasi gereksizdir.)

Daha once char ve float u gormustuk. Bunlar disinda kalan 'double' tipi
'float' a nazaran daha buyuk bir sahada saklanir ve daha hassas sonuclar
verebilir.

Cogu derleyicilerin matematik fonksiyonlari float tipini kullanmaz
double tipini kullanir. Bu nedenle verdiginiz float degeri size
transparan olarak double'a cevirir.

PRINTF'IN CEVIRIM KARAKTERLERI

Printf fonksiyonunda kullanilan karakterler sunlardir:

d desimal
o oktal
x heksadesimal
u unsigned (isaretsiz)
c karakter
s string (karakter katari)
f float (kayar nokta)

Bu harfler bir yuzde isaretinden sonra kullanirlar. Bu iki harf arasina
sunlar ilave edilebilir:

- sahasinin icinde sola dayanmis
(n) minimum saha uzunlugunu belirler
. n ile m yi birbirinden ayirir
(m) float tipi icin noktadan sonraki hane sayisi
l 'long' tipi oldugunu belirtmek icin

Bu programi derleyip sonuclarini inceleyin. Dilediginiz gibi degistirerek
sonuclari inceleyin.

MANTIKSAL KARSILASTIRMALAR

KARSILAS.C:
==================================================


main() /* Bir suru karsilastirma */
{
int x = 11y = 11z = 11;
char a = 40b = 40c = 40;
float r = 12.987s = 12.987t = 12.987;

/* Birinci grup */

if (x == y) z = -13; /* z = -13 olacak */
if (x > z) a = 'A'; /* a = 65 olacak */
if (!(x > z)) a = 'B'; /* bu hicbir sey yapmayacak */
if (b <= c) r = 0.0; /* r = 0.0 olacak */
if (r != s) t = c/2; /* t = 20 olacak */

/* Ikinci grup */

if (x = (r != s)) z = 1000; /* x pozitif olacak ve
z = 1000 olacak */
if (x = y) z = 222; /* bu x = y and z = 222 yapar */
if (x != 0) z = 333; /* z = 333 olacak */
if (x) z = 444; /* z = 444 olacak */

/* Ucuncu grup */

x = y = z = 77;
if ((x == y) && (x == 77)) z = 33; /* z = 33 olur */
if ((x > y) || (z > 12)) z = 22; /* z = 22 olacak */
if (x && y && z) z = 11; /* z = 11 olur */
if ((x = 1) && (y = 2) && (z = 3)) r = 12.00; /* Bu ise
x = 1 y = 2 z = 3 r = 12.00 yapar */
if ((x == 2) && (y = 3) && (z = 4)) r = 14.56; /* Birsey degistiremez */


/* Dorducu grup */

if (x == x); z = 27.345; /* z daima deger degistirir */
if (x != x) z = 27.345; /* Hicbirsey degismez */
if (x = 0) z = 27.345; /* x = 0 olur z degismez */

}

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

Karsilas.C isimli programa lutfen bakin. Ilk basinda dokuz tane
degisken hazirliyoruz. Daha once yapmadigimiz sekilde bunlari hem
tanimlayip hem ilk degerlerini veriyoruz.

Gordugunuz gibi if ile komutlar arasinda bir satir birakmamiz gerekmiyor.
Programin daha okunabilir olmasi icin arada satir birakmak sart degildir.

Birinci gruptaki karsilastirmalar iki degiskeni karsilastirdiklari icin
en basit olanlari. Ilk satirda x in y ye esit olup olmadigina bakiyoruz.
Burada iki esit isareti yerine (==) tek esit de kullanilabilirdi fakat
manasi degisirdi.

Ucuncu satirda NOT isaretini goruyorsunuz. Bu unlem isareti herhangi bir
karsilastirmanin sonucunu degistirmek icin kullanilabilir.

DAHA ZOR KARSILASTIRMALAR


Ikinci grupta yer alan karsilastirmalar daha zor. Ilk once paranaaaler
arasinda tuhaf bir ifade yer aliyor.. Bunu anlamak icin C dilindeki
'EVET' ve 'HAYIR' kavramlarini bilmemiz gerekiyor. C de 'HAYIR' 0
degerindedir. 'EVET' ise sifirdan degisik herhangi birseydir. Bir
EVET/HAYIR testinin sonucu herhangi bir integer yada karakter
degiskenine atanabilir.

Ilk ornege bakin: r!=s deyimi r nin degeri 0.0 a atandigindan 'EVET'
bir sonuc verecektir. Bu sonuc sifirdan degisik bir rakam ve herhalde 1
olacaktir. Olusan bu sonuc x degiskenine atanir. Sayet x den sonra iki
esit isareti olsa idi (x == (r!=s) gibi) bu durumda bu 1 degeri x ile
karsilastirilirdi. Fakat tek bir isaret oldugundan r ile s yi
karsilastirmanin sonucu x e atanir. Ayrica bu atama isleminin sonucu da
sifirdan degisik oldugundan z de 1000 e esitlenir.

Ikinci ornekte ise x degiskeni y nin degerini alir cunku arada tek esit
isareti vardir. Ayrica sonuc 11 oldugundan z de 222 ye esitlenir.

Ikinci grubun ucuncusunde x i sifira karsilastiriyoruz. Sayet sonuc
'EVET' ise yani x sifir degilse z ye 333 degerini atiyoruz. Bu grubun
en son orneginde ise sayet x in degeri sifir degil ise z ye 444
atiyoruz. Yani ucuncu ve dorduncu ornekler birbirine esdirler.

Ucuncu gruptaki karsilastirmalar yeni deyimler sunuyor. Yani 'AND' ve
'OR' deyimleri. Ilk once 3 degiskene de 77 degerini atiyoruz ki islemlere
bilinen degerlerle basliyabilelim. Buradaki ilk ornekte yeni kontrol
isaretimiz '&&' i goruyoruz. Bu satirin okunusu ise:
'Sayet x y ye esit ise vede x 77 ye esit ise z nin degerini 33 yap.'
Yani AND operandi icin iki taraftaki islemlerin EVET (TRUE) sonuc
vermesi gereklidir.

Bundan sonraki ornek ise '||' (OR) isaretini gosteriyor. Bu satir ise
'Sayet x y den buyuk ise YADA z 12 den buyuk ise z nin degerini 22 yap.'
z nin degeri 12 den buyuk oldugu icin x in y den buyuk olup olmamasi
onemli degildir. Cunku OR operandi icin ikisinden birinin EVET olmasi
yeterlidir.

Bircok kisimdan olusan bir mantiksal karsilastirma yaparken karsilastirma
soldan saga dogru yapilir ve sonuc garantilendiginde bu satirin
islenmesi durur. Mesela bir AND karsilastirmasinda sayet AND in sol
tarafindaki islem HAYIR (FALSE) sonuc verirse sag tarafindaki islem
yapilmaz. Yada bir OR isleminde sol tarafindaki islem EVET (TRUE) sonuc
verirse islemin OR dan sonrasina bakilmaz.

OPERANDLARIN ISLEM SIRASI

Hangi operand ilk once islenir? Bu konuda bircok kural vardir ve
derleyicinin kitabini bunlari uzun uzun anlatir. Fakat benim tavsiyem
bunlarla ugrasmak yerine once islenmesini istediginiz kisimin cevresine
paranaaa koymanizdir.

Ucuncu gruptaki orneklere devam ederek dorduncu ornekte uc tane basit
degiskenin birbiri ile AND edildigini goruyoruz. Ucunun de degerleri
sifirdan degisik oldugundan sonuc EVET oluyor ve z nin degeri 11 e
esitlenir.

Bundan sonraki ornekte ise uc tane atama islemi gorunuyor. Sayet daha
onceki ornekleri anladiysaniz bu 'if' komutunun dort tane degeri
degistirdigini gorebilirsiniz.

BIR HILE

Ucuncu grubun en son orneginde ise bir hile var. Ilk once (x==2) nin
HAYIR la sonuc verdigini goruyoruz. Ve daha once gordugumuz gibi C dili
sonuctan emin oluncaya kadar if komutunu isler. Yani hepsi AND oldugu
icin vede ilk ifade HAYIR (FALSE) oldugu icin islemi o noktada keser
ve yz ve r nin degerleri degismez.

Dorduncu gruptaki orneklerin hicbiri calismaz. Bu grup basinizi derde
sokabilecek komutlardir. ilk ornekte x == x komutu daima dogrudur fakat
hemen arkasindan gelen noktali virgul yuzunden bundan sonra gelen
z=27.345 komutu ayri bir komut olarak her zaman islenir.

ikincisi daha kolay - x daima x e esit olacagindan denklem daima yalnis
olacaktir. Son olarak x e sifir degeri atanir ve paranaaain sonucu sifir
oldugundan z ye atama yapilmaz.

C NIN CABUK TARAFLARI

C de 3 tane bakinca hicbir seye benzemeyen fakat programlarken hiz
saglayan kestirme yol vardir. Bu metodlar iyi C programcilari tarafindan
cok SIK kullanildigindan ogrenmenizde fayda vardir.

KESTIRME.C:
=================================================

main()
{
int x = 0y = 2z = 1025;
float a = 0.0b = 3.14159c = -37.234;

/* Arttirma */
x = x + 1; /* Bu x i bir arttirir */
x++; /* Bu da.. */
++x; /* Bu da.. */
z = y++; /* z = 2 y = 3 */
z = ++y; /* z = 4 y = 4 */

/* Azaltma */
y = y - 1; /* Bu y nin degerini bir azaltir */
y--; /* Bu da.. */
--y; /* Buddah.. */
y = 3;
z = y--; /* z = 3 y = 2 */
z = --y; /* z = 1 y = 1 */

/* aritmetik islemler */
a = a + 12; /* a ya 12 eklemek */
a += 12; /* 12 daha eklemek.. */
a *= 3.2; /* a yi 3.2 ile carpmak */
a -= b; /* b yi a dan cikarmak */
a /= 10.0; /* a yi ona bolmek */

/* sartli islemler */
a = (b >= 3.0 ? 2.0 : 10.5 ); /* Bu islem....... */

if (b >= 3.0) /* ve bu islemler.. */
a = 2.0; /* birbiri ile aynidir */
else /* ve ayni sonucu */
a = 10.5; /* saglarlar. */

c = (a > b?a:b); /* c a yada b nin max ini alir */
c = (a > b?b:a); /* c a yada b nin min ini alir. */
}
================================================== =

KESTIRME.C ye bakin. Bu programda ilk komutta x in degeri bir tane
arttiriliyor. Ikinci ve ucuncu komutlar da ayni seyi yaparlar. Yani iki
tane arti isareti degiskenin degerini bir arttirir. Ayrica sayet ++
isareti degiskenin onunde ise degisken kullanilmadan once degeri
arttirilir sayet ++ isareti degiskenin arkasinda (saginda) ise
kullanildiktan sonra degeri arttirilir.

Dorduncu komutta ise y nin degeri z ye atanir ve daha sonra da y nin
degeri bir arttirilir. Bundan sonraki komutta ise y nin degeri ilk once
arttirilir daha sonra bu deger z ye verilir.

Ikinci grupta azaltici operatorleri goruyoruz. Ayni arttirici operatorler
gibi bu gruptaki ornekler de bir oncekiler ile aynidir.

Ucuncu grupta aritmetik kestirme metodlari goruyoruz. ilk ornekte a ya
12 eklenir. Bunun altindaki satirda ise tekrar ayni sey yapilir. Yani +=
operatoru soldaki degiskene sag tarafin sonucunun eklenecegini belirtir.
Yine ayni sekilde bu is carpma cikarma ve bolme islemleri icin de
yapilabilir.

Dorduncu grupta ise a ya karmasik bir degerin atandigini goruyoruz.
Bunun hemen altindaki if... satirlari ise bu tek satir ile es anlamdadir.
Bu karsilastirma operatoru uc parcadan olusmustur. Bu parcalar
birbirinden soru ve iki nokta isaretleri ile ayrilirlar. Ilk once soru
isaretinden onceki kisim degerlendirilir sonuc EVET cikar ise soru
isaretinden hemen sonraki deger dondurulur sayet sonuc HAYIR cikar ise
iki nokta isaretinden sonraki deger dondurulur.

Bundan sonra ise bu karsilastirma operatorunun c ye atama yapmakta
kullanildigini goruyoruz. Ilk once a ile b nin hangisinin degeri buyukse
o degere c ye atanir ve ikincide ise hangisi daha kucuk ise o c ye
atanir.

ODEV:

1. Birden onikiye sayacak bir program yazin. Bu program sayarken
rakamlari ve bu rakamlarin karelerini ekrana yazsin.

1 1
2 4
3 9 gibi..

2. Birden onikiye sayan programi biraz degistirerek sayimi yazan ve 1 in
inversini bes haneli alan bir program yazin. Yani:

1 1.00000
2 .50000
3 .33333
4 .25000 gibi..

3. Birden yuze kadar sayan fakat 32 ila 39 arasindaki degerleri yazan bir
program yazin. Her satira bir rakam yazilsin..
--------------------------------------------------------------------------

Fonksiyonlar ve degiskenler

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 basligidirnn");
}

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"rakamkaresi);
}

bitis() /* Bitis fonksiyonu tanimlaniyor. */
{
printf("nKarelerin toplami: %d dir..n"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
paranaaa 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 paranaaa
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
paranaaaler 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 "toplam"
degiskenine de "karesi" degiskeninin degerini ekliyoruz.

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
fonksiyona o degerin bir kopyasini gecirdik. Bu sayede "index" in asil
degeri fonksiyon tarafindan kazara zarar goremez. "rakam" isimli
degiskenimizi fonksiyon icinde istedigimiz gibi degistirebilirdik fakat
ana programa geri dondugumuzde "index" in degeri yine ayni kalirdi.

Boylece degiskenin degerinin zarar gormesini onlemis oluyoruz fakat ayni
zamanda ana programa bir deger dondurmemize de mani oluyoruz. Pointers
kisimina gelince cagiran fonkisyona degeri dondurmek icin iyi tanimli
bir metod gorecegiz. O zamana kadar ana programa deger dondurmenin yegane
yolu global degiskenler kullanaraktir. Global degiskenlerden biraz
bahsetmistik bu konu icersinde daha da bahsedecegiz.

Programa devam ederek bitis() isimli bir fonksiyonun cagirilisina
geliyoruz. Bu cagirma da hicbir yerel degiskeni olmayan fonksiyonu
cagirir. "toplam" degiskeninin degerini yazdiktan sonra ana kesime donen
program yapacak baska birsey olmadigini gorunce durur.

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 xy;

for(x = 0;x <= 7;x++) {
y = squ(x); /* x*x i hesaplayalim.. */
printf("%d nin karesi %d dir...n"xy);
}

for (x = 0;x <= 7;++x)
printf("%d nin karesi %d dir...n"xsqu(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. Paranaaaler
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 xysqr()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"indexy);
}

for (index = 0; index <= 7;index++) {
z = index;
y = glsqr();
printf("%d in karesi %10.4f dir.n"indexy);
}
}

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 %dn"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 %dn"say);
sayac = 77;
}

baslik_3()
{
printf("Baslik_3 deki degeri ise %dn"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