C Programlama Dili - Sayfa 2

**Arthur** · 07-09-2008

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
*quot;char*quot; 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(*quot;Isim %s dur. n*quot;isim);
printf(*quot;Icinden bir karakter: %cn*quot;isim[2]);
printf(*quot;Ismin bir parcasi: %s n*quot;*amp;isim[3]);
}

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

Bu programda ilk once *quot;char*quot; 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 *quot;isim*quot; 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 *quot;#define*quot; ile
NULL karakteri programin basinda sifir olarak tanimlayabiliriz.)

printf komutundaki %s isareti printf'e *quot;isim*quot; isimli katardan sifira
rastlayincaya kadar ekrana yazmasini belirtir. Dikkat etmeniz gereken bir
nokta *quot;isim*quot; 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
*quot;isim*quot; degiskeninin yanina koseli parantezler arasinda gosterebiliriz.

Son printf komutunda ise katarin 4. karakterinden itibaren yazmanin bir
ornegidir. *quot;isim*quot; degiskeninin onundeki *amp; (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*quot;Rosalinda*quot;);
strcpy(isim2*quot;Zeke*quot;);
strcpy(baslik*quot;Bu bir basliktir.*quot;);

printf(*quot; %snn*quot;baslik);
printf(*quot;isim 1: %s n*quot;isim1);
printf(*quot;isim 2: %s n*quot;isim2);

if(strcmp(isim1isim2)*gt;0) /* sayet isim1 *gt; isim2 ise 1 dondurur */
strcpy(karisikisim1);
else
strcpy(karisikisim2);

printf(*quot;Alfabetik olarak en buyuk isim %s dir.n*quot;karisik);

strcpy(karisikisim1);
strcat(karisik*quot; *quot;);
strcat(karisikisim2);
printf(*quot;Iki isim birden %sn*quot;karisik);
}
=================================================
Ilk once 4 tane katar tanimliyoruz. Daha sonra *quot;strcpy*quot; 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 (*quot;x=23*quot; gibi). Veri
sagdakinden soldakine kopyalanir. Bu komutun yapilmasindan sonra isim1
in icinde *quot;Rosalinda*quot; olacaktir - den-densiz olarak. Den-denler
derleyicinin sizin bir katar tanimladiginizi anlamasi icin gereklidir.

KATARLARIN ALFABETIK OLARAK SIRAYA KONMASI

Ilginizi cekebilecek diger bir fonksiyonda *quot;strcmp*quot; dur. Sayet kendisine
gecirilen birinci katar ikinciden daha buyukse 1 dondurur ayni ise 0 ve
ikinci daha buyukse -1 dondurur. *quot;Zeke*quot; 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 *quot;strcat*quot; isimli yeni bir fonksiyon goreceksiniz. Gorevi
bir katarin sonuna diger katari eklemektir. Bunu yaparken NULL karakterin
de yerli yerinde olmasini saglar. Burada *quot;isim1*quot; *quot;karisik*quot; 'a
kopyalanir daha sonra *quot;karisik*quot; a iki bosluk ve *quot;isim2*quot; 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 *lt; 12;index++)
degerler[index] = 2 * (index + 4);

for (index = 0;index *lt; 12;index++)
printf(*quot;Index = %2d deki degeri %3d dir..n*quot;indexdegerler[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 *quot;degerler[0]*quot; *quot;degerler[1]*quot; vs. dir.
Ilk *quot;for*quot; dongusunde bunlara deger atiyoruz ikincisi ise index
degiskeni ve *quot;degerler*quot; dizisinin icindekileri ekrana yaziyor.

BIR KAYAR NOKTA DIZINI

BUYUKDIZ.C:
=================================================
char isim1[] = *quot;Birinci Program basligi*quot;;

main()
{
int index;
int ivir[12];
float tuhaf[12];
static char isim2[] = *quot;Ikinci Program Basligi*quot;;

for (index = 0;index *lt; 12;index++) {
ivir[index] = index + 10;
tuhaf[index] = 12.0 * (index + 7);
}

printf(*quot;%sn*quot;isim1);
printf(*quot;%snn*quot;isim2);
for (index = 0;index *lt; 12;index++)
printf(*quot;%5d %5d %10.3fn*quot;indexivir[index]tuhaf[index]);
}
================================================

Burada *quot;float*quot; 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 *quot;static*quot;
koymak zorunlugumuz var. Baska yeni birsey yok bu programda. Degiskenler
rastgele degerlere atanir ve sonra da bu degerler ekrana yazdirilir.

**Arthur** · 07-09-2008

POINTER VE ARITMETIK

Her cesit islemler pointer'lar ile mumkun degildir. Pointer bir adres
oldugundan ona bir sabit rakam ekleyip daha ilerideki bir adrese
erismek mumkundur. Ayni sekilde pointer'in adresinde bir rakam cikartip
daha onceki hafiza bolgelerine erismek mumkundur. Iki pointer'i toplamak
pek mantikli degildir cunku bilgisayardaki adresler sabit degildir.
Cikacak rakamin tuhaf olacagi icin pointer ile carpma da yapilamaz. Ne
yaptiginizi dusunurseniz yapabilecekleriniz ve yapamayacaklariniz kendini
belli edecektir.

TAMSAYI POINTER'I

*quot;list*quot; isimli tamsayi dizisine 100 den 199 a kadar degerler verilir. Daha
sonra 28. elemanin adresini *quot;pt*quot; isimli pointer'a atiyoruz. Daha sonra
ekrana yazdigimizda gercektende o degeri aldigini goruyoruz.

Daha onceki konularda bir fonksiyondan veri degerlerini dondurmek icin
iki metod oldugunu soylemistim. Ilki bir dizi kullanarakti. Ikincisini
herhalde tahmin edersiniz. Sayet tahmininiz *quot;pointer sayesinde*quot; idiyse
tebrikler.

CIFTYON.C:
================================================== ==
main()
{
int cevizlerelmalar;

cevizler = 100;
elmalar = 101;
printf(*quot;Baslangic degerleri %d %dn*quot;cevizlerelmalar);

/* *quot;degistir*quot; i cagirinca */
degistir(cevizler*amp;elmalar); /* cevizlerin DEGERI ve */
/* elmalarin adresini geciriyoruz */

printf(*quot;Bitis degerleri ise %d %d dir..n*quot;cevizlerelmalar);
}

degistir(kuru_yemismeyvalar) /* kuru_yemis tamsayidir */
int kuru_yemis*meyvalar; /* meyvalar bir tamsayi pointer'idir */
{
printf(*quot;Degerler %d %dn*quot;kuru_yemis*meyvalar);
kuru_yemis = 135;
*meyvalar = 172;
printf(*quot;Sonraki degerler %d %dn*quot;kuru_yemis*meyvalar);
}
=================================================
Burada iki tane tamsayi degiskeni (pointer degil) tanimliyoruz:
*quot;cevizler*quot; ve *quot;elmalar*quot;. Once bunlara birer deger atiyoruz ve *quot;degistir*quot;
isimli fonksiyonu cagiriyoruz. Cagirirken *quot;cevizler*quot; in degeri (100) ve
*quot;elmalar*quot; degiskeninin adresini geciriyoruz. Fakat fonksiyona da bir
deger ve bir adres gelecegini haber vermemiz gereklidir. Bunun icin
fonksiyonun parametreleri tanimlanirken bir adres tasiyacak olan sembolun
basina bir yildiz koymamiz yeterlidir.

Fonksiyonun icinde bu iki degeri degistirip eski ve yeni degerleri
ekrana yaziyoruz. Bu program calistiginda ana programdaki *quot;cevizler*quot; in
degerinin ayni kaldigini fakat *quot;elmalar*quot; in yeni degerlerini aldigini
goreceksiniz.

*quot;cevizler*quot; in degerinin ayni kalmasinin nedeni fonksiyona bir
deger gecirildiginde C dilinin o degerin bir kopyasini fonksiyona
gecirmesi yuzundendir. Programa geri dondugunuzde degerin bir kopyasini
kullandigimiz icin asil degerin degismedigini goreceksiniz.

*quot;elmalar*quot; in degerinin degismesi ise yine fonksiyona *quot;elmalar*quot;
degiskeninin adresinin bir kopyasi gecirildigi halde bu adres ana
programdaki *quot;elmalar*quot; a karsilik geldigi icin fonksiyonda bu adresteki
degeri degistirir degistirmez *quot;elmalar*quot; in da degeri degismis olur.

ODEV

1. Bir karakter katari tanimlayin ve icine *quot;strcpy*quot; ile bilgi koyun. Bir
dongu ve pointer ile katari harf-harf (teker teker) ekrana yazin.
Programin basinda pointer'i katarin ilk elemanina atayin daha sonra cift
arti isareti ile pointer'in degerini arttirin. Ayri bir tamsayi degiskeni
ile kac karakter yazilacagini kontrol edin..

2. 1. deki programi pointeri katarin sonuna atayip cift eksi isaretini
kullanarak sondan basa dogru yazmasi icin degistiriniz.

c++ dersleri 8.bölüm

C Dili - 9. Konu

Standart Input/Output

BASITIO.C:
=================================================
#include *lt;stdio.h*gt; /* input/output icin standard header */

main()
{
char c;

printf(*quot;Herhangi bir tusa basin. X = Programi durdurur. n*quot;);

do {
c = getchar(); /* klavyeden bir tus okuyalim */
putchar(c); /* ekranda gosterelim. */
} while (c != 'X'); /* ta ki okunan bir X oluncaya dek... */

printf(*quot;nProgramin sonu.n*quot;);
}
================================================

Standart I/O deyimi verinin girildigi ve ciktigi en normal yerleri
klavyeyi ve ekrani kast eder. Bu kutuge ilk baktiginizda *quot;#include
*lt;stdio.h*gt;*quot; komutunu goreceksiniz. Bu komut on-derleyiciye kucuktur ve
buyuktur isaretleri arasinda yer alan kutuk isminin programa eklenmesini
soyler. Bazen *lt; *gt; isaretleri yerine den-den *quot; *quot; isaretleri de
gorebilirsiniz. Aralarindaki fark *lt;*gt; isaretlerinin on-derleyiciye su
anda calistiginiz diskte / dizinde degil de bu tip kutuklerin konuldugu
yerde aramasini bildirir. Halbuki den-den isaretleri ile belirlenmis bir
kutuk ismi sizin su anda bulundugunuz disk / dizinde aranir. Genellikle
*quot;bu tip kutuklerin konuldugu yer*quot; derleyiciye daha onceden belirtilir.
Ornegin Quick C derleyicisinde derleyiciye girmeden once:
SET INCLUDE=C:INCLUDE
yazmak derleyicinin bundan sonra butun 'include' edilecek yani eklenecek
kutuklerin C: diskinin INCLUDE dizininde aranmasini belirtir.

Sonu .h ile biten kutuklerin ozel bir fonksiyonu vardir. Bunlara header
yada baslik kutukleri denir. Genellikle iclerinde bazi fonksiyonlari
kullanmak icin gereken tanimlamalar yer alir. Bu kullandigimiz *quot;stdio.h*quot;
kutugu ise bir suru *quot;#define*quot; komutundan olusur.

C DE INPUT/OUTPUT ISLEMLERI

C dilinde lisanin bir parcasi olarak tanimlanmis input/output komutlari
yoktur bu nedenle bu fonksiyonlarin kullanici tarafindan yazilmasi
gereklidir. Her C kullanan kisi kendi input/output komutlarini yazmak
istemediginden derleyici yazarlari bu konuda calisma yapmislar ve bize
bir suru input/output fonksiyonlari saglamislardir. Bu fonksiyonlar
standart hale gelmislerdir ve hemen her C derleyicisinde ayni
input/output komutlarini bulabilirsiniz. C nin lisan tanimi Kernigan ve
Richie tarafindan yazilmis bir kitaptir ve onlar bu gorecegimiz
input/output fonksiyonlari bu kitaba katmislardir.

Bu *quot;stdio.h*quot; isimli kutugu incelemenizde fayda vardir. Icinde bircok
anlamadiginiz nokta olacaktir fakat bazi kisimlar tanidik olacaktir.

DIGER INCLUDE KUTUKLERI

C de buyuk programlar yazmaya basladiginizda programlari ufak parcalara
ayirip ayri ayri derlemek isteyebilirsiniz. Bu degisik parcalarin ortak
kisimlarini tek bir kutukte toplayip bir degisiklik gerektiginde sadece o
ortak kutukten yapmayi isteyebilirsiniz (ornegin global degisken
tanimlari.) Bu gibi durumlarda *quot;#include*quot; kutukleri cok faydali olacaktir.

*quot;BASITIO*quot; YA GERI DONELIM

*quot;c*quot; isimli degisken tanimlanir ve ekrana mesaj yazilir. Daha sonra
kendimizi *quot;c*quot; buyuk harf X e esit olmadigi surece devam eden bir dongunun
icinde buluyoruz. Bu programdaki iki yeni fonksiyon su an icin ilgi
noktamiz. Bunlar klavyeden bir tus okumak ve ekrana bir karakter yazmayi
saglarlar.

*quot;getchar()*quot; isimli fonksiyon klavyeden okudugu tusu dondurur bu deger
*quot;c*quot; ye atanir. *quot;putchar()*quot; fonksiyonu ise bu degeri ekrana yansitir.

Bu programi derleyip calistirdiginizda bir surpriz ile karsilasacaksiniz.
Klavyeden yazdiginizda ekrana herseyin iyi bir sekilde yansitildigini
goreceksiniz. RETURN tusuna bastiginizda ise butun satirin tekrar ekrana
yazildigini goreceksiniz. Her karakteri teker teker ekrana getirmesini
soyledigimiz halde programimiz sanki butun satiri sakliyor gibi.

DOS BIZE YARDIMCI OLUYOR (YADA ISE KARISIYOR)

Bu durumu anlayabilmek icin DOS un nasil calistigini anlamamiz
gereklidir. Klavyeden tuslar DOS kontrolu ile okundugu zaman RETURN tusu
basilana dek basilan tuslar bir sahada saklanir. RETURN basilinca da
butun satir programa dondurulur. Tuslara basilirken karakterler ekrana da
yansitilir. Bu duruma da *quot;eko*quot; ismi verilir.

Simdi anlatilanlari goz onunde bulundurarak programimiz calisirken ekrana
eko edilenlerin DOS tarafindan yapildigini anlayabilirsiniz. Siz RETURN e
basinca da bu saklanan tuslar programa gonderilir. Bunu daha iyi anlamak
icin icinde buyuk harf X olan bir satir yazin. DOS buyuk X in ozel bir
tus oldugundan habersiz siz RETURN e basana kadar tuslari kabul etmeye
devam eder. RETURN e basinca ise bu katar programa gecirilir ve program
X e rastlayincaya kadar ekrana karakterleri birer birer yazar.

Isletim sisteminin bu tuhafliklari karsisinda yilmayin. Bazi
programlarinizda bu ozellik isinize yarayabilir. Fakat simdi biz az once
yazdigimiz programin dusundugumuz gibi calismasini saglayalim.

TEKIO.C:
=================================================

#include *lt;stdio.h*gt;

main()
{
char c;

printf(*quot;Herhangi bir tusa basin. X = Programi durdurur. n*quot;);

do {
c = getch(); /* bir tus oku */
putchar(c); /* basilan tusu goster */
} while (c != 'X'); /* ta ki c == 'X' olana dek */

printf(*quot;nProgramin sonu.n*quot;);
}
=================================================

Bu programdaki yegane degisiklik olan yeni fonksiyon *quot;getch()*quot; yine
klavyeden tek bir karakter okur. Farki *quot;getchar*quot; gibi DOS'a
takilmamasidir. Bir karakter okur ve ekrana yansitmadan bu tusu programa
dondurur.

Bu programi calistirdiginizda bir oncekindeki gibi tekrarlanan satirlar
olmadigini goreceksiniz. Ayrica program artik 'X' e basar basmaz
durmaktadir. Burada baska bir problemimiz var. RETURN'e basinca cursor
ekranin soluna gitmektedir ama bir alt satira inmemektedir.

SATIR ATLAMAMIZ LAZIM

Cogu uygulama programi siz RETURN e basinca program o RETURN e ek olarak
bir de *quot;Line Feed*quot; yani satir atlama karakteri ilave eder. Satir atlama
otomatik olarak yapilmaz. Bundan sonraki programda bu sorunu da halletmis
olacagiz.

IYIIO.C:
================================================
#include *quot;stdio.h*quot;
#define CR 13 /* CR sembolunu 13 olarak tanimlar */
#define LF 10 /* LF sembolunu 10 olarak tanimlar */

main()
{
char c;

printf(*quot;Tuslara basin. Durmak icin X e basin.n*quot;);

do {
c = getch(); /* Bir karakter oku */
putchar(c); /* basilan tusu ekrana yaz */
if (c == CR) putchar(LF); /* sayet basilan RETURN tusu ise
bir SATIR ATLAMA karakteri yolla */
} while (c != 'X');

printf(*quot;nProgramin sonu.n*quot;);
}
================================================
Programin ilk basinda CR 'nin artik 13 e esit oldugunu ve LF nin de 10
oldugunu belirtiyoruz. Sayet ASCII tablosundan bakarsaniz RETURN tusuna
karsilik gelen kodun 13 oldugunu gorursunuz. Ayni tabloda satir atlama
kodu da 10 dur.

Ekrana basilan tusu yazdiktan sonra sayet bu tus RETURN tusu ise bir
satir atlayabilmemiz icin satir atlama kodunu ekrana yaziyoruz.

Programin basindaki *quot;#define*quot; lar yerine *quot;if (c == 13) putchar(10);*quot;
diyebilirdik fakat ne yapmak istedigimiz pek belirgin olmazdi.

**Arthur** · 07-09-2008

HANGI METOD DAHA IYI?

Burada ekrandan bir harf okumanin iki yolunu inceledik. Her ikisinin de
avantajlari ve dezavantajlari var. Bunlara bir bakalim.

Ilk metodda butun isi DOS ustlenmektedir. Programimiz baska islerle
ugrasirken DOS bizim icin satiri hazirlayabilir ve RETURN'e basilinca bu
satiri programa dondurebilir. Fakat bu metodda karakterleri basildiklari
anda fark etmemiz imkansizdir.

Ikinci metodda tuslari teker teker fark etmemiz mumkundur. Fakat
program bu okuma sirasinda butun zamanini okumaya harcar ve baska bir is
yapamaz ve bilgisayarin tum zamanini bu isle almis oluruz.

Hangi metodun uzerinde calistiginiz program icin daha uygun oldugunu
programci olarak siz karar vereceksiniz.

Burada *quot;getch()*quot; fonksiyonun tersi olan *quot;ungetch()*quot; isimli bir fonksiyon
daha oldugunu da belirtmeliyim. Sayet bir karakteri *quot;getch()*quot; le okuduktan
sonra fazla okudugunuzu fark ederseniz bu fonksiyon ile okunan tusu geri
koyabilirsiniz. Bu bazi programlarin yazilimini kolaylastirmaktadir cunku
bir tusu istemediginizi onu okuyuncaya kadar bilemezsiniz. Sadece bir tek
tusu *quot;ungetch*quot; edebilirsiniz fakat genellikle bu yeterlidir.

BIRAZ TAMSAYI OKUYALIM

TAMOKU.C:
=================================================
#include *lt;stdio.h*gt;

main()
{
int deger;

printf(*quot;0 ila 32767 arasinda bir rakam yazin durmak icin 100 girin.n*quot;);

do {
scanf(*quot;%d*quot;°er); /* bir tamsayi oku (adresi ile) */
printf(*quot;Okunan deger %d idi. n*quot;deger);
} while (deger != 100);

printf(*quot;Programin sonun*quot;);
}
===============================================

Alistigimiz tip bir program olan TAMOKU'da *quot;scanf*quot; isimli yeni bir
fonksiyon goruyoruz. Cok kullandigimiz *quot;printf*quot; fonksiyonuna cok benzeyen
bu fonksiyonun gorevi istenilen tip verileri okuyup degiskenlere atamak.

*quot;printf*quot; den en buyuk farki *quot;scanf*quot; in degisken degerleri yerine
adreslerini kullanmasidir. Hatirlayacaginiz gibi bir fonksiyonun
parametrelerinin degerlerini degistirebilmesi icin degiskenin adresine
ihtiyaci vardir. *quot;scanf*quot; fonksiyonuna adres yerine deger gecirmek C
dilinde en SIK rastlanan hatalardan biridir.

*quot;scanf*quot; fonksiyonu girilen satiri satirdaki bosluklara bakmadan ve bu
sekilde kullanildiginda rakam olmayan bir karakter bulana kadar bir
tamsayi okur.

Sayet 32766 den buyuk bir rakam girerseniz programin hata yaptigini
gorursunuz. Ornegin 65536 girerseniz programin 0 degerini dondurdugunu
gorursunuz. Buna sebep tamsayilarin hafizada saklanisinda onlara 16
bitlik bir saha ayrilmasindandir. Programinizda daha buyuk rakamlar
kullanacaksaniz 'long' yada 'float' tiplerini secebilirsiniz.

KARAKTER KATARI GIRISI

KATARIN.C:
================================================
#include *lt;stdio.h*gt;

main()
{
char big[25];

printf(*quot;Karakter katari girin en fazla 25 karakter.n*quot;);
printf(*quot;Birinci kolonda X yazarak programi bitirin.n*quot;);

do {
scanf(*quot;%s*quot;big);
printf(*quot;Yazdiginiz katar -*gt; %sn*quot;big);
} while (big[0] != 'X');

printf(*quot;Programin sonu.n*quot;);
}
==================================================

Bu program bir oncekine cok benzer fakat bu sefer bir kelime katari
giriyoruz. 25 elemanli bir dizi tanimlanmistir fakat en son deger bir '0'
olmasi gerektiginden kullanilabilen kisimi 24 dur. *quot;scanf*quot; deki
degiskenin onune *amp; ampersand isareti gerekmez cunku koseli parantezleri
olmayan bir dizi degiskeni C dilinde o dizinin baslangicini gosteren
bir adrestir.

Calistiginizda sizi bir supriz bekliyor. Yazdiginiz cumleyi program ayri
satirlarda gosterir. Bunun sebebi *quot;scanf*quot; bir katar okurken satirin
sonuna yada bir bosluga rastlayincaya kadar okumasina devam eder. Bir
dongu icinde oldugumuzdan program tekrar tekrar *quot;scanf*quot; i cagirarak
DOS'un giris sahasinda kalan butun karakterleri okur. Cumleleri kelimelere
boldugunden X ile baslayan herhangi bir kelimeye rastlayinca bu program
durur.

24 karakterden daha fazlasini girmeye calisin. Ne olduguna bakin. Size bir
hata mesaji verebilir yada programiniz aleti kilitleyebilir. Gercek bir
programda boyle seylerin sorumlulugu sizlerin omuzlarinizdadir. C dilinde
yazdiginiza size cok sey duser fakat ayni zamanda bircok kolaylik da
saglar.

C DE INPUT/OUTPUT PROGRAMLAMA

C dili cok miktarda input/output yapan programlar icin degil de bir
bircok icsel islemler yapan sistem programlari icin yazilmistir.
Klavye'den bilgi alma rutinleri cok kullanislidir fakat C size az
yardimci olur. Yani yapmaniz gereken I/O islemlerinde sorun cikmasini
onlemek icin detaylarla sizin ugrasmaniz lazimdir. Fakat genellikle
herhangi bir program icin bu tip fonksiyonlari bir defa tanimlamaniz
yeterlidir.

HAFIZADA.C:
=================================================
main()
{
int rakam[5] sonuc[5] index;
char satir[80];

rakam[0] = 5;
rakam[1] = 10;
rakam[2] = 15;
rakam[3] = 20;
rakam[4] = 25;

sprintf(satir*quot;%d %d %d %d %dn*quot;rakam[0]rakam[1]
rakam[2]rakam[3]rakam[4]);

printf(*quot;%s*quot;satir);

sscanf(satir*quot;%d %d %d %d %d*quot;*amp;sonuc[4]*amp;sonuc[3]
(sonuc+2)(sonuc+1)sonuc);

for (index = 0;index *lt; 5;index++)
printf(*quot;Sonuc %d dir. n*quot;sonuc[index]);

}
=================================================

Bu programda birkac tane degisken tanimliyoruz ve *quot;rakamlar*quot; isimli
diziye de *quot;sprintf*quot; fonksiyonunu incelemek icin rastgele sayilar
atiyoruz. Bu fonksiyon *quot;printf*quot; e cok benzer. Yegane farki ciktisini
ekrana yazmak yerine bir karakter dizisine yazmasidir. Bunu da ilk
parametresi olarak veriyoruz. Yani program bu fonksiyondan dondukten
sonra *quot;satir*quot; dizisinin icinde bes tane rakam olacaktir. Ikinci ile
ucuncu rakamlar arasindaki bosluk *quot;sscanf*quot; fonksiyonunun bunlarin
uzerinden atlamasini gormek icindir.

Bunun altinda *quot;printf*quot; i kullanarak bu hazirladigimiz satiri yaziyoruz.
Daha sonra gordugunuz *quot;sscanf*quot; fonksiyonu ise *quot;scanf*quot; gibi ekrandan
okumak yerine bizim *quot;satir*quot; dizimizden degerleri okur. Gordugunuz gibi
*quot;sscanf*quot; e rakamlarin konacagi dizinin adreslerini cok degisik sekillerde
verebiliyoruz. Ilk ikisi sadece dizideki 5. ve 4. elemanlarin adreslerini
index vererek tanimliyorlar sonraki ikisi ise dizinin baslangic adresine
bir offset (bir rakam) ekleyerek buluyorlar. Sonuncusu ise koseli
parantezi olmayan bir dizinin o dizinin baslangic elemaninin adresini
gostereceginden hicbir sey gerektirmiyor.

Bazen bir programin ciktilarini standart ciktidan (ekrandan) bir baska
kutuge yoneltmek istenir. Fakat hata mesajlarini gibi bazi mesajlari hala
ekrana yollamak isteyebilirsiniz:

OZEL.C:
=================================================
#include *lt;stdio.h*gt;

main()
{
int index;

for (index = 0;index *lt; 6;index++) {
printf(*quot;Bu satir standart ciktiya gidiyor.n*quot;);
fprintf(stderr*quot;Bu satir ise standart hataya gidiyor.n*quot;);
}

exit(4); /* Bu komut DOS 'un ERRORLEVEL komutu ile bir batch file'da
(yigit kutugunde) kontrol edilebilir. Bu programin
d*#8221;nd£rd£g£ deger soyle kontrol edilebilir:

A*gt; COPY CON: DENE.BAT *lt;RETURN*gt;

OZEL
IF ERRORLEVEL 4 GOTO DORT
(Dortten kucukse buraya devam eder..)
.
.
GOTO BITTI
ORT
(dort yada buyukse buraya devam eder)
.
.
:BITTI

*lt;F6*gt; *lt;RETURN*gt;

*/
}
==================================================

Bu program bir dongu ve icinde iki satirdan olusur. Bu satirlardan bir
tanesi standart ciktiya bir tanesi de standart hataya gider. Burada
gordugunuz *quot;fprintf*quot; komutu *quot;printf*quot; e cok benzer fakat ciktinin nereye
gidecegini de belirtmenizi saglar. Bu alanda bir sonraki konuda daha uzun
duracagiz.

Program calisinca ekranda on iki tane satir goreceksiniz. Sayet bu
programi:

A*gt; OZEL *gt; CIKTI

seklinde calistirirsaniz ekranda sadece alti tane standart hataya giden
mesajlari goreceksiniz. Geri kalan (standart ciktiya giden) alti tanesi
ise *quot;cikti*quot; isimli kutukte yer alacaktir.

YA exit(4) KOMUTU ?

Bu programdaki en son satir olan *quot;exit(4)*quot; komutu programi sona erdirir
ve dort degerini DOS a dondurur. Parantezlerin arasinda 0 ila 9 degerleri
kullanilabilir. Sayet bir *quot;batch*quot; (yigit) kutugu icinde bu programi
calistiriyorsaniz bu degeri ERRORLEVEL komutu ile kontrol edebilirsiniz.

ODEV

1. Bir dongu icinde bir harf okuyun ve ekrana bu harfi normal *quot;char*quot;
tipinde gosterin. Bu harfi bir rakam olarak da gosterin. Programi
durdurmak icin dolar sembolunu bekleyin. *quot;getch*quot; fonksiyonunu kullanarak
programin tusa basilir basilmaz islemesini saglayin. F tuslari gibi ozel
tuslara basarak ne oldugunu kaydedin. Her fonksiyon tusundan iki tane
deger donecektir. Birincisi sifir olup ozel bir tusa basildigini haber
verecektir.

**Arthur** · 07-09-2008

DIKKAT DIKKAT DIKKAT

Bu noktada C nin en sasirtici ve en cok yapilan hatasina rastliyoruz.
*quot;getc*quot; fonksiyonundan geri donen degisken bir karakterdir dolayisi ile
bunu *quot;char*quot; tipi bir degiskene atayabiliriz. Hatirlayalim ki bir *quot;char*quot;
degiskeni 0 ila 255 arasindaki degerleri alabilir.

Fakat cogu C derleyicilerinde EOF karakteri -1 olarak tanimlanmistir -
yani *quot;char*quot; degiskeninin disinda - Bu nedenle sayet char kullanirsak
program kutugun sonunun geldigini bulamaz ve sonsuz bir dongude takilir.
Bunun onune gecmesi kolaydir: EOF karakteri donmesini beklediginiz
durumlarda daima *quot;int*quot; tipi bir degisken kullanin.

Sayet sizin derleyiciniz icin EOF karakterinin ne oldugunu ogrenmek
isterseniz *quot;stdio.h*quot; isimli header'i okuyabilirsiniz.

KELIME KELIME OKUMAK

TEXTOKU.C:
=================================================
#include *quot;stdio.h*quot;

main()
{
FILE *fp1;
char birkelime[100];
int c;

fp1 = fopen(*quot;ONSATIR.TXT*quot;*quot;r*quot;);

do {
c = fscanf(fp1*quot;%s*quot;birkelime); /* kutukten bir kelime okuyalim */
printf(*quot;%sn*quot;birkelime); /* ekrana yazalim */
} while (c != EOF); /* ta ki EOF olana kadar */

fclose(fp1);
}
================================================

Bu program nerdeyse bir oncekinin aynisidir. Burada kelime kelime okumak
icin *quot;fscanf*quot; fonksiyonunu kullaniyoruz cunku *quot;fscanf*quot; fonksiyonu bir
bosluga gelince okumayi birakir.

FAKAT BIR PROBLEM VAR

Programi inceleyince verinin kutukten okundugunu ekrana yazildigini ve
daha sonra EOF olup olmadiginin kontrol edildigini goruyoruz. Bu nedenle
istemedigimiz birsey ekrana yazilmis oluyor. Buyuk ihtimalle programin
sonunda en son kelimeyi bir daha yaziyoruz - cunku zaten *quot;birkelime*quot; nin
icinde idi o deger.

Buna mani olmak icin bir baska program gorelim. Ismi IYIOKU.C olsun:

IYIOKU.C:
================================================
#include *quot;stdio.h*quot;

main()
{
FILE *fp1;
char birkelime[100];
int c;

fp1 = fopen(*quot;onsatir.txt*quot;*quot;r*quot;);

do {
c = fscanf(fp1*quot;%s*quot;birkelime); /* kutukten bir kelime oku... */
if (c != EOF)
printf(*quot;%sn*quot;birkelime); /* ekrana yaz... */
} while (c != EOF); /* ta ki EOF olana dek.. */

fclose(fp1); /* kutugu kapa */
}
================================================

Gordugunuz gibi bir *quot;if*quot; komutu ile sayet kutugun sonuna gelip
gelmedigimize bakiyoruz. Aslinda bu problem KAROKU.C da da vardi fakat
orada pek gorunmuyordu.

SONUNDA BUTUN BIR SATIR OKUYORUZ

SATIROKU.C:
=================================================

#include *quot;stdio.h*quot;

main()
{
FILE *fp1;
char birkelime[100];
char *c;

fp1 = fopen(*quot;ONSATIR.TXT*quot;*quot;r*quot;);

do {
c = fgets(birkelime100fp1); /* bir satir okuyalim */
if (c != NULL)
printf(*quot;%s*quot;birkelime); /* ekrana yazalim */
} while (c != NULL); /* ta ki NULL olana kadar.. */

fclose(fp1);
}

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

Bu program simdiye de gorduklerimize benziyor fakat NULL isimli yeni bir
nesne de katildi.

*quot;fgets*quot; fonksiyonu ile bir butun satiri ve sonundaki yeni satir
karakterini (n) bir diziye okur. Ilk parametre olarak donen
karakterleri koyacagimiz yerin adresi tanimlanir ikinci parametrede en
fazla kac karakter okunmasina izin verecegimizi belirtiyoruz ve son
olarak da kutuk degiskeninin ismini veriyoruz.

o Yani bu fonksiyon ya bir yeni satir karakterine rastlayana kadar yada
izin verilen karakter sayisi eksi bir kadar okur. Eksi birin sebebi ise
katarin sonunu belirten () sifir degerine yer birakmasidir.

Tabi sonunda kutugu kapatiyoruz..

DEGISKEN BIR KUTUK ISMI

HERKUTUK.C:
================================================
#include *quot;stdio.h*quot;

main()
{
FILE *fp1;
char birkelime[100]kutukismi[25];
char *c;

printf(*quot;Kutuk ismini girin -*gt; *quot;);
scanf(*quot;%s*quot;kutukismi); /* istenilen kutuk ismini alalim */

fp1 = fopen(kutukismi*quot;r*quot;);

do {
c = fgets(birkelime100fp1); /* kutukten bir satir okuyalim */
if (c != NULL)
printf(*quot;%s*quot;birkelime); /* ekrana yazalim */
} while (c != NULL); /* ta ki NULL olana kadar */

fclose(fp1);
}
===============================================

Burada ilk once kullanicidan *quot;scanf*quot; ile kutuk ismini kullanicidan
aliyoruz daha sonra kutugu acip satir satir ekrana yaziyoruz.

YAZICIYA NASIL BIRSEY YOLLAYABILIRIZ

PRINTDAT.C:
================================================
#include *quot;stdio.h*quot;

main()
{
FILE *guzel*printer;
int c;

guzel = fopen(*quot;onsatir.txt*quot;*quot;r*quot;); /* kutugu acalim */
printer = fopen(*quot;PRN*quot;*quot;w*quot;); /* printeri acalim */

do {
c = getc(guzel); /* kutukten bir karakter okuyoruz */
if (c != EOF) {
putchar(c); /* ekranda goruntuleyelim */
putc(cprinter); /* ve yaziciya yollayalim */
}
} while (c != EOF); /* ta ki (End Of File) kutuk bitene kadar */

fclose(guzel);
fclose(printer);
}
===============================================

Okumak icin *quot;onsatir.txt*quot; yi actiktan sonra yazmak icin *quot;PRN*quot; isimli
kutugu aciyoruz. Printere bir bilgi yollamak ayni bir kutuge yazmak
gibidir fakat standart bir kutuk ismi kullanmak zorundayiz. Bu konuda
kesin standartlar yoktur fakat genellikle bu isimler *quot;PRN*quot; *quot;LPT*quot;
*quot;LPT1*quot; yada *quot;LPT2*quot; dir.

Bazi yeni derleyicilerin *quot;stdprn*quot; diye onceden tanimli bir kutuk
tanimliyicilari vardir. Bu sayede siz printer'i bir kutuk gibi acmadan
ona veri yollayabilirsiniz.

Program birer birer butun kutugu okuyup ekranda gosterir ve printer'e
yollar. EOF kutuk sonu bulundugunda kutukler kapanir ve programv
biter.

ODEVLER:

1. Okunacak yazilacak kutuklerin isimlerini kullaniciya soran daha
sonra bu ikisini ve printer kutugunu acan bir program yazin. Program
bunlari actiktan sonra kutuk sonu gelinceye kadar okunacak kutugu harf
harf okuyup yazilacak kutuge ve yaziciya bu karakteri yollamalidir.

2. Programiniz kullaniciya bir kutuk ismi sorsun cevabi alinca da bu
kutugu ekranda satir numaralari ile birlikte gostersin..

c dersleri 10.bölüm

Structure ve Union'lar

STRUCTURE NEDIR?

Not: Structure'un tam tercumesi herhalde 'Yapi' olacak..

Bir structure kullanici tarafindan tanimlanmis bir veri tipidir. Su ana
kadar kullandigimiz veri tiplerinden cok daha karmasik olanlari
tanimlayabilirsiniz. Bir structure daha once tanimlanmis olan veri
tiplerinin bir araya gelmis halidir - ki bu veri tiplerine daha once
tanimladigimiz structure'lar da dahildir. Bu tanimi rahat anlamanin bir
yolu structure'un veriyi kullaniciya yada o programi kullanacak olan
kisiye daha rahat bir sekilde gruplamak icin kullanildigini
belirtebiliriz. Her zamanki gibi bir seyi anlamanin en iyi yolu
orneklere bakmaktir...

STRUCT1.C:
================================================

main()
{

struct {
char bas_harf; /* Soyadin bas harfi */
int yas; /* cocugun yasi */
int not; /* okulda not ortalamasi (100 uzerinden) */
} oglankiz;

oglan.bas_harf = 'R';
oglan.yas = 15;
oglan.not = 75;

kiz.yas = oglan.yas - 1; /* o oglandan bir yas kucuk */
kiz.not = 82;
kiz.bas_harf = 'H';

printf(*quot;%d yasindaki %c'nin aldigi not %d dir.n*quot;
kiz.yas kiz.bas_harf kiz.not);

printf(*quot;%d yasindaki %c'nin aldigi not %d dir.n*quot;
oglan.yas oglan.bas_harf oglan.not);
}
================================================

Program bir structure tanimi ile basliyor. *quot;struct*quot; kelimesinden sonra
kume isaretleri arasinda bazi basit degiskenler goruyorsunuz. Bu
degiskenler bu structure'i olusturan parcalardir. Kapanan kume
isaretinden sonra iki tane degisken ismi goruyorsunuz: *quot;oglan*quot; ve *quot;kiz*quot;.
Bu structure'un tanimina gore *quot;oglan*quot; artik 3 elemandan olusan bir
degiskendir. Bunlar *quot;bas_harf*quot; *quot;yas*quot; ve *quot;not*quot; dur ve herbiri kendi
tiplerinde bir veriyi saklayabilirler. *quot;kiz*quot; degiskeninin de ayni 3
elemani vardir fakat bu baska bir degiskendir. Yani 6 tane basit
degisken tanimlamis olduk..

TEK BIR BIRLESIK DEGISKEN

*quot;oglan*quot; degiskenini daha yakindan izleyelim. Daha once soyledigimiz gibi
*quot;oglan*quot; in her elemani basit birer degiskendir ve bu tip bir degiskenin
kullanilabilecegi heryerde kullanilabilir. Ornegin *quot;yas*quot; elemani bir
tamsayi degiskenidir dolayisiyla bir C programinda bir tamsayi
degiskeninin kullanilabilecegi her yerde kullanilabilir. Hesaplamalarda
bir sayac olarak I/O islemlerinde vs. Yegane problem bu *quot;yas*quot; isimli
basit degiskeni *quot;oglan*quot; ile beraber kullanmamiz gerekir. Bunu yapmak
icinde ikisini de yaziyoruz ve arasina bir nokta isareti koyuyoruz.
Oyleyse tum degisken ismi olan *quot;oglan.yas*quot; *quot;oglan*quot; degiskeninin *quot;yas*quot;
sahasi oluyor.. Bu yapiyi bu sahaya erismek istedigimiz heryerde
kullanabiliriz. Hatta sadece *quot;oglan*quot; yada *quot;yas*quot; dememiz kabul
edilmeyecektir. Tek baslarina isimlerin bir manasi yoktur.

DEGISKENLERE DEGER ATAMA

Yukardaki tanimlamayi kullanarak *quot;oglan*quot; ve *quot;kiz*quot; 'in her uc sahasina
(*quot;bas_harf*quot;*quot;yas*quot;*quot;not*quot;) degerler ayabiliriz. Dikkat etmeniz gereken bir
nokta *quot;oglan.bas_harf*quot;'in bir *quot;char*quot; tipi oldugudur. Bu nedenle
programda karakter verisine atanmistir. *quot;oglan*quot; in geri kalan iki sahasi
da tanimlandiklari 'tiplerde' degerlere atanir.. Sonra *quot;kiz*quot; isimli
degiskenin 3 sahasi da degerlere atanir. Burada atama sirasinin fark
etmeyecegini gosterebilmek icin farkli bir sira izlenmistir.

BU DEGERLERI NASIL KULLANABILIRIZ??

Alti basit degiskenimizin her elemanina veri atadiktan sonra onlarla
diledigimizi yapabiliriz. Bu ilk ornegi basit tutmak icin biz sadece
degerlerini ekrana yazdiriyoruz. *quot;printf*quot; satirinin alistigimizdan farkli
olmadigini goreceksiniz.

Structure'lar programi daha kolay yazmak ve anlamak icin cok faydali bir
gruplama metodudur. Bu ilk ornek cok basit oldugundan size structure'un
gercek degerini gostermekten acizdir fakat okumaya devam ederseniz
structure'un gercekten faydali oldugunu goreceksiniz.

**Arthur** · 07-09-2008

BIR UNION ORNEGI DAHA

UNION2.C:
================================================
#define OTO 1
#define TEKNE 2
#define UCAK 3
#define GEMI 4

main()
{
struct otomobil { /* bir otomobil icin structure */
int tekerlekler;
int camurluklar;
int kapilar;
};

typedef struct { /* bir gemi yada tekne icin structure */
int su_kesimi;
char boyu;
} TEKNEDEF;

struct {
char tasit; /* ne cins tasit ? */
int agirlik; /* tasitin gros agirligi */
union { /* tipe-bagimli bilgi */
struct otomobil oto; /* union'un birinci kismi */
TEKNEDEF tekne; /* union'un ikinci kismi */
struct {
char motorlar;
int kanat_acikligi;
} ucak; /* union'un 3uncu kismi */
TEKNEDEF ship; /* union'un 4uncu kismi */
} tasit_tip;
int deger; /* tasitin bin TL olarak degeri */
char sahibi[32]; /* sahibinin ismi */
} ford sun_fish piper_cub; /* 3 structure degiskeni */

/* birkac sahayi tanimlayalim */

ford.tasit = OTO;
ford.agirlik = 2742; /* deposu dolu iken */
ford.tasit_tip.oto.tekerlekler = 5; /* istepne dahil */
ford.tasit_tip.oto.kapilar = 2;

sun_fish.deger = 3742; /* trailer haric */
sun_fish.tasit_tip.tekne.boyu = 5;

piper_cub.tasit = UCAK;
piper_cub.tasit_tip.ucak.kanat_acikligi = 9;

if (ford.tasit == OTO) /* evet oyle */
printf(*quot;Ford'un %d tekerlegi var.n*quot;ford.tasit_tip.oto.tekerlekler);

if (piper_cub.tasit == OTO) /* hayirdegil */
printf(*quot;Ucagin %d tekerlegi var.n*quot;piper_cub.tasit_tip.
oto.tekerlekler);
}
==============================================

Bu ornekte union'larin cok rastlanilan bir kullanim tarzini goruyorsunuz.
Dusunun ki bircok tip tasittan olusan bir veri bankasi (veri tabani)
olusturmak istiyoruz. Bir arabadaki pervane sayisi yada bir teknedeki
tekerlek sayisini koymak komik olurdu. Verimli bir veri tabani olusturmak
icin bir kismi her cins tasit icin degisik bir kismi ayni tip kalan
verileri saklamaniz gerekecektir.

Burada bir structure tanimliyoruz ve bunun icine gidebilecek degisik
tiplere karar veriyoruz. Ilk once #definelarla bazi sabitler
tanimliyoruz daha sonra icindekilerin size hic te yabanci gelmeyecegi
*quot;otomobil*quot; isimli bir structure tanimliyoruz fakat degisken
tanimlamiyoruz.

TYPEDEF KOMUTU

Daha sonra *quot;typedef*quot; ile yeni bir cins veri tanimliyoruz. Bu da *quot;int*quot;
yada *quot;char*quot; gibi kullanilabilecek tumuyle yeni bir tip tanimliyoruz.
Structure'un ismi olmadigini fakat degisken tanimlanacagi yerde
*quot;TEKNEDEF*quot; ismini goruyorsunuz. Artik *quot;TEKNEDEF*quot; diye bir tipimiz vardir
ve bununla istedigimiz heryerde bir structure tanimlayabiliriz. Bu komut
degisken tanimlamasi yapmiyor fakat sadece tipi tanimliyor.

Buyuk harf kullanmak sadece sahsi tercih icindir fakat bir C standarti
degildir. Sadece *quot;typedef*quot; i bir degisken isiminden ayri tutmaktadir.

Daha once yarattigimiz parcalari kullanan buyuk kesime geldik. Bu
structure 5 parcadan olusmustur iki *quot;tasit*quot; ve *quot;agirlik*quot; isimli basit
degisken bir union ve *quot;deger*quot; ve *quot;sahibi*quot; isimli iki basit degisken
daha. Tabii ki burada onemle bakmamiz gereken union tanimlanmasidir.

Bakinca bunun 4 parcadan olustugunu goreceksiniz. Ilk parcasi *quot;oto*quot;
isimli ve daha once tanimladigimiz bir tipte olan degiskendir. Ikinci
kismi *quot;tekne*quot; ismindedir ve daha once tanimladigimiz *quot;TEKNEDEF*quot;
tipindedir. Ucuncu kesimi ise *quot;ucak*quot; isimli ve union icinde tanimlanan
bir structure'dur. Sonunda union'un en son parcasi olan *quot;gemi*quot; isimli
degisken de *quot;TEKNEDEF*quot; tipindedir.

Umarim bu dordunun gosterilen 3 mettoddan biri ile tanimlanabilecegi
sizin icin aciktir. Normalde herhalde en *quot;temiz*quot; tanim her birinin
*quot;typedef*quot; ile tanimlanmasi sayesinde olacaktir.

SIMDI NE OLDU?

Simdi icine dort cins veri saklayabilecegimiz bir yapimiz var. Her
kayitin uzunlugu en buyuk union'u tasiyan kayitin uzunlugunda olacaktir.
Bu durumda birinci kesim en buyugudur cunku 3 tamsayi degiskeninden
olusmaktadir. Digerleri ise bir karakter ve bir tamsayidan
olusmaktadirlar. Yani bu union'un ilk parcasi bu tipteki butun
structure'larin boyunu belirleyecektir. Elde edilen structure her dort
tip veriden birini saklamasi icin kullanilabilir fakat bu tip bir bir
degiskenin icinde neler saklandigini kontrol etmek programcinin isidir.
*quot;tasit*quot; isimli degisken orada ne tip bir tasit saklandigini belirtmek
icin kullanilmistir. Programin basindaki dort #define satiri *quot;tasit*quot; in
icinde saklanabilecekleri belirtir.

Ortaya cikan yapinin kullanimini gostermek icin birkac ornek de vardir.
Bazi degiskenlere degerler atanmis birkac tanesinin degeri ekrana
yazilmistir.

Union'lar hele yeni programlamaya baslayanlar tarafindan cok SIK
kullanilmaz. Bazen rastlayabilirsiniz ve ne ise yaradiklarini bilmenizde
fayda vardir. Su an icin detaylarini ogrenmenize luzum yoktur ve bu
nedenle bu ornekte fazla vakit harcamayin. Sayet bir gun saha tanimlari
degisen bir yapiya ihtiyaciniz olursa o zaman ogrenebilirsiniz. Fakat
kendi igiliginiz icin structure'lara alismaya bakin - onlar daha SIK
kullanilirlar.

ODEV

1. Icinde *quot;isim*quot; icin bir karakter dizisi *quot;ayaklar*quot; icin bir tamsayi
degiskeni ve *quot;kollar*quot; icin bir baska tamsayi degiskeni olan ISIMLI bir
structure tanimlayin. Bu structure ile 6 elemanlik bir dizin tanimlayin.
Bu sahanin icine degisik bilgiler atayin ve ekrana suna benzer bir cikti
saglayin:

Bir insanin 2 kolu ve 2 ayagi vardir.
Bir kopegin 0 kolu ve 4 ayagi vardir.
Bir televizyonun 0 kolu ve 4 ayagi vardir.
Bir sandalyenin 2 kolu ve 4 ayagi vardir.
vs.

2. Birinci programi tekrar yazip verileri ekrana yazmak icin bir
pointer'dan yararlanin.

Benzer Konular
Konu	Konuyu Başlatan	Forum	Cevaplar	Son Mesaj
Php Java Mysql Kitabı İndir,Php Java Mysql Programlama Kitabı İndir,Php Java Mysql	Arthur	Eğitim Programları	0	02-20-2010 05:39 PM
Yrd. Doç. Dr. Güzin Tural	Sultan Sencer	Bilim Adamları	0	10-01-2008 12:59 PM
Prof. Dr. Osman Horata	Sultan Sencer	Bilim Adamları	0	10-01-2008 12:56 PM
Prof. Dr. Şükrü Halûk Akalın	Sultan Sencer	Bilim Adamları	0	10-01-2008 12:55 PM

07-09-2008	#6 (permalink)
Arthur	Cevap: C Programlama Dili 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 quot;charquot; 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(quot;Isim %s dur. nquot;isim); printf(quot;Icinden bir karakter: %cnquot;isim[2]); printf(quot;Ismin bir parcasi: %s nquot;amp;isim[3]); } ================================================== Bu programda ilk once quot;charquot; 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 quot;isimquot; 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 quot;#definequot; ile NULL karakteri programin basinda sifir olarak tanimlayabiliriz.) printf komutundaki %s isareti printf'e quot;isimquot; isimli katardan sifira rastlayincaya kadar ekrana yazmasini belirtir. Dikkat etmeniz gereken bir nokta quot;isimquot; 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 quot;isimquot; degiskeninin yanina koseli parantezler arasinda gosterebiliriz. Son printf komutunda ise katarin 4. karakterinden itibaren yazmanin bir ornegidir. quot;isimquot; degiskeninin onundeki amp; (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(isim1quot;Rosalindaquot;); strcpy(isim2quot;Zekequot;); strcpy(baslikquot;Bu bir basliktir.quot;); printf(quot; %snnquot;baslik); printf(quot;isim 1: %s nquot;isim1); printf(quot;isim 2: %s nquot;isim2); if(strcmp(isim1isim2)gt;0) /* sayet isim1 gt; isim2 ise 1 dondurur / strcpy(karisikisim1); else strcpy(karisikisim2); printf(quot;Alfabetik olarak en buyuk isim %s dir.nquot;karisik); strcpy(karisikisim1); strcat(karisikquot; quot;); strcat(karisikisim2); printf(quot;Iki isim birden %snquot;karisik); } ================================================= Ilk once 4 tane katar tanimliyoruz. Daha sonra quot;strcpyquot; 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 (quot;x=23quot; gibi). Veri sagdakinden soldakine kopyalanir. Bu komutun yapilmasindan sonra isim1 in icinde quot;Rosalindaquot; olacaktir - den-densiz olarak. Den-denler derleyicinin sizin bir katar tanimladiginizi anlamasi icin gereklidir. KATARLARIN ALFABETIK OLARAK SIRAYA KONMASI Ilginizi cekebilecek diger bir fonksiyonda quot;strcmpquot; dur. Sayet kendisine gecirilen birinci katar ikinciden daha buyukse 1 dondurur ayni ise 0 ve ikinci daha buyukse -1 dondurur. quot;Zekequot; 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 quot;strcatquot; isimli yeni bir fonksiyon goreceksiniz. Gorevi bir katarin sonuna diger katari eklemektir. Bunu yaparken NULL karakterin de yerli yerinde olmasini saglar. Burada quot;isim1quot; quot;karisikquot; 'a kopyalanir daha sonra quot;karisikquot; a iki bosluk ve quot;isim2quot; 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 lt; 12;index++) degerler[index] = 2 (index + 4); for (index = 0;index lt; 12;index++) printf(quot;Index = %2d deki degeri %3d dir..nquot;indexdegerler[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 quot;degerler[0]quot; quot;degerler[1]quot; vs. dir. Ilk quot;forquot; dongusunde bunlara deger atiyoruz ikincisi ise index degiskeni ve quot;degerlerquot; dizisinin icindekileri ekrana yaziyor. BIR KAYAR NOKTA DIZINI BUYUKDIZ.C: ================================================= char isim1[] = quot;Birinci Program basligiquot;; main() { int index; int ivir[12]; float tuhaf[12]; static char isim2[] = quot;Ikinci Program Basligiquot;; for (index = 0;index lt; 12;index++) { ivir[index] = index + 10; tuhaf[index] = 12.0 * (index + 7); } printf(quot;%snquot;isim1); printf(quot;%snnquot;isim2); for (index = 0;index lt; 12;index++) printf(quot;%5d %5d %10.3fnquot;indexivir[index]tuhaf[index]); } ================================================ Burada quot;floatquot; 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 quot;static*quot; koymak zorunlugumuz var. Baska yeni birsey yok bu programda. Degiskenler rastgele degerlere atanir ve sonra da bu degerler ekrana yazdirilir.

07-09-2008	#7 (permalink)
Arthur	Cevap: C Programlama Dili POINTER VE ARITMETIK Her cesit islemler pointer'lar ile mumkun degildir. Pointer bir adres oldugundan ona bir sabit rakam ekleyip daha ilerideki bir adrese erismek mumkundur. Ayni sekilde pointer'in adresinde bir rakam cikartip daha onceki hafiza bolgelerine erismek mumkundur. Iki pointer'i toplamak pek mantikli degildir cunku bilgisayardaki adresler sabit degildir. Cikacak rakamin tuhaf olacagi icin pointer ile carpma da yapilamaz. Ne yaptiginizi dusunurseniz yapabilecekleriniz ve yapamayacaklariniz kendini belli edecektir. TAMSAYI POINTER'I quot;listquot; isimli tamsayi dizisine 100 den 199 a kadar degerler verilir. Daha sonra 28. elemanin adresini quot;ptquot; isimli pointer'a atiyoruz. Daha sonra ekrana yazdigimizda gercektende o degeri aldigini goruyoruz. Daha onceki konularda bir fonksiyondan veri degerlerini dondurmek icin iki metod oldugunu soylemistim. Ilki bir dizi kullanarakti. Ikincisini herhalde tahmin edersiniz. Sayet tahmininiz quot;pointer sayesindequot; idiyse tebrikler. CIFTYON.C: ================================================== == main() { int cevizlerelmalar; cevizler = 100; elmalar = 101; printf(quot;Baslangic degerleri %d %dnquot;cevizlerelmalar); /* quot;degistirquot; i cagirinca / degistir(cevizleramp;elmalar); /* cevizlerin DEGERI ve / / elmalarin adresini geciriyoruz / printf(quot;Bitis degerleri ise %d %d dir..nquot;cevizlerelmalar); } degistir(kuru_yemismeyvalar) / kuru_yemis tamsayidir / int kuru_yemismeyvalar; /* meyvalar bir tamsayi pointer'idir / { printf(quot;Degerler %d %dnquot;kuru_yemismeyvalar); kuru_yemis = 135; meyvalar = 172; printf(quot;Sonraki degerler %d %dnquot;kuru_yemismeyvalar); } ================================================= Burada iki tane tamsayi degiskeni (pointer degil) tanimliyoruz: quot;cevizlerquot; ve quot;elmalarquot;. Once bunlara birer deger atiyoruz ve quot;degistirquot; isimli fonksiyonu cagiriyoruz. Cagirirken quot;cevizlerquot; in degeri (100) ve quot;elmalarquot; degiskeninin adresini geciriyoruz. Fakat fonksiyona da bir deger ve bir adres gelecegini haber vermemiz gereklidir. Bunun icin fonksiyonun parametreleri tanimlanirken bir adres tasiyacak olan sembolun basina bir yildiz koymamiz yeterlidir. Fonksiyonun icinde bu iki degeri degistirip eski ve yeni degerleri ekrana yaziyoruz. Bu program calistiginda ana programdaki quot;cevizlerquot; in degerinin ayni kaldigini fakat quot;elmalarquot; in yeni degerlerini aldigini goreceksiniz. quot;cevizlerquot; in degerinin ayni kalmasinin nedeni fonksiyona bir deger gecirildiginde C dilinin o degerin bir kopyasini fonksiyona gecirmesi yuzundendir. Programa geri dondugunuzde degerin bir kopyasini kullandigimiz icin asil degerin degismedigini goreceksiniz. quot;elmalarquot; in degerinin degismesi ise yine fonksiyona quot;elmalarquot; degiskeninin adresinin bir kopyasi gecirildigi halde bu adres ana programdaki quot;elmalarquot; a karsilik geldigi icin fonksiyonda bu adresteki degeri degistirir degistirmez quot;elmalarquot; in da degeri degismis olur. ODEV 1. Bir karakter katari tanimlayin ve icine quot;strcpyquot; ile bilgi koyun. Bir dongu ve pointer ile katari harf-harf (teker teker) ekrana yazin. Programin basinda pointer'i katarin ilk elemanina atayin daha sonra cift arti isareti ile pointer'in degerini arttirin. Ayri bir tamsayi degiskeni ile kac karakter yazilacagini kontrol edin.. 2. 1. deki programi pointeri katarin sonuna atayip cift eksi isaretini kullanarak sondan basa dogru yazmasi icin degistiriniz. c++ dersleri 8.bölüm C Dili - 9. Konu Standart Input/Output BASITIO.C: ================================================= #include lt;stdio.hgt; /* input/output icin standard header / main() { char c; printf(quot;Herhangi bir tusa basin. X = Programi durdurur. nquot;); do { c = getchar(); / klavyeden bir tus okuyalim / putchar(c); / ekranda gosterelim. / } while (c != 'X'); / ta ki okunan bir X oluncaya dek... / printf(quot;nProgramin sonu.nquot;); } ================================================ Standart I/O deyimi verinin girildigi ve ciktigi en normal yerleri klavyeyi ve ekrani kast eder. Bu kutuge ilk baktiginizda quot;#include lt;stdio.hgt;quot; komutunu goreceksiniz. Bu komut on-derleyiciye kucuktur ve buyuktur isaretleri arasinda yer alan kutuk isminin programa eklenmesini soyler. Bazen lt; gt; isaretleri yerine den-den quot; quot; isaretleri de gorebilirsiniz. Aralarindaki fark lt;gt; isaretlerinin on-derleyiciye su anda calistiginiz diskte / dizinde degil de bu tip kutuklerin konuldugu yerde aramasini bildirir. Halbuki den-den isaretleri ile belirlenmis bir kutuk ismi sizin su anda bulundugunuz disk / dizinde aranir. Genellikle quot;bu tip kutuklerin konuldugu yerquot; derleyiciye daha onceden belirtilir. Ornegin Quick C derleyicisinde derleyiciye girmeden once: SET INCLUDE=C:INCLUDE yazmak derleyicinin bundan sonra butun 'include' edilecek yani eklenecek kutuklerin C: diskinin INCLUDE dizininde aranmasini belirtir. Sonu .h ile biten kutuklerin ozel bir fonksiyonu vardir. Bunlara header yada baslik kutukleri denir. Genellikle iclerinde bazi fonksiyonlari kullanmak icin gereken tanimlamalar yer alir. Bu kullandigimiz quot;stdio.hquot; kutugu ise bir suru quot;#definequot; komutundan olusur. C DE INPUT/OUTPUT ISLEMLERI C dilinde lisanin bir parcasi olarak tanimlanmis input/output komutlari yoktur bu nedenle bu fonksiyonlarin kullanici tarafindan yazilmasi gereklidir. Her C kullanan kisi kendi input/output komutlarini yazmak istemediginden derleyici yazarlari bu konuda calisma yapmislar ve bize bir suru input/output fonksiyonlari saglamislardir. Bu fonksiyonlar standart hale gelmislerdir ve hemen her C derleyicisinde ayni input/output komutlarini bulabilirsiniz. C nin lisan tanimi Kernigan ve Richie tarafindan yazilmis bir kitaptir ve onlar bu gorecegimiz input/output fonksiyonlari bu kitaba katmislardir. Bu quot;stdio.hquot; isimli kutugu incelemenizde fayda vardir. Icinde bircok anlamadiginiz nokta olacaktir fakat bazi kisimlar tanidik olacaktir. DIGER INCLUDE KUTUKLERI C de buyuk programlar yazmaya basladiginizda programlari ufak parcalara ayirip ayri ayri derlemek isteyebilirsiniz. Bu degisik parcalarin ortak kisimlarini tek bir kutukte toplayip bir degisiklik gerektiginde sadece o ortak kutukten yapmayi isteyebilirsiniz (ornegin global degisken tanimlari.) Bu gibi durumlarda quot;#includequot; kutukleri cok faydali olacaktir. quot;BASITIOquot; YA GERI DONELIM quot;cquot; isimli degisken tanimlanir ve ekrana mesaj yazilir. Daha sonra kendimizi quot;cquot; buyuk harf X e esit olmadigi surece devam eden bir dongunun icinde buluyoruz. Bu programdaki iki yeni fonksiyon su an icin ilgi noktamiz. Bunlar klavyeden bir tus okumak ve ekrana bir karakter yazmayi saglarlar. quot;getchar()quot; isimli fonksiyon klavyeden okudugu tusu dondurur bu deger quot;cquot; ye atanir. quot;putchar()quot; fonksiyonu ise bu degeri ekrana yansitir. Bu programi derleyip calistirdiginizda bir surpriz ile karsilasacaksiniz. Klavyeden yazdiginizda ekrana herseyin iyi bir sekilde yansitildigini goreceksiniz. RETURN tusuna bastiginizda ise butun satirin tekrar ekrana yazildigini goreceksiniz. Her karakteri teker teker ekrana getirmesini soyledigimiz halde programimiz sanki butun satiri sakliyor gibi. DOS BIZE YARDIMCI OLUYOR (YADA ISE KARISIYOR) Bu durumu anlayabilmek icin DOS un nasil calistigini anlamamiz gereklidir. Klavyeden tuslar DOS kontrolu ile okundugu zaman RETURN tusu basilana dek basilan tuslar bir sahada saklanir. RETURN basilinca da butun satir programa dondurulur. Tuslara basilirken karakterler ekrana da yansitilir. Bu duruma da quot;ekoquot; ismi verilir. Simdi anlatilanlari goz onunde bulundurarak programimiz calisirken ekrana eko edilenlerin DOS tarafindan yapildigini anlayabilirsiniz. Siz RETURN e basinca da bu saklanan tuslar programa gonderilir. Bunu daha iyi anlamak icin icinde buyuk harf X olan bir satir yazin. DOS buyuk X in ozel bir tus oldugundan habersiz siz RETURN e basana kadar tuslari kabul etmeye devam eder. RETURN e basinca ise bu katar programa gecirilir ve program X e rastlayincaya kadar ekrana karakterleri birer birer yazar. Isletim sisteminin bu tuhafliklari karsisinda yilmayin. Bazi programlarinizda bu ozellik isinize yarayabilir. Fakat simdi biz az once yazdigimiz programin dusundugumuz gibi calismasini saglayalim. TEKIO.C: ================================================= #include lt;stdio.hgt; main() { char c; printf(quot;Herhangi bir tusa basin. X = Programi durdurur. nquot;); do { c = getch(); / bir tus oku / putchar(c); / basilan tusu goster / } while (c != 'X'); / ta ki c == 'X' olana dek / printf(quot;nProgramin sonu.nquot;); } ================================================= Bu programdaki yegane degisiklik olan yeni fonksiyon quot;getch()quot; yine klavyeden tek bir karakter okur. Farki quot;getcharquot; gibi DOS'a takilmamasidir. Bir karakter okur ve ekrana yansitmadan bu tusu programa dondurur. Bu programi calistirdiginizda bir oncekindeki gibi tekrarlanan satirlar olmadigini goreceksiniz. Ayrica program artik 'X' e basar basmaz durmaktadir. Burada baska bir problemimiz var. RETURN'e basinca cursor ekranin soluna gitmektedir ama bir alt satira inmemektedir. SATIR ATLAMAMIZ LAZIM Cogu uygulama programi siz RETURN e basinca program o RETURN e ek olarak bir de quot;Line Feedquot; yani satir atlama karakteri ilave eder. Satir atlama otomatik olarak yapilmaz. Bundan sonraki programda bu sorunu da halletmis olacagiz. IYIIO.C: ================================================ #include quot;stdio.hquot; #define CR 13 / CR sembolunu 13 olarak tanimlar / #define LF 10 / LF sembolunu 10 olarak tanimlar / main() { char c; printf(quot;Tuslara basin. Durmak icin X e basin.nquot;); do { c = getch(); / Bir karakter oku / putchar(c); / basilan tusu ekrana yaz / if (c == CR) putchar(LF); / sayet basilan RETURN tusu ise bir SATIR ATLAMA karakteri yolla / } while (c != 'X'); printf(quot;nProgramin sonu.nquot;); } ================================================ Programin ilk basinda CR 'nin artik 13 e esit oldugunu ve LF nin de 10 oldugunu belirtiyoruz. Sayet ASCII tablosundan bakarsaniz RETURN tusuna karsilik gelen kodun 13 oldugunu gorursunuz. Ayni tabloda satir atlama kodu da 10 dur. Ekrana basilan tusu yazdiktan sonra sayet bu tus RETURN tusu ise bir satir atlayabilmemiz icin satir atlama kodunu ekrana yaziyoruz. Programin basindaki quot;#definequot; lar yerine quot;if (c == 13) putchar(10);*quot; diyebilirdik fakat ne yapmak istedigimiz pek belirgin olmazdi.

07-09-2008	#8 (permalink)
Arthur	Cevap: C Programlama Dili HANGI METOD DAHA IYI? Burada ekrandan bir harf okumanin iki yolunu inceledik. Her ikisinin de avantajlari ve dezavantajlari var. Bunlara bir bakalim. Ilk metodda butun isi DOS ustlenmektedir. Programimiz baska islerle ugrasirken DOS bizim icin satiri hazirlayabilir ve RETURN'e basilinca bu satiri programa dondurebilir. Fakat bu metodda karakterleri basildiklari anda fark etmemiz imkansizdir. Ikinci metodda tuslari teker teker fark etmemiz mumkundur. Fakat program bu okuma sirasinda butun zamanini okumaya harcar ve baska bir is yapamaz ve bilgisayarin tum zamanini bu isle almis oluruz. Hangi metodun uzerinde calistiginiz program icin daha uygun oldugunu programci olarak siz karar vereceksiniz. Burada quot;getch()quot; fonksiyonun tersi olan quot;ungetch()quot; isimli bir fonksiyon daha oldugunu da belirtmeliyim. Sayet bir karakteri quot;getch()quot; le okuduktan sonra fazla okudugunuzu fark ederseniz bu fonksiyon ile okunan tusu geri koyabilirsiniz. Bu bazi programlarin yazilimini kolaylastirmaktadir cunku bir tusu istemediginizi onu okuyuncaya kadar bilemezsiniz. Sadece bir tek tusu quot;ungetchquot; edebilirsiniz fakat genellikle bu yeterlidir. BIRAZ TAMSAYI OKUYALIM TAMOKU.C: ================================================= #include lt;stdio.hgt; main() { int deger; printf(quot;0 ila 32767 arasinda bir rakam yazin durmak icin 100 girin.nquot;); do { scanf(quot;%dquot;°er); /* bir tamsayi oku (adresi ile) / printf(quot;Okunan deger %d idi. nquot;deger); } while (deger != 100); printf(quot;Programin sonunquot;); } =============================================== Alistigimiz tip bir program olan TAMOKU'da quot;scanfquot; isimli yeni bir fonksiyon goruyoruz. Cok kullandigimiz quot;printfquot; fonksiyonuna cok benzeyen bu fonksiyonun gorevi istenilen tip verileri okuyup degiskenlere atamak. quot;printfquot; den en buyuk farki quot;scanfquot; in degisken degerleri yerine adreslerini kullanmasidir. Hatirlayacaginiz gibi bir fonksiyonun parametrelerinin degerlerini degistirebilmesi icin degiskenin adresine ihtiyaci vardir. quot;scanfquot; fonksiyonuna adres yerine deger gecirmek C dilinde en SIK rastlanan hatalardan biridir. quot;scanfquot; fonksiyonu girilen satiri satirdaki bosluklara bakmadan ve bu sekilde kullanildiginda rakam olmayan bir karakter bulana kadar bir tamsayi okur. Sayet 32766 den buyuk bir rakam girerseniz programin hata yaptigini gorursunuz. Ornegin 65536 girerseniz programin 0 degerini dondurdugunu gorursunuz. Buna sebep tamsayilarin hafizada saklanisinda onlara 16 bitlik bir saha ayrilmasindandir. Programinizda daha buyuk rakamlar kullanacaksaniz 'long' yada 'float' tiplerini secebilirsiniz. KARAKTER KATARI GIRISI KATARIN.C: ================================================ #include lt;stdio.hgt; main() { char big[25]; printf(quot;Karakter katari girin en fazla 25 karakter.nquot;); printf(quot;Birinci kolonda X yazarak programi bitirin.nquot;); do { scanf(quot;%squot;big); printf(quot;Yazdiginiz katar -gt; %snquot;big); } while (big[0] != 'X'); printf(quot;Programin sonu.nquot;); } ================================================== Bu program bir oncekine cok benzer fakat bu sefer bir kelime katari giriyoruz. 25 elemanli bir dizi tanimlanmistir fakat en son deger bir '0' olmasi gerektiginden kullanilabilen kisimi 24 dur. quot;scanfquot; deki degiskenin onune amp; ampersand isareti gerekmez cunku koseli parantezleri olmayan bir dizi degiskeni C dilinde o dizinin baslangicini gosteren bir adrestir. Calistiginizda sizi bir supriz bekliyor. Yazdiginiz cumleyi program ayri satirlarda gosterir. Bunun sebebi quot;scanfquot; bir katar okurken satirin sonuna yada bir bosluga rastlayincaya kadar okumasina devam eder. Bir dongu icinde oldugumuzdan program tekrar tekrar quot;scanfquot; i cagirarak DOS'un giris sahasinda kalan butun karakterleri okur. Cumleleri kelimelere boldugunden X ile baslayan herhangi bir kelimeye rastlayinca bu program durur. 24 karakterden daha fazlasini girmeye calisin. Ne olduguna bakin. Size bir hata mesaji verebilir yada programiniz aleti kilitleyebilir. Gercek bir programda boyle seylerin sorumlulugu sizlerin omuzlarinizdadir. C dilinde yazdiginiza size cok sey duser fakat ayni zamanda bircok kolaylik da saglar. C DE INPUT/OUTPUT PROGRAMLAMA C dili cok miktarda input/output yapan programlar icin degil de bir bircok icsel islemler yapan sistem programlari icin yazilmistir. Klavye'den bilgi alma rutinleri cok kullanislidir fakat C size az yardimci olur. Yani yapmaniz gereken I/O islemlerinde sorun cikmasini onlemek icin detaylarla sizin ugrasmaniz lazimdir. Fakat genellikle herhangi bir program icin bu tip fonksiyonlari bir defa tanimlamaniz yeterlidir. HAFIZADA.C: ================================================= main() { int rakam[5] sonuc[5] index; char satir[80]; rakam[0] = 5; rakam[1] = 10; rakam[2] = 15; rakam[3] = 20; rakam[4] = 25; sprintf(satirquot;%d %d %d %d %dnquot;rakam[0]rakam[1] rakam[2]rakam[3]rakam[4]); printf(quot;%squot;satir); sscanf(satirquot;%d %d %d %d %dquot;amp;sonuc[4]amp;sonuc[3] (sonuc+2)(sonuc+1)sonuc); for (index = 0;index lt; 5;index++) printf(quot;Sonuc %d dir. nquot;sonuc[index]); } ================================================= Bu programda birkac tane degisken tanimliyoruz ve quot;rakamlarquot; isimli diziye de quot;sprintfquot; fonksiyonunu incelemek icin rastgele sayilar atiyoruz. Bu fonksiyon quot;printfquot; e cok benzer. Yegane farki ciktisini ekrana yazmak yerine bir karakter dizisine yazmasidir. Bunu da ilk parametresi olarak veriyoruz. Yani program bu fonksiyondan dondukten sonra quot;satirquot; dizisinin icinde bes tane rakam olacaktir. Ikinci ile ucuncu rakamlar arasindaki bosluk quot;sscanfquot; fonksiyonunun bunlarin uzerinden atlamasini gormek icindir. Bunun altinda quot;printfquot; i kullanarak bu hazirladigimiz satiri yaziyoruz. Daha sonra gordugunuz quot;sscanfquot; fonksiyonu ise quot;scanfquot; gibi ekrandan okumak yerine bizim quot;satirquot; dizimizden degerleri okur. Gordugunuz gibi quot;sscanfquot; e rakamlarin konacagi dizinin adreslerini cok degisik sekillerde verebiliyoruz. Ilk ikisi sadece dizideki 5. ve 4. elemanlarin adreslerini index vererek tanimliyorlar sonraki ikisi ise dizinin baslangic adresine bir offset (bir rakam) ekleyerek buluyorlar. Sonuncusu ise koseli parantezi olmayan bir dizinin o dizinin baslangic elemaninin adresini gostereceginden hicbir sey gerektirmiyor. Bazen bir programin ciktilarini standart ciktidan (ekrandan) bir baska kutuge yoneltmek istenir. Fakat hata mesajlarini gibi bazi mesajlari hala ekrana yollamak isteyebilirsiniz: OZEL.C: ================================================= #include lt;stdio.hgt; main() { int index; for (index = 0;index lt; 6;index++) { printf(quot;Bu satir standart ciktiya gidiyor.nquot;); fprintf(stderrquot;Bu satir ise standart hataya gidiyor.nquot;); } exit(4); / Bu komut DOS 'un ERRORLEVEL komutu ile bir batch file'da (yigit kutugunde) kontrol edilebilir. Bu programin d#8221;nd£rd£g£ deger soyle kontrol edilebilir: Agt; COPY CON: DENE.BAT lt;RETURNgt; OZEL IF ERRORLEVEL 4 GOTO DORT (Dortten kucukse buraya devam eder..) . . GOTO BITTI ORT (dort yada buyukse buraya devam eder) . . :BITTI lt;F6gt; lt;RETURNgt; / } ================================================== Bu program bir dongu ve icinde iki satirdan olusur. Bu satirlardan bir tanesi standart ciktiya bir tanesi de standart hataya gider. Burada gordugunuz quot;fprintfquot; komutu quot;printfquot; e cok benzer fakat ciktinin nereye gidecegini de belirtmenizi saglar. Bu alanda bir sonraki konuda daha uzun duracagiz. Program calisinca ekranda on iki tane satir goreceksiniz. Sayet bu programi: Agt; OZEL gt; CIKTI seklinde calistirirsaniz ekranda sadece alti tane standart hataya giden mesajlari goreceksiniz. Geri kalan (standart ciktiya giden) alti tanesi ise quot;ciktiquot; isimli kutukte yer alacaktir. YA exit(4) KOMUTU ? Bu programdaki en son satir olan quot;exit(4)quot; komutu programi sona erdirir ve dort degerini DOS a dondurur. Parantezlerin arasinda 0 ila 9 degerleri kullanilabilir. Sayet bir quot;batchquot; (yigit) kutugu icinde bu programi calistiriyorsaniz bu degeri ERRORLEVEL komutu ile kontrol edebilirsiniz. ODEV 1. Bir dongu icinde bir harf okuyun ve ekrana bu harfi normal quot;charquot; tipinde gosterin. Bu harfi bir rakam olarak da gosterin. Programi durdurmak icin dolar sembolunu bekleyin. quot;getch*quot; fonksiyonunu kullanarak programin tusa basilir basilmaz islemesini saglayin. F tuslari gibi ozel tuslara basarak ne oldugunu kaydedin. Her fonksiyon tusundan iki tane deger donecektir. Birincisi sifir olup ozel bir tusa basildigini haber verecektir.

07-09-2008	#9 (permalink)
Arthur	Cevap: C Programlama Dili DIKKAT DIKKAT DIKKAT Bu noktada C nin en sasirtici ve en cok yapilan hatasina rastliyoruz. quot;getcquot; fonksiyonundan geri donen degisken bir karakterdir dolayisi ile bunu quot;charquot; tipi bir degiskene atayabiliriz. Hatirlayalim ki bir quot;charquot; degiskeni 0 ila 255 arasindaki degerleri alabilir. Fakat cogu C derleyicilerinde EOF karakteri -1 olarak tanimlanmistir - yani quot;charquot; degiskeninin disinda - Bu nedenle sayet char kullanirsak program kutugun sonunun geldigini bulamaz ve sonsuz bir dongude takilir. Bunun onune gecmesi kolaydir: EOF karakteri donmesini beklediginiz durumlarda daima quot;intquot; tipi bir degisken kullanin. Sayet sizin derleyiciniz icin EOF karakterinin ne oldugunu ogrenmek isterseniz quot;stdio.hquot; isimli header'i okuyabilirsiniz. KELIME KELIME OKUMAK TEXTOKU.C: ================================================= #include quot;stdio.hquot; main() { FILE fp1; char birkelime[100]; int c; fp1 = fopen(quot;ONSATIR.TXTquot;quot;rquot;); do { c = fscanf(fp1quot;%squot;birkelime); / kutukten bir kelime okuyalim / printf(quot;%snquot;birkelime); / ekrana yazalim / } while (c != EOF); / ta ki EOF olana kadar / fclose(fp1); } ================================================ Bu program nerdeyse bir oncekinin aynisidir. Burada kelime kelime okumak icin quot;fscanfquot; fonksiyonunu kullaniyoruz cunku quot;fscanfquot; fonksiyonu bir bosluga gelince okumayi birakir. FAKAT BIR PROBLEM VAR Programi inceleyince verinin kutukten okundugunu ekrana yazildigini ve daha sonra EOF olup olmadiginin kontrol edildigini goruyoruz. Bu nedenle istemedigimiz birsey ekrana yazilmis oluyor. Buyuk ihtimalle programin sonunda en son kelimeyi bir daha yaziyoruz - cunku zaten quot;birkelimequot; nin icinde idi o deger. Buna mani olmak icin bir baska program gorelim. Ismi IYIOKU.C olsun: IYIOKU.C: ================================================ #include quot;stdio.hquot; main() { FILE fp1; char birkelime[100]; int c; fp1 = fopen(quot;onsatir.txtquot;quot;rquot;); do { c = fscanf(fp1quot;%squot;birkelime); /* kutukten bir kelime oku... / if (c != EOF) printf(quot;%snquot;birkelime); / ekrana yaz... / } while (c != EOF); / ta ki EOF olana dek.. / fclose(fp1); / kutugu kapa / } ================================================ Gordugunuz gibi bir quot;ifquot; komutu ile sayet kutugun sonuna gelip gelmedigimize bakiyoruz. Aslinda bu problem KAROKU.C da da vardi fakat orada pek gorunmuyordu. SONUNDA BUTUN BIR SATIR OKUYORUZ SATIROKU.C: ================================================= #include quot;stdio.hquot; main() { FILE fp1; char birkelime[100]; char c; fp1 = fopen(quot;ONSATIR.TXTquot;quot;rquot;); do { c = fgets(birkelime100fp1); / bir satir okuyalim / if (c != NULL) printf(quot;%squot;birkelime); / ekrana yazalim / } while (c != NULL); / ta ki NULL olana kadar.. / fclose(fp1); } =============================================== Bu program simdiye de gorduklerimize benziyor fakat NULL isimli yeni bir nesne de katildi. quot;fgetsquot; fonksiyonu ile bir butun satiri ve sonundaki yeni satir karakterini (n) bir diziye okur. Ilk parametre olarak donen karakterleri koyacagimiz yerin adresi tanimlanir ikinci parametrede en fazla kac karakter okunmasina izin verecegimizi belirtiyoruz ve son olarak da kutuk degiskeninin ismini veriyoruz. o Yani bu fonksiyon ya bir yeni satir karakterine rastlayana kadar yada izin verilen karakter sayisi eksi bir kadar okur. Eksi birin sebebi ise katarin sonunu belirten () sifir degerine yer birakmasidir. Tabi sonunda kutugu kapatiyoruz.. DEGISKEN BIR KUTUK ISMI HERKUTUK.C: ================================================ #include quot;stdio.hquot; main() { FILE fp1; char birkelime[100]kutukismi[25]; char c; printf(quot;Kutuk ismini girin -gt; quot;); scanf(quot;%squot;kutukismi); /* istenilen kutuk ismini alalim / fp1 = fopen(kutukismiquot;rquot;); do { c = fgets(birkelime100fp1); / kutukten bir satir okuyalim / if (c != NULL) printf(quot;%squot;birkelime); / ekrana yazalim / } while (c != NULL); / ta ki NULL olana kadar / fclose(fp1); } =============================================== Burada ilk once kullanicidan quot;scanfquot; ile kutuk ismini kullanicidan aliyoruz daha sonra kutugu acip satir satir ekrana yaziyoruz. YAZICIYA NASIL BIRSEY YOLLAYABILIRIZ PRINTDAT.C: ================================================ #include quot;stdio.hquot; main() { FILE guzelprinter; int c; guzel = fopen(quot;onsatir.txtquot;quot;rquot;); / kutugu acalim / printer = fopen(quot;PRNquot;quot;wquot;); / printeri acalim / do { c = getc(guzel); / kutukten bir karakter okuyoruz / if (c != EOF) { putchar(c); / ekranda goruntuleyelim / putc(cprinter); / ve yaziciya yollayalim / } } while (c != EOF); / ta ki (End Of File) kutuk bitene kadar / fclose(guzel); fclose(printer); } =============================================== Okumak icin quot;onsatir.txtquot; yi actiktan sonra yazmak icin quot;PRNquot; isimli kutugu aciyoruz. Printere bir bilgi yollamak ayni bir kutuge yazmak gibidir fakat standart bir kutuk ismi kullanmak zorundayiz. Bu konuda kesin standartlar yoktur fakat genellikle bu isimler quot;PRNquot; quot;LPTquot; quot;LPT1quot; yada quot;LPT2quot; dir. Bazi yeni derleyicilerin quot;stdprnquot; diye onceden tanimli bir kutuk tanimliyicilari vardir. Bu sayede siz printer'i bir kutuk gibi acmadan ona veri yollayabilirsiniz. Program birer birer butun kutugu okuyup ekranda gosterir ve printer'e yollar. EOF kutuk sonu bulundugunda kutukler kapanir ve programv biter. ODEVLER: 1. Okunacak yazilacak kutuklerin isimlerini kullaniciya soran daha sonra bu ikisini ve printer kutugunu acan bir program yazin. Program bunlari actiktan sonra kutuk sonu gelinceye kadar okunacak kutugu harf harf okuyup yazilacak kutuge ve yaziciya bu karakteri yollamalidir. 2. Programiniz kullaniciya bir kutuk ismi sorsun cevabi alinca da bu kutugu ekranda satir numaralari ile birlikte gostersin.. c dersleri 10.bölüm Structure ve Union'lar STRUCTURE NEDIR? Not: Structure'un tam tercumesi herhalde 'Yapi' olacak.. Bir structure kullanici tarafindan tanimlanmis bir veri tipidir. Su ana kadar kullandigimiz veri tiplerinden cok daha karmasik olanlari tanimlayabilirsiniz. Bir structure daha once tanimlanmis olan veri tiplerinin bir araya gelmis halidir - ki bu veri tiplerine daha once tanimladigimiz structure'lar da dahildir. Bu tanimi rahat anlamanin bir yolu structure'un veriyi kullaniciya yada o programi kullanacak olan kisiye daha rahat bir sekilde gruplamak icin kullanildigini belirtebiliriz. Her zamanki gibi bir seyi anlamanin en iyi yolu orneklere bakmaktir... STRUCT1.C: ================================================ main() { struct { char bas_harf; / Soyadin bas harfi / int yas; / cocugun yasi / int not; / okulda not ortalamasi (100 uzerinden) / } oglankiz; oglan.bas_harf = 'R'; oglan.yas = 15; oglan.not = 75; kiz.yas = oglan.yas - 1; / o oglandan bir yas kucuk / kiz.not = 82; kiz.bas_harf = 'H'; printf(quot;%d yasindaki %c'nin aldigi not %d dir.nquot; kiz.yas kiz.bas_harf kiz.not); printf(quot;%d yasindaki %c'nin aldigi not %d dir.nquot; oglan.yas oglan.bas_harf oglan.not); } ================================================ Program bir structure tanimi ile basliyor. quot;structquot; kelimesinden sonra kume isaretleri arasinda bazi basit degiskenler goruyorsunuz. Bu degiskenler bu structure'i olusturan parcalardir. Kapanan kume isaretinden sonra iki tane degisken ismi goruyorsunuz: quot;oglanquot; ve quot;kizquot;. Bu structure'un tanimina gore quot;oglanquot; artik 3 elemandan olusan bir degiskendir. Bunlar quot;bas_harfquot; quot;yasquot; ve quot;notquot; dur ve herbiri kendi tiplerinde bir veriyi saklayabilirler. quot;kizquot; degiskeninin de ayni 3 elemani vardir fakat bu baska bir degiskendir. Yani 6 tane basit degisken tanimlamis olduk.. TEK BIR BIRLESIK DEGISKEN quot;oglanquot; degiskenini daha yakindan izleyelim. Daha once soyledigimiz gibi quot;oglanquot; in her elemani basit birer degiskendir ve bu tip bir degiskenin kullanilabilecegi heryerde kullanilabilir. Ornegin quot;yasquot; elemani bir tamsayi degiskenidir dolayisiyla bir C programinda bir tamsayi degiskeninin kullanilabilecegi her yerde kullanilabilir. Hesaplamalarda bir sayac olarak I/O islemlerinde vs. Yegane problem bu quot;yasquot; isimli basit degiskeni quot;oglanquot; ile beraber kullanmamiz gerekir. Bunu yapmak icinde ikisini de yaziyoruz ve arasina bir nokta isareti koyuyoruz. Oyleyse tum degisken ismi olan quot;oglan.yasquot; quot;oglanquot; degiskeninin quot;yasquot; sahasi oluyor.. Bu yapiyi bu sahaya erismek istedigimiz heryerde kullanabiliriz. Hatta sadece quot;oglanquot; yada quot;yasquot; dememiz kabul edilmeyecektir. Tek baslarina isimlerin bir manasi yoktur. DEGISKENLERE DEGER ATAMA Yukardaki tanimlamayi kullanarak quot;oglanquot; ve quot;kizquot; 'in her uc sahasina (quot;bas_harfquot;quot;yasquot;quot;notquot;) degerler ayabiliriz. Dikkat etmeniz gereken bir nokta quot;oglan.bas_harfquot;'in bir quot;charquot; tipi oldugudur. Bu nedenle programda karakter verisine atanmistir. quot;oglanquot; in geri kalan iki sahasi da tanimlandiklari 'tiplerde' degerlere atanir.. Sonra quot;kizquot; isimli degiskenin 3 sahasi da degerlere atanir. Burada atama sirasinin fark etmeyecegini gosterebilmek icin farkli bir sira izlenmistir. BU DEGERLERI NASIL KULLANABILIRIZ?? Alti basit degiskenimizin her elemanina veri atadiktan sonra onlarla diledigimizi yapabiliriz. Bu ilk ornegi basit tutmak icin biz sadece degerlerini ekrana yazdiriyoruz. quot;printf*quot; satirinin alistigimizdan farkli olmadigini goreceksiniz. Structure'lar programi daha kolay yazmak ve anlamak icin cok faydali bir gruplama metodudur. Bu ilk ornek cok basit oldugundan size structure'un gercek degerini gostermekten acizdir fakat okumaya devam ederseniz structure'un gercekten faydali oldugunu goreceksiniz.

07-09-2008	#10 (permalink)
Arthur	Cevap: C Programlama Dili BIR UNION ORNEGI DAHA UNION2.C: ================================================ #define OTO 1 #define TEKNE 2 #define UCAK 3 #define GEMI 4 main() { struct otomobil { /* bir otomobil icin structure / int tekerlekler; int camurluklar; int kapilar; }; typedef struct { / bir gemi yada tekne icin structure / int su_kesimi; char boyu; } TEKNEDEF; struct { char tasit; / ne cins tasit ? / int agirlik; / tasitin gros agirligi / union { / tipe-bagimli bilgi / struct otomobil oto; / union'un birinci kismi / TEKNEDEF tekne; / union'un ikinci kismi / struct { char motorlar; int kanat_acikligi; } ucak; / union'un 3uncu kismi / TEKNEDEF ship; / union'un 4uncu kismi / } tasit_tip; int deger; / tasitin bin TL olarak degeri / char sahibi[32]; / sahibinin ismi / } ford sun_fish piper_cub; / 3 structure degiskeni / / birkac sahayi tanimlayalim / ford.tasit = OTO; ford.agirlik = 2742; / deposu dolu iken / ford.tasit_tip.oto.tekerlekler = 5; / istepne dahil / ford.tasit_tip.oto.kapilar = 2; sun_fish.deger = 3742; / trailer haric / sun_fish.tasit_tip.tekne.boyu = 5; piper_cub.tasit = UCAK; piper_cub.tasit_tip.ucak.kanat_acikligi = 9; if (ford.tasit == OTO) / evet oyle / printf(quot;Ford'un %d tekerlegi var.nquot;ford.tasit_tip.oto.tekerlekler); if (piper_cub.tasit == OTO) / hayirdegil / printf(quot;Ucagin %d tekerlegi var.nquot;piper_cub.tasit_tip. oto.tekerlekler); } ============================================== Bu ornekte union'larin cok rastlanilan bir kullanim tarzini goruyorsunuz. Dusunun ki bircok tip tasittan olusan bir veri bankasi (veri tabani) olusturmak istiyoruz. Bir arabadaki pervane sayisi yada bir teknedeki tekerlek sayisini koymak komik olurdu. Verimli bir veri tabani olusturmak icin bir kismi her cins tasit icin degisik bir kismi ayni tip kalan verileri saklamaniz gerekecektir. Burada bir structure tanimliyoruz ve bunun icine gidebilecek degisik tiplere karar veriyoruz. Ilk once #definelarla bazi sabitler tanimliyoruz daha sonra icindekilerin size hic te yabanci gelmeyecegi quot;otomobilquot; isimli bir structure tanimliyoruz fakat degisken tanimlamiyoruz. TYPEDEF KOMUTU Daha sonra quot;typedefquot; ile yeni bir cins veri tanimliyoruz. Bu da quot;intquot; yada quot;charquot; gibi kullanilabilecek tumuyle yeni bir tip tanimliyoruz. Structure'un ismi olmadigini fakat degisken tanimlanacagi yerde quot;TEKNEDEFquot; ismini goruyorsunuz. Artik quot;TEKNEDEFquot; diye bir tipimiz vardir ve bununla istedigimiz heryerde bir structure tanimlayabiliriz. Bu komut degisken tanimlamasi yapmiyor fakat sadece tipi tanimliyor. Buyuk harf kullanmak sadece sahsi tercih icindir fakat bir C standarti degildir. Sadece quot;typedefquot; i bir degisken isiminden ayri tutmaktadir. Daha once yarattigimiz parcalari kullanan buyuk kesime geldik. Bu structure 5 parcadan olusmustur iki quot;tasitquot; ve quot;agirlikquot; isimli basit degisken bir union ve quot;degerquot; ve quot;sahibiquot; isimli iki basit degisken daha. Tabii ki burada onemle bakmamiz gereken union tanimlanmasidir. Bakinca bunun 4 parcadan olustugunu goreceksiniz. Ilk parcasi quot;otoquot; isimli ve daha once tanimladigimiz bir tipte olan degiskendir. Ikinci kismi quot;teknequot; ismindedir ve daha once tanimladigimiz quot;TEKNEDEFquot; tipindedir. Ucuncu kesimi ise quot;ucakquot; isimli ve union icinde tanimlanan bir structure'dur. Sonunda union'un en son parcasi olan quot;gemiquot; isimli degisken de quot;TEKNEDEFquot; tipindedir. Umarim bu dordunun gosterilen 3 mettoddan biri ile tanimlanabilecegi sizin icin aciktir. Normalde herhalde en quot;temizquot; tanim her birinin quot;typedefquot; ile tanimlanmasi sayesinde olacaktir. SIMDI NE OLDU? Simdi icine dort cins veri saklayabilecegimiz bir yapimiz var. Her kayitin uzunlugu en buyuk union'u tasiyan kayitin uzunlugunda olacaktir. Bu durumda birinci kesim en buyugudur cunku 3 tamsayi degiskeninden olusmaktadir. Digerleri ise bir karakter ve bir tamsayidan olusmaktadirlar. Yani bu union'un ilk parcasi bu tipteki butun structure'larin boyunu belirleyecektir. Elde edilen structure her dort tip veriden birini saklamasi icin kullanilabilir fakat bu tip bir bir degiskenin icinde neler saklandigini kontrol etmek programcinin isidir. quot;tasitquot; isimli degisken orada ne tip bir tasit saklandigini belirtmek icin kullanilmistir. Programin basindaki dort #define satiri quot;tasitquot; in icinde saklanabilecekleri belirtir. Ortaya cikan yapinin kullanimini gostermek icin birkac ornek de vardir. Bazi degiskenlere degerler atanmis birkac tanesinin degeri ekrana yazilmistir. Union'lar hele yeni programlamaya baslayanlar tarafindan cok SIK kullanilmaz. Bazen rastlayabilirsiniz ve ne ise yaradiklarini bilmenizde fayda vardir. Su an icin detaylarini ogrenmenize luzum yoktur ve bu nedenle bu ornekte fazla vakit harcamayin. Sayet bir gun saha tanimlari degisen bir yapiya ihtiyaciniz olursa o zaman ogrenebilirsiniz. Fakat kendi igiliginiz icin structure'lara alismaya bakin - onlar daha SIK kullanilirlar. ODEV 1. Icinde quot;isimquot; icin bir karakter dizisi quot;ayaklarquot; icin bir tamsayi degiskeni ve quot;kollar*quot; icin bir baska tamsayi degiskeni olan ISIMLI bir structure tanimlayin. Bu structure ile 6 elemanlik bir dizin tanimlayin. Bu sahanin icine degisik bilgiler atayin ve ekrana suna benzer bir cikti saglayin: Bir insanin 2 kolu ve 2 ayagi vardir. Bir kopegin 0 kolu ve 4 ayagi vardir. Bir televizyonun 0 kolu ve 4 ayagi vardir. Bir sandalyenin 2 kolu ve 4 ayagi vardir. vs. 2. Birinci programi tekrar yazip verileri ekrana yazmak icin bir pointer'dan yararlanin.

Konuyu Toplam 1 Üye okuyor. (0 Kayıtlı üye ve 1 Misafir)

Seçenekler
Yazdırılabilir şekli göster Sayfayı E-Mail olarak gönder

Maxi Hayat * Program Deposu * File4Share * Nasıl Yaparız? * Modifiye Otomobiller * Yerli Yabancı Klipler * Html RenkKodları * Program İndir * Oyun İndir *