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);
}