Gönderen Konu: BU SAHALARIN BAZILARINI KULLANALIM  (Okunma sayısı 6140 defa)

0 Üye ve 1 Ziyaretçi konuyu incelemekte.

Çevrimdışı Morphosis

  • Üye
  • **
  • İleti: 74
BU SAHALARIN BAZILARINI KULLANALIM
« : 06 Haziran 2008, 12:40:14 ös »
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.

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