Bilgisayardaki C İle İlgili Herşey

'Bilgisayar Hakkında Genel Bilgiler' forumunda Siraç tarafından 29 Ocak 2009 tarihinde açılan konu

  1. Siraç

    Siraç Site Yetkilisi Admin Editör

    Sponsorlu Bağlantılar
    Bilgisayardaki C İle İlgili Herşey konusu
    Bilgisayardaki C İle İlgili Herşey

    C Dersleri 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 progr*** 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 progr*** 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 (=[​IMG] 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 rak*** 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 progr*** 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",rak***karesi);
    }

    bitis() /* Bitis fonksiyonu tanimlaniyor. */
    {
    printf("nKarelerin toplami: %d dir..n",toplam);
    }
    ============================== ==================== ==


    KARETOPL.C isimli programa bir bakin. Bu progr*** 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
    progr*** 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 progr*** 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. Progr*** 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.

    alıntı
     

Bu Sayfayı Paylaş