C Dili - (devamı)

C Dili - 8. Konu

POINTER NEDIR?

Basitce, pointer, bir adrestir. Bir degisken olmak yerine, bir degiskenin
hafizadaki adresini tasiyan bir 'ok isareti'dir.

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

main() /* Pointer kullanimi ornegi */
{
int index,*pt1,*pt2;

index = 39; /* herhangi bir deger */
pt1 = &index; /* 'index' in adresi */
pt2 = pt1;

printf("Deger simdi %d %d %d dir.n",index,*pt1,*pt2);

*pt1 = 13; /* 'index' in degerine degisiklik yapalim */

printf("Degistikten sonra ise %d %d %dn",index,*pt1,*pt2);
}

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

Su an icin, programin index degiskenini ve iki tane astrisk ile baslayan
terimlerin tanimlandigi yere bakmayin. Aslinda astrisk denilen bu isarete,
biz simdilik 'yildiz' diyelim.

Programda ilk once, index degiskenine 39 degerini atiyoruz. Bunun
altindaki satirda ise, pt1'e tuhaf bir deger atanmasini goruyoruz - index
degiskeni, ve onunde bir & ampersand isareti ile. Bu ornekte, pt1 ve pt2
pointer dir, ve index de basit bir degiskendir. Simdi bir problemle karsi
karsiyayiz. Bu programda pointer kullaniliyor, fakat nasil kullanilacagini
ogrenmedik.

Bu gorecekleriniz biraz aklinizi karistiracak, fakat bunlari anlamadan
gecmeyin.

IKI ONEMLI KURAL

1. Onune ampersand isareti konmus bir degisken, o degiskenin adresini
belirtir. Yani altinci satir, soyle okunabilir: "pt1, index isimli
degiskenin adresini alir."

2. Onune yildiz konmus bir pointer, kendisinin tuttugu adreste bulunan
degeri gosterir. Programin dokuzuncu satiri, soyle okunabilir: "pt1
pointer'inin gosterdigi yere, 13 degeri atandi."

HAFIZA YARDIMCISI

1. & 'i bir adres olarak dusunun.
2. * 'i adresteki deger olarak dusunun.

pt1 ve pt2 pointer olarak, kendileri bir deger tasimazlar, fakat
bellekteki bir adresi gosterirler. Bu programda, 'index' degiskenini
gosteren pointer'lar oldugu icin, degiskenin degerini hem index ile, hemde
onun adresini tasiyan pointer'lar ile degistirebiliriz.

Dokuzuncu satirda, index degiskeninin degeri, pt1 pointer'i ile
degistiriliyor. Program icinde 'index' i kullandigimiz herhangi biryerde,
(pt1 baska birseye atanincaya kadar), '*pt1' i de kullanmamiz
mumkundur, cunku pt1, index'in adresini tasimaktadir.

BIR BASKA POINTER

Programa degisklik katmak icin, birbaska pointer daha tanimladim. "pt2"
isimli bu pointer, yedinci satirda "pt1"'in tasidigi adresi almaktadir. Bu
atamadan once, ayni henuz deger atanmamis degiskenler gibi icinde rastgele
bilgiler vardir. Bundan sonra, "pt2" de "index" degiskeninin adresini
tasimaktadir. Ornegin, dokuzuncu satirda "*pt1" i "*pt2" ile degistirsek
de, sonuc ayni olacaktir - cunku iki pointer da ayni adresi tasimaktadir.

SADECE BIR DEGISKEN

Bu programda uc tane degisken var gibi gorunse de, aslinda bir tane
degisken tanimlidir. Iki pointer ise, bu degiskenin adresini tutmaktadir.
Bu durum, "printf" komutunun hep 13 degerini yazmasindan da anlasilabilir.

Bu gercekten anlamasi zor bir kavramdir, fakat en kucuk C programlari
disinda hepsi tarafindan kullanildigi icin, ogrenmeniz gereklidir.

POINTER NASIL TANIMLANIR

Programin ucuncu satirinda, ilk once "index" isimli degisken tanimlanir,
daha sonra da iki tane pointer tanimlamasi goreceksiniz. Ikinci tanim, su
sekilde okunabilir: "pt1'in gosterecegi adres, bir tamsayi degiskenine ait
olacak." Yani, "pt1", tamsayi bir degiskeninin pointer'i olur. Ayni
sekilde, "pt2" de, yine bir tamsayi degiskeninin pointer'i olur.

Bir pointer, bir degiskenin adresini tasimak icin tanimlanir.
Tanimlandigindan baska bir degisken tipi icin kullanimi "uyumsuz veri
tipi" hatasinin olusmasina sebep olur. Ornegin, "float" tipi bir pointer,
"int" tipli bir degiskenin adresini alamaz.

POINTER'LI IKINCI PROGRAMIMIZ

POINTER2.C:
=================================================
main()
{
char katar[40],*orada,bir,iki;
int *pt,list[100],index;

strcpy(katar,"Bu bir karakter kataridir.");

bir = katar[0]; /* bir ve iki ayni degeri tasirlar */
iki = *katar;
printf("Ilk cikti %c %cn",bir,iki);

bir = katar[8]; /* bir ve iki ayni degeri tasirlar */
iki = *(katar+;
printf("Ikinci cikti %c %cn",bir,iki);

orada = katar+10; /* katar+10 ve katar[10] aynidir. */
printf("Ucuncu cikti %cn",katar[10]);
printf("Dorduncu cikti %cn",*orada);

for (index = 0;index < 100;index++)
list[index] = index + 100;
pt = list + 27;
printf("Besinci cikti %dn",list[27]);
printf("Altinci cikti %dn",*pt);
}
================================================

Bu programda, iki tane pointer, iki tane dizi ve uc tane degisken
tanimliyoruz. "orada" isimli pointer, karakter tipi, ve "pt" ise, tamsayi
tipindedir.

BIR KATAR DEGISKENI ASLINDA BIR POINTER DIR

C programlama dilinde, bir katar degiskeni, o katarin baslangicini
gosteren bir pointer olarak tanimlanmistir. Programda bir bakin: once
"katar" isimli diziye sabit bir katar atiyoruz. Daha sonra, "bir" isimli
degiskene, "katar" in ilk harfini atiyoruz. Sonra, "iki" isimli degiskene,
ayni degeri atiyoruz. Ikinci satirda "*katar[0]" yazmak yalnis olurdu,
cunku yildiz isareti, koseli parantezlerin yerini almaktadir.

"katar" i neredeyse tam bir pointer gibi kullanabilirsiniz, yegane farki,
tuttugu adres degistirilemez, ve daima o katarin baslangic adresini
gosterir.

Onkinci satira gelince, katarin dokuzuncu karakterinin (sifirdan
basladigimiz icin), iki ayri sekilde "bir" ve "iki" isimli degiskenlere
atandigini goruyoruz.

C programlama dili, pointer'in tipine gore, index ayarlamasini
otomatik olarak yapar. Bu durumda, "katar" bir "char" olarak tanimlandigi
icin, baslangic adresine 8 eklenir. Sayet "katar" "int" (tamsayi) olarak
tanimlanmis olsa idi, index iki ile carpilip, "katar" in baslangic
adresine eklenirdi.

"orada" bir pointer oldugu icin, 16. satirda "katar" in 11. elemaninin
adresini tasiyabilir. "orada" gercek bir pointer oldugu icin, herhangi bir
karakter degiskeninin adresini gosterebilir.

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

"list" isimli tamsayi dizisine, 100 den 199 a kadar degerler verilir. Daha
sonra, 28. elemanin adresini, "pt" 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 "pointer sayesinde" idiyse,
tebrikler.

CIFTYON.C:
================================================== ==
main()
{
int cevizler,elmalar;

cevizler = 100;
elmalar = 101;
printf("Baslangic degerleri %d %dn",cevizler,elmalar);

/* "degistir" i cagirinca, */
degistir(cevizler,&elmalar); /* cevizlerin DEGERI ve, */
/* elmalarin adresini geciriyoruz */

printf("Bitis degerleri ise, %d %d dir..n",cevizler,elmalar);
}

degistir(kuru_yemis,meyvalar) /* kuru_yemis tamsayidir */
int kuru_yemis,*meyvalar; /* meyvalar bir tamsayi pointer'idir */
{
printf("Degerler %d %dn",kuru_yemis,*meyvalar);
kuru_yemis = 135;
*meyvalar = 172;
printf("Sonraki degerler %d %dn",kuru_yemis,*meyvalar);
}
=================================================
Burada, iki tane tamsayi degiskeni (pointer degil) tanimliyoruz:
"cevizler" ve "elmalar". Once bunlara birer deger atiyoruz, ve "degistir"
isimli fonksiyonu cagiriyoruz. Cagirirken, "cevizler" in degeri (100), ve
"elmalar" 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 "cevizler" in
degerinin ayni kaldigini fakat "elmalar" in yeni degerlerini aldigini
goreceksiniz.

"cevizler" 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.

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

ODEV

1. Bir karakter katari tanimlayin, ve icine "strcpy" 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 <stdio.h> /* input/output icin standard header */

main()
{
char c;

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

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

printf("nProgramin sonu.n");
}
================================================

Standart I/O deyimi, verinin girildigi ve ciktigi en normal yerleri,
klavyeyi ve ekrani kast eder. Bu kutuge ilk baktiginizda, "#include
<stdio.h>" komutunu goreceksiniz. Bu komut on-derleyiciye, kucuktur ve
buyuktur isaretleri arasinda yer alan kutuk isminin programa eklenmesini
soyler. Bazen, < > isaretleri yerine den-den " " isaretleri de
gorebilirsiniz. Aralarindaki fark, <> 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,
"bu tip kutuklerin konuldugu yer", 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 "stdio.h"
kutugu ise, bir suru "#define" 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 "stdio.h" 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 "#include" kutukleri cok faydali olacaktir.

"BASITIO" YA GERI DONELIM

"c" isimli degisken tanimlanir, ve ekrana mesaj yazilir. Daha sonra,
kendimizi "c", 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.

"getchar()" isimli fonksiyon, klavyeden okudugu tusu dondurur, bu deger
"c" ye atanir. "putchar()" 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 "eko" 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 <stdio.h>

main()
{
char c;

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

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

printf("nProgramin sonu.n");
}
=================================================

Bu programdaki yegane degisiklik olan yeni fonksiyon "getch()", yine
klavyeden tek bir karakter okur. Farki, "getchar" 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 "Line Feed" yani satir atlama karakteri ilave eder. Satir atlama
otomatik olarak yapilmaz. Bundan sonraki programda, bu sorunu da halletmis
olacagiz.

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

main()
{
char c;

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

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("nProgramin sonu.n");
}
================================================
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 "#define" lar yerine "if (c == 13) putchar(10);"
diyebilirdik, fakat ne yapmak istedigimiz pek belirgin olmazdi.

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, "getch()" fonksiyonun tersi olan "ungetch()" isimli bir fonksiyon
daha oldugunu da belirtmeliyim. Sayet bir karakteri "getch()" 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 "ungetch" edebilirsiniz, fakat genellikle bu yeterlidir.

BIRAZ TAMSAYI OKUYALIM

TAMOKU.C:
=================================================
#include <stdio.h>

main()
{
int deger;

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

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

printf("Programin sonun");
}
===============================================

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

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

"scanf" 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 <stdio.h>

main()
{
char big[25];

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

do {
scanf("%s",big);
printf("Yazdiginiz katar -> %sn",big);
} while (big[0] != 'X');

printf("Programin sonu.n");
}
==================================================

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. "scanf" deki
degiskenin onune & 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, "scanf" bir katar okurken, satirin
sonuna yada bir bosluga rastlayincaya kadar okumasina devam eder. Bir
dongu icinde oldugumuzdan, program tekrar tekrar "scanf" 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,"%d %d %d %d %dn",rakam[0],rakam[1],
rakam[2],rakam[3],rakam[4]);

printf("%s",satir);

sscanf(satir,"%d %d %d %d %d",&sonuc[4],&sonuc[3],
(sonuc+2),(sonuc+1),sonuc);


for (index = 0;index < 5;index++)
printf("Sonuc %d dir. n",sonuc[index]);

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

Bu programda, birkac tane degisken tanimliyoruz, ve "rakamlar" isimli
diziye de, "sprintf" fonksiyonunu incelemek icin rastgele sayilar
atiyoruz. Bu fonksiyon, "printf" 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, "satir" dizisinin icinde, bes tane rakam olacaktir. Ikinci ile
ucuncu rakamlar arasindaki bosluk, "sscanf" fonksiyonunun bunlarin
uzerinden atlamasini gormek icindir.

Bunun altinda "printf" i kullanarak bu hazirladigimiz satiri yaziyoruz.
Daha sonra gordugunuz, "sscanf" fonksiyonu ise, "scanf" gibi ekrandan
okumak yerine, bizim "satir" dizimizden degerleri okur. Gordugunuz gibi,
"sscanf" 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 <stdio.h>

main()
{
int index;

for (index = 0;index < 6;index++) {
printf("Bu satir, standart ciktiya gidiyor.n");
fprintf(stderr,"Bu satir ise standart hataya gidiyor.n");
}

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

A> COPY CON: DENE.BAT <RETURN>

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

<F6> <RETURN>

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

Bu program, bir dongu, ve icinde iki satirdan olusur. Bu satirlardan bir
tanesi standart ciktiya, bir tanesi de standart hataya gider. Burada
gordugunuz "fprintf" komutu, "printf" 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> OZEL > CIKTI

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

YA exit(4) KOMUTU ?

Bu programdaki en son satir olan "exit(4)" komutu, programi sona erdirir,
ve dort degerini DOS a dondurur. Parantezlerin arasinda 0 ila 9 degerleri
kullanilabilir. Sayet bir "batch" (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 "char"
tipinde gosterin. Bu harfi bir rakam olarak da gosterin. Programi
durdurmak icin, dolar sembolunu bekleyin. "getch" 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.

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

BIR KUTUGE YAZMAK

ONSATIR.C:
=================================================
#include <stdio.h>
main()
{
FILE *fp;
char ivir[25];
int index;

fp = fopen("ONSATIR.TXT","w"); /* yazmak icin acalim */
strcpy(ivir,"Bu bir ornek satirdir.");

for (index = 1;index <= 10;index++)
fprintf(fp,"%s Satir no: %dn",ivir,index);

fclose(fp); /* Kutugu kapayalim */
}
================================================

Bir kutuge yazan ilk programimiz. Herzamanki gibi, "stdio.h" i programa
ekliyoruz, ve daha sonra cok tuhaf bir degisken tanimliyoruz.

"FILE" tipi, bir kutuk degiskenidir, ve "stdio.h" in icinde
tanimlanmistir. Kullanacagimiz kutuge erismek icin bir 'kutuk pointeri'
tanimlamaktadir.

KUTUGUN ACILMASI

Bir kutuge yazmadan once, onu acmamiz gereklidir. Acmak demek, sisteme o
kutugun ismini bildirmek, ve yazmak istedigimizi belirtmektir. Bunu,
"fopen" fonksiyonu ile yapiyoruz. "fp" isimli kutuk pointer'i, bu acilan
kutuge ait bazi bilgileri tutar. "fopen" ise, iki parametre gerektirir.
Birincisi, kutugun ismidir. Buyuk harf, kucuk harf, yada karisik fark
etmez.

OKUMAK "r"

"fopen" in ikinci parametresi ise, acilacak kutuk ile ne yapilacagini
belirtir. Buraya, "r" "w" yada "a" yazabiliriz. "r" kullanildiginda, kutugun
okuma icin acilacagini belirtir. "w", kutuge yazilacagini, ve "a" ise
zaten var olan bir kutuge bilgi ekleyeceginizi belirtir. Bir kutugu okumak
icin acmak icin, o kutugun diskte var olmasini geretirir. Sayet kutuk yok
ise, "fopen", geriye NULL degerini dondurur.

YAZMAK "w"

Bir kutuk yazmak icin acilinca, sayet diskte yoksa yaratilir, sayet varsa,
icindeki bilgiler silinir.

EKLEMEK "a"

Bir kutuk eklemek modunda acildiginda, sayet yoksa yaratilir, varsa, veri
giris pointer'i bu kutugun sonuna ayarlanir. Bu sayede yeni bilgi
yazilinca, kutugun sonuna yazilmis olur.

KUTUGE YAZMAK

Bir kutuge yazmak, ekrana yazmak ile neredeyse aynidir. En onemli farklar,
yeni fonksiyon isimleri, ve kutuk pointer'inin bu fonksiyonlara parametre
olarak eklenmesidir. Ornek programda, "fprintf" komutu "printf" komutunun
yerini alir.

KUTUGU KAPATMAK

Bir kutugu kapatmak icin, sadece "fclose" komutunu kullanmak yeterlidir.
Parametre olarak da kutugun pointer'ini gecirmek yeterlidir. DOS, program
sona erince kullandigi kutukleri kapattigindan, "fclose" u kullanmak sart
degildir, fakat bir aliskanlik yapmasi icin, kullandiginiz kutukleri
kapatmanizi tavsiye ederim.

Bu programi calistirdiginizda, ekranda hicbir sey cikarmaz. Program
bittikten sonra, "ONSATIR.TXT" isimli kutugu inceleyin. Icinde programin
yazdigi on satirlik ciktiyi goreceksiniz.

KARAKTERLERI TEKER TEKER YAZMAK

KAROUT.C:
==================================================
#include <stdio.h>
main()
{
FILE *kutukpoint;
char digerleri[35];
int index,say;

strcpy(digerleri,"Ek satirlar.");
kutukpoint = fopen("onsatir.txt","a"); /* eklemek icin acmak */

for (say = 1;say <= 10;say++) {
for (index = 0;digerleri[index];index++)
putc(digerleri[index],kutukpoint); /* bir karakter yaz */
putc('n',kutukpoint); /* bir de <RETURN> */
}
fclose(point);
}
==================================================

Normal "include" kutugumuzden sonra, "kutukpoint" isimli bir kutuk
pointeri tanimliyoruz. Yazacagimiz bilgileri tutmasi icin, "digerleri"
isminde bir karakter dizisi tanimliyoruz. Daha sonra bu actigimiz sahaya,
"strcpy" fonksiyonu ile "Ek satirlar." sozcugunu yaziyoruz. Bundan sonra,
yine ayni kutugu "append" yani eklemek icin aciyoruz.

Bu program iki tane ic ice donguden olusuyor. Distaki dongu, sadece birden
ona kadar sayiyor.. Icindeki dongu ise, yazilan karakter sifir olmadigi
surece, "putc" fonksiyonunu cagirir.

"putc" FONKSIYONU

Bu programin ilgimizi ceken yonu, "putc" fonksiyonudur. Belirtilen kutuge
bir karakter yazan bu fonksiyon, ilk parametre olarak yazilacak karakteri,
ikinci olarak da kutuk pointer'ini veriyoruz. "Digerleri" isimli dizi
bitince satirin sonuna bir <RETURN> karakteri koymak icin "putc" yi tekrar
cagiriyoruz.

Dis dongu on kere tekrarlandiktan sonra, program kutugu kapatip sona
eriyor. Bu program calistiktan sonra kutugu incelerseniz, gercektende
sonuna 10 satir eklendigini gorursunuz.

BIR KUTUGU OKUMAK


KAROKU.C:
=================================================
#include <stdio.h>

main()
{
FILE *tuhaf;
int c;

tuhaf = fopen("ONSATIR.TXT","r");

if (tuhaf == NULL) printf("Boyle bir kutuk yokn");
else {
do {
c = getc(tuhaf); /* Bir karakter oku */
putchar(c); /* ekranda goster */
} while (c != EOF); /* Kutuk sonuna (END OF FILE) a kadar devam */
}
fclose(tuhaf);
}
===============================================

Bir kutuk okuyan ilk programimiz! "stdio.h" ve iki degisken tanimindan
sonra, "fopen" fonksiyonunda okumak icin "r" parametresini veriyoruz. Daha
sonra, kutuk acmanin basarili olip olmadigini kontrol ediyoruz. Sayet
basarili degilse, geriye NULL degeri donecektir.

Program, bir "do while" dongusunun icinde tek bir karakter okuyup, ekrana
yaziyor. Bu dongu, ta ki, "getc" fonksiyonu kutugun sonunu belirten EOF
dondurene kadar surer. EOF donunce de, kutuk kapatilir, ve program sona
erer.

DIKKAT DIKKAT DIKKAT

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

Fakat, cogu C derleyicilerinde EOF karakteri, -1 olarak tanimlanmistir -
yani, "char" 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 "int" tipi bir degisken kullanin.

Sayet sizin derleyiciniz icin EOF karakterinin ne oldugunu ogrenmek
isterseniz, "stdio.h" isimli header'i okuyabilirsiniz.


KELIME KELIME OKUMAK

TEXTOKU.C:
=================================================
#include "stdio.h"

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

fp1 = fopen("ONSATIR.TXT","r");

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

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

Bu program, nerdeyse bir oncekinin aynisidir. Burada, kelime kelime okumak
icin "fscanf" fonksiyonunu kullaniyoruz, cunku "fscanf" 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 "birkelime" nin
icinde idi o deger.

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

IYIOKU.C:
================================================
#include "stdio.h"

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

fp1 = fopen("onsatir.txt","r");

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

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

Gordugunuz gibi, bir "if" 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 "stdio.h"

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

fp1 = fopen("ONSATIR.TXT","r");

do {
c = fgets(birkelime,100,fp1); /* bir satir okuyalim */
if (c != NULL)
printf("%s",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.

"fgets" 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 "stdio.h"

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

printf("Kutuk ismini girin -> ");
scanf("%s",kutukismi); /* istenilen kutuk ismini alalim */

fp1 = fopen(kutukismi,"r");

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

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

Burada, ilk once kullanicidan "scanf" ile kutuk ismini kullanicidan
aliyoruz, daha sonra kutugu acip, satir satir ekrana yaziyoruz.

YAZICIYA NASIL BIRSEY YOLLAYABILIRIZ

PRINTDAT.C:
================================================
#include "stdio.h"

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

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

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

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

Okumak icin, "onsatir.txt" yi actiktan sonra, yazmak icin "PRN" 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 "PRN" , "LPT",
"LPT1" yada "LPT2" dir.

Bazi yeni derleyicilerin, "stdprn" 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..