Gönderen Konu: DIKKAT DIKKAT DIKKAT  (Okunma sayısı 6451 defa)

0 Üye ve 1 Ziyaretçi konuyu incelemekte.

Çevrimdışı Morphosis

  • Üye
  • **
  • İleti: 74
DIKKAT DIKKAT DIKKAT
« : 06 Haziran 2008, 12:39:33 ös »
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..

c dersleri 10.bölüm

Structure ve Union'lar

STRUCTURE NEDIR?

Not: Structure'un tam tercumesi herhalde 'Yapi' olacak..

Bir structure, kullanici tarafindan tanimlanmis bir veri tipidir. Su ana
kadar kullandigimiz veri tiplerinden cok daha karmasik olanlari,
tanimlayabilirsiniz. Bir structure, daha once tanimlanmis olan veri
tiplerinin bir araya gelmis halidir - ki bu veri tiplerine, daha once
tanimladigimiz structure'lar da dahildir. Bu tanimi rahat anlamanin bir
yolu, structure'un, veriyi kullaniciya yada o programi kullanacak olan
kisiye daha rahat bir sekilde gruplamak icin kullanildigini
belirtebiliriz. Her zamanki gibi, bir seyi anlamanin en iyi yolu,
orneklere bakmaktir...

STRUCT1.C:
================================================

main()
{

struct {
char bas_harf; /* Soyadin bas harfi */
int yas; /* cocugun yasi */
int not; /* okulda not ortalamasi (100 uzerinden) */
} oglan,kiz;

oglan.bas_harf = 'R';
oglan.yas = 15;
oglan.not = 75;

kiz.yas = oglan.yas - 1; /* o, oglandan bir yas kucuk */
kiz.not = 82;
kiz.bas_harf = 'H';

printf("%d yasindaki %c'nin aldigi not, %d dir.n",
kiz.yas, kiz.bas_harf, kiz.not);

printf("%d yasindaki %c'nin aldigi not, %d dir.n",
oglan.yas, oglan.bas_harf, oglan.not);
}
================================================

Program, bir structure tanimi ile basliyor. "struct" kelimesinden sonra,
kume isaretleri arasinda bazi basit degiskenler goruyorsunuz. Bu
degiskenler, bu structure'i olusturan parcalardir. Kapanan kume
isaretinden sonra, iki tane degisken ismi goruyorsunuz: "oglan" ve "kiz".
Bu structure'un tanimina gore, "oglan" artik, 3 elemandan olusan bir
degiskendir. Bunlar "bas_harf", "yas", ve "not" dur, ve herbiri, kendi
tiplerinde bir veriyi saklayabilirler. "kiz" degiskeninin de ayni 3
elemani vardir, fakat bu baska bir degiskendir. Yani, 6 tane basit
degisken tanimlamis olduk..

TEK BIR BIRLESIK DEGISKEN

"oglan" degiskenini daha yakindan izleyelim. Daha once soyledigimiz gibi,
"oglan" in her elemani, basit birer degiskendir, ve bu tip bir degiskenin
kullanilabilecegi heryerde kullanilabilir. Ornegin, "yas" elemani, bir
tamsayi degiskenidir, dolayisiyla, bir C programinda bir tamsayi
degiskeninin kullanilabilecegi her yerde kullanilabilir. Hesaplamalarda,
bir sayac olarak, I/O islemlerinde vs. Yegane problem, bu "yas" isimli
basit degiskeni "oglan" ile beraber kullanmamiz gerekir. Bunu yapmak
icinde, ikisini de yaziyoruz, ve arasina bir nokta isareti koyuyoruz.
Oyleyse, tum degisken ismi olan "oglan.yas", "oglan" degiskeninin "yas"
sahasi oluyor.. Bu yapiyi, bu sahaya erismek istedigimiz heryerde
kullanabiliriz. Hatta, sadece "oglan" yada "yas" dememiz, kabul
edilmeyecektir. Tek baslarina, isimlerin bir manasi yoktur.


DEGISKENLERE DEGER ATAMA

Yukardaki tanimlamayi kullanarak, "oglan" ve "kiz" 'in her uc sahasina
("bas_harf","yas","not") degerler ayabiliriz. Dikkat etmeniz gereken bir
nokta, "oglan.bas_harf"'in bir "char" tipi oldugudur. Bu nedenle,
programda karakter verisine atanmistir. "oglan" in geri kalan iki sahasi
da, tanimlandiklari 'tiplerde', degerlere atanir.. Sonra, "kiz" isimli
degiskenin 3 sahasi da, degerlere atanir. Burada atama sirasinin fark
etmeyecegini gosterebilmek icin, farkli bir sira izlenmistir.

BU DEGERLERI NASIL KULLANABILIRIZ??

Alti basit degiskenimizin her elemanina veri atadiktan sonra, onlarla
diledigimizi yapabiliriz. Bu ilk ornegi basit tutmak icin, biz sadece
degerlerini ekrana yazdiriyoruz. "printf" satirinin alistigimizdan farkli
olmadigini goreceksiniz.

Structure'lar, programi daha kolay yazmak ve anlamak icin, cok faydali bir
gruplama metodudur. Bu ilk ornek cok basit oldugundan, size structure'un
gercek degerini gostermekten acizdir, fakat okumaya devam ederseniz,
structure'un gercekten faydali oldugunu goreceksiniz..