C dersleri 9

IC ICE VE ISIMLI STRUCTURE'LAR

ICICE.C:
===============================================
main()
{
struct insan {
char isim[25];
int yas;
char durum; /* E = Evli , B = Bekar */
} ;

struct tumveri {
int not;
struct insan ozellikler;
char yemek[25];
} ogrenci[53];

struct tumveri hoca,asistan;

hoca.not = 94;
hoca.ozellikler.yas = 34;
hoca.ozellikler.durum = 'E';
strcpy(hoca.ozellikler.isim,"Mary Smith");
strcpy(hoca.yemek,"Salamli sandvic");

asistan.ozellikler.yas = 87;
asistan.ozellikler.durum = 'E';
strcpy(asistan.ozellikler.isim,"Old Lady Brown");
asistan.not = 73;
strcpy(asistan.yemek,"Yogurt ve ekmek");

ogrenci[1].ozellikler.yas = 15;
ogrenci[1].ozellikler.durum = 'B';
strcpy(ogrenci[1].ozellikler.isim,"Billy Boston");
strcpy(ogrenci[1].yemek,"Findik ezmesi");
ogrenci[1].not = 77;

ogrenci[7].ozellikler.yas = 14;
ogrenci[12].not = 87;

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

Simdiye kadar gordugumuz structure'lar basit fakat kullanisli idi.
Yuzlerce yada binlerce elemandan olusan structure'lar tanimlamak
mumkundur, fakat butun hepsini siradan tanimlamak yerine hierarsik bir
duzen kullanmak, programcinin lehine olur.

Ilk structure'da 3 eleman vardir, fakat arkasindan bir degisken ismi
gelmemektedir. Yani, biz sadece bir structure tanimladik, ve hicbir
degisken tanimlamadik. Basina "insan" ismini koydugumuzdan, bu
structure'un ismi de "insan" dir. Bu isim, bu structure duzenini kullanmak
istedigimizde kullanilir, fakat bu structure degiskenlerinden biri, bu
isimle kullanilamaz. Dolayisi ile, yeni bir tip tanimlamis olduk - ayni
"char" yada "int" gibi, ve neredeyse ayni sekilde, bu yeni tipi
kullanabiliriz.

Bundan sonraki structure tanimlamasi, 3 sahadan olusuyor. Ikinci sahasi,
daha once tanimladigimiz "insan" structure'unu kullaniyor. "insan" tipi
degiskenin ismine "ozellikler" ismini veriyoruz. Yeni structure, iki tane
basit degisken de kullaniyor, "not" isimli tamsayi degiskeni,
"yemek[25]" isimli bir karakter dizisi, ve "ozellikler" isimli bir
structure. "ozellikler" in icinde 3 degisken oldugu icin, bu structure 5
degisken tanimlamis oluyor. Bu structure'a da, "tumveri" ismini veriyoruz,
ki bu da bir baska tip tanimlanmasidir. Sonunda, 53 degiskenlik, ve
"tumveri" tipinde bir dizi tanimliyoruz, ve buna "ogrenci" ismini
veriyoruz. Sayet bunlar sizin icin anlasilir idi ise, her birine deger
atanabilen toplam olarak 53 kere 5 degisken tanimladigimizi gorursunuz.

IKI DEGISKEN DAHA

Bir degisken tipi tanimimiz olduguna gore, onu iki degisken daha
tanimlamada kullanabiliriz. "hoca" ve "assistan" isimli degiskenler de
"tumveri" tipindedir, her birinin icine bilgi konulabilecegimiz , 5 er
sahadan olusurlar.

BU SAHALARIN BAZILARINI KULLANALIM

Bundan sonraki bes satirda, "hoca" 'nin her sahasina bilgi yaziyoruz. Ilk
saha olan "not", daha once gordugumuz diger structure'lar gibi kullanilir,
cunku ic ice structure taniminda degildir. Daha sonra, bu hocanin yasini
kaydetmek istiyoruz, ve bu ise ic ice structure'da bulunuyor. Bu sahaya
erismek icin, "hoca" degiskeni ile baslayip, "ozellikler" grup ismini
ekliyoruz, ve hangi sahasi ile ilgilendigimizi belirtmek icin, "yas"
ismini de ekliyoruz. "durum" ise ayni "yas" gibi kullanilir, fakat son iki
sahaya deger atama ise, karakter katari olduklarindan, "strcpy" fonksiyonu
ile gerceklestirilir.

"strcpy" nin icindeki degisken isimlerinin, bircok parcadan olusmasina
ragmen, hala degisken isimleri olduguna dikkat edin..

"assistan" degiskeni ise, ayni sekilde rastgele bilgilere atanir, fakat
degisik bir sirada. Son olarak bazi "ogrenci" degiskenlerine de atama
yapilir, ve program sona erir.

Bu programi derlediginizde, "stack overflow" hatasi ile
karsilasabilirsiniz. C dili, otomatik degiskenlikleri stack sahasina
gecirerek kullanir, ve cogu derleyici (sayet belirtmezseniz) 2048 byte lik
bir stack sahasi kullanir. Dolayisi ile, stack boyunu degistirmeniz
gerekecektir. Nasil yapilacagi ise, derleyiciden derleyiciye degisir.


STRUCTURE'LAR HAKKINDA DAHA BILGI

Structure'lari, ta ki iyice kafaniz karisincaya kadar ic ice tanimlamak
mumkundur. Duzgun bir sekilde tanimlarsaniz, bilgisayar karistirmaz -
cunku C de buna bir SINIR yoktur.

Structure'lar, baska structure tanimlarindan olusabilir. Bu diger
structure'lar ise, basit degiskenlerden olusmus olabilir. Structure
kullanirken once tutucu, onlari kullanmaya alistikca, daha cesur davranin.

UNION NEDIR?

UNION1.C:
================================================
main()
{
union {
int deger; /* Union'un birinci parcasi */
struct {
char ilk; /* Bu iki deger ise, ikinci.. */
char ikinci;
} yarim;
} rakam;

long index;

for (index = 12;index < 300000;index += 35231) {
rakam.deger = index;
printf("%8x %6x %6xn",rakam.deger, rakam.yarim.ilk,
rakam.yarim.ikinci);
}
}
===============================================

Basitce, bir union sayesinde ayni veriye degisik tipler ile, yada ayni
veriye degisik isimlerle erismenize izin verir.

Bu ornekte, union'un iki parcasi var. Ilki, hafizada iki bytelik bir
degisken olarak saklanan "deger" isimli bir tamsayidir. Ikinci eleman ise,
"ilk" ve "ikinci" isimli iki karakter degiskeninden olusur. Bu iki
degisken, "deger" in saklandigi ayni sahada tutulur - cunku union'un amaci
budur. Bir union ile, hafizada ayni yerde, degisik tip veriler
saklanabilmesini saglar. Bu durumda, "deger" in icine bir tamsayi
koyabilirsiniz, ve bu degeri iki parca halinde "ilk" ve "ikinci" isimli
degiskenler ile alabilirsiniz. Bu teknik genellikle veri bytelarini bir
araya getirip beraber okumak icin kullanilir, ornegin, bir mikroislemcinin
registerlerini beraber okumak icin.

Bir union'daki sahalara erismek, bir structure'un sahalarina erismege cok
benzer, ve bunu ornekten incelemeyi size birakiyoruz.

Bu program calistiginda cogu derleyici, veriler iki tane f ile baslar
gorunecektir. Bu da, heksadesimal ciktinin, karakter degiskeni integer'a
degistirmesi ve +/- bitini sola kaydirmasi yuzunden olur. Ekrana
gostermeden once "char" veri tiplerini "int" tiplerine degistirmek, "ff"
lere mani olacaktir. Bunu yapmak icin, iki yeni "int" tipi degisken
tanimlamaniz gerekecektir, ve onlara "char" tipi degisken degerleri
atamaniz gerekecektir.

Calistirdiginizda, verinin "int" olarak ve iki tane "char" olarak
yazildigini goreceksiniz. "char" tipi degiskenlerin sirasi
degistirilmistir, cunku hafizada bu sekilde saklanmaktadir. Bu konuyu
kendinize dert etmeyin, fakat incelemek isterseniz, cok ilginc bir konu
olabilir.

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("Ford'un %d tekerlegi var.n",ford.tasit_tip.oto.tekerlekler);

if (piper_cub.tasit == OTO) /* hayir,degil */
printf("Ucagin %d tekerlegi var.n",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
"otomobil" isimli bir structure tanimliyoruz, fakat degisken
tanimlamiyoruz.

TYPEDEF KOMUTU

Daha sonra, "typedef" ile yeni bir cins veri tanimliyoruz. Bu da, "int"
yada "char" gibi kullanilabilecek tumuyle yeni bir tip tanimliyoruz.
Structure'un ismi olmadigini, fakat degisken tanimlanacagi yerde,
"TEKNEDEF" ismini goruyorsunuz. Artik, "TEKNEDEF" 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, "typedef" i, bir degisken isiminden ayri tutmaktadir.

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

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

Umarim bu dordunun gosterilen 3 mettoddan biri ile tanimlanabilecegi,
sizin icin aciktir. Normalde, herhalde en "temiz" tanim, her birinin
"typedef" 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.
"tasit" isimli degisken, orada ne tip bir tasit saklandigini belirtmek
icin kullanilmistir. Programin basindaki dort #define satiri, "tasit" 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 "isim" icin bir karakter dizisi, "ayaklar" icin bir tamsayi
degiskeni, ve "kollar" 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.

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

DINAMIK YER ACMA

Dinamik yer acma, ilk karsilastiginizda korkutucu bir tanimdir, fakat
aslinda o kadar zor degildir. Su ana kadar kullandigimiz tum degiskenler,
statik degiskenler idiler. Yani, derleyici tarafindan, derleme yada link
etabinda kendilerine yer ayrilmisti. (Aslinda bazilari "otomatik"
degiskenler olduklarindan, derleyici tarafindan dinamik olarak yer
ayrilmisti, fakat bu bize gorunmuyordu). Dinamik degiskenler, program
yuklendiginde var olmayan, fakat gerektiginde kendilerine hafizada yer
tahsis edilen degiskenlerdir. Bu metod ile, diledigimiz kadar degiskeni
tanimlamak, kullanmak, ve baska degiskenlerin o sahayi kullanmasi icin,
o sahayi tekrar serbest birakabiliriz.

DINLIST.C:
=================================================
main()
{
struct hayvan {
char ismi[25];
char cinsi[25];
int yasi;
} *evcil1, *evcil2, *evcil3;

evcil1 = (struct hayvan *)malloc(sizeof(struct hayvan));
strcpy(evcil1->ismi,"General");
strcpy(evcil1->cinsi,"Karisik Birsey");
evcil1->yasi = 1;

evcil2 = evcil1; /* evcil2 simdi yukaridaki veri
yapisina karsilik geliyor */

evcil1 = (struct hayvan *)malloc(sizeof(struct hayvan));
strcpy(evcil1->ismi,"Bobi");
strcpy(evcil1->cinsi,"Labrador");
evcil1->yasi = 3;

evcil3 = (struct hayvan *)malloc(sizeof(struct hayvan));
strcpy(evcil3->ismi,"Kristal");
strcpy(evcil3->cinsi,"Alman Coban");
evcil3->yasi = 4;

/* Yukardaki bilgiyi yazalim */

printf("%s, bir %sdir ve %d yasindadir.n", evcil1->ismi,
evcil1->cinsi, evcil1->yasi);

printf("%s, bir %sdir ve %d yasindadir.n", evcil2->ismi,
evcil2->cinsi, evcil2->yasi);

printf("%s, bir %sdir ve %d yasindadir.n", evcil3->ismi,
evcil3->cinsi, evcil3->yasi);

evcil1 = evcil3; /* evcil1 simdi evcil3 un gosterdigi
yapiyi gosteriyor */

free(evcil3); /* bir structure'u siliyor */
free(evcil2); /* bu da bir baska structure'u siliyor */
/* free(evcil1); bu yapilamaz - niye? anlatacagim! */
}
==================================================

"hayvan" isimli bir structure tanimlama ile basliyoruz. Bu tanimladigimiz
tip ile bir degisken tanimlamiyoruz, sadece 3 tane pointer tanimliyoruz.
Bu programin dev***** da bakarsaniz, hicbir yerde bir degisken tanimina
rastlayamazsiniz. Guzel. Veriyi saklayabilecegimiz hicbir yer yok.
Elimizdeki yegane sey, 3 tane pointers dir. Birseyler yapabilmek icin,
degiskenler tanimlamamiz gerekli, o zaman dinamik olarak tanimlayalim