C Dili – 10. Konu

BİR DOSYAYA YAZMAK

ONSATIR.C:
================================================================
#include <stdio.h>
main()
{
FILE *fp;
char ivir[25];
int index;
fp = fopen("onsatir.txt","w"); /* yazmak icin açalım */
strcpy(ivir,"Bu bir ornek satirdir.");
for (index = 1;index <= 10;index++)
fprintf(fp,"%s Satir no: %d\n",ivir,index);
fclose(fp); /* dosyayı kapayalim */
}
================================================================

Bir dosyaya yazan ilk programımız. Her zamanki gibi, “stdio.h” i programa
ekliyoruz, ve daha sonra cok tuhaf bir degisken tanımlıyoruz.

“FILE” tipi, bir dosya değiskenidir, ve “stdio.h” in icinde tanimlanmıştır.
Kullanacağımız dosyaya erişmek icin bir ‘dosya pointeri’ tanimlamaktadır.
Bu pointer sayesinde, dosyayı açtıktan sonra, ondan okumak yada yazmak gibi işlemler yapabiliriz.

DOSYA YOLU

Dosyaya ulaşmak için diskin başından beri geçilen yola dosya yolu diyoruz.
Örneğin, masa üstünüzde bulunan ve “beni.oku” ismindeki bir dosyaya giden yol, C dilinde
Windows altında şu şekilde yazılabilir: “C:\\Users\\ben\\Desktop\\beni.oku”
(Windows’da dosya yolu ters bölü işaretleriyle yazılmaktadır.  Hatırlarsanız C dilinde ters bölünün özel bir anlamı vardır; bu nedenle ikişer tane konması gereklidir.)
Linux altında ise aynı yol şu şekilde yazılabilir: “/home/ben/Desktop/beni.oku”
Yukarıdaki örnekte gibi bir yol belirtmezseniz, sadece dosyanın ismini yazarsanız, programınız hangi klasörde çalıştırılırsa, dosya da o klasörde yaratılır.

DOSYANIN  AÇILMASI

Bir kutuge yazmadan once, onu açmamız gereklidir. Açmak demek, sisteme o
dosyanın ismini bildirmek, ve yazmak veya okumak istedigimizi belirtmektir. Bunu,
“fopen” fonksiyonu ile yapiyoruz. “fp” isimli dosya pointer’i, bu açılan
dosyaya ait bazi bilgileri tutar. “fopen” ise, iki parametre gerektirir.
Birincisi, dosyanın ismidir. Linux kullanıyorsanız, işletim sistemi büyük küçük harf ayrımı yapar.
Yani dosyayı yaratırken küçük harfle yarattıysanız, tekrar erişirken de küçük harfle açmanız gerekecektir.

OKUMAK “r”

“fopen” in ikinci parametresi ise, acilacak dosya 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 dosyayı okumak icin açmak icin, o kutugun diskte var olmasini geretirir. Şayet dosya yok ise, “fopen”, geriye NULL degerini dondurur.

YAZMAK “w”

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

EKLEMEK “a”

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

Tam listesi şudur:

r  - Dosyayı okumak için açmak
w - Dosyaya yazmak için açmak (dosyanın var olması gerekmez)
a - Dosyanın sonuna eklemek için açmak (dosyanın var olması gerekmez)
r+ - Dosyayı hem yazmak hem okumak için açmak, başından başlayarak
w+ - Dosyayı hem okumak hem yazmak için açmak (dosyayı siler)
a+ - Dosyayı hem okumak hem yazmak için açmak (dosya varsa sonuna ekler)

DOSYAYA YAZMAK

Bir dosyaya yazmak, ekrana yazmak ile neredeyse aynidir. En onemli farklar,
yeni fonksiyon isimleri, ve dosya pointer’inin bu fonksiyonlara parametre
olarak eklenmesidir. Ornek programda, “fprintf” komutu “printf” komutunun
yerini alir.

DOSYAYI KAPATMAK

Bir dosyayı kapatmak icin, sadece “fclose” komutunu kullanmak yeterlidir. Parametre olarak da dosyanın pointer’ini gecirmek yeterlidir. İşletim sistemi, program sona erince kullandigi dosyaları kapattigindan, “fclose” u kullanmak sart degildir, fakat bir aliskanlik yapmasi icin, kullandiginiz dosyaları kapatmanizi tavsiye ederim.

Bu programi calistirdiginizda, ekranda hicbir sey cikarmaz. Program bittikten sonra, “onsatir.txt” isimli dosyayı inceleyin. Icinde programin yazdigi on satirlik ciktiyi goreceksiniz.

KARAKTERLERI TEKER TEKER YAZMAK

KAROUT.C:
================================================================
#include <stdio.h>
main()
{
FILE *dosyapoint; char digerleri[35]; int index,say;
strcpy(digerleri,"Ek satirlar.");
dosyapoint = fopen("onsatir.txt","a"); /* eklemek icin açmak */
   for (say = 1;say <= 10;say++) {
for (index = 0;digerleri[index];index++)
putc(digerleri[index],dosyapoint); /* bir karakter yaz */
putc('\n',dosyapoint); /* bir de <RETURN> */
}
fclose(point);
}
================================================================

Normal “include” satırımızdan sonra, “dosyapoint” isimli bir dosya 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 dosyayı “append” yani sonuna eklemek icin açıyoruz.

Bu program iki tane iç içe döngüden olusuyor. Dıştaki dongu, sadece birden
ona kadar sayiyor.. Içindeki dongu ise, yazilan karakter sıfır olmadigi
surece, “putc” fonksiyonunu cagirir.

“putc” FONKSIYONU

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

Dış dongu on kere tekrarlandiktan sonra, program dosyayı kapatip sona eriyor. Bu program calistiktan sonra dosyayı incelerseniz, gercektende sonuna 10 satir eklendigini gorursunuz.

BIR DOSYAYI OKUMAK

KAROKU.C:
================================================================

#include <stdio.h>
main()
{
FILE *dosya;
int c;
dosya = fopen("onsatir.txt","r");
if (dosya == NULL) printf("Boyle bir dosya yok\n");
else {
do {
c = getc(dosya); /* Bir karakter oku */
putchar(c); /* ekranda goster */
} while (c != EOF); /* Dosya sonuna (END OF FILE) a kadar devam */
}
fclose(dosya);
}
================================================================

Bir dosya okuyan ilk programimiz! “stdio.h” ve iki degisken tanimindan
sonra, “fopen” fonksiyonunda okumak icin “r” parametresini veriyoruz. Daha
sonra, dosya açmanin 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 dosyanın sonunu belirten EOF
dondurene kadar surer. EOF donunce de, dosya kapatilir, ve program sona
erer.

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); /* dosyadan 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 dosyadan 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); /* dosyadan bir kelime oku... */
if (c != EOF)
printf("%s\n",birkelime); /* ekrana yaz... */
} while (c != EOF); /* ta ki EOF olana dek.. */
fclose(fp1); /* dosyayı kapa */
}
================================================================

Gordugunuz gibi, bir “if” komutu ile, sayet dosyanın 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 dosya
degiskeninin ismini veriyoruz.

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.
Tabi sonunda, dosyayı kapatiyoruz..

DEGISKEN DOSYA ISMI

HERDOSYA.C:
================================================================
#include "stdio.h"
main()
{
FILE *fp1;
char birkelime[100],dosyaismi[25];
char *c;
printf("Dosya ismini girin -> ");
scanf("%s",dosyaismi); /* istenilen dosya ismini alalim */
fp1 = fopen(dosyaismi,"r");
do {
c = fgets(birkelime,100,fp1); /* dosyadan 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 dosya ismini kullanicidan
aliyoruz, daha sonra dosyayı 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"); /* dosyayı acalim */
printer = fopen("PRN","w"); /* printeri acalim */
do {
c = getc(guzel); /* dosyadan bir karakter okuyoruz */
if (c != EOF) {
putchar(c); /* ekranda goruntuleyelim */
putc(c,printer); /* ve yaziciya yollayalim */
}
} while (c != EOF); /* ta ki (End Of File) dosya bitene kadar */
fclose(guzel);
fclose(printer);
}
================================================================

Okumak icin, “onsatir.txt” yi actiktan sonra, yazmak icin “PRN” isimli
dosyayı aciyoruz. Printere bir bilgi yollamak, ayni bir dosyaya yazmak
gibidir, fakat standart bir dosya 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 dosya tanimliyicilari vardir. Bu sayede, siz printer’i bir dosya gibi açmadan, ona veri yollayabilirsiniz.

Program, birer birer butun dosyayı okuyup, ekranda gosterir, ve printer’e yollar. EOF , dosya sonu bulundugunda, dosyalar kapanir, ve program biter.

BİNARY (BİNER) OKUMA VE YAZMA

Bazen dosyaya bilgileri olduğu gibi yazmak, ve hatta ASCII kodları 0-31 yada 127-255 arası bilgiler girmek isteyebilirsiniz. Bunlara binary bilgiler denir. Örneğin bir programın derlenmiş hali, bir MP3 parça yada bir JPG resim binary verilere örnektir.

Bir dosyayı “binary” olarak açmak isterseniz, bunu fopen() a bildirmeniz gereklidir. Bunu da fopen’ın ikinci parametresine “b” harfini ekleyerek yapabilirsiniz. “rb” yada “wb” gibi örneğin.

Bunları okumak için C de  “fread” kullanılır, yazmak için ise  “fwrite” kullanılır. İki fonksiyon da veri blokları ile çalışır yani bellekten arka arkaya kısımları okur yada yazar. Genelde array (dizin) ler kullanılır. Bunlara parametre olarak adres girildiğinden, dilerseniz pointer geçirebilirsiniz yada  daha sonra göreceğimiz structure ları bile diske bunlarla yazabilir yada okuyabilirsiniz.

Tanımı:

size_t fread(void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);       
size_t fwrite(const void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);

Buradaki void *ptr lafı, herhangi bir cins pointer konabileceği belirtilmek için konmuştur, karakter pointer yada integer pointer gibi. fread’in 4 parametresi vardır. Birincisi, sizin dizinin (array) adresidir. İkincisi, dizinin her elemanının boyudur. Üçüncü ise, dizide kaç tane eleman olduğudur. Sonuncu parameter ise malum dosya pointer’ımızdır.

Örnek:

================================================================
#include <stdio.h>
main() {
	FILE *fp;
	char x[10]="ABCDEFGHIJ";
	fp=fopen("c:\\test.bin", "wb");
	fwrite(x, sizeof(x[0]), 10, fp);
	fclose(fp);
}

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

ODEVLER:

1. Okunacak, yazilacak dosyaların isimlerini kullaniciya soran, daha sonra
bu ikisini ve printer dosyası açan bir program yazin. Program bunlari
actiktan sonra, dosya sonu gelinceye kadar okunacak dosyayı harf harf
okuyup, yazilacak dosyaya ve yaziciya bu karakteri yollamalidir.

2. Programiniz, kullaniciya bir dosya ismi sorsun, cevabi alinca da, bu
dosyayı ekranda, satir numaralari ile birlikte gostersin..

Bir Sonraki Konu