DevC++
http://rapidshare.de/files/15384335/...setup.rar.html

PellesC
http://rapidshare.de/files/16492891/...Setup.rar.html


TurboC
http://rapidshare.de/files/16492148/TC.rar.html
BorlandC
http://rapidshare.de/files/16820448/bc.zip.html


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 parantez
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 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 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 ödev 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 a,b,c;

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 (a,b,c), 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 a,b,c; /* -32767 den 32767 ye - tamsayi olarak */
char x,y,z; /* 0 dan 255 e - tamsayi olarak */
float num,toy,thing; /* 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 = 11,y = 11,z = 11;
char a = 40,b = 40,c = 40;
float r = 12.987,s = 12.987,t = 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 parantezler
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
parantez 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 y,z 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 parantezin 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 = 0,y = 2,z = 1025;
float a = 0.0,b = 3.14159,c = -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",rakam,karesi);
}

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,
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 "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 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 %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
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++ dersleri 5.bölüm

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.

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

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: %cn",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(" %snn",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 %sn",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("%sn",isim1);
printf("%snn",isim2);
for (index = 0;index < 12;index++)
printf("%5d %5d %10.3fn",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] = %dn",index,matrix[index]);

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

for (index = 0;index < 5;index++) /* degismis matrix i yazalim */
printf("Geri donen matrix[%d] = %dn",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] = %dn",i,list);

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

for (i = 0;i < 5;i++) /* print modified matrix */
printf("Sonraki matrix[%d] = %dn",i,list);
}
==================================================

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[j] = i * j; /* Bu bir carpim tablosudur */

for (i = 0;i < 25;i++)
for (j = 0;j < 12;j++)
dev[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[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 = %4dn",index,dizi1[index],dizi2[index],
diziler[index]);
__________________

C++ Geni$ Icerikli Ders Anlatım :


TEMEL BILGILER


C++ bilindigi gibi programlama dünyasinda en çok ilgi gören C dilinden türemistir. C++`i klasik C dilinden farkli yapan yani; Nesne Yönelimli Programlamayi da ( Object Oriented Programming) C`nin sözdizimi kurallariyla birlikte desteklemesidir. Normalde C ile sadece yapisal programlama yaparken C++ dili ile hem yapisal hem de nesne yönelimli programlar yazabilirisiniz. C++ diline baslarken önce dilin C`den gelen ve temel olan özelliklerini ögrenmek gerekir. Örnegin, degisken tanimlama, atama ve diger basit aritmektik islemler, kontrol yapilari ve döngüler gibi.
Teknolojinin ulastigi son noktadaki programlama dillerinden olan C ve C++, bir çok yeni ve güçlü özellikleri içerir. Derslerimiz devam ettikçe bunlarin teker teker içine girecegiz. C dilinin özelliklerinin %80 i C++`da da mevcuttur (bu karsilastirma sahsi görüsümdür). Zaten C++, C`nin üst gurubudur. Bunu söyle siralayabiliriz. C, C++ ve C# dir.
C dilinin avantajlari, az komut kümesinden olusmasi ve bu komutlarin diger yüksek seviyeli dillere nazaran daha hizli çalismasidir. Ayrica C deki kütüphaneler sayesinde fonksiyon tanimlamaniza gerek kalmadan islemlerinizi yapmak mümkün olacaktir. Bu konuda çok detaya inmeden, programlamaya geçmek istiyorum. Çünkü, programlamaya basladigimizda her örnekten sonra o an kullandigimiz programin içinde geçen fonksiyon, hata, degisken, belirleyiciler, kisitlamalar, notasyonlar v.s gibi bilgilerden ara ara bahsedecegim. Yalniz çok önemli olan bir konuya burada deginmek istiyorum. C nin avantajlarini programlamayla birlikte görmek güzel ama C nin dezavantajlarini programlamadan önce bilmeliyiz ki bunlardan sakinalim. Öncelikle Tanimlayicilardan bahsetmek istiyorum. Her derleyici ve assmbley için degiskenleri, sabitleri, etiketleri ve fonksiyon adlarini tanimlama kurallari vardir. Bu notasyonlara, tanimlayici denir. C++ da tüm tanimlayicilar a, . . . , z - A, . . . , Z harfleri ile ya da alt çizgi "_" ile baslar. Bundan sonra rakam, harf, ya da alt çizgi kullanilabilir. ANCI C uyumlu derleyiciler 31 karaktere kadar tanimlayici kabul ederler fakat tanimlayicinin ilk sekiz karakterini kullanmayi kendimize aliskanlik etmeliyiz. Dikkat etmemiz gereken özelliklerden biri de kullandigimiz ifadelerdeki büyük küçük harflerdir. C ve C++ büyük ve küçük harf duyarliligina sahiptir. Kullandigimiz ifadeleri birbirinden farkli ve ayni ifade olarak kullaniyorsak programimiz hata verecektir. Bunu bir örnekle anlatayim:
Program
program
PROGRAM

Bu sekilde tanimlarsak hepsi birbirinden farkli ifadeler olarak C++ da okunacaktir. Biz Sunu aliskanlik edinmeliyiz; tanimlayicilarimizin bas harfi büyük olacak. Büyük ve küçük harf kombinasyonlarinin kullanilmasi ile önceden yapilan tanimlamalar bazen isi zorlastirabilir. Eger bu degiskenlerden birini kullanmak isterseniz, bu zamana kadar nasil tanimladiginizi bilmeniz gerekir. Örnegin printf()`in PRINTF() olarak çagrilmasi durumunda " bilinmeyen tanimlayici " (Unknown identifier) hata mesaji vererek sizi uyarir. Buna benzer olarak %f ve %F kullanimi hata verdirecektir. Programlamayi yaparken bunlara dikkat etmemiz gerekecek. Çünkü bir degiskeni veya tanimlayiciyi basta nasil kullandiysaniz üç, dört sayfa kod yazdiktan sonrada ayni sekliyle kullanmak zorundasinizdir. Iste burada en büyük handikap yasanacaktir. Çünkü C/C++ derleyicileri her zaman hatanin nerde oldugunu göstermez. Bunu programci kendisi satir satir takip ederek bulacaktir. Bundan dolayi bu söylediklerime bastan dikkat etmemiz gerekiyor.
__________________

ILK ÖRNEK


Ilk programimiz!// ilk1.cpp// Ekrana "Bu benim ilk programim" yazdiriyoruz#include int main(){ cout << "Bu benim ilk programim"; return 0; }Simdi Yazdigimiz programi inceleyelim: "//" isaretini açiklama satirlarinda kullaniyoruz. C++ derleyicisi bu notasyonla baslayan satiri okumaz. Bununla birlikte daha uzun cümlelerimiz olursa bunlari da " /* */ " notasyonunun içinde yazicagiz. Bu özellik de C den bize kalma. Demistik zaten C `nin tüm özelliklerini C++ içerir. Fakat biz genelde " // " yi kullanacagiz.
#include : Bu bizim C++ da bulunan kütüphane dosyamizi çagirmaya yariyor. Ben size söyle tarif edeyim. iostream.h kütüphanesindeki hazir olan " cout " fonksiyonunu çagiriyor. Yani buda bizim fazla kod yazmamiza engel oluyor. .h ile biten dosyalar kütüphane dosyalaridir. Bunu suna da benzetebiliriz. Farz edelim ki elimizde bir alet çantasi var içinden tornavidayi çagirdigimizda vida sikacagizdir. Bu da ona benziyor. C++ da ki hazir kütüphanelerde bir çok hazir fonksiyonlar vardir. Ilerde Bu hazir fonksiyonlar isimizi görmemeye baslayinca kendi kütüphanemizi yapmaya baslayacagiz. Tabi bu seviyeye geldigimizde olayi hemen hemen kavramis olacagiz, tabi neden olmasin öyle degil mi?
Daha sonraki satir her C++ programinda mutlaka bulunmasi gereken bir satirdir. Her C++ programinda main() fonksiyonu olmak zorundadir; bu fonksiyonumuzun önünde ise o fonksiyonun dönderdigi degiskenin veri tipi olmalidir. Tabi ki C++ fonksiyonlar ve onlarin dönderdikleri degerler konusunu da ileride isleyecegiz.
Bir sonraki satirda ise; C++ fonksiyonlar ve kod bloklari " { } " parantezleri arasinda bulunmalidir. main de bir fonksiyon ise onun içindeki kodlar dogal olarak { } parantezleri arasindadir.
Program derlenip çalistirildiginda ise ( Turbo C++ 3.1 kullaniyorsaniz ctrl+f9 kisa yoluyla programi çalistirabilirsiniz (Run) ) karsimiza "Bu benim ilk programim" yazisi çikacaktir. Iste bu yaziyi ekrana veren komut da iostream.h kütüphanesindeki cout fonksiyonudur.
Önemli bir nokta ise C++ dilinde her satir ifadenin sonuna " ; " koymak zorundayiz. Bundan farkli olarak #include satirlarinin ve bir kaç farkli satirin arkasina " ; " gelmez. Bunlari ileride görecegiz.
Return 0 : programimizin (ayni zamanda main fonksiyonumuzun) çikis noktasidir. Eger return ile 0 degeri dönderirsek programimizin güvenle çiktigini isletim sistemine bildirmis oluruz. Bu sayede güvenle programimizin çalistigini görecegiz.
Simdi size bir örnek daha verecegim bununla da ayni çiktiyi elde edecegiz. Arasindaki farklari eminim basit olarak sizlerde göreceksinizdir.
// ilk2.cpp// Ekrana "Bu benim ilk programim" yazdiriyoruz#include main(){printf("Selam bu benim ilk programim.
"); return 0; }Evet simdi burada çok fark varmis gibi gözüküyor aslinda ama öyle degil. Sadece kütüphanemiz stdio.h oldu ve ekrana yazdir fonksiyonumuzda printf oldu. Bu özellik C den kalma. Bunlar diger program ile ayni islevi görüyor. Buradaki fark "
" notasyonu. Bu notasyon bir sonraki satira geçmek için kullanilir.
__________________

DEGI$KENLER

Simdi bize yine çok lazim olacak bir özellik de degisken tanimlamak ve atama yapmaktir. Bunu bir örnek üzerinde anlatmak istiyorum. Örnegimiz

// degisken.cpp// Burda degisken tanimlamayi görecegiz.// Ayni zamanda verilen bir sayiyi kendisi ile carpma 2.2=4 gibi#include #include // kütüphane dosyamizmain(){ int i; // Degisken tanimlama cout << "Bir sayi giriniz: "; cin >> i; i=i*i; cout << "sonuc: " << i ;return 0;}

Burada bundan önce yaptigimiz programlardan farkli olarak int i kullandik, yani degisken tanimladik.
Degisken Nasil Tanimlanir?
Degiskenleri tanimlamak için asagidaki sema kullanilir.
[Veri Tipi] [Degisken Adi];
Örnegin
int sayi; Simdi degisken.cpp örnegindeki int i; kismini anlamissinizdir. Burada degiskenlere deginmek istiyorum. Biz yukarda Içinde sayi tutan bir degiskeni tanimladik. Benzer olarak asagidaki tanimlamalar da vardir.
char c;
int i;
float f;
double d;
unsigned int ui;
Burada [Veri Tipi] [Degisken Adi]; bu kaliba göre tanimlama yaptigimiz için önce Veri Tiplerini inceleyelim.
__________________

PHP- Kodu:
VERI TIPLERI


1) Int tip.
Integer = Tamsayi
Tamsayilari içerir. Bellekte 2 Byte tutar. DOS`ta ve Win3.1`de 16 bit uzunlugunda ama Windows9x, WinNT, Win200 ve WinXP 32 bit uzunlugundadir.
Deger araliklari Short ve long için degisir.
Örnek: 5, -20, 1 gibi.
2) Sort tip.
Tam sayilari içerir. 16 bit uzunlugundadir.
signed: -32768 ile +32767 arasinda deger alir, unsigned: 0 ile 65535 arasinda deger alir.
3) Long tip.
Tam sayilar içerir. 32 bit uzunlugundadir.
signed: -2147483648 ile +2177483647 arasinda deger alir, unsigned: 0 ile 65535 arasinda deger alir.
4) Gerçel Tipler (Float, Double, Long double
Gerçel sayilari içerirler.
float : Bellekte 4 Byte yer tutar. 3.4E-38 ile 3.4E+38 araliginda deger alir. Hassasiyet 7-8 basamaktir.
double : Bellekte 8 Byte ter tutar. 1.7E-308 ile 1.7E308 araliginda deger alir. Hassasiyet 15-16 basamaktir.
long double : doublenin tipinin daha genisidir.1.2E-4932 ile 1.2E-4932 araliginda deger alir. Hassasiyet 19-20 basamak.
5) Char Tip
Char : Karakter
Alfanumerik karakterleri içerir. Ve ya 8 bit uzunlugunda tamsayi.
signed: -128 ile 127 arasinda deger alir, unsigned: 0 ile 255 arasinda deger alir.
Örnegin: ` 0,1,2,3,4,5,6,7,... ` , ` *,-,+,... ` , `a,b,c,....,A,B,C,D,,,,, `
6) Bool tip.
true(dogru) = 1 veya false(yanlis) = 0 degerini alir. Eski derleyiciler bu türü desteklemeyebilir. Yeni ANSI C++ standardinda eklenmistir. Bu soyut matematik gördüyseniz. "p V q" ya benzer :) ( matematikçiyiz, konusturalim azicik). Deger araligi ise ya 1 dir (dogru) yada 0 dir (yanlis).
7) Enum tip.
enum siralanmis degerleri tutar. Short int ile ayni degeri tasir.
Basta Fazla Detaya inip sizi bunaltmak istemiyorum. Çünkü C++ dili baslarda karmasik gelen bir dildir. Bu da zaten kendisini yüksek seviyeli bir dil yapiyor :). Ben size Bu dilin temel özelliklerini anlatarak basit programlar yapmayi gösterecegim.
Bu temel bilgileri aldiktan sonra programlamaya geçebiliriz. Derleyici Olarak ben Turbo C++ 3.1 i tavsiye ederim. Su an bununla baslar iseniz isiniz daha kolay olacaktir (bence). Ilerde Borland a geçecegiz.
Degisken tanimlama konusunda bir konuya daha deginmek istiyorum. Degiskenlere deger atama ve ayni anda bir çok degisken tanimlamamiz C++ da mümkündür.
char c = `c`;
int i = 5;
Daha sonradan deger atama:
char c;
int i;
c = `c `;
i = 5;

Bir de ayni anda bir çok degisken tanimlayalim.
Örnegin:
int x , y , z;
x = y = z = 5;
x,y,z` nin degeri 5 oldu

Bir sonraki derste ise degiskenlerle birlikte bir de Operatörleri ele alacagiz.

Kodu:
OPERATÖR ve OPERANT NEDIR?


Bunu bir örnek üzerinde anlatmak istiyorum. Örnegin; x + y ``de x ve y operand + ise operatördür. Bu bir aritmetiksel operatördür. Matematikte islemler operatörler ve operandlar ile anlatilir. Operatörleri öncelikle türlerine göre ayiralim:
1) Aritmetiksel operatörler + , - , * , / , % , ++ , --
2) Karsilastirma operatörleri < , > , <=, >= , ==, !=
3) Esitleme operatörleri = , += , -=, *= , /= , %= , <=, >>=, &=, != , ^=
4) Mantiksal Operatörler ! , || , &&
5) Bit bazinda islem yapan operatörler & , ! , ^ , ~ ,
Aritmetiksel (Matematiksel) Operatörler:

Matematiksel ifadeleri günlük hayattaki biçimde bilgisayarda yazamadigimiz için belli kurallara uymamiz gerekir. Bu kisim önemli oldugu için biraz genis yer verecegim. Kullandigimiz matematiksel islemler ve anlamlari söyledir:

Toplama+Çikarma-Çarpma*Bölme/Modulus(mod)%Bir arttirma ++Bir azaltma--

Bu operatörle verilen iki veya daha fazla operand toplanabilir. Yazilis sekli Asagidaki gibidir.
degisken1 + degisken2
Eger bu iki degiskeni Sonuç gibi baska bir degiskene atarsak esitleme operatörüyle asagidaki gibi yapariz.
Sonuç = degisken1 + degisken2
Buna bir örnek verelim.
// toplama.cpp//Vize ve final notlarinindan geçme notunu hesaplama#include #include main() { int vize, final, ort; vize = 10; final = 80; ort = vize * 0.4 + final * 0.6; cout<< "Geçme notunuz: " << ort;}
Burada çarpma operatörünü de kullandik sanirim, artik digerlerinin de ne oldugunu kavramis oldunuz. Bir örnekte isi ucuza getirdim :). Fakat bir artma ve bir azalmaya örnek verelim. Bu bana çok lazim olmustu.
Burada dikkat etmemiz gereken olay " ++ " operatörünü degiskenin önüne yazmaniz gerektigidir. Bu sayede degisken bir arttirilarak isleme konur. Arkasina konursa degisken islenir, sonra bir arttirilir. " -- " operatöründe ise ayni sekilde de bir azaltma yapilir.
// carpim.cpp// x i bir arttirip y yi bir azaltip çarptik.#include main() { int x = 5; int y = 10; cout << "x = " <Iste bir fark daha yakaladik bunu da hemen örnek üzerinde anlatalim. Sanirim buraya kadar geldigimiz yerlerde int i , çarpma islemini, bir arttirip azaltmayi gördük, ama diyeceksiniz ki " endl " ne oluyor? Hemen açiklayayim; Satir sonunu belirterek yeni satira geçmemizi saglar, bir nevi "
" Escape operatörü gibi bir isleve sahiptir.


Karsilastirma Operatörleri:

OperatörC++ örnegiAnlami>x > yx, y`den büyüktür=x >= y x, y`den büyüktür veya y`ye esittir<=x <= yx, y`den küçüktür veya y`ye esittir==x ==y x, y`ye esittir!=x != yx, y`ye esit degildir

Bunlarin teker teker ne oldugunu söylemeye gerek yok. Ifadeler gayet basittir. Burada dikkat etmemiz gereken önemli bir sey var: " >=, <=, ==, !=" notasyonlarini kullanirken iki notasyon arasinda bosluk birakmamaliyiz. Buna dikkat edelim!
Esitleme ( Atama) Operatörleri:

Bunlarida liste halinda verelim.
OperatörC++ örnegiAnlami=x = yx`in degeri y`ninkine atanir+=x += y x`e x+y`nin degeri atanir.-=x -= y x`e x-y`nin degeri atanir.*=x *= yx`e x*y`nin degeri atanir./=x /= y x`e x/y`nin degeri atanir%=x %= yx`e x%y`nin degeri atanir.<<=x <<= yx`e x<>=x >>= yx`e x>>y`nin degeri atanir.&=x &= yx`e x&y`nin degeri atanir.!=x != yx`e x!y`nin degeri atanir.^=x ^= yx`e x^y`nin degeri atanir.

__________________

IF KOMUTU


if komutu anlasilmasi ve yazilimi en basit olanidir. if komutu, bir grup komutun kosullu olarak yürütülmesi amaciyla kullanilir. Buna bir örnek verecek olursak; düsünün ki bir sinav yapiliyor ve 50 ve üzeri alanlar geçecek. Bunun için if i kullanirsak not 50 ye esit veya büyükse (büyük esit) geçer not olacak.


PHP- Kodu:
//not.cpp// 50 ve 50 den yukarsi geçiyor.#include main(){int not;cout << "Notu yaziniz:"; cin >> not; if ( not >= 50 ) cout << "Geçtiniz!";}

PHP- Kodu:
if ( not >= 50 ) cout << "Geçtiniz!";if (ifade){ Komut; Komut;...}

Burda görüldügü gibi if (ifade) ve sonraki komutlarda { } blogunun içine yazilir. Simdi if`e bir de su açidan yaklasalim. if in kelime anlami "eger" dir. Mantik sudur: eger belirtilen parametre dogruysa, if komutu, if ten sonra gelen bloktaki fonksiyonlari gerçeklestirir. Dogru degilse, if den sonraki blogu yok sayar. Burada bir detaya daha inmek istiyorum. Ne demistik, mantik islemlerinde olay ya dogrudur (1) ya da yanlistir (0). Simdi yukaridaki if in genel kullanim sekline tekrar bakalim. Bunu, eger parametre dogru ise kullanabiliriz. Bir de bunun tersini düsünelim. Bit bazinda islemlerde sanirim ( ! ) bunu görmüstük. Her bir biti ters çevirir.


PHP- Kodu:
if (!ifade){ komut (yanlis (0)); Komut (yanlis (0));....}


Derdimi anlamis oldugunuzu ümit ediyorum . Ama bence buranin üstünde biraz daha duralim. Çünkü bunu anlarsak digerlerinde zorlanmayiz. Son yaptigimizda ifadeyi tersine çevirdik.




PHP- Kodu:
//pozitif.cpp// Bunada açiklama yaptirmayin:) ( yapamadimda) #include main() {int x; cout << "Bir sayi girin:" ;cin>> x;if ( x > 0 )cout << "Pozitif" ;}


Aynisinin negatif ini de siz yapin. Simdi bir de iç içe if örnegine bakalim:

PHP- Kodu:
//gecti.cpp// Buna açiklama yapmiycam! #include main() { int not

?: KOMUTU


Bu komut, yalnizca C++ a özgüdür. Kendine özgü bir yazilimi ve mantiksal kullanimi vardir. if-else komutunun kisaltilmisidir. Fakat, tüm if-else komutlari yerine kullanilmaz. Yalnizca karsilastirma sonrasi, tek komut kullanilan uygulamalar için geçerlidir. Bu söylediklerimizi örnek üstünde gösterelim:

//tekcift.cpp
//tekcift.cpp yi bu sefer ?: ile yapiyoruz
#include
main()
{
int sayi;
cout<< "Bir sayi giriniz:";
cin >> sayi;
cout << (sayi %2==1 ? "tek" : "çift") ;
}
Kullanis biçimi: cout << (sayi %2==1 ? "tek" : "çift") ; çok basit ama dikkat edelim. Her zaman kullanmiyoruz.

SWITCH-CASE KOMUTU


Switch Case deyimi islev bakimindan if deyimine çok benzemektedir. Çok sayida if islem bloklari kullandigimizda programin okunurlugu azalacak ve programi izlemek zorlasacaktir. Programimizin bir degerini bir çok degerle karsilastirmak gerektiginde switch komutunu kullanacagiz. Switch seçenegi ile degiskenin durumuna göre bir çok durum içersinden bir tanesi gerçeklestirilir. Istersek de if deyimi ile switch case`` yi birlikte kullanabiliriz. Switch in yaptigi is kisaca, ifadenin degerini sirayla sabitlerle karsilastirarak ve her satiri islemektir.

switch( Kontrol Degiskeni ) { case Sabit1 : komut1; case Sabit2 : komut2; . . . default : Komutson; }

Buna en basit örnegimizi verelim


//switch.cpp// switch-case yi ögreniyoruz.#include main(){int i;cout<< " 1 ile 4 arasi sir sayi giriniz:";cin>>i;switch(i){case 1 :cout<<"1 Girdiniz"; break;case 2 :cout<<"2 Girdiniz"; break;case 3 :cout<<"3 Girdiniz"; break;case 4 :cout<<"4 Girdiniz"; break;default:cout<<"1 ile 4 ten farkli"; }}

Burada gördügümüz gibi i degiskenine bagli olarak program isliyor. Case``lerinin aldigi degere göre kendinden sonra gelen komutlari isliyorlar. Burada daha önce görmedigimiz break komutunu gördük. Buna ilerde daha detayli olarak deginecegim. Fakat biraz bahsetmek istiyorum. Programimizda degiskene 1 degerini verdigimizi farz edelim. Case 1 adli satiri geçip ondan sonraki komut dizisini isleme soktuk. Bu islemin tamamlanmasi için break komutu kullaniliyor. Yazilimda break komutu goto gibi islev görür ve derleyiciye switch komutundan çikmasi için talimat verir. Sorunu ortadan kaldirmak için her durum için break deyimi eklemeliyiz (tavsiye). Ne demistik; bir çok karsilastirma oldugunda switch``e ihtiyaç duyuyoruz. Karsilastirmalarin hiç biri olmadigi anda da ortaya default tan sonraki satirin islenmesi kaliyor. Sanirim bu örnekte basit olarak anlamis olacagiz.
Daha karmasik bir örnek verecek olursak:

//ucgen.cpp// Program girecegimiz ölçülere göre üçgenin Alan, Yükseklik ve Tabanini bulur// switch-case örnegimiz.#include int main() { char secenek; float alan, yukseklik, taban; cout << "Program girecegimiz ölçülere göre üçgen``in Alan, Yükseklik ve Tabanini bulur!
" << endl << " A ---> Alan : Bulmak için yükseklik ve tabani girecegiz:" << endl << " h ---> Yükseklik : Bulmak için alan ve tabani girecegiz:" << endl << " t ---> Taban : Bulmak için alan ve yüksekligi girecegiz:" << endl << endl << endl; cout<< "Seçeneginiz? ---> A, h, t :"; cin>> secenek; switch(secenek) { case ``a``: case ``A``: { cout<< endl <> yukseklik; cout<> taban; alan = 0.5 * taban * yukseklik; cout<> alan; cout<> taban; yukseklik = 2.0 * alan / taban; cout << endl << endl << "Yükselik: " << yukseklik << endl; break; } case ``t``: case ``T``: { cout << endl <> alan; cout << endl << "Yüksekligi: "; cin >> yukseklik; taban = 2.0 * yukseklik / alan; cout << endl << endl <<"Tabani: " << taban << endl; break; } } return 0; }

Gayet basit bir örnek degiskenleri tanimladik. Caseleri koyduk ve caselerden sonra gelecek komut satirlarini yerlestirdik. Bu program göründügü gibi zor degildir.