Standart IO

#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:

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 İŞLEMLERI

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.

DİĞER 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 BİZE YARDIMCI OLUYOR (YADA IŞE KARIŞIYOR)

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.

#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.

#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

#include <stdio.h>

main()
{
int deger;

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

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

printf("Programin sonu\n");
}

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 GİRİŞİ

#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 -> %s\n",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.

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 %d\n",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:

#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
:DORT
(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.

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.

BIR KUTUGE YAZMAK

#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: %d\n",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, cindeki 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 onra, "ONSATIR.TXT" isimli kutugu inceleyin. Icinde programin yazdigi on satirlik ciktiyi goreceksiniz.

KARAKTERLERI TEKER TEKER YAZMAK

#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" FONKSİYONU

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

#include <stdio.h>

main()
{
int deger;

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

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

printf("Programin sonu\n");
}

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

#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("%s\n",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.

#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("%s\n",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

#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 (\0) sifir degerine yer birakmasidir.

DEĞİŞKEN BİR KUTUK İSMİ

#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 BİRŞEY YOLLAYABİLİRİZ

#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 program biter.