C dersleri 10

DINAMIK DEGISKEN TANIMLAMAK

Programin ilk satiri, "evcil1" isimli pointer'a birsey ata***** 3
degiskenden olusan bir dinamik yapi tanimliyor. Programin kalbi, satirin
ortasinda gomulu bulunan "malloc" fonksiyonudur. Bu, baska bilgilere
ihtiyaci olan "hafiza ayir" fonksiyonudur. "malloc" fonksiyonu, normalde,
hafizanin "heap" denilen kesiminde, "n" karakter boyunda, ve karakter
tipinde bir yer ayiracaktir. "n", fonksiyona gecirilen yegane
parametredir. "n" hakkinda birazdan konusacagiz, fakat ilk once "heap":

HEAP NEDIR?

Her derleyicinin calisacak kodun boyu, kac degisken
kullanilabilecegi, kaynak kodun boyu gibi sinirlari vardir. IBM-PC ve
uyumlular icin bu sinir cogu derleyici icin 64K lik bir calisacak kod
boyudur. (Calisacak koddan kastim, ismi EXE yada COM ile biten
kutuklerdir.) Bunun sebebi, IBM-PC nin 64K lik segman boyuna sahip bir
mikroisleyiciye sahip olmasindandir. Daha "uzakta" yer alan veriye ise,
ozel erisme yontemleri gerektirmektedir. Programi kucuk ve verimli tutmak
icin, bu yontemler kullanilmamakta, ve program, cogu programlar icin
yeterli olan 64K lik bir sahaya sigmak zorunlulugundadir.

Heap sahasi, bu 64K lik sahanin disinda bulunan ve programlarin veri ve
degisken saklamak icin kullanilabilecekleri bir yerdir. Veriler ve
degiskenler, sistem tarafindan "malloc" cagirilinca heap'e konur. Sistem,
verinin nereye kondugunu takip eder. Istedigimizde, bir degiskeni tanimsiz
yaparak, heap de bosluklar yaratiriz. Sistem bu bosluklara, yeni "malloc"
tanimlari oldugunda baska veriler ko***** kullanir. Yani, heap'in yapisi
son derece dinamiktir - surekli degisir..

SEGMANLAR HAKKINDA

Daha pahalli derleyiciler, kullanmak istediginiz hafiza tipini secmenizi
saglarlar. Lattice yada Microsoft'un derleyicileri ile, program boyunun
64K nin altinda kalmasini, ve programin daha verimli calismasi ile
programin 640K sinirinda kalmasi, daha uzun adresleme metodu ile daha az
verimli calismasi arasinda bir secim yapabilirsiniz. Uzun adresleme,
segmanlar arasi erisimi gerektireceginden, biraz daha yavas calisan
programlara sebep olacaktir. Yavaslama, cogu programlar icin onemsiz
olacaktir.

Sayet bir programin kodu ve hafiza gereksinimi toplam 64K yi asmiyorsa, ve
stack'i kullanmiyorsa, bir .COM kutugu haline getirilebilir. Bir .COM
kutugu hafizanin bir kopyasi seklinde oldugu icin, cok hizli bir sekilde
yuklenebilir. Halbuki .EXE tipindeki bir kutugun adreslerinin hafizada
yeniden yerlestirilmesi gereklidir. Dolayisi ile ufak hafiza modeli, daha
hizli yuklenen programlar yaratabilir. Bunun hakkinda endiselenmeyin,
birkac programcinin endiselendigi ufak bir detaydir.

Dinamik tanimlama ile, verileri "heap" e saklamak mumkundur. Tabii, lokal
degiskenleri, ve indeks sayaclari tipindeki degisenleri heap de saklamak
istemezsiniz - sadece buyuk dizileri ve structure'lari..

Kucuk hafiza modelinde kalmaktan daha onemli birsey, bilgisayarin
hafizasinin sinirlarinda kalmaktir. Sayet programiniz cok buyuk birkac
saha tanimliyorsa, fakat bunlari ayni zamanda kullanmiyorsa, bir parcasini
dinamik olarak tanimlayip, kullanip, silebilirsiniz. Sonra, ayni sahayi
bir baska veri parcasi icin kullanabilirsiniz.

"malloc" A GERI DONUS

Umarim, "heap" hakkindaki parca, size "malloc" ile ne yaptigimizi
gostermistir. Sadece, sisteme kendisine bir parca hafiza verilmesini talep
edip, bu sahanin ilk elemanina (baslangicina) bir pointer dondurmektedir.
Parantezler arasinda gerekli olan yegane parametre, istenilen blok'un
boyudur. Bu programda, basinda tanimladigimiz structure'u saklayabilecek
bir yere ihtiyacimiz vardir. "sizeof", yeni bir fonksiyondur, en azindan
bize, ve parantezlerinin icindeki parametresinin boyunu byte cinsinden
dondurmektedir. Yani, "hayvan" structure'unun boyunu byte olarak
dondurmektedir. Bu deger "malloc" a dondurulur. Fonksiyonu cagirinca bize
heap'de bir saha ayrilmis oluyor, ve "evcil1" bu sahanin baslangicini
gosteriyor.

CAST NEDIR?

Hala, "malloc" fonksiyonun onunde, tuhaf gorunuslu bir birsey var. Buna
"cast" denir. "malloc" fonksiyonu normalde, ayrilan sahanin baslangicini
gosteren "char" tipli bir pointer dondurur. Cogu zaman, "char" tipli bir
pointer istemeyiz. Biz bu ornekte, "hayvan" structure'unu gosterecek bir
pointer istiyoruz, ve bu nedenle, derleyiciye bu tuhaf yapi ile bunu
belirtiyoruz. Cast'i koymazsaniz, cogu derleyici, pointer'i dogru bir
sekilde dondurecektir, size bir uyari mesaji verip, gayet iyi calisan bir
program yaratacaktir. Iyi programlama teknigi, derleyicinin uyari
mesajlari vermesine mani olmaktir.

DINAMIK OLARAK TANIMLADIGIMIZ SAHAYI KULLANMAK

Structure ve pointer konusu ile ilgili konusmamizi hatirlarsaniz, sayet
bir structure'umuz ve onu gosteren bir pointer'imiz varsa, icindeki
herhangi bir degiskene erisebiliriz. Denemek icin, programin bundan
sonraki 3 satirinda, structure'a degerler atayacagiz. Bu komutlarin statik
olarak tanimli atamalara benzedigini fark edeceksiniz.

Bundan sonraki satirda, "evcil1" in degerini "evcil2" ye atiyoruz. Bunu
yapmak, yeni bir veri yaratmiyor, sadece ayni yeri gosteren iki tane
pointer'imiz oluyor. "evcil2", simdi yarattigimiz structure'u gosterdigi
icin, "evcil1", birbaska dinamik tanimli structure yaratmakta
kullanilabilir.

o "evcil2" yi de yeni dinamik tanim icin kullanabilirdik.

Sonunda, bir baska saha tanimlayip, "evcil3" u bunun baslangicina
atiyoruz.

DINAMIK TANIMLI SAHADAN KURTULMAK

Birbaska yeni fonksiyon ise, "free" dir. Bu fonksiyon, ayirdigimiz hafiza
parcasini tekrar sisteme iade etmekte kullanilir. Kullanimi icin, bloku
gosteren bir pointer'i, parametre olarak gecirin.

Dinamik tanimin bir baska ozelligini gostermek icin, bir baska sey daha
yapiyoruz. "evcil1" in degeri, "evcil3" e ataniyor. Bunu yaparak, "evcil1"
in tuttugu degeri kaybetmis oluyoruz - cunku artik "evcil3" un degerini
tutmaktadir. Dolayisi ile, artik hicbir zaman kullanilamaz. Bu hafiza
sahasi, bu noktadan sonra erisilemez, ve "ziyan" olmustur. Bu, bir
programda normal olarak yapmayacaginiz birseydir - sadece dikkatinizi
cekmek icin konulmustur.

Ilk "free" fonksiyon cagirimi, "evcil1" ve "evcil3" un gosterdigi sahayi
ortadan kaldirir, ikincisi de "evcil2" nin gosterdigi sahayi ortadan
kaldirir. Dolayisi ile, daha once yarattigimiz verileri kaybetmis olduk.
Heap'de bir parca daha bilgi vardir, fakat onun yerini gosteren bir
pointer olmadigi icin, erisilemez. "evcil1" in sahasini tekrar "free"
etmeye calismak, bir hata olacaktir, cunku zaten "evcil3" ile ayni yer
ortadan kaldirilmistir. Fakat endiselenmeye luzum yoktur, cunku DOS a
donunce, butun heap sahasi silinecektir.

BAYAGI COK KONUSTUK

Bu son program hakkinda nerdeyse 4 sayfa konustuk, fakat iyi harcanmis bir
zaman idi bu. Sizin icin dinamik tanimlama hakkinda ogrenmediginiz hicbir
seyin kalmadigini bilmek, sevindirici birsey olmali. Tabii ki, bu sahanin
kullanimi hakkinda bircok sey orgenebilirsiniz, fakat dinamik tanimlama
hakkinda daha fazla ogrenebileceginiz birsey yoktur.

BIR POINTER DIZISI

BUYUKDIN.C:
================================================== ==

main()
{
struct hayvan {
char ismi[25];
char cinsi[25];
int yasi;
} *evcil[12], *point; /* bu, 13 tane pointer ve
0 degisken tanimliyor */

int index;

/* ilk once, dinamik sahayi ivir zivirla dolduralim. */

for (index = 0;index < 12;index++) {
evcil[index] = (struct hayvan *)malloc(sizeof(struct hayvan));
strcpy(evcil[index]->ismi,"General");
strcpy(evcil[index]->cinsi,"Karisik cins");
evcil[index]->yasi = 4;
}

evcil[4]->yasi = 12; /* Bu atamalar, bazi sahalara */
evcil[5]->yasi = 15; /* nasil luzumsuz bilgi */
evcil[6]->yasi = 10; /* yazilabilecegini gosterir. */

/* yukarda tanimladiklarimizi yazalim. */

for (index = 0;index <12;index++) {
point = evcil[index];
printf("%s, bir %s, ve %d yasindadir.n", point->ismi,
point->cinsi, point->yasi);
}

/* Iyi programlama teknigi, dinamik yaratilmis sahanin, */
/* sisteme iade edilmesini soyler.. */

for (index = 0;index < 12;index++)
free(evcil[index]);
}

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

Bu program, bir oncekine cok benzer. Basit tutmak icin, 12 elemanlik bir
pointer dizisi tanimliyoruz, ve bir "point" isimli bir pointer daha
tanimliyoruz.

Size yeni olan "*evcil[12]" terimini biraz anlatmakta fayda var. Burada
yaptigimiz 12 tane pointer'dan olusan bir dizi tanimladik. Ilki "evcil[0]"
ve sonuncusu "evcil[11]". Aslinda, bir diziyi indekssiz kullanmak, o
dizinin adresini verdiginden, kendi basina "evcil" demekle, pointerin
pointerini tanimlamis oluyoruz. Bu C de tumuyle yasaldir, ve hatta daha
ileri de gidebilirsiniz - fakat cabucak kafaniz karisir. Dolayisi ile,
"int ****pt" demek, yasaldir, ve bu bir pointer'in pointer'inin
pointer'inin pointer'ini tanimlar - sayet dogru saydiysam. Iyice C ye
alisincaya kadar bu tip seylerden kacinmanizi tavsiye ederim.

Simdi, 12 tane pointer'imiz var, ve biz bunlar herhangi bir pointer gibi
kullanabiliriz. Bir dongu icinde kendimize dinamik yer acip, icine
istedigimiz verileri yazabiliriz. Rastgele secilmis bazi sahalara yeniden
bilgi atadiktan sonra, ekrana sonuclari yaziyoruz. "point" isimli pointer,
sadece size gosterme amaci ile kullanilmistir. Veri, "evcil[n]" diyerek
tanimlanabilirdi. Son olarak 12 veri bloku "free" ile serbest birakilir ve
program sona erer.

c dersleri 12.bölüm

BUYUK VE KUCUK HARFLER

BUY-KUC.C:
==================================================
#include <STDIO.H>
#include <ctype.h> /* Not: Derleyiciniz bunu gerektirmeyebilir */

main()
{
FILE *fp;
char satir[80], kutukismi[24];
char *c;

printf("Kutuk ismini girin -> ");
scanf("%s",kutukismi);
fp = fopen(kutukismi,"r");

do {
c = fgets(satir,80,fp); /* bir satir oku */
if (c != NULL) {
karistir_butun_karakterleri(satir);
}
} while (c != NULL);

fclose(fp);
}

karistir_butun_karakterleri(satir)

/* Bu fonksiyon butun buyuk harfleri kucuge, butun kucukleri
de buyuge cevirir. Diger butun karakterleri etkilemez. */

char satir[];
{
int index;

for (index = 0;satir[index] != 0;index++) {
if (isupper(satir[index])) /* buyuk harfse,1 doner */
satir[index] = tolower(satir[index]);
else {
if (islower(satir[index])) /* kucuk harfse,1 doner */
satir[index] = toupper(satir[index]);
}
}
printf("%s",satir);
}
=================================================

Bu basit programdaki yeni fonksiyonlar sunlardir:

isupper(); Karakter buyuk harfmidir?
islower(); Karakter kucuk harfmidir?
toupper(); Karakteri buyuk harf yap.
tolower(); Karakteri kucuk harf yap.


ilk fonksiyon, sayet parametresi olarak gecirilen deger, buyuk harf ise
('A'-'Z'), 1 degerini dondurur, sayet baska bir karakter ise, 0 degeri doner.

ikincisi, sayet parametresi kucuk harf ise, 1 degerini dondurur.

3uncu ve son fonksiyonlar ise, parametre olarak gecirilen karakteri buyuk
yada kucuk harfe degistirirler.

KARAKTERLERIN SINIFLANDIRILMASI

KARKLAS.C:
=================================================
#include <stdio.h>
#include <ctype.h> /* Derleyiciniz bunu gerektirmeyebilir */

main()
{
FILE *fp;
char satir[80], kutukismi[24];
char *c;

printf("Kutukismi -> ");
scanf("%s",kutukismi);
fp = fopen(kutukismi,"r");

do {
c = fgets(satir,80,fp); /* bir satir oku */
if (c != NULL) {
veriyi_say(satir);
}
} while (c != NULL);

fclose(fp);
}

satiri_say(satir)
char satir[];
{
int beyazlar, kars, rakamlar;
int index;

beyazlar = kars = rakamlar = 0;

for (index = 0;satir[index] != 0;index++) {
if (isalpha(satir[index])) /* 1 eger satir[] alfabetik ise */
kars++;
if (isdigit(satir[index])) /* 1 eger satir[] rakam ise */
rakamlar++;
if (isspace(satir[index])) /* 1 eger satir[] bosluk ise tab, */
beyazlar++; /* yada yeni satir ise */
} /* sayan dongunun sonu */

printf("%3d%3d%3d %s",beyazlar,kars,rakamlar,satir);
}
================================================

Bircok yerde, n yi, yeni bir satiri belirtmek icin kullandik, fakat cok
kullanilan baska kontrol karakterleri de vardir. Bu sekilde tanimlidirlar:

n Yeni satir
t Tab
b Bir hane geri
" Cift tirnak
\ Ters bolu
NULL (sifir)

Gordugunuz program, bir karakterin tipini belirleyen fonksiyonlar
kullanir. Kullandigi 3 fonksiyon sunlardir:

isalpha(); Karakter alfabetik mi?
isdigit(); Karakter bir rakam mi?
isspace(); Karakter n , t yada bosluk mu?

Program yeterince basit, bu nedenle daha fazla detaylara girmiyorum..
Bu yeni fonksiyonlarin kullanimi da, ayni "isupper" yada "toupper"
fonksiyonlari gibidir.


c++ dersleri 13.bölüm

Komut Satirinda Verilen Parametrelerin Okunmasi

Parametre Nedir?

Parametre kullancinin, program isminin yaninda yazdigi ek bilgilerdir.
Parametreler, birbirinden bosluk ile ayrilirlar. Kullanici, herhangi bir
komutun yaninda parametreler girebilir. SIMDINE.C de de gorebileceginiz gibi,
bu parametreleri programa gecirmek son derece kolaydir. Bunu yapmak icin,

main(adet,kelime)
int adet;
char *kelime[];
{

seklinde tanimlanmalidir. 'adet' degiskeni, kac tane parametre girildigini
sayar. Bu, sayet hic parametre girilmemisse, 1 dir, ve parametre
girildikce, bu deger artar. Ornegin,

rm -ie myfile.out

orneginde, adet=3 dur, yani komut satirinda birbirinden boslukla ayrilmis
3 sozcuk vardir.

'Kelime' degiskeni ise, bir pointerlar dizisidir. Bu dizinin her elemani,
bellekteki parametrelerin, baslangic adreselerini tutar. Yani,

kelime[0] ----->> rm.exe
kelime[1] ----->> -ie
kelime[2] ----->> myfile.out

gibidir. Daima, 'kelime' nin 0 inci elemani, programin isminin baslangic
adresini tutar, bundan sonra gelen diger 1,2 ve diger indeksler, diger
parametrelerin baslangic adreselerini tutarlar. Kullanimlari, ornegin,
normal bir char buffer[80] tipli bir diziye atamak icin, soyle olabilir:

strcpy(buffer,kelime[2]);

tabii, isim kelime, ve adet olmak zorunda degildir, herhangi birsey
olabilir. C de alisilmis tutum, 'adet' yerine 'argc' ve 'kelime' yerine
'argv' sozcuklerinin kullanilmasidir. Kelimenin kac tane indeksi oldugu,
'adet' degiskeninden bulunabilir: Kelime, daima (adet-1) tane indekse
sahiptir.