C Kitabı

Ders 1: Giriş
• Giriş
• 1.1 Tarihçe
• 1.2 Neden C?
• 1.3 İlk C Programı
• 1.4 Başlık Dosyaları
• 1.5 Kaynak Kodunun Derlenmesi
• 1.6 C Kodlarının Temel Özellikleri
• 1.7 Kod Yazımı için Bazı Tavsiyeler
Giriş
Bu ilk derste, bir C programın nasıl derlenip çalıştırılacağı ve Internet'te bulabileceğiz
derleyicilerden bahsedilecektir. En basit C programının derleyip çalıştırdıktan sonra, geriye
kalan sadece C Programlama Dili'nin kurallarını, yapısını ve deyimlerini öğrenmekten
ibarettir.
1.1 Tarihçe
C Programlama Dili genel amaçlı orta seviyeli ve yapısal bir programlama dilidir. 1972
yılında Dennis Ritchie tarafından Bell Telefon Labaraturvarında Unix işletim sistemi ile
kullanılmak için tasarlanmıştır. C, özellikle sistem programlamada sembolik makine dili
(Asembler) ile tercih edilmektedir. İşletim sistemleri, derleyiciler ve debug gibi aşağı seviyeli
sistem programlarının yazılımında yoğun olarak C programlama dili kullanılır.
C'nin yayılması ve gelişmesi, büyük bir bölümü C dili ile yazılan UNIX işletim sisteminin
popüler olmasıyla başlamıştır. C Programlama Dili, hemen her alanda kullanılmaktadır.
Günümüzde nesneye yönelik programlama dilleri (C++, Java) ve script dilleri (JavaScript,
JavaApplet, PHP) gibi programlama dilleri C Programlama Dili'nden esinlenmiştir.
C taşınabilir (portable) bir dildir. Yani herhangi bir C programı hiçbir değişikliğe uğramadan,
veya çok az bir değişimle, başka bir derleyicide ve/veya işletim sisteminde derlenebilir.
Örneğin, Windows işletim sistemlerinde yazılan bir C kodu, Linux, UNIX veya VAX gibi
işletim sistemlerinde de derlenebilir. Taşınabilirlik, herkesin kabul ettiği bir standart ile
gerçekleştirilebilir. Bugün, C Programla Dili için American National Standards Institute
(ANSI) kurumunun Mart 2000'de belirlediği C99: ISO/IEC 9899:1999 standartı Standart C
olarak kabul edilmiştir.
Burada verilen C notarında, ağırlıklı olarak ANSI C veya diğer adıyla Standart C konu
edilmiştir.
1.2 Neden C?

C Programlama Dili'ni popüler kılan önemli nedenler aşağıda listelenmiştir:
• C, güçlü ve esnek bir dildir. C ile işletim sistemi veya derleyici yazabilir, kelime
işlemciler oluşturabilir veya grafik çizebilirsiniz.
• C, iyi bir yazılım geliştirme ortamına sahiptir.
• C, özel komut ve veri tipi tanımlamasına izin verir.
• C, taşınabilir bir dildir.
• C, gelişimini tamamlamış ve standardı oluşmuş bir dildir.
• C, yapısal bir dildir. C kodları fonksiyon olarak adlandıralan alt programlardan
oluşmuştur.
• C++, Java, JavaScript, JavaApplet, PHP, C#, ... gibi diller C dilinden esinlenmiştir.
1.3 İlk C Programı
Program 1.1 de verilen C programı derlendikten sonra, ekrana 'Merhaba Dünya!' yazısını
basan yalın bir C programıdır. Satır başlarına yerleştirilen 1:, 2: 3: ... rakamlarının
yazılmasına gerek yoktur. Bu rakamlar sadece daha sonra program ile ilgili açıklama
yapılırken, ilgili satırda bulunan kodlar izah edilirken kullanılacaktır. Bu programın
bilgisayarda ilk.c adı ile kaydedilmiştir.
Program 1.1: Derlendikten sonra ekrana 'Merhaba Dünya!' yazar
01:
02:
03:
04:
05:
06:
07:
/* ilk.c: ilk C programi */
#include
main()
{
printf("Merhaba Dünya!\n");
}
/* ... */
Programda, 1. satırda /* ... */ sembolleri görülmektedir. Bu ifadeler arasında
yazılan herhangi bir metin, işlem vb. satırlar, derleyici tarafından işlenmez
(değerlendirilmez). Yani /* */ ifadeleri açıklama operatörüdür.
NOT
Açıklama operatörü olarak C++ tarzı iki-bölü (//) de
kullanılmaktadır. Günümüzde birçok C derleyicisi //
operatörünü desteklemektedir. Bu operatörü kullanmadan
önce derleyicinizin bu operatörü desteklediğinden emin
olun.
/*
Bu satırlar derleyici tarafından
değerlendirilmez. Ayrıca programın
tarzı
çalışma hızını da değiştirmez.
*/
C
// Bu satırlar derleyici tarafından
// değerlendirilmez. Ayrıca programın C++
tarzı
// çalışma hızını da değiştirmez.

#include
2. satırdaki #include deyimi, programda eklenecek olan başlık dosyanını işaret eder.
Bu örnekte verilen başlık dosyası (header file) stdio.h dir. #include
ifadesi stdio.h dosyasının derleme işlemine dahil edileceğini anlatır[1]-[2].
main()
4. satırdaki main() özel bir fonksiyondur. Ana program bu dosyada saklanıyor
anlamındadır. Programın yürütülmesine bu fonksiyondan başlanır. Dolayısıyla her C
programında bir tane main() adlı fonksiyon olmalıdır.
printf()
6. satırdaki printf() standart kütüphane bulunan ekrana formatlı bilgi yazdırma
fonksiyondur. stdio.h dosyası bu fonksiyonu kullanmak için program başına ilave
edilmiştir. Aşağıda printf() fonksiyonunun basit kullanımı gösterilmiştir.
Örnek kullanım şekli
Ekranda yazılacak ifade
printf("Element: Aluminyum");
Element: Aluminyum
printf("Atom numarası = %d",13); Atom numarası = 13
printf("Yoğunluk = %f g/cm3",2.7);
printf("Erime noktası = %f
derece",660.32);
1.4 Başlık Dosyaları
Yoğunluk = 2.7 g/cm3
Erime noktası = 660.32
derece
C dilinde bir program yazılırken, başlık dosyası (header file) olarak adlandırılan bir takım
dosyalar #include önişlemcisi kullanılarak program içine dahil edilir. C kütüphanesinde
bulunan birçok fonksiyon, başlık dosyaları içindeki bazı bildirimleri kullanır. Bu tür
dosyaların uzantısı .h dir. ANSI C'deki standart başlık dosyaları şunlardır:
assert.h locale.h stddef.h
ctype.h math.h stdio.h
errno.h setjmp.h stdlib.h
float.h signal.h string.h
limits.h stdarg.h time.h
Bir çok C derleyicisinde yukarıdakilere ek olarak tanımlanmış başlık dosyaları da vardır.
Bunlar derleyicinin yardım kısmından veya derleyicinin kullanım kılavuzundan öğrenilebilir.
ilk.c programında kullanılan başlık dosyası stdio.h, #include ifadesi ile
derleme işlemine dahil edilmiştir. stdio.h standard giriş/çıkış (STandarD-Input-Output)
kütüphane fonksiyonları için bazı bildirimleri barındıran bir dosyasıdır. Programda kullanılan
printf() fonksiyonunu kullanmadan önce bu başlık dosyası programın başına mutlaka ilave
edilmelidir. Aksi halde derleme esnasında
undefined reference to _printf
şeklinde bir hata mesajı ile karşılaşılır.
1.5 Kaynak Kodunun Derlenmesi
C programları veya kaynak kodları (source code) uzantısı .c olan dosyalarda saklanır.
Kaynak kod, bir C derleyicisi (C compiler) ile nesne koduna (object code) daha sonra uygun

ir bağlayıcı (linker) programı ile işletim sistemininde çalıştırılabilen (executable) bir koda
dönüştürülür. Bazı işletim sistemleri ile kullanılan C Derleyicileri ve bu derleyicilerde ilk.c
programının komut satırında nasıl derleneceği Tablo 1.1'de verilmiştir. Eğer ismi geçen
derleyicinin bir editörü varsa ilk.c bu editör de derlenebilir.
Tablo 1.1: İşletim sistemleri, bazı derleyiciler ve derleme komutları
İşletim Sistemi Derleyici Derleme Çalıştırma
Microsoft C cl ilk.c ilk.exe
Borland Turbo C Web tcc ilk.c ilk.exe
MS-DOS / Borland C bcc ilk.c ilk.exe
Windows Zortec C ztc ilk.c ilk.exe
GCC (GNU Compiler Collection) gcc ilk.c -o
ilk.exe
Windows için Web ilk.exe
GCC (GNU Compiler Collection) gcc ilk.c -o
UNIX / Linux
Web
ilk ilk
./ilk veya nice
Bunların dışında, komut satırını kullanmadan, kodlarınızı Windows ortamında çalışan GCC
tabanlı DevC++ veya Salford Plato3 derleyicileri ile derlemek mümkün. Bu tip derleyicilerde
hata ayıklama işlemini kolaylaştırmak için kodlar farlı renkte gösterilir. Fakat program
çıktıları için kullanılan ekran klasik DOS ekranıdır. Şekil 1.1 ve 1.2"de bu programların ekran
görüntüleri verilmiştir.
Şekil 1.1: DevC++ derleyicine ait editör. Derleme ve çalıştırma işlemleri araç çubuğu
üzerindeki butonlarla yapılır.

Şekil 1.2: Silverfrost Salford (Plato3) derleyicine ait editör. Derleme, bağlama ve çalıştırma
işlemleri araç çubuğu üzerindeki butonlarla yapılır.
Derslerimizde kullanılan kaynak kodları, Turbo C ve GCC derleyicileri ile komutsatırında
derlenmiştir. Turbo C derleyicisi isteğe bağlı editörden veya komut satırından derlenebilir.
Editörü başlatmak için C:\TC> dizini altındaki TC.EXE dosyasının çalıştırılması yeterlidir.
Şekil 1.3'de Turbo C editör ortamı gösterilmiştir.

Şekil 1.3: Turbo C derleyicisine ait editör. Derleme için F9, Derleme bağlama ve çalıştırma
işlemleri için CTRL+F9 tuş kombinasyonu kullanılabilir..
ilk.c nin Borland Turbo C ve GCC Programları ile derlenmesi ve çalıştırılması:
DERLEME ve ÇALIŞTIRMA
MS DOS (Turbo C)
C:\TC> tcc ilk.c
C:\TC> ilk.exe
Linux (GCC)
$ gcc ilk.c -o ilk
$ ./ilk
ilk.c nin çıktısı:
ÇIKTI
Merhaba Dünya!
1.6 C Kodlarının Temel Özellikleri
Bir C programı aşağıda verilen özellikleri mutlaka taşımalıdır.
• Yazılımda kullanılacak olan her fonksiyon için ilgili başlık dosyası programın başına
ileve edilmedlidir.
• Her C programı main() fonksiyonunu içermelidir.
• Program içinde kullanılacak olan değişkenler ve sabitler mutlaka tanımlanmalıdır.
• Satırın sonuna ; işareti konmalıdır.
• Her bloğun ve fonksiyonun başlangıcı ve bitişi sırasıyla { ve } sembolleridir.

• C dilinde yazılan kodlarda küçük-büyük harf ayrımı vardır (case sensitive).
Örneğin A ile a derleyici tarafından farklı değerlendirilir.
• Açıklama operatörü /* */ sembolleridir.
1.7 Kod Yazımı için Bazı Tavsiyeler
• Program açıklamaları ve döküman hazırlama program yazıldıkça yapın! Bu
unutulmaması gereken çok önemli husustur.
• Değişken, sabit ve fonksiyon adları anlamlı kelimelerden seçilip yeterince uzun
olmalıdır. Eğer bu isimler bir kaç kelimeden oluşacak ise, kelimeler alt çizgi ( _ ) ile
ayrılmalıdır veya her kelime büyük harfle başlamalıdır. Örneğin:
•
• int son_alinan_bit;
• void KesmeSayisi();
• float OrtalamaDeger = 12.7786;
• Sabitlerin bütün harflerini büyük harfle yazın. Örneğin:
•
• #define PI 3.14;
• const int STATUS=0x0379;
• Her alt yapıya girerken birkaç boşluk veya TAB tuşunu kullanın. Bu okunabilirliği
arttıracaktır. Örneğin:
•
• k = 0;
• for(i=0; i

• Giriş
• 2.1 Veri Tipleri
• 2.2 Değişkenler
• 2.3 Sabitler
• 2.4 Rakamsal Bilgiler
• 2.5 Değişken Bildirim Yerleri ve Türleri
• 2.6 Tip Dönüşümleri
Giriş
Orta ve yüksek seviyeli dillerin hemen hemen hepsinde veri tipi ve değişken kavramı
bulunmaktadır. Bu kısımda C programlama dilindeki temel veri tipleri, tanımlayıcılar,
değişkenler ve sabitler konu edilecektir.
2.1 Veri Tipleri
Veri tipi (data type) program içinde kullanılacak değişken, sabit, fonksiyon isimleri gibi
tanımlayıcıların tipini, yani bellekte ayrılacak bölgenin büyüklüğünü, belirlemek için
kullanılır. Bir programcı, bir programlama dilinde ilk olarak öğrenmesi gereken, o dile ait veri
tipleridir. Çünkü bu, programcının kullanacağı değişkenlerin ve sabitlerin sınırlarını belirler.
C programlama dilinde dört tane temel veri tipi bulunmaktadır. Bunlar:
char
int
float
double
Fakat bazı özel niteleyiciler vardır ki bunlar yukarıdaki temel tiplerin önüne gelerek onların
türevlerini oluşturur. Bunlar:
short
long
unsigned
Bu niteleyiciler sayesinde değişkenin bellekte kaplayacağı alan isteğe göre değiştirilebilir.
Kısa (short), uzun (long), ve normal (int) tamsayı arasında yalnızca uzunluk farkı vardır.
Eğer normal tamsayı 32 bit (4 bayt) ise uzun tamsayı 64 bit (8 bayt) uzunluğunda ve kısa
tamsayı 16 biti (2 bayt) geçmeyecek uzunluktadır. İşaretsiz (unsigned) ön eki kullanıldığı
taktirde, veri tipi ile saklanacak değerin sıfır ve sıfırdan büyük olması sağlanır. İşaretli ve
işaretsiz verilerin bellekteki uzunlukları aynıdır. Fakat, işaretsiz tipindeki verilerin üst limiti,
işaretlinin iki katıdır.
NOT
Kısa ve uzun tamsayı tutacak tanımlayıcılar için int
anahtar kelimesinin yazılmasına gerek yoktur.
short s; /* short int s; anlamında */
long k; /* long int k; anlamında */

Bir C programı içerisinde, veri tiplerinin bellekte kapladığı alan sizeof operatörü ile
öğrenilebilir. İlgi cekici olan, bu alanların derleyiciye ve işletim sistemine bağlı olarak
değişiklik göstermesidir. Program 2.1'de, sizeof operatörü kullanılarak, veri tiplerinin bellek
uzunlularının nasıl ekrana yazdırılacağı gösterilmiştir. Programın çıktısı, farklı derleyiciler ve
işletim sisteminde denendiğinde bu durum daha iyi anlaşılır. Lütfen inceleyin.
Program 2.1: Değişken tipleri ve türevlerinin bellekte kapladıkları alanlar
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
ÇIKTI
/* 02prg01.c : sizeof operatörünün kullanımı */
#include
main()
{
printf( "char
sizeof(char));
printf( "short
sizeof(short));
printf( "int
sizeof(int));
printf( "long
sizeof(long));
: %d bayt\n",
: %d bayt\n",
: %d bayt\n",
: %d bayt\n",
printf( "unsigned char : %d bayt\n",
sizeof(unsigned char));
printf( "unsigned short : %d bayt\n",
sizeof(unsigned short));
printf( "unsigned int
sizeof(unsigned int));
printf( "unsigned long
sizeof(unsigned long));
printf( "float
sizeof(float));
printf( "double
sizeof(double));
printf( "long double
sizeof(long double));
}
: %d bayt\n",
: %d bayt\n",
: %d bayt\n",
: %d bayt\n",
: %d bayt\n",
Windows (32 bit) Turbo C Windows (32 bit) Salford
Linux (32 bit) GCC
Linux (64
bit) GCC

char : 1
bayt
short : 2
bayt
int : 2
bayt
long : 4
bayt
unsigned char : 1
bayt
unsigned short : 2
bayt
unsigned int : 2
bayt
unsigned long : 4
bayt
float : 4
bayt
double : 8
bayt
long double : 10
bayt
char : 1
bayt
short : 2
bayt
int : 4
bayt
long : 4
bayt
unsigned char : 1
bayt
unsigned short : 2
bayt
unsigned int : 4
bayt
unsigned long : 4
bayt
float : 4
bayt
double : 8
bayt
long double : 10
bayt
char : 1
bayt
short : 2
bayt
int : 4
bayt
long : 4
bayt
unsigned char : 1
bayt
unsigned short : 2
bayt
unsigned int : 4
bayt
unsigned long : 4
bayt
float : 4
bayt
double : 8
bayt
long double : 12
bayt
char
: 1 bayt
short
: 2 bayt
int
: 4 bayt
long
: 8 bayt
unsigned
char :
1 bayt
unsigned
short :
2 bayt
unsigned
int :
4 bayt
unsigned
long :
8 bayt
float
: 4 bayt
double
: 8 bayt
long
double
: 16
bayt
int veritipi ve türevleri ile hesaplanabilecek en küçük ve en büyük tamsayılar için aşağıdaki
formül kullanılabilir:
Alt sınır = -2 8*sizeof(tip)
Üst sınır = 2 8*sizeof(tip) -1
Örneğin 4 baytlık bir int tipi için:
Alt sınır = -2 8*sizeof(int) = -2 32 = -2147483648
Üst sınır = 2 8*sizeof(int) -1 = 2 32 -1 = 2147483647
Tablo 2.1'de bütün tipler, bellekte kapladıkları alanlar ve hesaplanabilcek (bellekte doğru
olarak saklanabilecek) en büyük ve en küçük sayılar listelenmiştir.
Tablo 2.1: Değişken tipleri ve bellekte kapladıkları alanlar
Veri Tipi Açıklama
Bellekte
işgal ettiği
Alt sınır
boyut
Üst sınır
(bayt)
char Tek bir -128 127
karakter veya
unsigned
1
küçük
char
tamsayı için
0 255
short int Kısa tamsayı
-32,768 32,767
unsigned
2
için
short int
0 65,535

-2,147,483,648 2,147,483,647
int
Tamsayı için 4
0 4,294,967,295
int
unsigned
-
long int Uzun
tamsayı için 8 9,223,372,036,854,775,808 9,223,372,036,854,775,807
unsigned
long int
0 18,446,744,073,709,551,615
Tek duyarlı
gerçel sayı
float
4
için (7
-3.4e +/- 38 +3.4e +/- 38
basamak)
Çift duyarlı
gerçel sayı
double
8
için (15
-1.7e +/- 308 +1.7e +/- 308
basamak)
2.2 Değişkenler
Değişkenler bilgisayarın geçici belleğinde bilginin saklandığı gözlere verilen sembolik
adlardır. Bir C programında, bir değişken tanımlandığında bu değişken için bellekte bir yer
ayrılır. Her değişkenin tuttuğu değerin nasıl bir veri olduğunu gösteren (önceki bölümde
anlatılan) bir veri tipi vardır [1], [3].
C programlama dilinde, değişkenler ve sabitler programın başında bulunmalıdır. Bazı
uygulamalarda değişkenin bir başlangıç değerinin olması istenir. Böyle durumlarda değişken
bildirilirken başlangıç değeri verilebilir. Örneğin:
char isim='X', z; /* değer atamak zorunlu değil */
int sayi=0, n;
float toplam=0.0, sonuc=22.14;
Değişken isimleri verirken bazı kurallara uymak zorunludur. Bunlar:
• Değişken adları en fazla 32 karakterden oluşabilir. 32 karakterden uzun değişken
adları ilk 32 karakteri değerlendirilir. Geriye kalan karakterler işleme tabi tutulmaz.
• Değişken adları ingiliz alfabesinde bulunan karakterler (A-Z) veya (a-z) yada rakamlar
(0-9) ile yazılmalıdır. Türkçe karakterler, özel karakter veya boşluk karakteri
kullanılamaz.
• Değişken adları herhangi bir rakam ile başlayamaz. Ilk karakter bir harf olamalıdır.
Sonrakiler rakamlardan oluşabilir.
• Aşağıda verilen kelimeler ANSI C 'nin anahtar kelimeleridir (key words) ve değişken
ismi olarak kullanılamaz.
•
• auto double int struct
• break else long switch
• case enum register typedef
• char extern return union

• const float short unsigned
• continue for signed void
• default goto sizeof volatile
• do if static while
Bu kurallara göre aşağadaki değişken (sabit, fonksiyon) adlarının geçerliliğini inceleyiniz.
Değişken/Sabit/Fonksiyon/Yapı Adı Geçerlilik Açıklama
asal geçerli -
Momentum geçerli -
ivme geçerli -
olasilik geçerli -
IsikHizi geçerli -
isik_hizi geçerli Alt çizgi karakteri '_' kullanılabilir
isik hizi geçersiz Boşluk karakteri kullanılamaz
ışık_hızı geçersiz Türkçe karakter kullanılamaz
1Bit geçersiz rakam ile başlanamaz
typedef geçersiz Anahtar kelimelerden birisi kullanılamaz
2.3 Sabitler
Sabit bildirimi, başlangıç değeri verilen değişken bildirimi gibi yapılır. Ancak, veri tipinin
önüne const anahtar sözcüğü konmalıdır. Örneğin:
const float PI = 3.142857;
const double NOT= 12345.8596235489;
const int EOF= -1;
const char[] = "devam etmek için bir tuşa basın...";
gibi sabit bildirimleri geçerli olup bunların içerikleri program boyunca değiştirilemez.
Yalnızca kullanılabilir. Genellikle, sabit olarak bildirilen değişken isimleri büyük harflerle,
diğer değişken isimlerinin ise küçük harflerle yazılması (gösterilmesi) C programcıları
tarafından geleneksel hale gelmiştir.
Birçok C programında sabitler #define önişlemci komutu ile de tanımlandığını görebilirsiniz.
Bu komutla sabit bildirimi, bir program parçasına ve makro fonksiyon tanımlaması
yapılabilir. Bir program geliştirilirken simgesel sabitlerin kullanılması programın
okunurluğunu arttırır ve bazen gerekli de olabilir. Aşağıda verilen simgesel sabit bildirimleri
geçerlidir.
#define MAX 100
#define DATA 0x0378
#define YARICAP 14.22

2.4 Rakamsal Bilgiler
C programlama dili içinde tanımlanabilecek sabit rakamlar rakamsal bilgi (literal) olarak
adlandırılır. Her veri tipi kendi rakamsal bilgisine sahiptir. Bu bilgiler, kaynak kod içerisinde,
özel değerleri ifade eder. Örneğin aşağıdaki atama işleminde 25 ve 17.2 sayıları gibi:
i = 25; /* 25, int tipinde bir rakamsal bilgidir */
r = 17.2; /* 17.2, double tipinde bir rakamsal bilgidir */
C dilinde bütün tamsayı sabitler varsayılan (default) olarak int tipinde, gerçel sayı sabitler
varsayılan olarak double tipindedir. Ancak sabitleri gösteren rakamların sonuna eklenecek U
(veya u), L (veya l) ve F (veya f) harfleri ile bu durum değiştirilebilir. Bu yüzden, aşağıdaki
atamalar aynı anlamda değildir.
i = 25; /* int rakam */
i = 25U; /* unsigned int rakam */
i = 25L; /* long int rakam */
i = 25UL; /* unsigned long rakam */
i = 25L; /* long int rakam */
r = 17.2; /* double rakam */
r = 17.2L; /* long double rakam */
r = 17.2F; /* float rakam */
Tamsayı (int) rakamsal bilgiler, 8 (oktal) ve 16 (hexadesimal) sayı tabanında da
gösterilebilir. Bunun için sabit rakamın başına, 8 tabanı için 0 (sıfır) ve 16 tabanını için 0x
sembolleri eklenir. 16'lık sistemdeki hafler büyük (A, B, C, D, E ve F) veya küçük (a, b, c ,d,
e ve f) olabilir. Buna gösterime göre, aşağıdaki atmalar aynı anlamadadır:
i = 75; /* i = 75, 10 tabanında */
i = 0113; /* i = 75, 8 tabanında */
i = 0x4b; /* i = 75, 16 tabanında */
i = 0x4B; /* i = 75, 16 tabanında */
Gerçel sayılar ondalıklı veya üstel olmak üzere iki biçimde gösterilebilir. Örneğin 123.456
sayısının aynı anlama gelen dört farklı gösterimi aşağıda verilmiştir. Üstel gösterimde,
1.23456e+2 veya 1.23456E+2 sayısı matematikteki 1.23456 x 10 2 gösterimi ile eşdeğerdir.
x = 123.456; /* ondalıklı gösterimi */
x = 123.456e+0; /* üstel gösterim */
x = 1.23456e+2; /* üstel gösterim */
x = 1234.56E-1; /* üstel gösterim */
Karakter sabitler, bir harf için tek tırnak, birden çok karakter için çift tırnak içinde belirtilirler.
'A' /* bir karakter */
"Merhaba Dunya" /* bir karakter kümesi */
Program 2.1'de, program içinde tanımlanan değişken sabitlerin ekrana nasıl yazdırılacağı
gösterilmiştir.
Program 2.2: Değişkenlerin ve sabitlerin ekrana yazdırılması
01: /* 02prg02.c : Değişkenler ve sabitlerin ekrana

02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
ÇIKTI
yazdırılması */
#include
#define PI 3.141593
int main()
{
const int MAX = 100;
char c = 'a';
char *s = "Bu bir sicim";
int i = 22;
float f = 33.3;
double d = 44.4;
printf("PI = %lf\n",PI);
printf("MAX= %d\n", MAX);
printf("c = %c\n", c);
printf("s = %s\n", s);
printf("i = %d\n", i);
printf("f = %f\n", f);
printf("d = %lf\n",d);
return 0;
}
PI = 3.141593
MAX= 100
c = a
s = Bu bir sicim
i = 22
f = 33.299999
d = 44.400000
2.5 Değişken Bildirim Yerleri ve Türleri
Yerel (local) Bildirim
Yerel değişkenler kullanıldığı fonksiyon içerisinde bildirilir. Yalnızca bildirildiği fonksiyon
içerisinde tanınır ve kullanılabilir.
int topla(int a,int b)
{
/* yerel (local) değişken c nin bildirimi */
int c;
c = a + b;
return c;
}
Genel (general) Bildirim

Genel değişkenler bütün fonksiyonların dışında bildirilir. Bir değişken program boyunca
sürekli olarak kullanılıyorsa genel olarak bildirilmelidir.
#include
void karesi();
/* m ve n global tip değişkendir.
Bu iki değişken tüm program boyunca kullanılmaktadır. */
int m,n;
main()
{
m=7;
karesi();
printf("%d nin karesi %d dir",m,n);
}
void karesi(){
n = m*m;
}
2.6 Tip Dönüşümleri
Bir formül içerisinde bir çok değişken veya sabit olabilir. Bu değişken ve sabitler birbirinden
farklı tipte olursa, hesap sonucunun hangi tipte olacağı önemlidir. Bir bağıntıda, içeriği
dönüşüme uğrayan değişkenler eski içeriklerini korurlar. Dönüştürme işlemi için geçiçi bellek
alanı kullanılır; dönüştürülen değer kullanıldıktan sonra o alan serbest bırakılır.
char kr;
int tam;
long int ltam;
unsigned int utam;
short int stam;
float f;
double d;
bildirimlerine göre:
Bağıntı Sonuç Tipi
------- ----------
kr+5 int
kr+5.0 double
d+tam double
f+d-2 double
utam-tam unsigned
ltam*tam long
tam/2 int
tam/2.0 double
NOT
Tamsayılar arası bölme kesme hatalarına (truncation error)
neden
olur.
Bunun anlamı iki tamsayının oranı yine bir tamsayıdır.

örneğin: 4/2=2; ama 3/2=1 (1.5 değil).
Bir değişkenin sabit değerin veya bağıntının önüne tür veya takı (cast) yazılarak sonucun
hangi tip çıkması istendiği söylenebilir. Genel yazım biçimi:
(tür tipi) bağıntı;
Örneğin:
int x=9;
float a,b,c;
double d;
...
a = x/4;
b = x/4.0;
c = (float) x/4;
işleminin sonucunda a değişkenine 2.0, b ve c değişkenlerine 2.25 değeri aktarılır. Yani 9/4
ile 9/4.0 farklı anlamdadır.
Ders 3: Operatörler
• Giriş
• 3.1 Aritmetik Operatörler
• 3.2 Atama Operatörleri
• 3.3 sizeof Operatörü
Giriş
Operatörler, değişkenler veya sabitler üzerinde matematiksel ve karşılaştırma işlemlerini
yapan simgelerdir. Yani bir operatör bir veya daha fazla nesne (değişken) üzerinde işlem
yapan sembollerdir. Bu kısımdam aritmetik operatörler, atama operatörleri ve sizeof
operatörü anlatıcaktır. Karşılaştırma Operatörleri, Mantıksal Operatörler ve Bit Düzeyinde
işlem yapan operatörler daha sonraki bölümlerde incelenektir.
3.1 Aritmetik Operatörler
Değişken veya sabitler üzerinde temel aritmetik işlemleri gerçekleyen operatörlerdir. Bunlar
Tablo 3.1'de listelenmiştir.
Tablo 3.1: Aritmetik Operatörler
Operatör Açıklama Örnek Anlamı
+ toplama x + y x ve y nin toplamı
- çıkarma x - y x ve y nin farkı
* carpma x * y x ve y nin çarpımı
/ bölme x / y x ve y nin oranı

% artık bölme x % y x / y den kalan sayı
3.2 Atama Operatörleri
Bu operatörler bir değişkene, bir sabit vaya bir aritmetik ifade atamak (eşitlemek) için
kullanılır.
Birleşik atama: bazı ifadelerde işlem operatörü ile atama operatörü birlikte kullanılarak,
ifadeler daha kısa yazılabilir. Eğer ifade
değişken = değişken [operatör] aritmetik ifade;
şeklinde ise, daha kısa bir biçimde
değişken [operatör]= aritmetik ifade;
olarak yazılabilir. Bu operatörler Tablo 3.2'de listelenmiştir.
Tablo 3.2: Atama Operatörleri
Operatör Açıklama Örnek Anlamı
= atama x = 7; x = 7;
+= ekleyerek atama x += 3 x = x + 3
-= eksilterek atama x -= 5 x = x - 5
*= çarparak atama x *= 4 x = x * 4
/= bölerek atama x /= 2 x = x / 2
%= bölüp, kalanını atama x %= 9 x = x % 9
++ bir arttırma x++ veya ++x x = x + 1
-- bir azaltma x-- veya --x x = x - 1
Bu tanımlamalara göre, aşağıdaki atamaları inceleyiniz:
/* bir arttırma işlemleri */
i++;
++i;
i += 1;
i = i + 1;
/* karmaşık atamalar */
f *= i; // f = f * i; anlamında
f *= i+1; // f = f * (i+1); anlamında
z /= 1 + x; // z = z / (1+x); anlamında
Bir arttırma veya eksiltme operatörlerini kullanırken dikkatli olunmalıdır. Çünkü aşağıdaki
türden atamalar bazen karışıklığa neden olur.
a = 5; // a = 5
b = a++; // a = 6 ve b = 5
c = ++a; // a = 7 ve c = 7

Program 3.1: Aritmetik ve atama operatörlerinin kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
ÇIKTI
/* 03prg01.c: Aritmetik ve atama operatorlerinin
kullanimi */
#include
main()
{
int x, y; /* yerel degikenlerin bildirimi
*/
x = 1; /* x in baslangic degeri */
y = 3; /* y nin baslangic degeri */
printf(" x = %d ve y = %d, olarak
veriliyor.\n", x, y);
x = x + y;
printf("x

09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
ÇIKTI
int i; /* bir tamsayı */
int dizi[5]; /* 5 elemanlı bir
tamsayı dizi */
double d; /* bir gercel sayı */
double mizan[6]; /* 6 elemanlı bir
gercel dizi */
char c; /* tek bir karakter */
char str[] = "masa"; /* bir karakter
topluluğu */
printf("sizeof(int) = %d\n",sizeof(int));
printf("sizeof(i) = %d\n",sizeof(i));
printf("sizeof(dizi) =
%d\n\n",sizeof(dizi));
printf("sizeof(double)=
%d\n",sizeof(double));
printf("sizeof(d) = %d\n",sizeof(d));
printf("sizeof(mizan) =
%d\n\n",sizeof(mizan));
printf("sizeof(char) = %d\n",sizeof(char));
printf("sizeof(c) = %d\n",sizeof(c));
printf("sizeof(str) = %d\n",sizeof(str));
return 0;
}
sizeof(int) = 4
sizeof(i) = 4
sizeof(dizi) = 20
sizeof(double)= 8
sizeof(d) = 8
sizeof(mizan) = 48
sizeof(char) = 1
sizeof(c) = 1
sizeof(str) = 5
Programda sizeof(int) değeri ile sizeof(i) değerinin aynı olduğu görülür. dizinin
boyutu 5 olduğu için, sizeof(dizi) = sizeof(int)*5 = 20 şeklinde hesaplanmaktadır.
Diğerleri için benzer durum söz konusu. Ancak, str 4 elemanlı bir dizi olduğu halde
sizeof(str) = 5 dir. Neden? Bunu ilerideki bölümlerde öğreneceğiz.
Ders 4: Temel Giriş/Çıkış Fonksiyonları
• Giriş
• 4.1 printf() Fonksiyonu

• 4.2 scanf() Fonksiyonu
• 4.3 puts() Fonksiyonu
• 4.4 gets() Fonksiyonu
• 4.5 getchar() Fonksiyonu
• 4.6 Formatlı Çıktı
Giriş
Temel giriş/çıkış fonksiyonları, bütün programla dillerinde mevcuttur. Bu tür fonksiyonlar,
kullanıcıya ekrana veya yazıcıya bilgi yazdırmasına, ve bilgisayara klavyeden veri girişi
yapmasına izin verir. Temel giriş/çıkış fonksiyonları kullanılırken stdio.h başlık dosyası
programın başına eklenmelidir. Bu kısımda, en çok kullanılan giriş/çıkış fonksiyonları
anlatılacaktır.
4.1 printf() Fonksiyonu
Standart C kütüphanesinde bulunan printf() fonksiyonu, değişkenlerin tuttuğu değerleri,
onların adreslerini veya bir mesajı ekrana belli bir düzenle (format) standart çıkışa (stdout),
yani ekrana, yazdırmak için kullanılan fonksiyondur. Daha önce yazılan örnek programlarda
printf() fonksiyonundan yararlanmıştık. Şimdi bu fonksiyonun nasıl kullanıldığına bakalım.
Genel yazım biçimi:
int printf(const char *format, ...);
Basit olarak ekrana Hata oluştu!.. şeklinde bir mesaj yazırma işlemi:
printf("Hata Oluştu!..");
şeklindedir. Çoğu zaman ekrana, programda kullanılan bir değişkenin değeri yazdırılmak
istenebilir. Örneğin ekrana bir tamsayı değişkeninin içeriğini basırımak için, printf()
....
int x = 12;
printf("x in değeri %d dir", x);
....
gibi kullanılır. Bu program parçasının ekran çıktısı şöyle olacaktır:
x in değeri 12 dir
Bu örnekte printf fonksiyonuna iki parametre aktarılmıştır. Birincisi ekranda gösterilecek ve
çift tırnaklar arasına yazılan ifadeler, ikincisi ise ekranda sayısal değeri gösterilmek istenen
değişken (x).
*format üç kısımdan oluşmaktadır:
I. Düz metin (literal string): yazdırılmak istenen ileti.

II.
Örneğin: printf("Ben gelmedim kavga için..."); gibi.
Konrol karakterleri (escape squence): değişkenlerin ve sabitlerin nasıl yazılacağını
belirtmek veya imlecin alt satıra geçirilmesi gibi bazı işlemlerin gerçekleştirilmesi için
kullanılır. Bu karakterler Tablo 4.1'de listelenmiştir.
Örneğin: printf("\tDostun evi gönlüdür...\n"); gibi.
Tablo 4.1: Kontrol karakterleri
Karakter Anlamı
\a Ses üretir (alert)
\b imleci bir sola kaydır (backspace)
\f Sayfa atla. Bir sonraki sayfanın başına geç (formfeed)
\n Bir alt satıra geç (newline)
\r Satır başı yap (carriage return)
\t Yatay TAB (horizontal TAB)
\v Dikey TAB (vertical TAB)
\" Çift tırnak karakterini ekrana yaz
\' Tek tırnak karakterini ekrana yaz
\\ \ karakterini ekrana yaz
%% % karakterini ekrana yaz
III.
Tip belirleyici (conversion specifier): % işareti ile başlar ve bir veya iki karakterden
oluşur (%d gibi). Ekrana yazdırılmak istenen değişkenin tipi, % işaretinden sonra
belirtilir (Bkz. Tablo 4.2) Örneğin: printf("x in değeri %d dir"); gibi.
Tablo 4.2: Tip karakterleri
Tip Karakteri Anlamı Yazdırılacak veri tipi
%c tek bir karakter char
%s karakter dizisi (string) char
%d işaretli ondalık tamsayı int, short
%ld uzun işaretli ondalık tamsayı long
%u işaretsiz ondalık tamsayı unsigned int, unsigned short
%lu işaretsiz uzun tamsayı unsigned long
%f Gerçel sayı float
%lf Çift duayarlı gerçel sayı double
Tip karakterlerini kullanarak, birden çok veri tipi yazdırılabilir. Örneğin:
...
int not= 12;
float pi = 3.14;
char kr = 'A';
gibi.
printf(" not = %d , pi = %f ve kr = %c dir", not, pi, kr);
...
printf() fonksiyonu esnektir. Parametreler herhangi bir C deyimi olabilir. Örneğin x ve y

nin toplamı şöyle yazılabilir:
printf("%d", x+y);
printf fonksiyonu kullanımı Program 4.1'de verilmiştir.
Program 4.1: printf() fonksiyonunun kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
/* 04prg01.c
Sayısal değerleri ekrana yazdırmak için
printf fonksiyonunun kullanımı */
#include
main()
{
int a = 2, b = 10, c = 50;
float f = 1.05, g = 25.5, h = -0.1, yuzde;
printf("3 tamsayi : %d %d %d\n", a, b,
c);
printf("3 tamsayi [TAB] : %d \t%d \t%d\n",
a, b, c);
printf("\n");
printf("3 reel sayi (yanyana) : %f %f %f\n",
f, g, h);
printf("3 reel sayi (altalta) :
\n%f\n%f\n%f\n\n", f, g, h);
yuzde = 220 * 25/100.0;
printf("220 nin %%25 i %f dir\n", yuzde);
printf("%f/%f isleminin sonucu = %f\n", g,
f, g / f);
printf("\nprogram sonunda beep sesi
cikar...\a");
}
return 0;
ÇIKTI
3 tamsayi : 2 10 50
3 tamsayi [TAB] : 2 10 50
3 reel sayi (yanyana) : 1.050000 25.500000 -0.100000
3 reel sayi (altalta) :
1.050000
25.500000
-0.100000
220 nin %25 i 55.000000 dir
25.500000/1.050000 isleminin sonucu = 24.285715
program sonunda beep sesi cikar...

printf fonksiyonunun geri dönüş değeri int tipindedir. Bu geri dönüş değeri çıktının kaç
karakter olduğunu gösterir. Yani, printf fonksiyonu, *format ile tanımlanmış karakter
topluluğunun kaç bayt olduğu hesaplar[6]. Program 4.2, printf'in bu yönünüde ortaya
çıkaran bir programdır.
Program 4.2: printf() fonksiyonunun kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
/* 04prg02.c
printf fonksiyonunun geri dönüş değerini
gösterir */
#include
int main()
{
int karSay;
int sayi = 1234;
karSay = printf("Ugurlu sayim = %d\n",sayi);
printf("Ust satirda karakter sayisi: %d
dir\n", karSay);
}
ÇIKTI
return 0;
Ugurlu sayim = 1234
Ust satirda karakter sayisi: 20 dir
11. satırdaki işlemle, hem ekrana Ugurlu sayim = 1234 iletisi bastırılmakta, hem de karSay
değişkenine bu iletinin uzunluğu atanmaktadır. Ekrana basılan karakterlerin sayısı (\n
karakteri dahil) 20 dir.
4.2 scanf() Fonksiyonu
Birçok programda ekrana verilerin bastırılmasının yanısıra klavyeden veri okunması
gerekebilir. scanf() fonksiyonu klavyeden veri okumak için kullanılan fonksiyondur.
printf() gibi scanf() fonksiyonuda Tablo 4.1 ve Tablo 4.2'de verilen karakterleri kullanır.
Örneğin klaveden bir x tamsayısı okumak için:
scanf("%d",&x);
satırını yazmak yeterli olacaktır. Burada & işareti adres operatörü olarak adlandırılır ve Böüm
11'de ayıntılı olarak açıklanacaktır. Klavyeden iki farklı sayı okunmak istendiğnde scanf()
fonksiyonu şöyle kullanılabilir:
scanf("%d %f",&x,&y);

veriler klavyeden
16 1.56
yada
16 1.56
veya
16
1.56
şekilinde girilebilir. Program 4.3'de scanf() fonsiyonunun kullanımı gösterilmiştir.
Program 4.3: scanf() fonksiyonun kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
ÇIKTI
/* 04prg03.c
scanf() fonksiyonu ile int ve float
tipindeki verilerin okunması */
#include
main()
{
int t;
float g;
printf("Bir gercel sayi girin: ");
scanf("%f",&g);
printf("Bir tamsayi girin : ");
scanf("%d",&t);
printf("\n");
printf("\t %f * %f = %f\n",g,g,g*g);
printf("\t %d * %d = %d\n",t,t,t*t);
return 0;
}
Bir gercel sayi girin: 1.34
Bir tamsayi girin : 12
1.340000 * 1.340000 = 1.795600
12 * 12 = 144
4.3 puts() Fonksiyonu
Ekrana yazdırılacak ifade bir karakter topluluğu ise, printf()'e alternatif olarak puts()
fonksiyonu kullanılabilir. Ancak puts(), ekrana bu karakter topluluğu yazdıktan sonra,
imleci alt satıra geçirir. Buna göre:
printf("Sevgi varlığın mayasıdır.\n");
ile
puts("Sevgi varlığın mayasıdır.");
kullanımları eşdeğerdir.

puts() fonksiyonu Tablo 4.1 de verilen kontrol karakterleri ile kullanılabilir.
puts("Bu birinci satır...\nBu ikinci satır.");
Bu birinci satır...
Bu ikinci satır.
4.4 gets() Fonksiyonu
Klavyeden bir karakter topluluğu okumak için kullanılır. Okuma işlemi yeni satır
karakteriyle(\n) karşılasılıncaya kadar sürer. puts() - gets() arsındaki ilişki, printf() -
scanf() arasındaki gibidir. Yani,
ile
scanf("%s",str);
gets(str);
aynı anlamdadır. puts() - gets() fonksiyonlarının kullanımı daha sonra ayrıntılı
işlenecektir.
4.5 getchar() Fonksiyonu
Bu fonksiyon ile standart girişten bir karakter okunur. Programı istenen bir yerde dudurup, bir
karakater girinceye kadar bekletir. Örneğin:
...
for(i=0; i

Stringlerde %s yerine %ws
biçimindeki kullanım ile sağlanır. Burada w yazılacak olan sayının alan genişliği olarak
adlandırılır. Gerçel bir değişken ekrana yazılacaksa, değişkenin virgülden sonra kaç
basamağının yazdırılacağı k sayısı ile belirlenir. Ancak w > k + 2 olmalıdır.
int i=583,j=1453;
printf("%d %d\n",i,j); /* serbest biçim */
printf("%5d %8d\n",i,j); /* formatlı */
program parçasının ekran çıktısı şöyledir:
ÇIKTI
583 1453
583 1453
Birinci satır serbest formatta ikinci satır ise formatlı yazılmıştır. i değişkeninin tuttuğu 583
sayısı %5d formatıyla yazdırılınca, bu sayı için 5 alan genişliği tanımlanır arakasından sağdan
başlayarak sayı bu alana yazılır. Benzer olarak j değişkeni, 8 alan genişlikli bir bölgeye
yazılır.
Gerçel sayılarda iş biraz daha karışık. Örneğin:
int x=123.456;
printf("%f\n",x); /* serbest biçim */
printf("%8.2f\n",x); /* formatlı */
program parçası çalıştırıldığında aşağıdaki sonuç gözlenir:
ÇIKTI
123.456001
123.46
Birinci satır serbest formatta ikinci satır ise formatlı yazılmıştır. İkinci satırda x değişkeni için
ayrılan alan genişliği 8 ve noktadan sonra 2 basamağa kadar hassasiyet önemsenmiştir. Dikkat
edilirse noktadan sonra sayı uygun bir şekilde yuvarlanmış ve sayı sağa dayalı olarak
yazılmıştır.
Son olarak formatlı çıktı ile ilgili bir örnek Program 4.4'de verilmiştir. İnceleyiniz.
Program 4.4: printf() in formatlı kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
/* 04prg04.c: Formatlı çıktı */
#include
main()
{
float x = 7324.25, y = 244.531;
int i = 1299;
char *c = "Merhaba C";

10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
}
printf("%10d\n" ,i);
printf("%10s\n" ,c);
printf("%10.5f\n",x);
printf("%10.1f\n",y);
return 0;
ÇIKTI
1299
Merhaba C
7324.25000
244.5
Ders 5: Temel Kütüphane Fonksiyonları
• Giriş
• 5.1 Matematiksel Fonksiyonlar (math.h)
• 5.2 Standart Kütüphane Fonksiyonları (stdlib.h)
• 5.3 Karakter Üzerinde İşlem Yapan Fonksiyonlar (ctype.h)
Giriş
Bu kısımda, C Programlama Dili'nde sık kullanılan ve diğer bölümlerde yararlanacağımız
kütüphane fonksiyonlarının bazıları işlenecektir. Kütüphane fonksiyonu C dilinde önceden
tanımlanmış hazır fonksiyonlarıdır. C dilinde birçok iş bu fonksiyonlarla yapılmaktadır.
Her kütüphane fonksiyonu bir başlık dosyasında tanımlanmıştır. Bu yüzden bir kütüphane
fonksiyonunu kullanmadan önce, onun hangi başlık dosyası ile kullanılması gerektiğini
bilmelisiniz.
5.1 Matematiksel Fonksiyonlar (math.h)
Matematiksel fonksiyonların hemen hemen hepsi double veri tipindedir. Bu fonksiyonlardan
biri program içinde kullanılacaksa math.h başlık dosyası program içine eklenmelidir. En çok
kullanılan matematiksel fonksiyonlar Tablo 5.1'de listelenmiştir.
Tablo 5.1: math.h kütüphanesinde tanımlı bazı fonksiyonlar

Fonksiyon Bildirimi Açıklama Örnek Sonuç
int abs(int x); x tamsayısının mutlak değerini hesaplar abs(-4) 4
x gerçel sayısının mutlak değerini
double fabs(double x); fabs(-4.0) 4.000000
hesaplar
double floor(double x'e (x'den büyük) en yakın tamsayıyı
abs(-2.7)
x);
3.000000
gönderir
x'e (x'den küçük) en yakın tamsayıyı
double ceil(double x); abs(5.6)
gönderir
5.000000
double sqrt(double x); pozitif x sayısının karekökünü hesaplar sqrt(4.0) 2.000000
double pow(double x,
double y);
x y pow(2.,
değerini hesaplar
3.)
8.000000
pozitif x sayısının doğal logaritmasını
double log(double x);
log(4.0)
hesaplar, ln(x)
1.386294
double log10(double pozitif x sayısının 10 tabanındaki
log10(4.0)
x);
0.602060
logaritmasını hesaplar
radyan cinsinden girilien x sayısının sinüs
double sin(double x);
sin(3.14) 0.001593
değerini hesaplar
radyan cinsinden girilien x sayısının
-
double cos(double x);
cos(3.14)
kosinüs değerini hesaplar
0.999999
radyan cinsinden girilien x sayısının
-
double tan(double x);
tan(3.14)
tanjant değerini hesaplar
0.001593
sinüs değeri x olan açıyı gönderir. Açı -
double asin(double x); asin(0.5) 0.523599
pi/2 ile pi/2 arasındadır.
cosinüs değeri x olan açıyı gönderir. Açı
double acos(double x); acos(0.5) 1.047198
-pi/2 ile pi/2 arasındadır.
tanjant değeri x olan açıyı gönderir. Açı -
double atan(double x); atan(0.5) 0.463648
pi/2 ile pi/2 arasındadır.
NOT
Bir programda math.h kütüphanesi kullanılacakca, GCC
derleyicisi -lm seçeneği ile birlikte kullanılmalıdır.
Örneğin test.c içinde math.h'i kullanıyorsa derleme:
gcc -lm test.c -o test
şeklinde yapılmalıdır. Aksi halde bir hata mesajı ile
karşılaşılır.
Trigonometrik (sin, cos, tan) fonksiyonlar kendisine parametre olarak gelen değeri radyan
olarak kabul eder ve sonucu hesaplar. Eğer açılar derece cinsinden hesaplanması gerekiyorsa
şu dönüşüm kullanılanılabilir:
radyan = (3.141593/180.0) * derece;
Program 5.1: sin(), cos(), and tan() fonksiyonlarının kullanımı
01:
02:
03:
04:
05:
/* 05prg01.c
30 dercelik açının sinüs, kosinüs, tanjant ve
kotanjant değerleri */
#include

06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
ÇIKTI
#include
#define PI 3.141593
int main()
{
double aci = 30.0;
aci *= PI/180.0; /* radyana çevir */
puts("30 derecenin");
printf("sinusu : %lf\n", sin(aci));
printf("kosinusu : %lf\n", cos(aci));
printf("tanjanti : %lf\n", tan(aci));
printf("kotanjanti: %lf\n", 1.0/tan(aci));
return 0;
}
30 derecenin
sinusu : 0.500000
kosinusu : 0.866025
tanjanti : 0.577350
kotanjanti: 1.732051
5.2 Standart Kütüphane Fonksiyonları (stdlib.h)
Standart kütüphanede, programı sonlandıran, dinamik bellek yönetiminde kullanılan veya
rastgele sayı üretme vb. işlevleri yerine getiren bir çok fonksiyon mevcuttur. Bu kısımda,
bunlardan bir kaçı Tablo 5.2'de listelenmiştir.
Tablo 5.2: stdlib.h kütüphanesinde tanımlı bazı fonksiyonlar
Fonksiyon
Bildirimi
int atoi(const
char *s);
long atol(const
char *s);
double atof(const
char *s);
void
durum);
exit(int
int rand(void);
max(a,b)
Açıklama Örnek Sonuç
Bir karakter topluluğunu tamsayıya
atoi("-12345")
çevirir
-12345
Bir karakter topluluğunu uzun
tamsayıya çevirir
Bir karakter topluluğunu gercel
atof("-123.546")
sayıya çevirir
-123.456
Programı sonlandırarak kontrolü
exit(1)
işletim sistemine geri verir.
-
0 ile RAND_MAX arasında rastgele
sayı
üretir.
rand() 50485132
RAND_MAX, stdlib.h içinde
atol("1234567890") 1234567890
tanımlanmış bir sembolik sabittir
stdlib.h'de tanımlanmış iki
sayıdan en büyüğünü bulan makro max(5, 9) 9

min(a,b)
fonksiyon
stdlib.h'de tanımlanmış iki
sayıdan en küçüğünü bulan makro
fonksiyon
min(5, 9) 5
Program 5.2: rand() fonksiyonu kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
ÇIKTI
/* 05prg02.c
0-100 arasında 10 tane rasgele sayı üretir */
#include
#include
int main()
{
int i, ri;
for(i=1; i

isdigit(c) c bir rakam ise 0 dan farklı, değilse 0 gönderir isdigit('4') 2
islower(c) c a-z arasında ise 0 dan farklı, değilse 0 gönderir islower('P') 0
isupper(c) c A-Z arasında ise 0 dan farklı, değilse 0 gönderir islower('P') 4
c sayısı ile verilen ASCII koda sahip karakteri elde
toascii(c)
toascii(65) A
eden makro
tolower(c) c karakterini küçük harfe çevirir tolower('D') d
toupper(c) c karakterini büyük harfe çevirir toupper('b') B
Program 5.3: ctype.h kütüphansinde bulunan bazı makroların kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
ÇIKTI
/* 05prg03.c
ASCII kodları 32-127 arasında olan
karakterler üzerinde
ctype.h kütüphanesinde tanımlı bazı
makroların kullanımı */
#include
#include
int main(void)
{
int i;
char c;
for(i=32; i

55 7 7 1
56 8 8 1
57 9 9 1
58 : : 0
59 ; ; 0
60 < < 0
61 = = 0
62 > > 0
63 ? ? 0
64 @ @ 0
65 A a 0
66 B b 0
67 C c 0
68 D d 0
69 E e 0
70 F f 0
71 G g 0
72 H h 0
73 I i 0
74 J j 0
75 K k 0
76 L l 0
77 M m 0
78 N n 0
79 O o 0
80 P p 0
81 Q q 0
82 R r 0
83 S s 0
84 T t 0
85 U u 0
86 V v 0
87 W w 0
88 X x 0
89 Y y 0
90 Z z 0
91 [ [ 0
92 \ \ 0
93 ] ] 0
94 ^ ^ 0
95 _ _ 0
96 ` ` 0
97 a a 0
98 b b 0
99 c c 0
100 d d 0
101 e e 0
102 f f 0
103 g g 0
104 h h 0
105 i i 0
106 j j 0
107 k k 0
108 l l 0
109 m m 0
110 n n 0
111 o o 0
112 p p 0
113 q q 0
114 r r 0
115 s s 0
116 t t 0
117 u u 0
118 v v 0
119 w w 0
120 x x 0
121 y y 0
122 z z 0
123 { { 0

124 | | 0
125 } } 0
126 ~ ~ 0
Ders 6: Karşılaştırma Deyimleri
• Giriş
• 6.1 Karşılaştırma Operatörleri ve Mantıksal Operatörler
• 6.2 if, if-else Yapısı
• 6.3 switch - case Yapısı
• 6.4 ? Karşılaştırma Operatörü
Giriş
Program içerisinde bazen iki veya daha fazla değerin karşılaştırılması gerekebilir. Bunun için,
bütün programlama dillerinde karşılaştırma deyimleri mevcuttur. C dili, if, switch ve ?
olmak üzere üç tip karşılaştırma işlemi yapmaya izin verir. Ancak ? bir operatördür. if
karşılaştırma deyimi ile, diğer programlama dilinde olduğu gibi if-else yapısı da kurulabilir.
switch deyimi, bir değişkenin içeriğine göre program akışını yönlendirir.
6.1 Karşılaştırma Operatörleri ve Mantıksal Operatörler
Tablo 6.1'de listelenen Karşılaştırma Operatörleri, sayısal değerleri veya karakterleri
mukayese etmek için kullanılır.
Tablo 6.1: Karşılaştırma Operatörleri
Operatör Açıklama Örnek Anlamı
> büyüktür x > y x, y den büyük mü?
< küçüktür x < y x, y den küçük mü?
== eşittir x == y x, y ye eşit mi?
>= büyük-eşittir x >= y x, y den büyük yada eşit mi?

C dilinde, bir mantıksal işlemin sonucu tamsayı 0 (sıfır) veya başka bir değer olur. 0 olumsuz
0'dan farklı değerler olumlu olarak yorumlanır. Buna göre, aşağıdaki program parçasının
...
int x = 1, y = 2, s, u, z;
s = 2 > 1;
u = x > 3;
z = x 0;
printf("%d\t%d\t%d", s, u, z);
...
çıktısı:
1 0 1
şeklinde olur. Bunun nedeni:
• 2 her zaman 1 den büyük olduğu için s değişkenine 1,
• x = 1 < 3 olduğu için x değişkenine 0,
• z = x 0; eşitliğin sağtarafının sonucu olumlu olduğu için z değişkenine
1 atanır.
6.2 if, if-else Yapısı
Bu deyimler, koşullu işlem yapan deyimlerdir. if ve else tek bir karşılaştırma deyimi olup
else kullanımı isteğe bağlıdır. Eğer bu koşul olumlu ise if den sonraki bölüm yürütülür ve
else den sonraki bölüm atlanır. Koşul olumsuz ise if den sonraki küme atlanır ve eğer varsa,
else den sonraki kümedeki işlemler gerçekleştirilir.
if deyiminin yapının genel biçimi şöyledir:
if(koşul)
{
...
deyimler; (küme)
...
}
if deyimi kullanılırken kümenin başlangıcı ve bitişini gösteren, küme parantezleri
kullanılmasında kullanıcıya bir esneklik sunulmuştur. Eğer if deyiminden sonra icra edilecek
deyimler tek satırdan oluşuyorsa, bu işaretlerin kullanılması zorunlu değildir. Yani, if
deyimden sonra { ve } işaretleri kullanılmamışsa, bu deyimi takip eden sadece ilk satır işleme
konur. Bu durum, else if, else deyimlerinde ve daha sonra işlenecek for ve while gibi
döngü deyimlerinde de geçerlidir.
Buna göre aşağıdaki kullanım
ile
if(x == y){
puts("x ve y esit");
}
if(x == y)
puts("x ve y esit");

eşdeğerdir.
if deyiminin else ile birlikte kullanımı şu şekildedir:
if(koşul){
...
deyimler; (küme1)
...
}
else{
...
deyimler; (küme2)
...
}
Bu yapının kullanılmasına dair bir örnek Program 6.1'de gösterilmiştir. Program, klavyeden
girilen bir tamsayının çift olup olmadığını sınar. Bilindiği gibi, çift sayılar, 2 ile kalansız
bölünebilen sayılardır.
Program 6.1: if-else deyiminin kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
/* 06prg01.c
Klavyeden girilen bir sayının çift olup
olmadığını sınar. */
#include
int main()
{
int sayi;
}
ÇIKTI
printf("Bir sayi girin: ");
scanf("%d",&sayi);
if (sayi % 2 == 0)
printf("sayi cifttir.\n");
else
printf("sayi tektir.\n");
return 0;
Bir sayi girin: 3
sayi tektir.
Mantıksal Operatörler kullanarak birden çok karşılaştırma birleştirilebilir. Buna iyi bir örnek
Program 6.2'de gösterilmiştir. Program, bir yılın artık yıl olup olmadığını sınar. Bir yıl içinde,
Şubat ayı 29 gün olursa o yıl artık yıl olarak adlandırılır. Artık yıl peryodik olarak 4 yılda bir
gelir. Genel kanı "bir yıl 4 ile tam bölünebirse o yıl artık yıldır" şeklindedir. Fakat 1996 artık
yıl iken 1800 artık yıl değildir. Genel sorgulama söyle olmalıdır: Eğer bir yıl

• 4 ile tam bölünüyorsa VE 100'e tam bölünmüyorsa VEYA
• 400 'e tam bölünüryorsa
o yıl artık yıldır.
Program 6.2: if-else deyiminin kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
/* 06prg02.c: Bir yılın artık yil olup
olmadığını sınar. */
#include
void main()
{
int yil;
printf("Bir yil girin: ");
scanf("%d",&yil);
if( yil % 4 == 0 && yil % 100 != 0 || yil %
400 == 0 )
printf("%d artik yil\n",yil);
}
ÇIKTI
else
printf("%d artik yil degil\n",yil);
Bir yil girin: 1996
1996 artik yil
Eğer program içinde kullanılacak koşulların sayısı ikiden çok ise aşağıdaki yapı kullanılır:
if(koşul_1)
{
...
deyimler; (küme_1)
...
}
else if(koşul_2)
{
...
deyimler; (küme_2)
...
}
.
.
.
else if(koşul_n-1)
{
...
deyimler; (küme_n-1)
...
}
else

{
}
...
deyimler; (küme_n)
...
Program 6.3, ax 2 + bx + c = 0 formundaki ikinci dereceden bir polinomun köklerini
hesaplamaktadır. Programda delta değerinin sıfırdan küçük olması durumda köklerin
karmaşık sayıya dönüşeceğide göz önüne alınmıştır. Bu program if, else if ve else yapısı
göstermek için klasik bir örnektir.
Program 6.3: if, else if, else yapısı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
/* 06prg03.c:
ax*x + bx + c = 0 denkleminin (karmaşık
sayılı kökler dahil) çözümü */
#include
#include
int main()
{
float a, b, c, delta, x1, x2, x, kok_delta;
printf("a, b, c degerlerini girin:\n");
scanf("%f %f %f",&a,&b,&c);
delta = b*b - 4.0*a*c;
if( delta > 0.0 ){
x1 = ( -b + sqrt(delta) )/( 2.0*a );
x2 = ( -b - sqrt(delta) )/( 2.0*a );
printf("\nReel kokler:");
printf("\nx1 = %f",x1);
printf("\nx2 = %f",x2);
}
else if( delta < 0.0 ){
kok_delta = ( sqrt(-delta) ) / (2.0*a);
x = -0.5*b/a;
printf("\nKarmasik kokler:");
printf("\nx1 = %f + (%f)i", x,
kok_delta);
printf("\nx2 = %f - (%f)i", x,
kok_delta);
}
else{
x = -0.5*b/a;
}
printf("\nKokler eşit:");
printf("\nx1 = x2 = %f",x);
}
return 0;
ÇIKTI

a, b, c degerlerini girin:
2 4 -8
Reel kokler:
x1 = 1.236068
x2 = -3.236068
ÇIKTI
a, b, c degerlerini girin:
1 1 1
Karmasik kokler:
x1 = -0.500000 + (0.866025)i
x2 = -0.500000 - (0.866025)i
6.3 switch - case Yapısı
Bu deyim bir değişkenin içeriğine bakarak, programın akışını bir çok seçenekten birine
yönlendirir. case (durum) deyiminden sonra değişkenin durumu belirlenir ve takip eden gelen
satırlar (deyimler) işleme konur. Bütün durumların aksi söz konu olduğunda
gerçekleştirilmesi istenen deyimler default deyiminden sonraki kısımda bildirilir. Genel
yazım biçimi:
switch(değişken)
{
case sabit1:
...
deyimler;
...
case sabit2:
...
deyimler;
...
.
.
.
case sabitn:
...
deyimler;
...
default:
...
hata deyimleri veya varsayılan deyimler;
...
}
Program Program 6.4'te switch deyiminin basit bir kullanımı gösterilmiştir.
Program 6.4: switch-case yapısının kullanımı
01:
02:
03:
/* 06prg04.c: switch - case yapısının kullanımı
*/

04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
ÇIKTI
#include
int main(void)
{
char kr;
printf("Lutfen bir karakter girin\n");
kr = getchar(); /* tek bir karakterin
okunması */
switch (kr)
{
case 'a':
printf("a harfine bastiniz\n");
case 'b':
printf("b harfine bastiniz\n");
default:
printf("a veya b ye basmadiniz\n");
}
return 0;
}
Lutfen bir karakter girin
a
a harfine bastiniz
b harfine bastiniz
a veya b ye basmadiniz
ÇIKTI
Lutfen bir karakter girin
b
b harfine bastiniz
a veya b ye basmadiniz
ÇIKTI
Lutfen bir karakter girin
k
a veya b ye basmadiniz
ÇIKTI
Lütfen bir karakter girin
c
a veya b ye basmadiniz
Programda, klavyeden okunan tek bir karakter değişkenin içeriğine bakılıp uygun dallanmalar
yaptırılmıştır. 11. satırda değişken getchar() fonksiyonu ile okutulmuştur. Eğer 'a' veya
'b' karakterlerinden biri girilirse, ekrana bu harflerin girildiğine dair mesaj yazılacak, aksi

takdirde bu karakterin dışında bir karakterin giriş olarak kullanıldığı gösteren bir mesaj
yazılacaktır. Örneğin 'c' karakteri klavyeden girilmiş ise a veya b ye basmadiniz gibi.
Fakat 'a' karakterleri girildiğinde ekrana her üç durumda yazdırılmaktadır. Bunun sebebi,
case 'a': durumunda sırasıyla 16, 18 ve 20. satırların işleme konmasıdır. Bunu engellemek
için 16. satırdan sonra programın başka bir yere yönlendirilmesi gerekir. Bu yönlendirme
break deyimi ile yapılır. Derleyici bu deyim ile karşılaştığında, bulunduğu yapının içinden
koşulsuz olarak ayrılır ve takip eden işleme başlar.
Program 6.4'te case 'a': durumu için 16, 18 ve 20. satırlar da işleme konumuştu. Eğer
klavyeden 'a' karakterini girip ekrana sadece a harfine bastiniz iletisi yazdırılmak
isteniyorsa, 20. satıra break deyimi ilave edilmelidir. break deyiminin kullanımı Program
6.5'te gösterilmiştir.
Program 6.5: switch-case yapısı ve break kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
ÇIKTI
/* 06prg05.c: switch - case yapısı ve break
kullanımı */
#include
int main(void)
{
char kr;
printf("Lutfen bir karakter girin\n");
kr = getchar(); /* tek bir karakterin
okunması */
return 0;
}
switch (kr)
{
case 'a':
printf("a harfine bastiniz\n");
break;
case 'b':
printf("b harfine bastiniz\n");
break;
default:
printf("a veya b ye basmadiniz\n");
break;
}
Lutfen bir karakter girin
a
a harfine bastiniz
ÇIKTI
Lutfen bir karakter girin
k

a veya b ye basmadiniz
Program 6.6 switch-case yapısın farklı bir kullanımı ile ilgili bir örnektir. Programda, önce
iki sayı isteniyor ardından yapılan seçimle bu sayıların toplamı, farkı, çarpımı veya oranı
ekrana yazdırılıyor.
Program 6.6: switch-case yapısı ve break kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
/* 06prg06.c: switch-case yapısı */
#include
#include
int main(void)
{
int secim;
float x,y, sonuc;
}
ÇIKTI
printf("Iki sayi girin: ");
scanf("%f %f",&x,&y);
puts("*** Menu ***");
puts("[1] Toplama");
puts("[2] Cikarma");
puts("[3] Carpma");
puts("[4] Bolme");
printf("Seciminiz: ");
scanf("%d",&secim);
switch( secim )
{
case 1:
sonuc = x + y;
printf("Toplam = %f\n",sonuc);
break;
case 2:
sonuc = x-y;
printf("Fark = %f\n",sonuc);
break;
case 3:
sonuc = x * y;
printf("Carpim = %f\n",sonuc);
break;
case 4:
sonuc = x/y;
printf("Oran = %f\n",sonuc);
break;
default:
puts("Yanlis secim !\a");
}
return 0;
Iki sayi girin: 3 8

*** Menu ***
[1] Toplama
[2] Cikarma
[3] Carpma
[4] Bolme
Seciminiz: 1
Toplam = 11.000000
ÇIKTI
Iki sayi girin: 3 8
*** Menu ***
[1] Toplama
[2] Cikarma
[3] Carpma
[4] Bolme
Seciminiz: 7
Yanlis secim !
switch-case yapısı if-else yapısının bir alternatifidir. Yani, Program 6.6'daki switchcase
kısmı, if-else yapısı ile de aşağıdaki gibi yazılabilirdi. İnceleyiniz.
switch( secim )
{
case 1:
sonuc = x + y;
printf("Toplam =
%f\n",sonuc);
break;
case 2:
sonuc = x-y;
printf("Fark =
%f\n",sonuc);
break;
case 3:
sonuc = x * y;
printf("Carpim =
%f\n",sonuc);
break;
case 4:
sonuc = x/y;
printf("Oran =
%f\n",sonuc);
break;
!\a");
}
default:
puts("Yanlis
secim
if(secim == 1){
sonuc = x + y;
printf("Toplam =
%f\n",sonuc);
}
else if(secim == 2){
sonuc = x-y;
printf("Fark =
%f\n",sonuc);
}
else if(secim == 3 ){
sonuc = x * y;
printf("Carpim =
%f\n",sonuc);
}
else if(secim == 4){
sonuc = x/y;
printf("Oran =
%f\n",sonuc);
}
else{
!\a");
}
puts("Yanlis
secim
6.4 ? Karşılaştırma Operatörü
Bu operatör, if-else karşılaştırma deyiminin yaptığı işi sınırlı olarak yapan bir operatördür.
Genel yazım biçimi:
(koşul) ? deyim1 : deyim2;

İlk önce koşul sınanır. Eğer koşul olumluysa deyim1 aksi takdirde deyim2 değerlendirilir.
deyim1 ve deyim2 de atama işlemi yapılamaz. Ancak koşul deyiminde atama işlemi
yapılabilir. deyim1 ve deyim2 yerine fonksiyon da kullanılabilir. Aşağıda bu deyimin
kullanımına ait örnekler verilmiştir.
x = ( a > b ) ? a : b;
Yukarıdaki ifadede koşul a'nın b'den büyük olmasıdır. Eğer olumluysa x adlı değişkene a,
değilse b değeri atanır. Bu şekilde kullanım if-else yapısı ile kurulmak istenirse:
if( a > b ) x = a;
else x = b;
şeklinde olacaktır. Program 6.7 ? karşılaştırma operatörünün basit bir kullanımını
göstermektedir.
Program 6.7: ? ve if kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
ÇIKTI
/* 06prg07.c: ? ve if-else yapısının kullanımı
*/
#include
int main(void)
{
float x, y, z;
printf("x : "); scanf("%f",&x);
printf("y : "); scanf("%f",&y);
if(y)
/* y, 0'dan
farklı mı? */
z = ( y > x ) ? x/y : x*y; /* y>x ise z
= x/y, değilse z = x*y */
else
z = 0.0;
printf("z = %f\n",z);
return 0;
}
x : 3
y : 5
z = 0.600000
ÇIKTI
x : 11
y : 0
z = 0.000000

12. satırdaki if deyimindeki koşul biraz farklıdır. Genel olarak koşul bu şekilde bildirilirse,
koşulun 0 dan farklı olup olmadığı sınanır. Yani:
if(y)
ile
if( y != 0 )
aynı anlamdadır.
Bu kullanım çok yagındır. Eğer y, 0 dan farklı ise koşul olumlu olarak değerlendirilecektir.
13. satırda ? ile bir sınama yapılmaktadır. Eğer y, x den büyük ise z değişkenine x/y, aksi
takdirde x*y değeri atanmaktadır. Eğer y = 0 ise z değişkenine 0 değeri atanmaktadır.
Ders 7: Döngüler
• Giriş
• 7.1 while Döngüsü
• 7.2 do ... while Döngüsü
• 7.3 for Döngüsü
• 7.4 İç içe Geçmiş Döngüler
• 7.5 Sonsuz Döngü
• 7.6 break Deyimi
• 7.7 continue Deyimi
Giriş
Döngü (loop) deyimleri, bir kümenin belli bir koşul altında tekrar edilmesi için kullanılır. C
programlama dilinde, while, do...while ve for olmak üzere üç tip döngü deyimi vardır.
Diğer programlama dillerinde olduğu gibi, bu deyimlerle istenildiği kadar iç-içe döngü yapısı
kullanılabilir.
7.1 while Döngüsü
Tekrarlama deyimidir. Bir küme ya da deyim while kullanılarak bir çok kez yinelenebilir.
Yinelenmesi için koşul sınaması döngüye girilmeden yapılır. Koşul olumlu olduğu sürece
çevrim yinelenir. Bu deyimin kullanımı Program 7.1 de gösterilmiştir. Genel yazım biçimi:
while(koşul)
{
...
döngüdeki deyimler; [küme]
...
}

Program 7.1: while döngüsü
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
ÇIKTI
/* 07prg01.c: while döngüsü */
#include
main()
{
int x=0;
while(x

03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
ÇIKTI
#include
main()
{
int sayi;
do
{
printf("Bir sayi girin : ");
scanf("%d",&sayi);
printf("iki kati : %d\n",2*sayi);
}while( sayi>0 ); /* koşul */
puts("Döngü sona erdi.");
return 0;
}
Bir sayi girin : 1
iki kati : 2
Bir sayi girin : 3
iki kati : 6
Bir sayi girin : 4
iki kati : 8
Bir sayi girin : -3
iki kati : -6
Cevrim sona erdi.
15. satırdaki koşul olumlu olduğu sürece (sayi>0 olduğu sürece), klavyeden yeni bir değer
12. satırda okunur. Aksi takdirde (sayi

02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
*/
ÇIKTI
#include
int main()
{
long i, n, faktor;
printf("Faktoriyeli hesaplanacak sayi girin :
");
scanf("%ld",&n);
faktor=1;
for(i=1; i

01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
ÇIKTI
/* 07prg04.c: Sayı sistemi
%d : desimal 10 tabanındaki sayı
%o : oktal 8 tabanındaki sayı
%x : hexadesimal 16 tabanındaki sayı (küçük
harf)
%X : hexadesimal 16 tabanındaki sayı (büyük
harf) */
#include
int main()
{
int i;
for (i=0; i

05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
ÇIKTI
= 3^3 + 7^3 + 1^3.
Bu program İç-içe geçmiş 3 döngü ile bütün
Aramstrong sayıları bulur. */
#include
int main()
{
int a,b,c, kup, sayi, k=1;
for(a=1; a

for döngüsünde, başlangıç, koşul ve artım parametrelerinden herhangi birini kullanmak
isteğe bağlıdır. Her hangi biri verilmediğinde döngünün nasıl davranacağı iyi
yorumlanmalıdır. Örneğin for döngüsünün hiçbir parametresi verilmezse, döngü sonsuz
çevrime girer. Yani:
gibi.
for(;;)
printf("Sonsuz döngü içindeyim...\n");
7.6 break Deyimi
Bir C programında, bir işlem gerçekleştirilirken, işlemin sona erdirilmesi bu deyim ile yapılır.
Örneğin, döngü deyimleri içindekiler yürütülürken, çevrimin, koşuldan bağımsız kesin olarak
sonlanması gerektiğinde bu deyim kullanılır. Mesela:
...
do{
scanf("%d",&x);
}while(1);
...
if(x==0) break;
printf("%f",1.0/x);
Yukarıdaki program parçasında, do ... while döngüsündeki koşul daima olumludur. Bu
durumda döngü sonsuzdur. Fakat döngü içinde if deyimindeki koşul gerçekleşirse, döngü
koşuluna bakılmaksızın terkedilir. Bu işlemi sağlayan break deyimidir.
Program 7.6 klavyeden girilen sayı pozitif olduğu sürece sayının faktoriyelini hesaplar. Sayı
negatif olduğunda döngü break ile sonlandırılır. Inceleyiniz.
Program 7.6: break deyiminin kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
/* 07prg06.c: n>=0 olduğu sürece n! değerini
hesaplar */
#include
int main()
{
long int i,n,faktor;
while(1) /* sonsuz döngü */
{
printf("Faktoriyeli hesaplanacak sayi
girin : ");
scanf("%ld",&n);
if(n

20:
21:
22:
23:
ÇIKTI
}
return 0;
}
printf("%ld! = %ld\n",n,faktor);
Faktoriyeli hesaplanacak sayi girin : 2
2! = 2
Faktoriyeli hesaplanacak sayi girin : 3
3! = 6
Faktoriyeli hesaplanacak sayi girin : 5
5! = 120
Faktoriyeli hesaplanacak sayi girin : 9
9! = 362880
Faktoriyeli hesaplanacak sayi girin : 0
0! = 1
Faktoriyeli hesaplanacak sayi girin : -4
7.7 continue Deyimi
Bir döngü içerisinde continue deyimi ile karşılaşılırsa, ondan sonra gelen deyimler atlanır ve
döngü bir sonraki çevrime girer. Örneğin:
...
for(x=-50;i

06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
ÇIKTI
#include
int main()
{
int x,y,k=1;
for (x=-3;x

Giriş
C Programlama Dili fonksiyon olarak adlandırılan alt programların birleştirilmesi kavramına
dayanır. Bir C programı bir yada daha çok fonksiyonun bir araya gelmesi ile oluşur. Bu
özellik bütün Yapısal Diller'in (C, Fortran, Pascal, ...) temelini oluşturur. Yapısal Diller'e
hakim olmak için fonksiyon oluşturmayı ve kullanmayı iyi öğrenmek gerekir.
Bu bölümde, C Programlama Dili'ndeki fonksiyon kavramı, sonraki bölümde (Bölüm 9) esnek
argümanlı fonksiyonlar ve main() fonksiyonu irdelenecektir.
8.1 Fonksiyon Kavramı
Fonksiyon, belirli sayıda verileri kullanarak bunları işleyen ve bir sonuç üreten komut
grubudur. Her fonksiyonun bir adı ve fonksiyona gelen değerleri gösteren argumanları
(bağımsız değişkenleri) vardır. Genel olarak bir fonksiyon Şekil 8.1'deki gibi bir kutu ile
temsil edilir:
Şekil 8.1:Bir fonksiyonun kutu gösterimi
Fonksiyonların girdilerine parametreler yada argumanlar denir. Bir fonksiyon bu
parametreleri alıp bir işleme tabi tutar ve bir değer hesaplar. Bu değer, çıktı veya geri dönüş
değeri (return value) olarak adlandırılır. Unutmayın ki, bir fonksiyonun kaç girişi olursa olsun
sadece bir çıkışı vardır.
C Programlama Dili, kullanıcısına bu türden fonksiyon yazmasına izin verir. C dilinde
hazırlanan bir fonksiyonun genel yapısı şöyledir:
FonksiyonTipi FonksiyonAdı(argüman listesi)
argumanların tip bildirimleri
{
Yerel değişkenlerin bildirimi
...
fonksiyon içindeki deyimler veya diğer fonksiyonlar
...
return geri dönüş değeri;
}
Örneğin iki sayının toplamının hesaplayacak bir fonksiyon şöyle tanımlanabilir:

* klasik biçim */
int topla(x,y)
int x,y
{
int sonuc;
sonuc = x + y;
return sonuc;
}
veya
/* modern biçim */
int topla(int x,int y)
{
int sonuc;
sonuc = x + y;
return sonuc;
}
veya
/* modern biçim */
int topla(int x,int y)
{
return (x+y);
}
Bu örnekte, fonksiyonun kimlik kartı! ve kutu gösterimi şöyledir:
• Fonksiyon tipi: int
• Fonksiyon adı : topla
• parametreler : x ve y
• geri dönüş değeri: x+y
Her üç program parçasında da return (geri dönüş) deyimi kullanılmaktadır. Bu deyim C
programlama dilinin anahtar sözcüklerinden biridir ve fonksiyon içerisinde sonucu, kendisini
çağıran yere göndemek için kullanılır. Yani topla fonksiyonu herhangi bir programın
içerisinde kullanıldığında, fonksiyonun üreteceği sonuç return deyiminden sonra belirtilen
değişken veya işlem olacaktır. Örneğin fonksiyon:
...
int t;
...
t = topla(9,6);
...
şeklinde kullanılırsa, t değişkenine 9+6=15 değeri atanır. topla() fonksiyonunun kullanımı
Program 8.1'in üzerinde açıklanmıştır.
8.2 Fonksiyon Bildirimi
Bir fonksiyonun bildirimi iki türlü yapılır:
1. Ana programdan önce:
2. ...

3. int topla(int x,int y) /* fonksiyon */
4. {
5. ...
6. }
7. ...
8. main()
9. {
10. ...
11. }
12. Ana programdan sonra: Bu durumda fonksiyon örneği (function prototype) ana
programdan önce bildirilmelidir.
13. ...
14. int topla(int x, int y); /* fonksiyon örneği */
15. ...
16. main()
17. {
18. ...
19. }
20. ...
21. int topla(int x, int y) /* fonksiyon */
22. {
23. ...
24. }
Bir C programı içinde, yazmış olduğunuz fonksiyonlar genellikle bu iki tipte kullanılır. İkinci
kullanımda fonksiyon prototipi mutlaka bildirilmelidir. Aksi halde bir hata mesajı ile
karşılaşılır. Fonksiyon prototipinde arguman isimlerinin yazılması zorunlu değildir. Sadece
arguman tiplerini belirtmek de yeterlidir. Yukarıdaki topla fonksiyona ait prototip:
int topla(int x, int y);
şekinde yazılabileği gibi
int topla(int, int);
şeklinde de yazılabilir.
Buraya kadar anlatılanlar Program 8.1 üzeride özetlenmiştir.
Program 8.1: topla fonksiyonunun ana programda kullanılması
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
/* 08prg01.c: iki sayıyı toplar ve sonucu
ekranda gösterir */
#include
int topla(int, int); /*** fonksiyon prototipi
***/
int main()
{
int toplam,a,b;
printf("Iki sayi girin : ");
scanf("%d %d",&a,&b);
/* fonksiyon çağırılıp, a ve b değerleri
parametre olarak aktarılıyor.
topla(a,b) = a + b değeri toplam
değişkenine atanması */
toplam = topla(a,b);

21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
printf("%d ve %d nin toplami %d dir.\n",
a,b,toplam);
}
ÇIKTI
return 0;
/*** fonksiyon tanımlanması ***/
/* Bu fonksiyon iki tamsayıyı toplar */
int topla( int x, int y )
{
int sonuc;
sonuc = x + y;
return sonuc;
}
Iki sayi girin : 5 12
5 ve 12 nin toplami 17 dir.
Programda, klavyeden okunan a ve b değişkenleri fonksiyonuna parametre olarak
aktarılmıştır. Bu değişkenlerin isimleri ile topla fonksiyonunda kullanılan değişkenlerin (x
ve y) isimleri aynı olması zorunlu değildir. Burara a ve b değişkenleri sırasıyla x ve y
değişkenleri yerine konmuştur. 16. satırda toplam adlı tamsayı değişkenine topla
fonksiyonunun dönüş değeri (a + b değeri) atanmıştır.
Belki karmaşık gelmiş olabilir. Fakat Program 8.1 daha kısa şöyle yazılabilirdi:
Program 8.1b: topla fonksiyonunun ana programda kullanılması
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
/* 08prg01b.c: iki sayıyı toplar ve sonucu
ekranda gösterir */
#include
int topla( int x, int y ){
return (x+y);
}
int main(void)
{
int toplam,a,b;
printf("Iki sayi girin : ");
scanf("%d %d",&a,&b);
toplam = topla(a,b);
printf("%d ve %d nin toplami %d dir.\n",
a,b,toplam);
return 0;
}

8.3 Geri Dönüş Değerleri
return anahtar sözcüğünün iki önemli işlevi vardır:
1. fonksiyonun geri dönüş değerini oluşturur
2. fonksiyonu sonlandırır
Bu deyiminden sonra bir değişken, işlem, sabit veya başka bir fonksiyon yazılabilir. Örneğin:
return (a+b/c); /* parantez kullanmak zorunlu değil */
return 10; /* değişken kullanmak mecbur değil */
return topla(a,b)/2.0; /* önce topla fonksiyonu çalışır */
Bir fonksiyonda birden çok geri dönüş değeri kullanılabilir. Fakat, ilk karşılaşılan return
deyiminden sonra fonksiyon sonlananır ve çağrılan yere bu değer gönderilir. Örneğin
aşağıdaki harf fonksiyonunda beş tane return deyimi kullanılmıştır.
char harf(int not)
{
if( not>=0 && not=50 && not=70 && not=80 && not=90 ) return 'A';
}
Bu fonksiyon kendisine parametre olarak gelen 0-100 arasındaki bir notun harf karşılığını
gönderir. Aslında geri gönderilen değer bir tanedir. Eğer bu fonksiyon aşağıdaki gibi
çağrılırsa:
char harfim;
...
harfim = harf(78);
...
harfim değişkenine 'C' değeri (karakteri) atanır.
Program 8.2'de bildirilen artik_yil fonksiyonu, kendisine parametre olarak gelen bir
tamsayıyı yıl bilgisi olarak kabul eder. Eğer yıl artık yıl ise 1 aksi halde 0 gönderir.
Programda iki tane return deyimi kullanıldığına dikkat ediniz. Artık yıl tanımı Bölüm 6'da
verilmişti.
Program 8.2: iki return deyimi kullanan bir fonksiyon
01:
02:
03:
04:
05:
06:
07:
/* 08prg02.c: Bir fonksiyonda iki return deyimi
*/
#include
int artik_yil(int); /* fonksiyon prototipi */

08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
void main()
{
int yil;
}
ÇIKTI
printf("Bir yil girin: ");
scanf("%d",&yil);
if( artik_yil(yil) )
printf("%d artik yil\n",yil);
else
printf("%d artik yil degil\n",yil);
/* yil artıl yıl ise 1 aksi halde 0 gönderir */
int artik_yil(int yil)
{
if( yil % 4 == 0 &&
yil % 100 != 0 ||
yil % 400 == 0 ) return 1;
else return 0;
}
Bir yil girin: 1996
1996 artik yil
8.4 void Fonksiyonlar
Bir fonksiyonun her zaman geri dönüş değerinin olması gerekmez. Bu durumda return
deyimi kullanılmayabilir. Eğer bu anahtar kelime yoksa, fonksiyon ana bloğu bitince
kendiliğinden sonlanır. Böyle fonksiyonların tipi void (boş, hükümsüz) olarak belirtilmelidir.
Bu tip fonksiyonlar başka bir yerde kullanılırken, herhangi bir değişkene atanması söz konusu
değildir, çünkü geri dönüş değeri yoktur. Ancak, void fonksiyonlara parametre aktarımı
yapmak mümkündür.
Program 8.3'de void fonksiyona örnek olarak bankamatik fonksiyonu ve kullanımı
gösterilmiştir. Bu fonksiyon kendisine parametre olarak gelen YTL cinsinden para miktarını
20, 10 ve 5 YTL'lik birimler halinde hesaplar. Girilen miktar 5 YTL'nin bir katı değilse,
ekrana uygun bir mesaj gönderir. bankamatik fonksiyonu bir dizi hesap yapmasına rağmen
geriye hiç bir değer göndermez.
Program 8.3: void tipinde bir fonksiyon kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
/* 08prg03.c: Basit bankamatik simulasyonu.
İstenen para miktarını 20, 10 ve 5'lik
birimlere böler
ve sonucu ekrana gösterir. */
#include
void bankamatik(int para)
{

10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
int a,yirmilik,onluk,beslik;
a = para;
if(a%5==0)
{
yirmilik = a/20;
a -= yirmilik*20;
onluk = a/10;
a -= onluk*10;
beslik = a/5;
a -= beslik*5;
printf("\nYirmilik = %d",yirmilik);
printf("\nOnluk = %d",onluk);
printf("\nBeslik = %d\n",beslik);
}
else
printf("Girilen miktar 5 YTL ve katlari
olmali!\a\n");
}
/* return deyimi yok !*/
int main()
{
int miktar;
printf("Cekilecek para miktari (YTL) = ");
scanf("%d",&miktar);
bankamatik(miktar);
değişkene atanmamış ! */
/* fonksiyon bir
}
retrun 0;
ÇIKTI
Cekilecek para miktari = 135
Yirmilik = 6
Onluk = 1
Beslik = 1
ÇIKTI
Cekilecek para miktari = 456
Girilen miktar 5 YTL ve katlari olmali!
void anahtar sözcüğü C'ye sonradan dahil edilmiştir. Standart C'de (ANSI C) bu deyimin
kullanılması zorunlu değildir. Ancak bu deyim okunabilirliği arttırmaktadır. Örneğin:
void bankamatik(int para) bankamatik(int para)
{ {

... ...
} }
şeklindeki kullanımlar geçerli ve aynı anlamdadır.
Başka bir void fonksiyon örneği Program 8.4'de verilmiştir. Programdaki kutu_ciz
fonksiyonu, iki for döngüsü kullanarak 'X' karakterlerinden oluşan basit bir kutu çizimi
yapar. Programda de sadece 18. satır defalarca işleme konur. Program çalıştırıldığında
8*35=280 adet 'X' karakteri ekrana bastırılır. İnceleyiniz.
Program 8.4: basit kutu çizen fonksiyon
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
/* 08prg04.c: Basit bir kutu çizen fonksiyon */
#include
void kutu_ciz( int satir, int sutun )
{
int sut;
for ( ; satir > 0; satir--)
{
for (sut = sutun; sut > 0; sut--)
printf("X");
}
ÇIKTI
}
int main(){
printf("\n");
kutu_ciz(8,35);
return 0;
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8.5 Fonksiyon Parametreleri
Fonksiyon parametreleri (argümanları) klasik ve modern olmak üzere iki türlü tanımanabilir.
Örneğin aşağıdaki fonksiyon kendisine parametre olarak gelen tamsayının faktoriyelini
gönderir. Bu fonksiyonun parametresi (n):
int faktoriyel(n) /* kalsik biçim */
int n
{

int i=1, f=1;
while(i

Şekil 8.2: Ana programdan alt programların (fonksiyonların) çağırılması.
Fonksiyonu çağırmak için, fonksiyonun adını yazmak yeterlidir.
Fonksiyonların sadece ana program tarafından çağrılması zorunlu değildir. Bir fonksiyon
başka bir fonksiyon tarafından da çağrılabilir. Bu tür kullanıma dair bir örnek Program 8.5'de
verilmiştir. yilin_gunu fonksiyonu, verilen bir tarihin yılın kaçıncı günü olduğunu hesaplar
ve çağrıldığı yere gönderir. İnceleyiniz.
Program 8.5: bir fonksiyonun başka bir fonksiyon tarafından çağrılması
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
/* 08prg05.c: Verilen bir tarihin yılın kaçıncı
günü olduğunu hesaplar. */
#include
int yilin_gunu(int, int, int);
int artik_yil(int);
int main(void)
{
int gun = 1; /* tarih: 01 Ağustos 2003 */
int ay = 8;
int yil = 2003;
printf("%02d %02d %d yilinin\n",gun,ay,yil );
printf("%d. gunudur\n",yilin_gunu(gun,ay,yil)
);
}
return 0;
/* yil artıl yıl ise 1 aksi halde 0 gönderir */
int artik_yil(int yil)
{
if( yil%4==0 && yil%100!=0 || yil%400==0 )
return 1;
else return 0;
}

29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
/* yılın kaçıncı günü olduğunu hesaplar ve o
günü gönderirir */
int yilin_gunu(int gun, int ay, int yil)
{
int ygun = gun;
switch(ay-1)
{
case 12: ygun += 31;
case 11: ygun += 30;
case 10: ygun += 31;
case 9: ygun += 30;
case 8: ygun += 31;
case 7: ygun += 31;
case 6: ygun += 30;
case 5: ygun += 31;
case 4: ygun += 30;
case 3: ygun += 31;
case 2: ygun += 28 + artik_yil(yil); /*
28+1 veya 28+0 */
case 1: ygun += 31;
}
}
return ygun;
ÇIKTI
01 08 2003 yilinin
213. gunudur
8.7 Makro Fonksiyon Tanımlaması
Başlık dosyalarında, bol miktarda makro fonksiyon uygulamalarına rastlanır. Makro
tanımlaması #define önişlemci komutu kullanılarak yapılır. Örneğin aşağıdaki makro
fonksiyonlar geçerlidir.
#define kare(x) (x)*(x)
#define delta(a,b,c) ((b)*(b)-4*(a)(c))
#define yaz() puts("Devam etmek için bir tuşa basın...")
Bu şekilde tanımlanan fonksiyonların kullanımı diğerleri gibidir. Yalnızca programın başında
tanımlanır. Ancak, bu tanımlamalarla fonksiyon bellekte bir yer işgal etmez. Basit bir makro
fonksiyon uygulaması Program 8.6'da gösterilmiştir. buyuk(a,b) makrosu a>b ise a değerini
aksi halde b değerini gönderir.
Program 8.6: Makro fonksiyon uygulaması
01:
02:
03:
04:
05:
/* 08prg06.c: makro fonksiyon uygulaması */
#include
#define buyuk(a,b) ( (a>b) ? a:b)

06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
ÇIKTI
int main()
{
int x,y,eb;
printf("iki sayı girin: ");
scanf("%d,%d",&x,&y);
eb = buyuk(x,y);
printf("buyuk olan %d\n",eb);
return 0;
}
iki sayı girin: 8,6
buyuk olan 8
Ders 9: Fonksiyonlar II (Alt programlar)
• Giriş
• 9.1 Esnek Argümanlı Fonksiyonlar
• 9.2 main Fonksiyonu
• 9.3 main Fonksiyonuna Parametre Aktarımı
• 9.4 Komut Satırı Örnekleri
Giriş
Bu kısımda, esnek argümanlı fonksiyonlar, main() fonksiyonu ve komut satırından main()
fonksiyonuna parametre aktarımı incelenektir.
9.1 Esnek Argümanlı Fonksiyonlar
Aşağıdaki gibi üçüncü dereceden bir polinom düşünelim:
P(x) = a + bx + cx 2 + dx 3
burada a, b, c, d katsayıları gerçel sayı sabitleridir. Bu polinomu temsil eden en basit
fonksiyon şöyle tanımlanabilir.
double p(double x, double a, double b, double c, double d)
{
double p = a + b*x + c*x*x + d*x*x*x;

}
return p;
Buna göre, x = 1.7 için, P(x) = 1 - 2x değerini hesaplamak için bu fonksiyon aşağıdaki gibi
çağırılmalıdır:
sonuc = p(1.7, 1.0, -2.0, 0.0, 0.0);
Burada, kullanılmayan katsayılar için 0.0 değeri mutlaka fonksiyona geçirilmelidir.
Kullanılmayan argumanlar geçirilmeden de fonksiyonu çağırmak mümkündür. C++, Fortran
90 gibi dillerde olduğu gibi, C Programlama Dili, kullanıcılarına argümanları esnek olarak
geçirme imkanı verir. Bunun anlamı, belli kurallar sağlandığında, p() fonksiyonu aşağıdaki
gibi çağrılabilmesidir:
/* x n a b */
sonuc = p(1.7, 2, 1.0, -2.0);
Esnek argümanlar için iki temel kural vardır:
• Esnek argümanlar kullanımı isteğe bağlıdır.
• Esnek argümanları oluşturan küme ardışık olarak listeye eklenmelidir.
Bu türden argümanlar, aşağıdaki gibi, fonksiyonun parametre listesi kısmında ... ile
belirtilir.
double p(double x, int n, ...)
{
}
Esnek Argumanlı Fonksiyon tanımlaması yapabilmek için stdarg.h kütüphanesinde üç tane
makro fonksiyon tanımlanmıştır. Bu fonksiyonlar Tablo 9.1'de listelenmiştir.
Tablo 9.1: stdarg.h'te tanımlı tip ve makro fonksiyonlar
Tip / Fonksiyon Açıklama
va_list ardışık esnek argümalar için tip belirleyici
va_start(ap,
n)
va_arg(ap,
tip)
va_end(ap)
va_list tipinde bildirilmiş ap göstericisi için bellekten n elemanlı yer
ayırır.
Veri tipi tip ile belirlenmiş küme elemanlarına eriştirir.
va_list tipinde bildirilmiş ap göstericisi için bellekten bölgeyi boşaltır.
Bu kurallar ışığında, p() fonksiyonunun genel kullanımı Program 9.1'de gösterilmiştir. p(),
kendisine parametre olarak gelen x, n ve a i katsayılarına göre
P(x,n) = a 0 + a 1 x + a 2 x 2 + ... + a n x n
polinomu hesaplar. a i (i = 0, 1, 2, ..., n) katsayları esnek argüman olarak bildirilmiştir.
Program 9.1: Sonu -1 ile biten kümeyi ekrana yazar
01:
02:
03:
04:
/* 09prg01.c: Polinom hesabı */
#include
#include

05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
#include
/* fonksiyon örneği */
double p(double, int, ...);
int main(void){
double x = 1.7;
printf("x = %lf icin:\n",x);
printf("p(x, 1, 1.0) = %lf\n",
p(x, 1, 1.0));
printf("p(x, 2, 1.0, -2.0) = %lf\n",
p(x, 2, 1.0, -2.0));
printf("p(x, 3, 1.0, -2.0, 0.2) = %lf\n",
p(x, 3, 1.0, -2.0, 0.2));
printf("p(x, 4, 1.0, -2.0, 0.2, 1.1) =
%lf\n",
p(x, 4, 1.0, -2.0, 0.2, 1.1));
printf("p(x, 5, 1.0, -2.0, 0.2, 1.1, -0.6) =
%lf\n",
p(x, 5, 1.0, -2.0, 0.2, 1.1, -0.6));
}
return 0;
/* Verilen x, n ve ai katsayıları için,
P(x,n) = a0 + a1*x + a2*x^2 + ... + an*x^n
polinomu hesaplar.
a0, a1, ..., an katsayları esnek arguman
olarak bildirilmiştir. */
double p(double x, int n, ...)
{
double a, t = 0.0;
int i;
/* arguman göstericisi; ag va_list tipinde */
va_list ag;
/* ag için bellekten n adet hücre ayır */
va_start(ag, n);
for(i=0; i

}
ÇIKTI
x = 1.700000 icin:
p(x, 1, 1.0) = 1.000000
p(x, 2, 1.0, -2.0) = -2.400000
p(x, 3, 1.0, -2.0, 0.2) = -1.822000
p(x, 4, 1.0, -2.0, 0.2, 1.1) = 3.582300
p(x, 5, 1.0, -2.0, 0.2, 1.1, -0.6) = -1.428960
Program 9.2'de, argümanları esnek olarak bildirilmiş topla(int n, ...) fonksiyonu, n tane
tamsayının sayının toplamını hesaplar.
Program 9.2: n tane sayının toplamını hesaplar
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
/* 09prg02.c
n tane sayının toplamının hesaplanması */
#include
#include
int topla(int, ...);
int main(void)
{
printf("topla(2, 11,22)
topla(2, 11,22));
printf("topla(3, 11,22,33)
topla(3, 11,22,33));
printf("topla(4, 11,22,33,44)
topla(4, 11,22,33,44));
= %d\n",
= %d\n",
= %d\n",
printf("topla(5, 11,22,33,44,55) = %d\n",
topla(5, 11,22,33,44,55));
printf("topla(6, 11,22,33,44,55,66) = %d\n",
topla(6, 11,22,33,44,66,66));
return 0;
}
/* Esnek argumanla tanımlanmış n tane tamsayının
sayının
toplamını gönderir */
int topla(int n, ...)
{
va_list ap;
int i, top = 0;
va_start(ap, n);
for (i=1; i

ÇIKTI
topla(2, 11,22) = 33
topla(3, 11,22,33) = 66
topla(3, 11,22,33,44) = 110
topla(5, 11,22,33,44,55) = 165
topla(6, 11,22,33,44,55,66) = 242
Argüman sayısı bilidirilmeden de bir küme üzerinde işlem yapılabilir. Ancak bu durumda
kümenin boyutu başka bir yöntemle hesaplanmalıdır. Program 9.3'de, argümanları esnek
olarak bildirilmiş argyaz(int arg, ...) fonksiyonu, son elemanı -1 olan bir kümenin
elemanlarını ekrana yazar. Kümenin sonu (yani boyutu) -1 ile belirlenmiş olur.
Program 9.3: Sonu -1 ile biten kümeyi ekrana yazar
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
/* 09prg03.c: Esnek argumanların yazdırılması
*/
#include
#include
/* herbiri int tipinde ve sonu -1 ile biten
kümeyi ekrana yazar */
void argyaz(int arg, ...)
{
va_list ap;
int i;
}
va_start(ap, arg);
for (i = arg; i != -1; i = va_arg(ap, int))
printf("%d ", i);
va_end(ap);
putchar('\n');
int main(void)
{
argyaz(5, 2, 14, 84, 97, 15, 24, 48, -1);
argyaz(84, 51, -1);
argyaz(-1);
argyaz(1, -1);
}
ÇIKTI
return 0;
5 2 14 84 97 15 24 48
84 51
1

9.2 main Fonksiyonu
Ana program anlamına gelen main de bir fonksiyondur. C programlarının başlangıcı ve sonu
bu fonksiyonla belirlenir. Buna göre, bir C (veya C++) programı sadece bir tane main
içerebilir.
main fonksiyonu da geri dönüş değeri kullanabilir. main fonksiyonunun geri dönüş değerinin
görevi, programın çalışması bittikten sonra sonucu işletim sistemine göndermektir. Program
içinde return deyimi ile iletilen değer 0 olduğunda, bu işletim sistemi tarafından "program
başarılı olarak sonlandı" olarak değerlendir. Başka bir deyişle,
return 0;
program, kullanıcının talebi doğrultusunda (olumlu anlamda) "yapması gereken işi yaptı"
mesajını işletim sistemine bildirilir. 0'dan farklı herhangi bir değer ise programın sorunlu
sonlandığı anlamına gelecektir. Bu yüzden bütün C programlarımızın sonuna return 0; ilave
ediyoruz.
Bazı programcılar main fonksiyonunun başına şey yazmaz.
main()
{
...
return 0;
}
Bu durumda geri dönüş değeri tamsayı (int) kabul edilir. Bu şekilde kullanımda, yeni tip
derleyiciler uyarı (warning) mesajı verebilirler. Bu yüzden, aşağıdaki kullanımı tavsiye
ediyoruz.
int main()
{
...
return 0;
}
Eğer ana programdan bir değer döndürülmeyecekse, main fonksiyonunun önüne aşağıdaki
gibi void deyimi eklelenmelidir. Ancak bu bazı derleyiciler tarafından hata olarak
yorumlanır. Bu nedenle, aşağıdaki kullanımlar pek tavsiye edilmez.
yada
void main()
{
...
}
void main(void)
{
...
}

9.3 main() Fonksiyonuna Parametre Aktarımı
NOT
Bu ve sonraki kısımda (9.3) anlatılanlar Bölüm 10, 11 ve 16
okunduktan sonra daha iyi anlaşılacaktır. Ancak, konu
akışını bozmamak için, bu konunun buraya konması uygun
bulunmuştur.
Ana programa parametre aktarımı, derlenmiş (çalıştırılabilir) bir program komut satırından
(işletim sistemi ortamından) çalıştırılacağı zaman yapılır. Parametre aktarımı, programın adı
yazılıp bir boşluk bırakıldıktan hemen sonra yapılır. Parametreler, komut satırından sayısal
olarak girilse bile program içinde karakter topluluğu (string) olarak gelir. Bu durumda, bu
ifadeleri sayısal değerlere çeviren (atoi(), atol(), atof() gibi) fonksiyonlar kullanılır.
Genel kullanım biçimi:
...
int main(arguman_sayısı, arguman_vektörü)
int arguman_sayısı;
char *arguman_vektörü[];
{
.
.
.
if(arguman_sayısı < ...){
printf("Eksik parametre !\n");
exit(1);
}
if(arguman_sayısı > ...){
printf("Cok fazla parametre !\n");
exit(1);
}
.
... arguman_vektörü[0] ... /* 1. eleman program adı */
... arguman_vektörü[1] ... /* 2. eleman 1. parametre */
... arguman_vektörü[2] ... /* 3. eleman 2. parametre */
.
}
Program 9.1, komut satırından girilen iki sayının toplamını hesaplar.
Program 9.1: Komut satırından girilen iki sayının toplamını hesaplar
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
/* topla.c
Komut satırından girilen iki sayının
toplamını hesaplar.
Kullanımı: topla sayı1 sayı2 */
#include
#include
int main(int argsay, char *argvek[]){
int toplam;
if(argsay < 3){
printf("Eksik parametre !\n");

15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
}
}
exit(1);
if(argsay > 3){
printf("Cok fazla parametre !\n");
exit(1);
}
toplam = atoi(argvek[1]) + atoi(argvek[2]);
printf("Toplamlari %d\n",toplam);
return 0;
Program 9.1, topla.c derlendikten sonra üretilen Windows ortamında üretilen topla.exe ve
Linux ortamında üretilen topla dosyasının çalıştırılması şöyledir:
• Turbo C 2.0 Derlecisi kullanılarak (topla.c programı C:\TC adlı dizinin altına
kaydedildiği
varsayılmıştır)

• Dev-C++ Derlecisi kullanılarak (topla.c programı C:\Users\bingul\Desktop
adlı dizinin altına kaydedildiği varsayılmıştır)
• Linux gcc derleyicisi kullanılarak (topla.c programı /home/bingul/ adlı dizinin
altına kaydedildiği varsayılmıştır)
Komut satırında yazılan dosya adı dahil toplam parametre sayısı 3 tür. Bunlar:
topla 4 9
| | |
V V V
argvek[0] argvek[1] argvek[2]
şeklindedir.
Program 9.1, komut satırından girilen iki sayının toplamını hesaplar. Bu programın daha
gelişmiş hali Program 9.2'de verilmiştir. Program 9.2 çalıştırıldığında, komut satırından
girilen iki sayı ve bir operatör bekler. Girilen operatöre göre beş aritmetik işlemden birinini
yapıp sonucu ekranda gösterir. İnceleyiniz.

Program 9.2: Komut satırından girilen iki sayı ve bir operatör bilgisine göre 5 işlemden
birini hesaplar
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
/* hesap.c: Komut satırından girilen iki sayı
üzerinde 5 işlem yapar.
*/
Kullanımı: hesap
#include
#include
int main(int args, char **argv)
{
int s1, s2;
float sonuc;
char op;
if(args != 4){
printf("Eksik veya fazla parametre !\n");
printf("Kullanimi: hesap
\n");
return 1;
}
s1 = atoi(argv[1]); /* 1. parametre:
sayi1 */
op = argv[2][0]; /* 2. parametrenin
ilk karakteri: operator */
s2 = atoi(argv[3]); /* 3. parametre:
sayi2 */
switch(op)
{
case '+':
sonuc = s1 + s2; break;
case '-':
sonuc = s1 - s2; break;
case '*':
sonuc = s1 * s2; break;
case '/':
sonuc = (float) s1 / s2; break;
case '%':
sonuc = s1 % s2; break;
default:
sonuc = 0.0;
printf("Yanlis operator %c\n",op);
printf("Operatorler: +, -, *, / veya
%%\n");
}
printf("sonuc = %f\n",sonuc);
return 0;
}
Program hesap.c adlı dosyada saklandığı varsayılırsa, programın Linux ortamındaki çıktısı
şöyle olacaktır:

9.4 Komut Satırı Örnekleri
Aşağıda verilen iki program, Linux işletim sistemindeki cp ve wc komutlarının basit kaynak
kodlarıdır:
• cp (copy) komutu, bir text dosyasının kopyasını oluşturur.
Kullanımı: cp kaynak_dosya hedef_dosya
• wc (word count) komutu, bir dosyanın kaç karakter, kelime satırdan oluştuğunu bulup
ekrana
yazar.
Kullanımı: wc dosya_adı
Ders 10: Diziler
• Giriş
• 10.1 Dizilerin Bildirimi
• 10.2 Dizilere Başlangıç Değeri Verme
• 10.3 Dizileri Yazdırma/Okuma
• 10.4 Sıralama (Sorting)
• 10.5 Karakter Dizileri (Strings)
• 10.6 Çok Boyutlu Diziler
• 10.7 Dizilerin Fonksiyonlarda Kullanılması
Giriş

Dizi, aynı tipteki verilere tek bir isimle erişmek için kullanılan bir kümedir. Bu küme
matematikteki küme kavramından biraz farklıdır. Bir dizi bildirildikten sonra, dizinin bütün
elemanları bellekte peşpeşe saklanır [1]. Bu yüzden dizilere tek bir isim altında çok sayıda
değişken içeren bellek bölgesi de denir. Buna göre, bir diziyi dizi yapan iki temel özellik
vardır [2]:
• dizi elemanların bellekte (program çalıştığı sürece) sürekli biçimde bulunması
• dizi elemanların aynı türden değişkenler olması
10.1 Dizilerin Bildirimi
Bir dizi çok sayıda değişken barındırdığından, bunları birbirinden ayırdetmek için indis adı
verilen bir bilgiye ihtiyaç vardır. C Programlama Dili'nde, bir dizi hangi tipte tanımlanmış
olursa olsun başlangıç indisi her zaman 0'dır.
Bir dizinin bildirim işleminin genel biçimi söyledir:
veriTipi dizi_adı[eleman_sayısı];
Örneğin, 5 elemanlı, kütle verilerini bellekte tutmak için, kutle dizisi şöyle tanımlanabilir:
float kutle[5];
Bu dizinin elemanlarına bir değer atama işlemi şöyle yapılabilir:
kutle[0] = 8.471
kutle[1] = 3.683
kutle[2] = 9.107
kutle[3] = 4.739
kutle[4] = 3.918
NOT
1. elemanın indisi 0,
5. elemanın indisinin 4 olduğuna dikkat edin.
Bildirim sırasında dizilerin eleman sayısı tamsayı türünden bir sabit ifadesiyle belirtilmesi
zorunludur. Örneğin:
int n = 100;
int a[n];
şeklindeki tanımlama, dizi uzunluğunun değişken (n) ile belirtilmesi nedeniyle geçersizdir.
Bunun yerine, dizilerin eleman sayısı aşağıdaki gibi sembolik sabitlerle belirtmek
mümkündür.
#define n 100
...
int a[n];
Bir dizinin bellekte kapladığı alanın bayt cinsinden karşılığı sizeof operatörü ile
öğrenilebilir.
int a[5], b, c;
...
b = sizeof(a); /* bellekte kapladığı alan: b = 4*5 =
20 bayt */

*/
c = sizeof(a) / sizeof(int); /* Dizinin boyutu : c = 20/4 = 5
10.2 Dizilere Başlangıç Değeri Verme
Bir diziye başlangıç değerleri aşağıdaki gibi kısa formda atanabilir:
float kutle[5]= { 8.471, 3.683, 9.107, 4.739, 3.918 };
int maliyet[3] = { 25, 72, 94 };
double a[4] = { 10.0, 5.2, 7.5, 0.0};
Küme parantezlerinin sonlandırıcı ; karakteri ile bittiğine dikkat ediniz.
Bir dizinin uzunluğu belirtilmeden de başlangıç değeri atamak mümkündür.
int a[] = { 100, 200, 300, 400 };
float v[] = { 9.8, 11.0, 7.5, 0.0, 12.5};
Derleyici bu şekilde bir atama ile karşılaştığında, küme parantezi içindeki eleman sayısını
hesaplar ve dizinin o uzunlukta açıldığını varsayar. Yukarıdaki örnekte, a dizisinin 4, v
dizisinin 5 elemanlı olduğu varsayılır.
10.3 Dizileri Yazdırma/Okuma
printf ve scanf fonksiyonları bir dizinin okunması ve yazdırılması için de kullanılır.
Örneğin bir A dizisinin aşağıdaki gibi bildirildiğini varsayalım:
int A[10];
Bu dizinin elemanlarını klavyeden okumak için:
for(i=0; i

03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
ÇIKTI
#include
#define N 10
int main()
{
int i;
float x[N], ort, toplam = 0.0;
for(i=0; i

Program 10.2: 10 sayının ortalamasını ve standart sapmasını hesaplar
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
/* 10prg02.c
10 tane sayının aritmetik ortlamasını ve
standart sapmasını hespalar. */
#include
#include
#define N 10
int main(void)
{
int i;
float x[N], toplam = 0.0, ort, std_sap = 0.0;
}
ÇIKTI
/* ortalama hesabı */
for(i=0; i

Bazı uygulamalarda bir grup sayının büyükten küçüğe, veya küçükten büyüğe, doğru
sıralanması gerekebilir. Bu tip sıralama problemleri için çeşitli algoritmalar geliştirilmiştir.
Sıralama mantığını anlamadan önce bir dizinin en büyük (veya en küçük) elemanının nasıl
bulunduğunu inceleyelim. Program 10.3, bir dizinin en büyük elemanını bulup ekrana yazar.
Program 10.3: Bir dizinin en büyük elemanının bulunuşu
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
ÇIKTI
/* 10prg03.c
Bir dizinin en büyük elemanını bulup ekrana
yazar */
#include
int main(void)
{
int a[10] = {100, -250, 400, 125 ,550, 900,
689, 450, 347, 700};
int k, eb;
/* ilk eleman en büyük kabul ediliyor */
eb = a[0];
for(k=1; keb ) eb = a[k];
printf("En buyuk eleman = %d\n",eb);
return 0;
}
En buyuk eleman = 900
En büyük sayıyı bulan bu algoritma oldukça kolaydır. 12. satırda eb = a[0]; ataması ile
dizinin ilk elemanının en büyük olduğu varsayılır. Daha sonra büyüğe rastladıkça (15. satır)
eb = a[k]; ile eb değişmektedir.
Program 10.3 bir dizinin en büyük elemanını bulur. En büyük elemanın kaçıncı indis (eleman)
olduğu sorgulanmak istendiğinde: programdaki koşul yapısını aşağıdaki gibi değiştirmek
yeterlidir. eb değiştikçe, i değişkeni en büyük elemanın indisini tutar.
for(k=0; k eb ){
eb = a[k];
i = k;
}
}
n elemanlı bir dizinin, elemanlarını büyükten küçüğe doğru sıralamak için çok popüler iki
algoritma aşağıda verilmiştir[2].
Seçerek Sıralama (Selection Sort):
En büyük elemanı bul başa koy biçimindeki sıramadır. Algoritmanın uygulaması Program

10.4'de
gösterilmiştir.
Bu algoritmada kullanılan kombinasyon sayısı (algoritmanın karmaşıklığı): n*(n-1)/2 dir.
Program 10.4: Seçerek Sıralama (Selection Sort) Algoritması
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
ÇIKTI
/* 09prg04.c
Seçerek Sıralama (Selection Sort) Algoritması
ile bir
dizinin elemanlarını büyükten küçüğe dogru
sıralar */
#include
#define n 10
int main(void)
{
int a[n] = {100, -250, 400, 125 ,550, 900,
689, 450, 347, 700};
int i, j, k, eb;
/* Dizinin kendisi */
printf("Once : ");
for(k=0;k

Kabarcık Sıralama (Bubble Sort):
Yanyana elemanları karşılaştırarak yer değiştir biçimde sıralamadır. Algoritmanın uygulaması
Program 10.5'de gösterilmiştir.
Bu algoritmanın karmaşıklığı: (n-1) 2 dir.
Program 10.5: Kabarcık Sıralama (Bubble Sort) Algoritması
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
/* 09prg05.c
Kabarcık Sıralama (Bubble Sort) Algoritması
ile bir
dizinin elemanlarını büyükten küçüğe dogru
sıralar */
#include
#define n 10
int main(void)
{
int a[n] = {100, -250, 400, 125 ,550, 900,
689, 450, 347, 700};
int j,k,gecici;
/* Dizinin kendisi */
printf("Once : ");
for(k=0; k

C dilinde, karakter dizileri oldukça sık kullanılır. Sadece karakter dizilerine özel olarak,
karakter dizilerinin sonuna sonlandırcı karakter olarak adlandırılan bir simge eklenir.
Sonlandırcı karakter, işlemlerin hızlı ve etkin bir biçimde yapılabilmesine olanak sağlar[2].
Sonlandırıcı karakter:
• dizinin bittiği yeri gösterir,
• ASCII tablosunun sıfır numaralı ('\0') karakteridir.
Karakter dizilerine iki şekilde başlangıç değeri verilebilir.
char s[7] = {'d','e','n','e','m','e','\0'};
yada
char s[7] = "deneme";
Birinci tanımlamada sonlandırıcı karakter programcı tarafından konmalıdır. Ikinci
tanımlamada ise buna gerek yoktur. Çünkü, sonlandırıcı karakter bu atamayla, derleyici
tarafından eklenir.
NOT
char s[7] = "deneme";
ataması geçeli olmasına rağmen, aşağıdaki atama
geçersizdir:
char
char s = "deneme";
Karakter dizileri gets() fonksiyonu ile klavyeden okunabilir.
char ad[20];
...
gets(ad);
s[7];
Program 10.6'da bir karakter dizisinin uzunluğunun nasıl bulunduğu, Program 10.7'de ise bir
karakter dizisinin tersyüz edilişi gösterilmiştir. İnceleyiniz.
Program 10.6: Bir karakter dizisinin uzunluğunu bulur
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
/* 09prg06.c: Bir karakter dizisinin uzunluğunu
bulur */
#include
int main(void)
{
char s[40];
int k = 0;
/* diziyi oku */
printf("Bir seyler yazin : ");
gets(s);
/* sonlandırıcı karaktere kadar karakterleri
say */
while( s[k]!='\0' )
k++;

20:
21:
ÇIKTI
printf("Dizinin uzunlugu : %d\n",k);
return 0;
}
Birseyler yazin : Gazintep Universitesi
Dizinin uzunlugu : 21
Program 10.7: Bir karakter dizisinin tersini bulur
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
ÇIKTI
/* 09prg07.c: Bir karakter dizisini tersyüz eder
*/
#include
int main(void)
{
char s[40], gecici;
int i, n;
/* diziyi oku */
printf("Bir seyler yazin : ");
gets(s);
/* sonlandırıcı karaktere kadar */
for(n=0; s[n] != '\0'; n++)
;
for(i=0; i

Bir dizi birden çok boyuta sahip olabilir. Örneğin iki boyutlu b dizisi şöyle tanımlanabilir:
float b[9][4];
İki boyutlu diziler matris olarak adlandırılır. ilk boyuta satır, ikinci boyuta sütün denir.
Yukarıda b matrisinin eleman sayısı 9x4=36 dır. Bu durumda, genel olarak bir dizi şöyle
gösterilir:
Tablo 10.1: Dizlerin Bildirimi
Dizi Çeşiti Genel Bildirimi Örnek
Tek boyutlu diziler (Vektörler) tip dizi_adı[eleman_sayısı] int veri[10];
İki boyutlu diziler (Matrisler) tip dizi_adı[satır_sayısı][sutun_sayısı] float mat[5][4
Çok boyutlu diziler tip dizi_adı[boyut_1][boyut_2]...[boyut_n]; double x[2][4]
Çok boyutlu diziler tek boyuta indir generek bellekte tutulurlar. Tek indisli dizilerde olduğu
gibi, çok indisli dizilere de başlangıç değeri vermek mümkün. Örneğin 3 satır ve 4 sütünlu
(3x4=12 elemanlı) bir x matrisinin elemanları şöyle tanımlanabilir:
int x[3][4] = {11,34,42,60, 72,99,10,50, 80,66,21,38};
yada
int x[3][4] = {11,34,42,60, /* 1. satır elemanları */
72,99,10,50, /* 2. satır elemanları */
80,66,21,38}; /* 3. satır elemanları */
Bu matris ekrana matris formunda yazılmak istendiğinde:
for(i=0; i

11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
}
int b[SAT][SUT] = {1, 2, 3, 4, 5, 6};
int c[SAT][SUT];
int i, j;
puts("A Matrisi:");
for(i=0; i

09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
{
ÇIKTI
int a[N][N], b[N][N], c[N][N];
int i,j,k,toplam;
puts("A Matrisini girin:");
for(i=0; i

01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
/* 10prg10.c: bir dizinin yazdırılması */
#include
void dizi_yaz(float x[], int n);
int main(){
float kutle[5]= { 8.471, 3.683, 9.107, 4.739,
3.918 };
}
dizi_yaz(kutle, 5);
return 0;
void dizi_yaz(float x[], int n)
{
int i;
}
ÇIKTI
for(i=0; i

09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
int enBuyuk(int a[], int n)
{
int k, en_buyuk_eleman;
}
ÇIKTI
/* ilk eleman en büyük kabul ediliyor */
en_buyuk_eleman = a[0];
for(k=1; ken_buyuk_eleman )
en_buyuk_eleman = a[k];
return en_buyuk_eleman;
int main()
{
int a[10] = {100, -250, 400, 125 ,550, 900,
689, 450, 347, 700};
int eb;
eb = enBuyuk(a,10);
printf("En buyuk eleman = %d\n",eb);
return 0;
}
En buyuk eleman = 900
Son olarak, bir kare matrisin iz (trace) değerini bulup ekrana yazan bir fonksiyon Program
10.12'de verilmişitir. Bir kare matrisin izi, matrisin asal köşegen üzerinde bulunan
elemanların toplamı olarak tanımlıdır. Bu tanıma göre, aşağıdaki matrisin izi 2 + 8 + 4 = 14
tür..
İz matematiksel olarak şöyle gösterilir:
Program 10.12: Bir matrisin izi
01:
02:
03:
04:
05:
06:
07:
08:
09:
/* 10prg12.c
Bir 3x3 bir matrisin izinin fonksiyonla
bulunması */
#include
double iz(double a[][3], int);
int main()

10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
{
double a[3][3], izA;
int i,j;
puts("matrisi girin:");
for(i=0; i

Giriş
Hemen hemen bütün programlama dillerinin temelinde gösterici (pointer) veri tipi
bulunmaktadır. Bir çok dil gösterici kullanımını kullanıcıya sunmamıştır veya çok sınırlı
olarak sunmuştur. Fakat C Progrmalam Dili'nde göstericiler yoğun olarak kullanılır. Hatta
gösterici kavramı C dilinin bel kemiğidir. Kavranması biraz güç olan göstericiler için -latife
yapılıp- C kullanıcılarını "gösterici kullanabilenler ve kullanmayanlar" olmak üzere iki gruba
ayıranlar da olmuştur. Özetle, bir C programcısı gösterici kavramını anlamadan C diline
hakim olamaz.
Türkçe yazılan C kitaplarda pointer kelimesi yerine aşağıdaki ifadelerden biri karşılaşılabilir:
pointer = işaretçi = gösterici = gösterge
Anlatımda, gösterici terimini kullanacağız.
11.1 Değişken ve Bellek Adresi
Bilgisayarın ana belleği (RAM) sıralı kaydetme gözlerinden oluşmuştur. Her göze bir adres
atanmıştır. Bu adreslerin değerleri 0 ila belleğin sahip olduğu üst değere bağlı olarak
değişebilir. Örneğin 64 MB bir bellek, 64*1024*1024 = 67108864 adet gözden oluşur.
Bir programlama dillinde, belli bir tipte değişken tanımlanıp ve bir değer atandığında, o
değişkene dört temel özellik eşlik eder:
1. değişkenin adı
2. değişkenin tipi
3. değişkenin sahip olduğu değer (içerik)
4. değişkenin bellekteki adresi
Örneğin tam adlı bir tamsayı değişkenini aşağıdaki gibi tanımladığımızı varsayalım:
int tam = 33;
Bu değişken için, int tipinde bellekte (genellikle herbiri 1 bayt olan 4 bayt büyüklüğünde) bir
hücre ayrılır ve o hücreye 33 sayısı ikilik (binary) sayı sitemindeki karşılığı olan 4 baytlık (32
bitlik):
00000000 00000000 00000000 00100001
sayısı elektronik olarak yazılır. tam değişkenine ait dört temel özellik Şekil 11.1'deki gibi
gösterilebilir:

Şekil 11.1: Bir değişkene eşlik eden dört temel özellik
Bellek adresleri genellikle onaltılık (hexadecimal) sayı sisteminde ifade edilir. 0x3fffd14
sayısı onluk (decimal) sayı sisteminde 67108116 sayına karşık gelir. Bunun anlamı, tam
değişkeni, program çalıştığı sürece, bellekte 67108116. - 67108120. numaralı gözler
arasındaki 4 baytlık hücreyi işgal edecek olmasıdır. Şekil 11.1'deki gösterim, basit ama
anlaşılır bir tasvirdir. Gerçekte, int tipindeki tam değişkeninin bellekteki yerleşimi ve içeriği
(değeri) Şekil 11.2'de gösterildiği gibi olacaktır.
Şekil 11.2: tam adlı değişkenin bellekteki gerçek konumu ve ikilik düzendeki içeriği
Değişkenin saklı olduğu adres, & karakteri ile tanımlı adres operatörü ile öğrenilebilir. Bu
operatör bir değişkenin önüne konursa, o değişkenin içeriği ile değil adresi ile ilgileniliyor
anlamına gelir. Aşağıdaki program parçasının:
çıktısı:
int tam = 33;
printf("icerik: %d\n",tam);
printf("adres : %p\n",&tam);
icerik: 33

adres : 3fffd14
şeklindedir. Burada birinci satır tam değişkeninin içeriği, ikinci ise adresidir. Adres
yazdırılırken %p tip belirleyicisinin kullanıldığına dikkat ediniz.
11.2 Gösterici Nedir?
Gösterici, bellek alanındaki bir gözün adresinin saklandığı değişkendir. Göstericilere veriler
(yani değişkenlerin içeriği) değil de, o verilerin bellekte saklı olduğu hücrenin başlangıç
adresleri atanır. Kısaca gösterici adres tutan bir değişkendir.
Bir gösterici, diğer değişkenler gibi, sayısal bir değişkendir. Bu sebeple kullanılmadan önce
program içinde bildirilmelidir. Gösterici tipindeki değişkenler şöyle tanımlanır:
tip_adı *gösterici_adı;
Burada tip_adı herhangi bir C tip adı olabilir. Değişkenin önünedeki * karakteri
yönlendirme (indirection) operatörü olarak adlandırılır ve bu değişkenin veri değil bir adres
bilgisi tutacağını işaret eder. Örneğin:
char *kr; /* tek bir karakter için */
int *x; /* bir tamsayı için */
float *deger, sonuc; /* deger gösterici tipinde, sonuc sıradan
bir gerçel değişkenler */
Yukarıda bildirilen göstericilerden; kr bir karakterin, x bir tamsayının ve deger bir gerçel
sayının bellekte saklı olduğu yerlerin adreslerini tutar.
Bir göstericiye, bir değişkenin adresini atamak için adres operatörünü kullanabiliriz. Örneğin
tamsayı tipindeki tam adlı bir değişken ve ptam bir gösterici olsun. Derleyicide, aşağıdaki gibi
bir atama yapıldığında:
int *ptam, tam = 33;
.
.
.
ptam = &tam;
ptam göstericisinin tam değişkeninin saklandığı adresi tutacaktır. Bu durum Şekil 11.3'deki
gibi tasvir edilir.

Şekil 11.3: Göstericinin bir değişkenin adresini göstermesi
Şekil 11.3'deki gösterimde, ptam göstericisinin içeriği tam değişkeninin içeriği (33) değil
adresidir (0x3fffd14). Ayrıca, ptam değişkeni, bellekte başka bir hücrede saklandığına ve bu
hücrenin int değil int * tipinde bir bölge olduğuna dikkat ediniz. Buraya kadar anlatılanlar,
Program 11.1'de özetlenmiştir.
Program 11.1: Bir değişkenin içeriğini ve adresini ekrana yazdırma
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
/* 10prg01.c: ilk gösterici programı */
#include
int main()
{
int *ptam, tam = 33;
ptam = &tam;
printf("tam: icerik = %d\n", tam);
printf("tam: adres = %p\n",&tam);
printf("tam: adres = %p\n",ptam);
return 0;
}
7. satırda değişkenler bildirilmiştir. 9. satırdaki atama ile tam değişkeninin adresi, ptam
göstericisine atanmıştır. Bu satırdan itibaren ptam, tam değişkeninin gösterir. 11. satıda tam'ın
içeriği (33 sayısı), 12. ve 13. satırda tam'ın adresi, %p tip karakteri ile, ekrana yazdırılmıştır.
Ekran çıktısı incelendiğinde, &tam ve ptam içereriğinin aynı anlamda olduğu görülür.
ÇIKTI
tam: icerik = 33
tam: adres = 0x3fffd14
tam: adres = 0x3fffd14
tam adlı değişkenin içeriğine ptam gösterici üzerinde de erişilebilir. Bunun için program
içinde ptam değişkeninin önüne yönelendirme operatörü (*) koymak yeterlidir. Yani *ptam,
tam değişkeninin adresini değil içeriğini tutar. Buna göre:
*ptam = 44;

komutuyla, ptam'ın adresini tuttuğu hücreye 44 değeri atanır. Bu durum, Program 11.2'de
gösterilmiştir.
Program 11.2: Bir değişkenin içeriğini ve adresini ekrana yazdırma
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
ÇIKTI
/* 10prg02.c: ikinci gösterici programı */
#include
int main()
{
int *ptam, tam = 33;
ptam = &tam; /* ptam -> tam */
printf("&tam = %p\n",&tam);
printf("ptam = %p\n",ptam);
printf("\n");
printf("tam = %d\n",tam);
printf("*ptam = %d\n",*ptam);
printf("\n");
*ptam = 44; /* tam = 44 anlamında */
printf("tam = %d\n",tam);
printf("*ptam = %d\n",*ptam);
return 0;
}
&tam = 0x3fffd14
ptam = 0x3fffd14
tam = 33
*ptam = 33
tam = 44
*ptam = 44
Özetle ptam = &tam atamasıyla:
• *ptam ve tam, tam adlı değişkenin içeriği ile ilgilidir.
• ptam ve &tam, tam adlı değişkenin adresi ile ilgilidir.
• * yönlendirme ve & adres operatörüdür.
11.3 Gösterici Aritmetiği
Göstericiler kullanılırken, bazen göstericinin gösterdiği adres taban alınıp, o adresten önceki
veya sonraki adreslere erişilmesi istenebilir. Bu durum, göstericiler üzerinde, aritmetik
işlemcilerin kullanılmasını gerektirir. Göstericiler üzerinde yalnızca toplama (+), çıkarma (-),
bir arttırma (++) ve bir eksiltme (--) operatörleri işlemleri yapılabilir.

Aşağıdaki gibi üç tane gösterici bildirilmiş olsun:
char *kar;
int *tam;
double *ger;
Bu göstericiler sırasıyla, bir karakter, bir tamsayı ve bir gerçel sayının bellekte saklanacağı
adreslerini tutar. Herhangi bir anda, tuttukları adresler de sırasıyla 10000 (0x2710), 20000
(0x4e20) ve 30000 (0x7530) olsun. Buna göre aşağıdaki atama işelemlerinin sonucu:
kar++;
tam++;
ger++;
sırasyla 10001 (0x2711), 20004 (0x4e24) ve 30008 (0x7538) olur. Bir göstericiye ekleme
yapıldığında, o anda tuttuğu adres ile eklenen sayı doğrudan toplanmaz. Böyle olsaydı, bu
atamaların sonuçları sırasıyla 10001, 20001 ve 30001 olurdu. Gerçekte, göstericiye bir
eklemek, göstericinin gösterdiği yerdeki veriden hemen sonraki verinin adresini
hesaplamaktır.
Genel olarak, bir göstericiye n sayısını eklemek (veya çıkarmak), bekllekte gösterdiği veriden
sonra (veya önce) gelen n. elemanın adresini hesaplamaktır. Buna göre aşağıdaki atamalar
şöyle yorumlanır.
kar++; /* kar = kar + sizeof(char) */
tam = tam + 5; /* tam = tam + 5*sizeof(int) */
ger = ger - 3; /* ger = ger - 3*sizeof(double) */
Program 11.3, bu bölümde anlatlanları özetlemektedir. İnceleyiniz.
Program 11.3: Gösterici aritmetiği
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
/* 10prg03.c: gösterici aritmetiği */
#include
int main()
{
char *pk, k = 'a';
int *pt, t = 22;
double *pg, g = 5.5;
pk = &k;
pt = &t;
pg = &g;
printf("Onceki adresler: pk= %p pt= %p
pg= %p \n", pk, pt, pg);
pk++;
pt--;
pg = pg + 10;
printf("Sonraki adresler: pk= %p pt= %p
pg= %p \n", pk, pt, pg);

ÇIKTI
return 0;
}
Onceki adresler: pk= 0xbfbbe88f pt= 0xbfbbe888
pg= 0xbfbbe880
Sonraki adresler: pk= 0xbfbbe890 pt= 0xbfbbe884
pg= 0xbfbbe8d0
11.4 Gösterici ve Diziler Arasındaki İlişki
C dilinde göstericiler ve diziler arasında yakın bir ilişki vardır. Bir dizinin adı, dizinin ilk
elemanının adresini saklayan bir göstericidir. Bu yüzden, bir dizinin herhangi bir elemanına
gösterici ile de erişilebilir. Örneğin:
int kutle[5], *p, *q;
şeklinde bir bildirim yapılsın. Buna göre aşağıda yapılan atamalar geçerlidir:
atandı */
atandı */
atandı */
p = &kutle[0]; /* birinci elemanın adresi p göstericisne
p = kutle; /* birinci elemanın adresi p göstericisne
q = &kutle[4]; /* son elemanın adresi q göstericisne
İlk iki satırdaki atamalar aynı anlamdadır. Dizi adı bir gösterici olduğu için, doğrudan aynı
tipteki bir göstericiye atanabilir. Ayrıca, i bir tamsayı olmak üzere,
ile
kutle[i];
*(p+i);
aynı anlamdadır. Bunun sebebi, p göstericisi kutle dizisinin başlangıç adresini tutmuş
olmasıdır. p+i işlemi ile i+1. elemanın adresi, ve *(p+i) ile de bu adresteki değer hesaplanır.
NOT
Bir dizinin, i. elemanına erişmek için *(p+i) işlemi
yapılması zorunludur. Yani
*p+i;
/* p nin gösterdiği değere (dizinin ilk
elemanına) i sayısını ekle */
*(p+i); /* p nin gösterdiği adresten i blok
ötedeki sayıyı hesapla */
anlamındadır. Çünkü, * operatörü + operatörüne göre işlem
önceliğine sahiptir.
Program 11.4'de tanımlanan fonksiyon kendine parameter olarak gelen n elemanlı bir dizinin
aritmetik ortlamasını hesaplar.
Program 11.4: Bir dizi ile gösterici arasındaki ilişki

01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
/* 10prg04.c: gösterici dizi ilişkisi */
#include
double ortalama(double dizi[], int n);
int main()
{
double a[5] = {1.1, 2.2, 3.3, 4.4, 5.5};
double o;
o = ortalama(a,5);
printf("Dizinin ortalaması = %lf\n",o);
return 0;
}
double ortalama(double dizi[], int n)
{
double *p, t=0.0;
int i;
}
ÇIKTI
p = dizi; /* veya p = &dizi[0] */
for(i=0; i

C (ve C++) programlama dilinde fonksiyon parametreleri değer geçerek (pass by value) yada
adres geçerek (pass by reference) olarak geçilebilir. Bu şekilde geçirilen parametreler,
fonksiyon içersinde değiştirilse bile, fonksiyon çağılıldıktan sonra bu değişim çağrılan yerdeki
değerini değiştirmez. Fakat, bir parametre adres geçerek aktarılısa, fonksiyon içindeki
değişikler geçilen parametreyi etkiler. Adres geçerek aktarım, gösterici kullanmayı zorunlu
kılar.
Örneğin, Program 11.5'de fonksiyonlara değer ve adres geçerek aktarımın nasıl yapılacağı
gösterilmiştir.
Program 11.5: Bir değişkenin içeriğini ve adresini ekrana yazdırma
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
/* 10prg05.c: Değer geçerek ve adres geçerek
aktarım */
#include
void f1(int ); /* iki fonksiyon */
void f2(int *);
int main()
{
int x = 55;
printf("x in degeri,\n");
printf("Fonksiyonlar cagrilmadan once:
%d\n",x);
/* f1 fonksiyonu çağrılıyor...*/
f1(x);
printf("f1 cagirildiktan sonra :
%d\n",x);
/* f2 fonksiyonu çağrılıyor...*/
f2(&x);
printf("f2 cagirildiktan sonra :
%d\n",x);
return 0;
}
/* Değer geçerek aktarım */
void f1(int n){
n = 66;
printf("f1 fonksiyonu icinde :
%d\n",n);
}
/* Adres geçerek aktarım */
void f2(int *n){
*n = 77;
printf("f2 fonksiyonu icinde :
%d\n",*n);
}

5. ve 6. satırlada kendine geçilen parametrenin değerini alan f1 fonksiyonu ve parametrenin
adresini alan f2 adlı iki fonksiyon örneği belirtilmişdir. 11. satırdaki x değişkeni 16. ve 21.
satırlarda, f1(x) ve f2(&x) fonksiyonlarına, sırasıyla değer ve adres geçerek aktarılmıştır. f1
içinde x (n = 66; işlemi ile) değişime uğramış, fakat çağrılma işleminin sonucunda, x'in
değeri değişmemiştir. Ancak f2 içinde x'in ( *n = 77 işlemi ile) değişimi, çağrıldıktan
sonrada korunmuştur. Yani, adres geçerek yaplıan aktarımda, f2'ye aktarılan değer değil adres
olduğu için, yollanan x parametresi f2 içinde değişikliğe uğrayacak ve bu değişim çağrıldığı
21. satırdan itibaren devam edecektir.
ÇIKTI
x in degeri,
Fonksiyonlar cagrilmadan once: 55
f1 fonksiyonu icinde : 66
f1 cagirildiktan sonra : 55
f2 fonksiyonu icinde : 77
f2 cagirildiktan sonra : 77
Program 11.6'da iki tamsayı değişkeninin nasıl takas (swap) edileceği gösterilmiştir. Bu
işlemi C porgramlama dilinde, eğer değişkenler global olarak bildirilmemişse, gösterici
kullanmadan bu işlemi yapmak imkansızdır.
Program 11.6: İki tamsayının birbiri ile takas edilmesi
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
/* 10prg06.c: iki sayının birbiri ile takas
edilmesi */
#include
void takas(int *, int *);
int main()
{
int a, b;
a=22; b=33;
printf("takas oncesi : a=%d b=%d\n",a,b);
takas(&a, &b);
printf("takas sonrasi: a=%d b=%d\n",a,b);
return 0;
}
void takas(int *x, int *y)
{
int z;
}
z = *x;
*x = *y;
*y = z;

ÇIKTI
takas oncesi : a=22 b=33
takas sonrasi: a=33 b=22
11.6 NULL Gösterici
Bir göstericinin bellekte herhangi bir adresi göstermesi, veya öncden göstermiş olduğu adres
iptal edilmesi istemirse NULL sabiti kullanılır. Bu sabit derleyicide ASCII karakter tablosunun
ilk karakteridir ve '\0' ile sembolize edilir.
int *ptr, a = 12;
.
.
ptr = &a; /* ptr bellekte a değişkenin saklandığı yeri
gösteriyor */
.
.
ptr = NULL; /* ptr bellekte hiç bir hücreyi göstermiyor */
*ptr = 8 /* hata! NULL göstericinin gösterdiği yere bir
değer atanamaz */
11.7 void Tipindeki Göstericiler
void göstericiler herhangi bir veri tipine ait olmayan göstericilerdir. Bu özelliğinden dolayı,
void gösterici genel gösterici (generic pointer) olarak da adlandırılır.
void göstericiler, void anahtar sözcüğü ile bildirilir. Örneğin:
gibi.
void *adr;
void göstericiler yalnızca adres saklamak için kullanılır. Bu yüzden diğer göstericiler
arasında atama işlemlerinde kullanılabilir. Örneğin aşağıdaki atamada derleyici bir uyarı veya
hata mesajı vermez:
void *v;
char *c;
.
.
.
v = c; /* sorun yok !*/
Program 11.7'de void tipindeki bir göstericinin, program içinde, farklı tipteki verileri nasıl
göstereceği ve kullanılacağı örneklenmiştir. İnceleyiniz.
Program 11.7: void gösterici ile farklı tipteki verileri gösterme
01:
02:
/* 10prg07.c: void gosterici (generic pointer)
uygulamasi */

03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
#include
void yaz(void *);
int main()
{
char kar = 'a';
int tam = 66;
double ger = 1.2;
void *veri;
veri = &kar;
printf("veri -> kar: veri %c karakter
degerini gosteriyor\n", *(char *) veri);
veri = &tam;
printf("veri -> tam: simdi veri %d tamsayi
degerini gosteriyor\n", *(int *) veri);
veri = &ger;
printf("veri -> ger: simdi de veri %lf
gercel sayi degerini gosteriyor\n", *(double *)
veri);
}
return 0;
ÇIKTI
veri -> kar: veri a karakter degerini gosteriyor
veri -> tam: simdi veri 66 tamsayi degerini
gosteriyor
veri -> ger: simdi de veri 1.200000 gercel sayi
degerini gosteriyor
Benzer olarak, fonksiyon parameterelerinin kopyalanması sırasında da bu türden atama
işlemleri kullanılabilir. Uygulamada, tipten bağımsız adres işlemlerinin yapıldığı
fonksiyonlarda, parametre değişkeni olarak void göstericiler kullanılır. Örneğin
void free (void *p)
{
.
.
.
}
Parametresi void *p olan free fonksiyonu, herhangi türden gösterici ile çağrılabilir.
Ders 12: Katarlar (Stringler)
• Giriş
• 12.1 Katar Bildirimi

• 12.2 Katarlara Başlangıç Değeri Atama
• 12.3 Katar Üzerinde İşlem Yapan Standart G/Ç Fonksiyonları
• 12.4 Bazı Katar Fonksiyonları
• 12.5 Katarların Fonksiyonlarda Kullanılması
Giriş
Katarlar anlaşılması en zor konulardan biridir. C programlama dilinde iki tırnak içine alınan
her ifadeye katar denir. Örneğin:
"Izmir"
"sonuc = %d\n"
"Devam etmek icin ENTER tusuna basin."
Türkçe yazılan C kitaplarda, ingilizce string kelimesi yerine aşağıdaki ifadelerden biri
karşılaşılabilir:
katar = karakter topluluğu = karakter dizisi = sözce = sicim
Anlatımda, katar terimini kullanacağız.
12.1 Katar Bildirimi
Katarlar, char tipinde bildirilen karakter dizileridir ve harfler, rakamlar, veya bazı
sembolleriden oluşur. C dilinde katar bildirimi için bir tip deyimi yoktur. Bu yüzden, bir
katara bir dizi veya gösterici gözüyle bakılır. Genel olarak bir katarın bildirimi:
yada
char katar_adı[eleman_sayısı];
char *katar_adı;
şeklinde yapılır. Örneğin bir öğrencinin isim bilgisi ad adlı bir katarla tutulmak istenirse:
yada
char ad[10];
char *ad;
şeklinde programın başında bildirilmelidir.
12.2 Katarlara Başlangıç Değeri Atama
Diğer dizi bildirimlerinde olduğu gibi, karakter dizilerine başlangıç değeri verilebilir. Örneğin
aşağıda verilen iki bildirim aynı anlamdadır:
char s[5]={'I','z','m','i','r','\0'};
char s[5]="Izmir";

Birinci satırdaki bildirimde '\0' (NULL) sonlandırıcı karakter dizisinin sonlandığını gösterir.
Daha önce de bahsedildiği gibi sonlandırıcı karakter, karakter dizileri üzerinde işlemlerin hızlı
ve etkin bir biçimde yapılabilmesine olanak sağlar. İkinci bildirimde buna gerek yoktur.
Eğer bir karakter dizisinin kaç eleman sayısı belirtilmezse, başlangıçta bildirilen karakter
sayısı kaç tane ise dizinin eleman sayısı o kadar olduğu varsayılır.
char s[] = "Ankara"; /* 6 elemanlı */
Eğer bildirim gösterici ile yapılmak isterirse:
yada
Ancak
char *s = "Ankara"; /* 6 elemanlı */
char *s;
s = "Ankara";
char s[6];
s = "Ankara";
şeklindeki bir atama geçersizdir. Çünkü bu şekilde yapılan bildirimde s bir değişken değil
dizidir.
Elemanları katar olan diziler tanımlamak mümkündür. Örneğin en uzunu 7 karakter olan 5
farklı isim bir çatı altında şöyle toplanabilir:
yada
yada
char isim[5][8] = { "Semra", "Mustafa", "Ceyhun", "Asli", "Leyla" };
char isim[][8] = { "Semra", "Mustafa", "Ceyhun", "Asli", "Leyla" };
char *isim[5] = { "Semra", "Mustafa", "Ceyhun", "Asli", "Leyla" };
Görüldüğü gibi, bu tip tanımlamalarda birinci boyut (satır) dizinin eleman sayısını, ikinci
boyut (sütun) her bir elemanın sahip olabileceği maksimum karakter sayısını gösterir.
NOT
Katar ifadelerinde doğrudan çift tırnak " veya ters bölü \
karakterleri kullanılamaz. Bu durumda katar ifadeleri
içerisinde
" yerine \"
\ yerine \\
kullanılmalıdır. Örneğin:
char *mes = "\"ilk.c\" dosyasinin yeri:";
char *yol = "C:\\WINDOWS\\DESKTOP\\C";
...
puts(mes);
puts(yol);
ile ekrana aşağıdaki satırlar bastırlır:
"ilk.c" dosyasinin yeri:
C:\WINDOWS\DESKTOP\C

12.3 Katarlar Üzerinde İşlem Yapan Standart G/Ç
Fonksiyonları
printf() ve scanf() fonksiyonları diğer tiplerde olduğu gibi formatlı okuma/yazma amaçlı
kullanılır. Katar formatı %s dir. Örneğin:
char str[20];
...
scanf("%s",str);
printf("%s\n",str);
satırları ile klavyeden okunan katarın ilk 20 karakteri ekrana yazdırlabilir. Burada printf()
fonksiyonu:
printf(str);
şeklinde de kullanılabir. Bu durumda, katar ekrana yazdırılır fakat imlec (cursor) bir alt satıra
geçmez.
gets() fonksiyonu klavyeden karakter dizisi almakta kullanılan bir C fonksiyonudur. Bu
fonksiyon, klavyeden girilen karakterleri diziye yerleştirdikten sonra dizinin sonuna otomatik
olarak NULL ('\0') karakterini ekler.
char str[20];
...
gets(str);
NOT
gets() fonksiyonunu kullanmak biraz tehlikeli olabilir.
Çünkü, gets() ile okuma yapılırken katarın büyüklüğünü
dikkate alınmaz. Örneğin:
char s[10];
gets(s);
şeklindeki okuma işleminde s en fazla 10 karakter
saklayabilirken, gets() ile 100 karakter girilirse, derleyici
bütün karakterleri saklamaya çalışır. Bu durumda, program
sağlıklı çalışmaz ve hata verir. Bu yüzden bazı derleyiciler,
gets() kullanıldığında aşağıdaki gibi bir uyarı verir.
warning: the `gets' function is dangerous and should
not be used.
Sonuç olarak, scanf() fonksiyonunu kullanmanız tavsiye
edilir.
puts() fonksiyonu bir karakter dizisini ekrana yazdırmak için kullanılır. Bu fonksiyon diziyi
ekrana yazdırdıktan sonra imleci (cursor) bir sonraki satıra geçirir.
char *str = "Hangi cilgin bana zincir vuracakmis sasarim";
...
puts(str);
puts(str) ile printf("%s\n",str) işlevsel olarak birbirine eşdeğerdir.

Buraya kadar anlatılanlar Program 12.1-3 de özetlenmiştir.
Program 12.1: Bir katarın farklı yöntemlerle ekrana yazdırılması
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
ÇIKTI
/* 12prg01.c
Bir katarın farklı yöntemlerle ekrana
yazılması */
#include
int main()
{
char dizi[7] = {'S', 'e', 'l', 'a', 'm',
'!', '\0'};
int i;
/* Herbir karakteri ayrı ayrı alt alta yaz
*/
printf("Dizi elemanlari:\n");
for (i=0; i

02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
ÇIKTI
karakterlerinin sayısı hesaplar */
#include
int main()
{
char str[20];
int i,sayac=0;
printf("Bir string girin: ");
gets(str);
for(i=0; str[i] != '\0'; i++)
if( str[i] == 'm') sayac++;
printf("'m' karakteri sayisi = %d\n",sayac);
return 0;
}
Bir katar girin: marmara
'm' karakteri sayisi = 2
13. satırdaki döngüde, str[i]!='\0', koşulu ile sonlandırıcı karaktere gelinip gelinmedği
sorgulanmaktadır. 14. satırda katar içindeki 'm' karakterine rastlanırsa sayac değeri bir
artmaktadır. Katar sonuna kadar bütün 'm' karakterlerinin toplamı hesaplanıp ekrana
yazdırılmıştır.
Program 12.2'deki döngü şöyle de yazılabilirdi:
...
for(i=0; str[i]; i++)
if(str[i] == 'm') sayac++;
...
Buradaki işlemle str[i], NULL karakterinden farklı olduğu sürece döngü devam ettirilmiştir.
Aşağıdaki program elemanlı katar olan bir karakter dizisini ekrana yazar.
Program 12.3: Bir katarı yazdırma
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
/* 12prg03.c: Bir elemanları katar olan karakter
dizisini yazdırma */
#include
int main()
{
char *gun[7] = { "Pazartesi", "Sali",
"Carsamba",
"Cumartesi", "Pazar" };
int i;
"Persembe",
"Cuma",

14:
15:
16:
ÇIKTI
for(i=0; i

Program 12.4: strcmp fonksiyonunun kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
/* 12prg04.c: Basit bir şifre programı.
Kullanıcı en fazla 3 kez yanlış şifre
girebilir. */
#include
#include
int main()
{
char sifre[8];
int sonuc, hak=3;
while( hak-- > 0 )
{
printf("Sifre : ");
gets(sifre);
al */
sonuc = strcmp(sifre,"elma%xj4");
if( sonuc==0 ){
kontrol */
puts("sifre dogru");
break;
}
else
puts("sifre yanlis");
}
/* şifreyi
/* şifre
}
return 0;
ÇIKTI
Sifre : admin
sifre yanlis
Sifre : root
sifre yanlis
Sifre : elma%xj4
sifre dogru
Program 12.5: strcpy fonksiyonunun kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
/* 12prg05.c: Bir katarı diğerine kopyalama */
#include
#include
int main()
{
char str1[] = "Deneme";
char str2[15], str3[15];
int i;
/* strcpy kullanarak kopyalama */

13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
ÇIKTI
strcpy(str2, str1);
/* strcpy kullanmadan kopyalama */
for(i=0; str1[i]; i++)
str3[i] = str1[i];
str3[i] = '\0'; /* sonlandırıcı ekle */
/* sonuçlar ekrana */
printf("str1 : %s\n",str1);
printf("str2 : %s\n",str2);
printf("str3 : %s\n",str3);
return 0;
}
str1 : Deneme
str2 : Deneme
str3 : Deneme
Program 12.6: strcat fonksiyonunun kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
ÇIKTI
/* 12prg06.c: Bir katarı diğerine ekler */
#include
#include
int main()
{
char mesaj[20] = "Selam "; /* 1. katar */
char isim[10]; /* 2. katar */
printf("Adiniz ? : ");
scanf("%s",isim);
/* ekle */
strcat(mesaj, isim);
printf("%s\n",mesaj);
return 0;
}
Adiniz ? : Mert
Selam Mert
Program 12.7: strlen fonksiyonunun kullanımı
01:
02:
03:
/* 12prg07.c: Bir karakter dizisinin uzunluğunu
bulur */

04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
ÇIKTI
#include
#include
int main()
{
char s[20];
int k = 0;
printf("Bir seyler yazin : ");
scanf("%s",s);
/* sonlandırıcı karaktere kadar */
while( s[k] != '\0' )
k++;
puts("Dizinin uzunlugu");
printf("strlen kullanarak =
%d\n",strlen(s));
printf("strlen kullanmadan = %d\n",k);
return 0;
}
Bir seyler yazin : deneme stringi
Dizinin uzunlugu
strlen kullanarak = 14
strlen kullanmadan = 14
Program 12.8: Isim sırlama
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
/* 12prg08.c
Kabarcık Sıralama (Bubble Sort) Algoritması
ile
isimleri alfabetik sırayla listeler */
#include
#include
#define n 5
int main()
{
char isim[n][8] = { "Semra", "Mustafa",
"Ceyhun", "Asli", "Leyla" };
char gecici[8];
int i,j,k;
puts("Once:\n------");
for(i=0; i

27:
28:
29:
30:
31:
32:
33:
34:
35:
{
}
strcpy(gecici ,isim[j]);
strcpy(isim[j] ,isim[j+1]);
strcpy(isim[j+1],gecici);
puts("\nSonra:\n------");
for(i=0; i

15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
printf("Uzunlugu (struzn) : %d\n",struzn(s));
printf("Uzunlugu (strlen) : %d\n",strlen(s));
return 0;
}
/* bir karakter dizisinin uzunluğunu hesaplar */
int struzn(char *str)
{
int n = 0;
}
ÇIKTI
while(str[n])
n++;
return n;
Bir katar girin: Programlama
Uzunlugu (struzn) : 11
Uzunlugu (strlen) : 11
Program 12.10: strrev dengi bir fonksiyon: strcev
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
/* 12prg10.c: Bir katarın tersini veren bir
fonksiyon */
#include
#include
char *strcev(char *);
int main()
{
char s[50];
printf("Bir katar girin: ");
scanf("%s",s);
printf("Katar, s : %s\n",s);
printf("Tersi, strcev(s) : %s\n",strcev(s));
return 0;
}
/* str katarını ters-yüz eder */
char *strcev(char *str)
{
int i,n;
char gecici;
n = strlen(str);
for(i=0; i

33:
34:
35:
36:
37:
ÇIKTI
}
str[i] = str[n-i-1];
str[n-i-1] = gecici;
return str; /* geri dönüş değeri bir gösterici
*/
}
Bir katar girin: Programlama
Katar, s : Programlama
Tersi, strcev(s) : amalmargorP
Ders 13: Dinamik Bellek Yönetimi
• Giriş
• 13.1 Dinamik Dizi Fonksiyonları
• 13.2 Dinamik Matrisler
Giriş
Bir C programı içerisinde, dizilerin boyutu ve kaç elemanlı olduğu program başında
belirtilirse, derleyici o dizi için gereken bellek alanını (bölgesini) program sonlanıncaya kadar
saklı tutar ve bu alan başka bir amaç için kullanılamaz [1]. Bu türden diziler statik dizi olarak
isimlendirilir. Statik dizinin boyutu programın çalışması esnasında (run time) değiştirilemez.
Fakat, programın çalışırken bir dizinin boyutu ve eleman sayısı bazı yöntemler kullanılarak
değiştirilebilir. Bu tür dizilere dinamik dizi denir. Dinamik diziler için gereken bellek
bölgesi, derleyici tarafından işletim sisteminden istenir, kullanılır ve daha sonra istenirse bu
bölge boşaltırılır. Bu bölümde, dinamik dizi kavramı ve dinamik bellek yönetimi
anlatılacaktır.
13.1 Dinamik Dizi Fonksiyonları
ANSI C'de, dinamik diziler işaretçi kullanılarak ve standart kütüphanedeki malloc(),
calloc(), realloc() ve free() fonksiyonlarının yardımıyla ile oluşturulur veya boşaltılır.
Bu fonksiyonlar Tablo 13.1 de listelenmiştir.
Tablo 13.1: stdlib.h kütüphanesindeki dinamik bellek fonksiyonları
Dinamik Bellek Fonksiyonu
void *malloc(size_t eleman_sayısı);
Açıklama
Bellekte herbiri size_t tipinde olan
eleman_sayısı kadar yer (bellek bloğu)
ayırır. Bu yer verilmezse geriye NULL gönderir.

void *calloc(size_t eleman_sayısı,
size_t nbayt);
void *realloc(void *ptr, size_t
nbayt);
void free(void *ptr);
Bellekte herbiri nbayt kadar yer işgal edecek
eleman_sayısı kadar boş yer ayırır ve bütün
bitleri sıfırlar. Bu yer ayrılamazsa geriye NULL
gönderir.
ptr işaretçisi ile gösterilen bellek bloğunu,
nbayt kadar büyüterek veya küçülterek
değiştirir. Bu iş gerçekleşmezse geriye NULL
gönderir.
Daha önce ayrılan adresi ptr'de saklanan
bellek alanının boşaltır.
Tamsayı tipinde bir dinamik dizi tanımlanırken aşağıdaki işlem basamakları izlenmelidir:
/* dinamik dizi bildirimi */
int *dizi;
/* eleman saysını belirle */
scanf("%d",&n);
/* n tane bellek bloğu isteniyor */
dizi = (int *) malloc( sizeof(int)*n );
/* Boş yer varmı sorgulanıyor */
if( dizi == NULL )
printf("Yetersiz bellek alanı\n"), exit(1);
...
/* dizi burada kullanılıyor */
...
/* bellek bloğu boşaltılıyor */
free(dizi);
Program 13.1, eleman sayısı klavyeden girilen bir dizinin aritmetik ortalamasını hesaplar.
Eleman sayısı sıfır veya negatif bir değer olduğunda, sonsuz döngüden çıkılır ve program
sonlanır. İnceleyiniz.
Program 13.1: Dinamik dizi ile ortalama hesabı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
/* 13prg01.c: Dinamik dizi ile ortalama hesabı
*/
#include
#include
int main(){
int n,i;
float *x, toplam, ort;
while(1)
{
/* dizinin eleman sayısı okunuyor */
printf("\nEleman sayısını girin: ");
scanf("%d",&n);

18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
);
ÇIKTI
/* eleman sayısı

06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
char *altKatar(char *str, int, int);
int main()
{
int i;
char *s, *parca;
s = "programlama";
for(i=0; s[i]; i++)
{
parca = altKatar(s, 0, i);
puts(parca);
}
return 0;
}
/* str'nin p1. elemanindan p2. elemanina kadar
olan alt katarını gonderir. */
char *altKatar(char *str, int p1, int p2)
{
int i, j=0, n;
static char *alt;
n = p2 - p1;
}
ÇIKTI
/* bellekten yer ayrılıyor... */
alt = (char *) malloc( n*sizeof(char) );
for(i=p1; i

01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
/* 13prg02.c: Dinamik matris tanımlama */
#include
#include
int main()
{
int **matris;
int satir, kolon;
int s, k;
int i;
printf("Matrisin satır sayısı: ");
scanf("%d", &satir);
printf("Matrisin kolon sayısı: ");
scanf("%d", &kolon);
/* dıştaki dizi için bellek alanı isteniyor
*/
matris = (int **) calloc(satir,
sizeof(int));
/* içteki dizi için bellek alanı isteniyor
*/
for(i = 0; i < satir; i++)
matris[i] = (int *) calloc(kolon,
sizeof(int));
/* matrisin elemanları okunuyor */
for(s = 0; s < satir; s++)
for(k = 0; k < kolon; k++) {
printf("Matrisin elemanı girin:
matris[%d][%d] = ", s, k);
scanf("%d", &(matris[s][k]));
}
printf("\nGirilen matris:\n");
for(s = 0; s < satir; s++) {
for(k = 0; k < kolon; k++)
printf("%4d", matris[s][k]);
}
printf("\n");
/* içteki dizi boşaltılıyor */
for(i = 0; i < satir; i++)
free((void *) matris[i]);
/* dıştaki dizi boşaltılıyor */
free((void *) matris);
}
return(0);
ÇIKTI
Matrisin satır sayısı: 2
Matrisin kolon sayısı: 3

Matrisin elemanı girin: matris[0][0] = 1
Matrisin elemanı girin: matris[0][1] = 2
Matrisin elemanı girin: matris[0][2] = 3
Matrisin elemanı girin: matris[1][0] = 5
Matrisin elemanı girin: matris[1][1] = 6
Matrisin elemanı girin: matris[1][2] = 8
Girilen matris:
1 2 3
5 6 8
Ders 14: Gösterici Uygulamaları
• Giriş
• 14.1 Gösterici Uygulamarı
Giriş
Bu bölümde bazı gösterici uygulamaları gösterilmiştir.
14.1 Gösterici Uygulamarı
i. Rastgele dizi
ii. Bir dizinin elemanlarını küçükten büyüğe doğru sıralama
iii. Bir dizinin kare kökünü hesaplayan fonksiyon
iv. Dinamik matris çarpımı
Program 14.1: Rastgele dizi
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
/* 14prg01.c: Rastgele Dizi */
#include
#include
/* dizinin ilk n elemanına [0,1] arasında
rastgele sayı atar */
void rastgele(double *dizi, int n){
int i;
}
for(i=0; i

21:
22:
23:
24:
25:
26:
27:
28:
29:
}
srand(1234567);
rastgele(x, 5);
puts("Rastgele dizi elemanları:");
for(i=0; i

38:
39:
}
printf("\n");
return 0;
ÇIKTI
Once : 22 44 11 55 33
Sonra: 11 22 33 44 55
Program 14.3: Bir dizinin kare kökünü hesaplayan fonksiyon
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
/* 14prg03.c: Bir dizinin kare kökünü hesaplayan
fonksiyon */
#include
#include
#include
double *kare_kok(double *, int);
int main()
{
double A[5] = {1.0, 2.0, 4.0, 8.0, 16.0};
double *B;
int i;
}
printf("A dizisi: ");
for(i=0; i

45: c[i] = sqrt(dizi[i]);
}
return c;
ÇIKTI
A dizisi: 1.000000 2.000000 4.000000 8.000000
16.000000
B dizisi: 1.000000 1.414214 2.000000 2.828427
4.000000
Program 14.4: Dinamik Matris Çarpımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
/* 14prg04.c: Dinamik Matris Çarpımı
Bu program A(mxn) matrisi ile B(pxq)
matrisini çarpımını hesaplar.
Çarpım matrisi C(mxq), C = AB dir. Çarpımın
sonucu matris_carp()
fonksiyonu ile hesaplanır.
Örnek:
~~~~~~
[ 1 0 2 ] [ 3 1 ] [ 1 0
2 ] [ 3 1 ] [ 5 1 ]
A = [-1 3 1 ] B =[ 2 1 ] ==> C = AB = [-1 3
1 ] [ 2 1 ] = [ 4 2 ]
[ 1 0 ]
[ 1 0 ]
*/
#include
#include
double **matris_carp(double **, int, int,
double **, int, int);
int main()
{
double **A;
double **B;
double **C;
int i, j;
/* A matrisi için bellekten yer ayır */
A = (double **) calloc( 2, sizeof(double));
for(i = 0; i < 2; i++)
A[i] = (double *) calloc(3,
sizeof(double));
/* B matrisi için bellekten yer ayır */
B = (double **) calloc( 3, sizeof(double));
for(i = 0; i < 3; i++)
B[i] = (double *) calloc(2,
sizeof(double));

44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
}
/* A matrisinin elemanları */
A[0][0] = 1.0; A[0][1] = 0.0; A[0][2] = 2.0;
A[1][0] =-1.0; A[1][1] = 3.0; A[1][2] = 1.0;
/* B matrisinin elemanları */
B[0][0] = 3.0; B[0][1] = 1.0;
B[1][0] = 2.0; B[1][1] = 1.0;
B[2][0] = 1.0; B[2][1] = 0.0;
/* C = AB matrisi */
C = matris_carp(A,2,3, B,3,2);
for(i=0; i

Ders 15: Yapılar ve Birlikler
• Giriş
• 15.1 enum Deyimi (Enumeration Constants)
• 15.2 Yapı, struct Deyimi (Structures)
• 15.3 typedef Deyimi
• 15.4 Birlik, union Deyimi
Giriş
C, kullanıcının kendi veri tipini tanımlamasına müsaade eder. Bu kısımda böyle veritiplerinin
nasıl oluşturulacağı anlatılacaktır.
15.1 enum Deyimi (Enumeration Constants)
Bu tip, değişkenin alabileceği değerlerin belli (sabit) olduğu durumlarda programı daha
okunabilir hale getirmek için kullanılır. Genel yazım biçimi:
enum tip_adı{değer_1, değer_2, ..., değer_n} değişken_adı;
tip_adı programcı tarafından verilen tip ismidir. değişken_adı ise program içinde
kullanılacak olan değişkenin adıdır. Eğer kullanılmazsa program içinde daha sonra enum ile
birlikte kullanılır. Örneğin:
enum bolumler{programcilik, donanim, muhasebe, motor};
tanımı ile derleyici programcilik için 0, donanim için 1, muhasebe için 2 ve motor için 3
değerini kabul ederek atamaları buna göre yapar. Değişken adı bildirilirse daha sonra enum
kullanmaya gerek kalmaz. Örneğin:
enum renkler {kirmizi, mavi, sari} renk;
enum gunler {pazartesi, sali, carsamba, persembe, cuma, cumartesi,
pazar};
gibi yapılan sabit tanımlamaları program içinde kullanılabilir:
enum bolumler bolum;
enum gunler gun;
...
bolum = muhasebe; /* bolum = 2 anlamında */
gun = cuma; /* gun = 4 anlamında */
renk = kirmizi; /* renk = 0 anlamında */
Program 15.1 enum anahtar kelimesinin basit kullanımları gösterilmiştir.
Program 15.1: enum kullanımı

01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
/* 15prg01.c: Klavyeden girilen bir sayının tek
olup olmadığını sınar */
#include
enum BOOLEAN{ FALSE, TRUE }; /* 0, 1 */
int tek(int n){ return (n % 2); }
int main()
{
enum BOOLEAN sonuc;
int x;
}
ÇIKTI
printf("Bir sayi girin: ");
scanf("%d",&x);
sonuc = tek(x); /* tek mi? */
if( sonuc == TRUE )
puts("Girilen sayi tek ");
else
puts("Girilen sayi cift");
return 0;
Bir sayi girin: 5
Girilen sayi tek
enum bloğu içinde tanımlanmış değişkenlerin sahip sabit olacağı değerler Program 15.2
olduğu gibi programcı tarafından belirlenebilir.
Program 15.2: enum kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
/* 15prg02.c: Beş sabit bölüm için enum
kullanımı */
enum bolumler{
programcilik = 1, /* 1 */
donanim, /* 2 */
muhasebe, /* 3 */
motor, /* 4 */
buro /* 5 */
} bolum;
int main()
{
bolum = donanim;
printf("bolum : %d\n",bolum);
bolum += 2; /* bolum = motor */
printf("Yeni bolum : %d\n",bolum);

22: return 0;
}
ÇIKTI
bolum : 2
Yeni bolum : 4
15.2 Yapı, struct Deyimi (Structures)
Aralarında mantıksal bir ilişki bulunan farklı türden bilgiler "yapılar (structures)" içerisinde
mantıksal bir bütün olarak ifade edilebilir. Yapılar diziler gibi bellekte sürekli kalır. Bir yapı
içerisindeki elemanlara üye (member) denir. Üyelerin herbiri farklı veri tipine sahip olabilir.
Bu sayede, kendi tipinizi üretebilirsiniz.
Genel yapı bildirimi:
struct yapı_adı{
tip yapı_değişken_ismi;
tip yapı_değişken_ismi;
...
};
NOT
enum ile sabit bildirimi yapılırken
struct ile değişken bildirimi yapılır.
Bir öğrenciye ait bilgileri bir çatı altında aşağıdaki gibi toplanabilir:
/* kayit veri tipi! */
struct kayit{
/* üyeler */
char ad[10];
long no;
short sinif;
};
Bu tipte bir değişken tanımlama:
struct kayit ogr1, ogr2;
şeklinde olabilir. ogr1 değişkeni ile tanımlanan 1. öğrencinin numarasına bir değer atama
işlemi:
ogr1.no = 2012597;
şeklinde yapılır. Bu deyimin kullanımı Program 15.3, ve 15.4'de gösterilmiştir. Inceleyiniz.
Program 15.3: struct deyiminin kullanımı
01:
02:
03:
04:
05:
06:
/* 15prg03.c
Bir öğrenciye ait bilgilerin struct deyimi
ile bir çatı altında toplanması */
#include

07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
ÇIKTI
/* kayit yapısı */
struct kayit{
char ad[10];
long no;
int sinif;
};
int main()
{
struct kayit ogr;
tipinde */
/* ogr değişkeni kayit
printf("Ogrenci Nosu : ");
scanf("%ld",&ogr.no);
printf("Ogrenci Adi : "); scanf("%s" ,
ogr.ad);
printf("Ogrenci Sinifi: "); scanf("%d"
,&ogr.sinif);
printf("\n*** Girilen bilgiler ***");
printf("\nNo : %ld",ogr.no);
printf("\nAdi : %s ",ogr.ad);
printf("\nSinifi: %d ",ogr.sinif);
return 0;
}
Ogrenci Nosu : 948589
Ogrenci Adi : Ahmet
Ogrenci Sinifi: 2
*** Girilen bilgiler ***
No : 948589
Adi : Ahmet
Sinifi: 2
Yapılar, diğer değişkenler gibi, fonksiyonlara parametre olarak geçirelilebilir.
Program 15.4: struct deyiminin kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
/* 15prg04.c
Yapıların bir fonksiyona parametere olarak
aktarılabilmesi */
#include
struct TARIH{
int gun,ay,yil;
};
void goster(struct TARIH x){
printf("Tarih: %02d-%02d-%4d\n", x.gun,
x.ay, x.yil);
}
int main()
{
struct TARIH n; /* n değişkeni TARIH tipinde

19:
20:
21:
22:
23:
24:
25:
*/
n.gun = 1;
n.ay = 8;
n.yil = 2003;
goster(n);
ÇIKTI
return 0;
}
Tarih: 01-08-2003
Yapılarla da, gösterici tanımlamaları yapılabilir. Ancak, bir yapı gösteren göstericinin,
gösterdiği yere yönlendirme operatörü, ->, ile erişilir.
Program 15.5: struct deyiminin kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
/* 15prg05.c: Bir yapı gösteren gösterici */
#include
struct Meyve{
float agirlik;
float fiyat;
};
int main()
{
struct Meyve *muz, elma;
float muzTutar, elmaTutar;
/* muz Meyve tipinde bir gösterici */
muz->agirlik = 2.50;
muz->fiyat = 3.50;
muzTutar = muz->fiyat * muz->agirlik;
/* elma Meyve tipinde bir değişken */
elma.agirlik = 2.00;
elma.fiyat = 1.75;
elmaTutar = elma.fiyat * elma.agirlik;
printf("Meyve Agırlık Birim Fiyatı
TUTAR (TL)\n");
printf("----- ------- ------------ ---
--------\n");
printf("Muz %7.2f %7.2f
%7.2f\n",
muz->agirlik, muz->fiyat, muzTutar);
printf("Elma %7.2f %7.2f
%7.2f\n",
elma.agirlik, elma.fiyat, elmaTutar);
return 0;
}

ÇIKTI
Meyve Agırlık Birim Fiyatı TUTAR (TL)
----- ------- ------------ -----------
Muz 2.50 3.50 8.75
Elma 2.00 1.75 3.50
15.3 typedef Deyimi
struct ile oluşturulan yapıda typedef deyimi kullanılırsa, bu yapıdan değişken tanımlamak
için tekrar struct deyiminin kullanılmasına gerek kalmaz.
typedef struct kayit{
char ad[10];
long no;
short sinif;
} ogr1,ogr2;
Program 15.4 küçük bir değişiklike Program 15.6'de yeniden yazılmıştır. Inceleyiniz.
Program 15.6: typedef - struct deyiminin kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
ÇIKTI
/* 15prg06.c
Yapıların bir fonksiyona parametere olarak
aktarılabilmesi.
typedef deyimi kullanıldığında struct
deyimine gerek yoktur */
#include
typedef struct{
int gun,ay,yil;
}TARIH;
void goster(TARIH x){
printf("Tarih: %02d-%02d-%4d\n", x.gun,
x.ay, x.yil);
}
int main(void)
{
TARIH n;
n.gun = 1;
n.ay = 8;
n.yil = 2003;
goster(n);
return 0;
}
Tarih: 01-08-2003

typedef başka kullanımı da vardır. C dilinde program kodları bu deyimle tamamen
türkçeleştirilebilir. Örneğin bu deyim:
typedef int tamsayi;
şeklinde kullanılırsa programda daha sonra int tipinde bir değişken tanımlarken şu biçimde
kullanılmasına izin verilir.
tamsayi x,y; /* int x,y anlaminda */
15.1 Birlik, union Deyimi
Birlikler de yapılar gibi sürekli belleğe yerleşen nesnelerdir. Birlikler yapılara göre seyrek
kullanılır. Bir programda veya fonksiyonda değişkenlerin aynı bellek alanını paylaşması için
ortaklık bildirimi union deyimi ile yapılır. Bu da belleğin daha verimli kullanılmasına imkan
verir. Bu tipte bildirim yapılırken struct yerine union yazılır. Genel yazım biçimi:
union birlik_adı{
tip birlik_değişken_ismi;
tip birlik_değişken_ismi;
...
};
union paylas{
float f;
int i;
char kr;
};
Yukarıdaki bildirim yapıldığında, değişkenler için bellekte bir yer ayrılmaz. Değişken
bildirimi:
union paylas bir,iki;
şeklinde yapılır. Üyelere erişmek aşağıdaki gibi olur:
bir.kr= 'A';
iki.f = 3.14;
bir.i = 2000;
Program 15.7: typedef - deyiminin kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
/* 15prg07.c
union x ve y nin aynı bellek alanını işgal
ettiğinin kanıtı */
#include
union paylas{
int x;
int y;
}z;
int main()
{
int *xAdres,*yAdres;

15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
ÇIKTI
z.x = 11;
xAdres = &z.x;
printf("x = %d y = %d\n",z.x, z.y);
z.y = 22;
yAdres = &z.y;
printf("y = %d y = %d\n",z.x, z.y);
printf("xAdres = %p yAdres = %p\n",xAdres,
yAdres);
return 0;
}
x = 11 y = 11
y = 22 y = 22
xAdres = 0x804974c
yAdres = 0x804974c
Ders 16: Dosya Yönetimi
• Giriş
• 16.1 Dosya Açma ve Kapama
• 16.2 Metin ve İkili Dosyalar
• 16.3 Dosya Fonksiyonları
• 16.4 Standart Dosyalar
Giriş
Birçok programda, bazı verilerin disk üzerinde saklanmasına gerek duyulur. Bütün
programlama dillerinde, sabit disk sürücüsü (Hard Disk Drive, HDD) üzerindeki verileri
okumak veya diske veri yazmak için hazır fonksiyonlar tanımlanmıştır. C programlama
dilinde, disk dosyasına erişim iki yöntemle yapılır. Bunlar üst düzey ve alt düzey olarak
adlandırılır. Üst düzey G/Ç yöntemi ANSI C tarafından desteklenmektedir. Bu kısımda Üst
düzey G/Ç konu edilecektir[1].
16.1 Dosya Açma ve Kapama
Bir dosyaya okuma/yazma yapmak için onun açılması gerekir. Dosya açmak için fopen(),
kapatmak için fclose() fonksiyonu kullanılır. Bu fonksiyonlar stdio.h başlık dosyasında
tanımlanmıştır.
Genel olarak, dosya açma kapama adımları şu şekildedir:
FILE *dosya; /* dosya göstericisi */
dosya = fopen(const char dosya_adı, const char mod);

...
dosya işlemleri
...
fclose(dosya);
Burada FILE, stdio.h içerisinde bildirilmiş bir yapıdır. mod ile açılacak olan dosyanın ne
amaçla açılacağı belirlenir[2].
Tablo 16.1: Dosya açma modları
Açılış Modu İşlem Türü
Salt okunur (read only). Dosyanın açılabilmesi için önceden oluştrulmuş
r
olması gerekir. Bu modda açılmş olan bir dosyaya yazma yapılamaz.
Yalnızca yazma (write only). Dosya diskte kayıtlı olsun veya olamsın dosya
w
yeniden oluşturulur. Bu modda açılmış olan bir dosyadan okuma yapılamaz.
Ekleme (append). Kayıtlı bir dosyanın sonuna veri eklemek için açılır. Bu
a
modda açılmış olan bir dosyadan okuma yapılamaz.
Okuma ve yazma. Bu modda açılmış olan bir dosyanın daha önce varolması
r+
gerekir.
Okuma ve yazma. Bu modda açılmış olan bir dosya var olsun veya olmasın
w+
dosya yeniden oluşturulur.
a+ Okuma ve yazma. Kayıtlı bir dosyanın sonuna veri eklemek için açılır.
deneme.dat adlı bir dosyanın, yazmak için açılıp açılmadığını test etmek için aşağıdaki kod
kullanılır:
FILE *yaz; /* dosya göstericisi */
yaz = fopen("deneme.dat", "w");
if( yaz == NULL ){
puts("dosya acilmiyor...");
exit(1);
}
...
/* açılırsa! dosya işlemleri */
...
fclose(yaz);
NOT
deneme.dat dosyası ile ana program aynı dizin içinde
olmalıdır. Aksi halde, dosyanın tam yolu bildirilmelidir.
Örneğin dosyanın yolu: C:\WINDOWS\DESKTOP\deneme.dat
ise dosya açılırken
yaz = fopen("C:\\WINDOWS\\DESKTOP\\deneme.dat",
"w");
şeklinde açık yol bildirilmelidir. Aynı işlem Linux ortamında

da
geçerlidir.
gibi.
yaz = fopen("/home/bingul/DATA/deneme.dat","w");
16.2 Metin ve İkili Dosyalar
İşletim sistemlerinde genelde iki çeşit dosya kullanımına rastlanmaktadır. Bunlar metin (text)
ve ikili (binary) dosyalar olmak üzere ikiye ayrılır. Dosyanın hangi türden olduğu açılırken
fopen() fonksiyonu ile belirtilebilir.
Açılış modunda metin dosyaları için t, ikili dosyalar için b eklenir. Örneğin "r+t" şeklinde
bir açılış modu var olan bir dosyanın okuma yazma ve metin olarak açılacağı anlamına gelir.
Benzer olarak "wb" açılış modu dosyanın ikili modda oluşturulacağını gösterir. Fakat bu
belirleme yapılmamışsa, varsayılan açılış modu metindir (yani t).
16.3 Dosya Fonksiyonları
Bu kısımda, Tablo 16.2'de verilen dosyalama foksiyonlarının bazılarının kullanımı, örnek
programlar üzerinde anlatılmıştır.
Tablo 16.2: Üst düzey dosyalama fonksiyonları
Fonksiyon
fopen()
fclose()
putc()
getc()
feof()
fprintf()
fscanf()
fputs()
fgets()
fwrite()
fread()
Görevi
Dosya oluşturur, açar
Dosyayı kapatır
Dosyaya bir karakter yazar
Dosyadan bir karakter okur
Dosya sonuna gelindiğini sorgular
Dosyaya formatlı veri yazar
Dosyadan formatlı veri okur
Dosyaya katar yazar
Dosyadan katar okur
Dosyaya dizi yazar
Dosyadan dizi okur
Program 16.1: Bir dosyaya veri yazma
01:
02:
03:
04:
05:
06:
07:
08:
09:
/* 16prg01.c:
10 öğrenciye ait bilgileri 'ogrenci.txt'
dosyasına kaydeder. */
#include
#include
int main()
{

10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
ÇIKTI
FILE *dg; /* dosya göstericisi */
const int n = 10; /* öğrenci sayısı */
char ad[10];
int no, Not, i=0;
dg = fopen("ogrenci.txt", "w");
if( dg == NULL )
puts("ogrenci.txt dosyasi acilmadi. !\n"),
exit(1);
puts("10 ogrenciye ait bilgileri girin:");
while( i++

C:\TC> edit ogrenci.txt
$ edit ogrenci.txt
yada
$ pico ogrenci.txt
NOT
ogrenci.txt dosyası daha önce oluşturulmuşsa Program
16.1 önceki verileri silip yerine yeni verileri yazacaktır. Bu
dosyaya yeni bir veri eklemek için fopen() fonksiyonunu 'a'
modu ile kullanılmalıdır.
Bir dosyadan veri okumanın bir çok şekli vardır. Veri okuma işlemine basit bir örnek Program
16.2 de sunulumuştur. Bu program ogrenci.txt dosyasında kayıtlı öğrencilerden, en düşük
notu, en yüksek notu ve sınıf ortalamasını (0'lar hariç) hesaplamaktadır.
Program 16.2: Bir dosyadan veri okuma
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
/* 16prg02.c:
ogrenci.txt dosyasından no, isim ve not
bilgileri okur ve
notlar arasından en büyüğü, en küçüğü ve
sınıf ortlamasını (0'lar hariç) hesaplar. */
#include
#include
int main()
{
FILE *dg; /* dosya işaretçisi */
char Ad[10];
int Not, No, eb, ek, n, top;
float ort;
if( (dg=fopen("ogrenci.txt","r")) == NULL )
puts("Dosya açılmadı !\n"), exit(1);
/* başlangıç değerleri ata */
ek = 1000; /* çok büyük */
eb = -1000; /* çok küçük */
top = 0; /* notların toplamı */
n = 0; /* notu 0'dan farlı
öğrencilerin toplamı */
while( !feof(dg) ) /*
dosyanın sonuna kadar */
{
fscanf(dg,"%d %s %d",&No,Ad,&Not); /*
verileri oku! */
if(Not>eb) eb = Not;
büyük ve en küçük bulunuyor... */
if(Not

44:
45:
ÇIKTI
fclose(dg); /*
dosyayı kapat */
ort = (float) top/n; /*
ortalama (0 lar hariç!) */
printf("En yuksek not = %2d\n",eb); /*
sonuçlar ekrana ... */
printf("En dusuk not = %2d\n",ek);
printf("Ortalama = %4.1f\n",ort);
return 0;
}
En yuksek not = 92
En dusuk not = 0
Ortalama = 69.2
Bir program içinde birden çok dosya açmak mümkündür. Örneğin bir dosyadan okunan
veriler farklı bir formatta başka bir dosyaya yazılması istenebilir.Program 16.3 kelvin.sck
dosyasında bulunan 100 adet kelvin cinsinden sıcaklık bilgilerini derece karşılıklarını
derece.sck dosyasına yazar. Bu iki sıcaklık arasındaki çevrim kuralı: K = 273 + C
şeklindedir.
Program 16.3: Bir dosyada saklı verileri farklı bir biçimde başka bir dosyaya yazma
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
/* 16prg03.c
'kelvin.sck' dosyasında bulunan 100 adet
kelvin cinsinden sıcaklık
bilgilerini derece karşılıklarını
'derece.sck' dosyasına yazar.
Bu iki sıcaklık arasındaki çevrim kuralı: K =
273 + C şeklindedir. */
#include
#include
int main(void)
{
/* dosya göstericileri */
FILE *oku, *yaz;
/* Dosya adları */
char *kaynak_dosya = "kelvin.sck";
char *hedef_dosya = "derece.sck";
float K,D;
int i=0, n=100;
/* Dosylara erişim mümkün mü ? */
if( (oku=fopen(kaynak_dosya, "r")) == NULL )
{
printf("%s dosyası acilmadi.\n",
kaynak_dosya);

30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
exit(1);
}
if( (yaz=fopen(hedef_dosya, "w")) == NULL )
{
printf("%s acilmadi.\n", hedef_dosya);
exit(2);
}
for(i=0; i derece.sck
cevirme islemi tamamlandi.
16.4 Standart Dosyalar
C Programlama Dili'nde bilgisayarın sahip olduğu ekran, klavye ve portlar birer dosya olarak
tanımlanmıştır. Bu dosyalara standart dosyalar denir. Program çalışmaya başladığında beş
adet standart dosya otomatik olarak açılır. C, stdio.h başlık dosyasında tanımlanan bütün bu
standart dosyalara birer sembolik isim vermiştir[3]. Bu isimler Tablo 16.3'de listelenmiştir.
Tablo 16.3: Standart Dosyalar
Dosya adı
stdout
stderr
stdin
stdprn
stdaux
Görevi
Standart çıkış ortamı (ekran)
Standart hata çıkış ortamı (ekran)
Standart giriş ortamı (klavye)
Standart LPT (paralel port)
Standart COM (seri port)
Bu dosyaların sembolik isimleri birer dosya göstericisidir. Bu sebeple FILE yapısal değişkeni
ile kullanılabilen dosya fonksiyonları bu dosyalar için de kullanılabilir. Örneğin, ekrana
(standart çıkışa) bir yazı bastırmak için:

fprintf(stdout,"Merhaba C\n");
Bilgilerin yazıcıya gönderilmesi için yine fprintf fonksiyonu kullanılır. Örneğin:
fprintf(stdprn,"Merhaba C\n");
satırı yazıcıya Merhaba C iletinini gönderir.
Ayrıca, LPT1 veya PRN ismini dosya ismi olarak kullanıp yazıcıya basım yapmak da
mümkündür [4]. Örneğin:
FILE *dg;
...
dg = fopen("LPT1","wt");
fprintf(dg,"Merhaba C\n");
...
flcose(dg);
NOT
Tablo 16.3 de verilen standart dosyalardan stdprn ve
stdaux Turbo C'de tanımlı iken Standart C'de tanımlı
değildir. (bkz: stdio.h)
Program 16.4 Turbo C derleyicisinde derlendiğinde hem ekrana hemde yazıcıya birer mesaj
yazar.
Program 16.4: Standart dosyaların kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
ÇIKTI
/* 16prg04.c
Standart dosyaları kullanarak hem ekrana
hemde
yazıcıya birer mesaj yazar. (sadece Turbo C)
*/
#include
int main()
{
fprintf(stdout,"Bu mesaj *ekrana*
yazilacak ...\n");
fprintf(stdprn,"Bu mesaj *yaziciya*
yazilacak ...\n");
return 0;
}
Bu mesaj *ekrana* yazilacak ...
NOT
Eğer yazıcı bağlı yada açık değilse, işletim sistemi
kullanıcıyı uyaracak ve programın çıktısı şöyle olacaktır:
Bu mesaj *ekrana* yazilacak ...
Yazma hatası yazılan aygıt PRN

Durdur, yeNiden dene, Yoksay, ipTal?d
Ders 18: Port Denetimi
• Giriş
• 18.1 Port Kavramı
• 18.2 Port G/Ç Fonksiyonları
• 18.3 Paralel Port Örnekleri
• 18.4 Seri Port Örnekleri
• 18.5 Linux'de Portlara Erişim
Giriş
Bu kısımda, ağırlıklı olarak Windows işletim sistemlerinde çalışan (Turbo C, Dev-C++ gibi)
derleyicilerin bünyesinde bulunan port fonksiyonları ve kullanımları anlatılacaktır. Linux
işletim sisteminde benzer uygulamaların nasıl yapılacağı bölüm sonunda verilmiştir.
Bir program içerisinden donanımsal birimlere erişmek veya onları kullanmak için birçok yol
vardır. En basiti, bu gibi birimlere aynı bellek gözüne erişilmiyormuş gibi gösterici kullanarak
erişmektir; ancak bu durum sistem mimarisinden dolayı her zaman mümkün olmayabilir. Bu
durumda, ilgili birimlere erişmek için derleyicilerin sahip olduğu hazır kütüphane
fonksiyonları kullanılır[1].
NOT
• Windows XP ve Vista işletim sistemileri, güvenlik
nedeniyle, C derleyicilerine ait portlara erişim
fonksiyonlarını kullanmaya da izin vermeyebilir.
• Linux işletim sistemi kullanıcıları ana kullanıcı (root)
olmadığı sürece, portlara erişim izni yoktur.
18.1 Port Kavramı
Anakartın üzerinde bir bilgisayarın en önemli bileşenleri (Veriyolları, Portlar, CPU, RAM,
BIOS, ChipSet, ROM, I/O devrelerinin çoğu) bulunur. Anakart, sistemin çalışmasını organize
eder. Bu organizasyon anakart üzerinde bulunan yongalar (entegre devreler) sayesinde
gerçekleşir. Anakart üzerinde bilgisayara veri giriş/çıkış için kullanılan pinlere veya

elektriksel bağlantı noktalarına port denir. Örneğin: Paralel port (LPT), seri port (COM),
AGP portu, PCI portları gibi.
Daha fazla bilgi için burayı tıklayın.
18.2 Port Giriş/Çıkış Fonksiyonları
Bir bilgisayarın portlarına erişmek için birçok fonksiyon vardır. Tablo 18.1'de, Turbo C
derleyicisinde bululunan ve bu konu ile ilgili birkaç fonksiyon tanıtılmıştır.
NOT
Turbo C derleyicisinde, port fonksiyonları kullanılabilmesi
için dos.h başlık dosyası programa ilave edilmelidir.
Tablo 18.1: dos.h'te tanımlı bazı port erişim fonksiyonları
Port Fonksiyonu
Açıklama
void outp(int port_adresi,int bayt_degeri); Porta bir baytlık veri yazar
void outport(int port_adresi,int deger);
Porta bir kelime * yazar
void outportb(int port_adresi,unsigned char deger); Porta bir baytlık veri yazar
int inp(int port_adresi);
Porttan bir baytlık veri okur
int inport(int port_adresi);
Porttan bir kelime okur
char inportb(int port_adresi);
Porttan bir baytlık veri okur
(*) kelime (word) : Porta yazılacak veya porttan okunacak, bir tamsayının bellekte
kaplayacağı alanı temsil eder. (Bu alan sizeof() operatörü ile öğrenilebilir)
Port foksiyonlarının kullanımı, örnek programlar üzerinde, bir sonraki bölümlerde
incelenmiştir. Bütün programlar Turbo C derleyicisinde denemiştir. Eger bu derleyiciye sahip
degilseniz, buradan inderbilirsiniz.
18.3 Paralel Port Örnekleri
Bu bölümde, bir önceki kısımda verilen port fonksiyonları ile, bir PC'nin paralel portunun
nasıl denetleneceği 6 tane örnek programda anlatılmıştır.
NOT
Standart bir PC'de LPT nin alt portlarının adresleri,
DATA için 0x378, STATUS için 0x379 ve CONTROL
0x37A dır;
Program 18.1: outp fonksiyonunun kulanımı
01:
02:
/* 18prg01.c: outp örneği */

03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
ÇIKTI
#include
#include
#define DATA 0x0378
int main()
{
int deger = 25;
outp(DATA, deger);
printf("\n%X nolu adrese %d degeri
yazildi.", DATA, deger);
return 0;
}
378 adresine 25 degeri yazildi.
Program 18.1'de 6. satırda tanımlanan porta, 12.satırda 25 değeri yazılmaktadır. Bu değer PC
paralel portunun DATA uçlarına yazılır. Bu sebeple 25 değeri ikili sistemde (binary) ifade
edilip 8 bite bölünür, yani 25 = 00011001 şekinde DATA portuna yazılır. Burada 1 portun
ilgili bacağına +5V DC sinyalini gönderir. 0 olan bağlantı noktalarına ise sinyal gönderilmez.
Bu değerler basit bir voltmetre ile ölçülüp test edilebilir.
Porta yazılmak veya porttan okunmak istenen veriyi ikili (binary) olarak görüntülemek yararlı
olabilir. Program 18.2'de cevir_taban2 fonksiyonu bu amaçla yazılmıştır.
Program 18.2: outportb fonksiyonun kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
/* 18prg02.c: outportb fonksiyonu */
#include
#include
#include
#define DATA 0x0378
long cevir_taban2(int);
int main()
{
int deger = 0x19; /* deger = 25 */
outportb(DATA,deger);
printf("\nDATA portuna gonderilen deger %d :
%08ld",deger, cevir_taban2(deger));
return 0;
}

23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
/* Bu fonksiyon 10 tabanındaki bir sayıyı
2 tabınındaki karşılığını hesaplar. */
long cevir_taban2(int x)
{
int i = 0, k;
long bin = 0;
}
ÇIKTI
while( x>0 )
{
if(x%2) k = 1;
else k = 0;
bin += k*pow(10,i++);
x /= 2;
}
return bin;
DATA portuna gonderilen deger 25 : 00011001
9. satırdaki cevir_taban2 fonksiyonu, kendisine parametere olarak gelen bir tamsayıyı iki
tabana çevirir. Ekranda porta yazılan değer ve onun iki tabanındaki karşılığı, uygun bir
formatla, 8 bit halinde gösterilmiştir.
inp() ve inportb() fonksiyonları, PC bağlantı noktalarından sırasıyla bir karakter ve bir
baytlık veri okumak mümkündür. Program 18.3, bu fonksiyonlar ile nasıl veri okunacağına
dair iyi bir fikir verir.
Program 18.3: inp ve inportb fonksiyonlarıyla paralel porta atanan varsayılan değerleri
öğrenme
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
/* 18prg03.c: inp ve inportb fonksiyonlarının
kullanımı */
#include
#include
#define DATA 0x0378
#define STATUS DATA+1
#define CONTROL DATA+2
int main()
{
int veri;
puts("Paralel porta atanan degerler (Hex):");
veri = inp(DATA);
printf( "Data portu : %X\n",veri );
veri = inp(STATUS);
printf( "Status portu : %X\n",veri );

22:
23:
24:
25:
26:
ÇIKTI
veri = inportb(CONTROL);
printf( "Kontrol portu : %X\n",veri );
return 0;
}
Paralel porta atanan degerler (Hex):
Data portu : 4
Status portu : 7F
Kontrol portu : CC
Programın elde ettiği değerler, porta hiç bir müdehale olmadan elde edilmiştir ve her
bilgisayarda başka bir sonuç verebilir. Bu fonksiyonların tek parameteresi olduğuna dikkat
ediniz.
Bir porta herhangi bir veri yazıldıktan sonra, bu veri o portun saklayıcısına (register) yazılır
ve yeni bilgi yazılmadıkça orada kalır. Program 18.4 CONTROL portuna ouportb ile yazılan
bir verinin inportb fonksiyonu ile okunması gösterilmiştir.
Program 18.4: inportb ve outportb fonksiyonlarının kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
ÇIKTI
/* 18prg04.c: inportb ve outportb örneği */
#include
#include
#define PORT 0x037A
int main()
{
int deger;
deger = inportb(PORT); /* varsayılan deger
*/
printf("\nPorta veri yazilmadan onceki deger
: %X",deger);
deger = 0x0A; /* deger = 10 */
outportb(PORT, deger);
deger = inportb(PORT);
printf("\nPorta veri yazdiktan sonraki deger
: %X",deger);
return 0;
}
Porta veri yazilmadan onceki deger : CC

Porta veri yazdiktan sonraki deger : CA
Program 18.4'ün çıktısı incelendiğinde, portta varsayılan değerin CCh, veri yazıldıktan
sonraki değerin CAh olduğu görülmektedir. CONTROL portunun ilk 4-bitine müdehale
edilebildiği halde ikinci 4-biti değiştirilememiş. Neden?
18.4 Seri Port Örnekleri
Bu bölümde, yine Standart C'de olmayan bilgisayarın seri portları üzerinden iletişim konu
edilecektir.
NOT
Standart bir PC'de COM1 için ilk adres 0x3F8, COM2 için
0x2F8 dir;
Standart PC'lerin seri iletişim portlarına erişim UART olarak adlandırılan bir birim üzerinden
gerçekleştirilir. Bu birim anakat üzerindeki bir entegre devredir. Ancak temel olarak bilinmesi
gereken alma saklayıcısına ve gönderme saklayıcısına nasıl erişileceği ve UART'ın
ayarlarının nasıl yapılacağıdır. Program 18.5'de bir dosya içeriğinin karakter karakter seri port
üzerinden karşı tarafa nasıl gönderileceği görülmektedir[1].
Program 18.5: Bir metin dosyasının içeriğini seri porta aktarır.
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
/* 18prg05.c: Bir metin dosyasının içeriğini
seri porta aktarır */
#include
#include
#include
int main()
{
char kr;
FILE *dosya;
/* UART'ın ayarlanması */
outportb(0x3FB,0x80);
outport (0x3F8,0x0C);
outportb(0x3FB,0x1B); /* 9600 bps.dur biti
1.cift eslik, 8 bit veri*/
/* dosya açılıyor */
if ( (dosya=fopen("deneme.txt", "r")) ==
NULL) {
puts ("Hata olustu! Dosya acilmadi.");
exit(1);
}
while( !feof(dosya) )
{
kr=getc(dosya); /*
dosyadan bir karakter oku */
while ( (inportb(0x3FD) & 0x20)==0 ); /*

31:
32:
gönderme saklayicisi sınanıyor */
ouportb(0x3F8,kr); /*
porta gönderiliyor */
}
fclose(dosya); /*
dosya kapatiliyor */
return 0;
}
Bir UART iletişim işine geçmeden önce ayarlanmalıdır; yani, iletişim hızı, hata biti kullanıp
kullanılmayacağı gibi birtakım bilgilerin yerleştirimi yapılmalıdır. UART'ın herhangi bir
andaki durumu, yani veri göndermeye hazır olup olmadığı, yeni veri gelip gelmediği gibi
bilgiler hat durum saklayıcısı üzerindeki bitlere bakılarak anlaşılır. Örneğin, UART'a
gönderilmesi için bir veri yazılmadan önce, göndermek için uygun olup olmadığı
sınanmalıdır. Program 18.6'de seri port üzerinden gelen karakterleri alıp ekrana nasıl yazıldığı
görülmektedir[1].
Program 18.6: Seri port üzerinden gelen karakterleri alıp ekrana yazar.
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
/* 18prg06.c: Seri port üzerinden gelen
karakterleri alıp ekrana yazar */
#include
#include
int main()
{
char kr;
/* UART'ın ayarlanması */
outportb(0x3FB,0x80);
outport (0x3F8,0x0C);
outportb(0x3FB,0x1B); /* 9600 bps.dur biti
1.cift eslik, 8 bit veri*/
while(1)
{
while( (inportb(0x3FD) & 0x01)==0 ); /*
yeni karakter gelene kadar bekle */
kr=inportb(0x3F8); /*
geleni al ve kr'ye yerleştir */
printf("%c", kr);
}
return 0;
}
Soru: Son iki programı öyle değiştirin ki, birinin klavyesinden girilen, diğerinin ekranında
görülsün.
18.5 Linux'de Portlara Erişim

Linux işletim sisteminde portlara erişmek için birkaç yol vardır. Burada, gcc derleyicisinin
içine gömülebilen assemble dili kullanılarak oluşturulan port fonksiyonları gösterilecektir.
Linux'de ana kullanıcı (root) olmadıkça veya ana kullanıcı izin vermedikçe portlara erişmeniz
mümkün değildir. Bu yüzden, önce programın portlara erişim izni verip vermediği
sınanmalıdır. Bunun için, /usr/include/sys/io.h dosyası içinde tanımlı ioperm()
fonksiyonu kullanılabilir.
Program 18.7 de basit bir port erişim programı verilmiştir. Kullanıcıların, programın başına
ilave edebileceği başlık dosyaları için ayrıca bkz. Bölüm 20.
Program 18.7: Linux'de port erişimi
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
/* 18prg07.c
Linux işletim sisteminde portlara erişim */
#include
#include
#include
#include "linuxPort.h"
int main()
{
int deger = 25;
/* porta erişim izni var mı?
sadece root ve onun izin verdiği
kullanıcılar erişebilir ) */
if( port_erisim() ) exit(1);
outportb(DATA, deger);
printf("\n%X nolu adrese %d degeri
yazildi.", DATA, deger);
return 0;
}
17. satırdaki port_erisim() fonksiyonu ioperm() fonksiyonunu çağırıp erişim iznini
denetler. port_erisim(), aşağıda verilen linuxPort.h dosyası içinde tanımlanmıştır.
linuxPort.h bütün Linux tabanlı işletim sistemlerinde bulunan gcc derleyici ile
kullanılabilir.
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
/********************************************************************
*
**
**
** linuxPort.h
**
**
**
** Linux işletim sisteminde kullanılabilecek port fonksiyonları
**
**
**

13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
** Oluşturma tarihi: Haziran 2006
**
** Enson güncelleme: Kasım 2008
**
**
**
*********************************************************************
/
//
// Standart PC için Port adresleri ----------------------------------
--
//
#define DATA 0x378
#define STATUS 0x379
#define CONTROL 0x37A
#define COM1 0x3F8
#define COM2 0x2F8
#define MCR 0x3FC // Modem Control Register (8 bit)
#define MSR 0x3FE // Modem Status Register (8 bit)
#define KEYB1 0x060
#define KEYB2 0x064
//
// port erişim fonksiyonları ----------------------------------------
--
// Bu fonksiyonlar, gcc derleyicisinde dosyasında
mevcuttur
//
void outportb(unsigned short port, unsigned char data)
{
__asm__ __volatile__ ("outb %1, %0"
:
: "dN" (port),
"a" (data));
}
void outport(unsigned short port, unsigned short data)
{
__asm__ __volatile__ ("outw %1, %0"
:
: "dN" (port),
"a" (data));
}
unsigned char inportb(unsigned short port)
{
unsigned char rv;
__asm__ __volatile__ ("inb %1, %0"
: "=a" (rv)
: "dN" (port));
return rv;
}
unsigned short inport(unsigned short port)
{
unsigned short rv;
__asm__ __volatile__ ("inw %1, %0"
: "=a" (rv)

74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100
:
101
:
102
:
103
:
104
:
105
:
106
:
107
:
108
:
109
:
110
:
111
:
112
:
113
:
114
:
115
:
116
:
117
}
: "dN" (port));
return rv;
//
// erisim izinlerini kontrol et -------------------------------------
//
int port_erisim(void)
{
int i, erisim = 0;
/* paralel porta erisim izni var mi? */
for(i=0; i

:
118
:
}
outportb(COM1 + 3 , 0x03); // 8 bit, parity yok, 1 dur biti
outportb(COM1 + 2 , 0xC0); // FIFO Kontrol saklayıcısı
Ders 19: Grafik Kullanımı
• Giriş
• 19.1 Grafik Ekranına Geçiş
• 19.2 Bazı Grafik Fonksiyonları
• 19.3 Renk Kodları
• 19.4 Örnekler
Giriş
Bu kısımda sadece Turbo C derleyicisine ait basit grafik uygulamaları kısaca anlatılmıştır.
Örneklerde verilen grafik fonksiyonları ANSI C de bulunmamaktadır. Bu yüzden bir çok C
derleyicisi, kendi bünyesinde farklı grafik fonksiyonlarına sahiptir. Örneğin Linux
ortamındaki grafik kullanmak için g2 kütüphanesi geliştirilmiştir.
19.1 Grafik Ekranına Geçiş
Turbo C'de, Grafik sistemine geçmek için, initgraph() fonksiyonunu kullanılır. Bütün
çizimler sadece DOS ortamında çalışır. Grafik fonksiyonlarının kullanılması için graphics.h
başlık dosyası programın başına ilave edilmelidir. Grafik işlemleri için temel işlemler:
#include
#include
...
int surucu = DETECT, grmod, hata_kodu; /* DETECT grafik
sürücüsünü otomatik seçer */
.
.
.
initgraph(&surucu, &grmod, ""); /* grafik ekranını başlat
*/
hata_kodu = graphresult(); /* hata_kodu al */
if (hata_kodu != grOk) /* hata_kodu 0 dan farklı
ise başlatma */
{
puts("Hata olustu.");
puts("Grafik ekrani baslatilamiyor.");
exit(1);
}

.
. /* grafik işlemleri ... */
.
closegraph(); /* grafik ekranını kapat */
şeklindedir.
NOT
initgraph fonksiyonundaki 3. parametre ("") boş
bırakıldığında kaynak dosyanın C:\TC dizininde olması
zorunludur.
Eğer kaynak dosya başka bir dizinin altında ise o zaman
initgraph(&surucu, &grmod, "C:\\TC");
şeklinde kullanılmalıdır.
Turbo C'de varsayılan grafik modu (640,480) çözünürlüğe ayarlanmıştır. Bu modda, Çizim
ekrenının sol-üst köşesine ait koordinat (0,0) olarak tanımlıdır. Varsayılan moddaki bazı
koordinatlar Şekil 19.1'de gösterilmiştir.
Şekil 19.1: Turbo C varsayılan moddaki koordinatlar
19.2 Bazı Grafik Fonksiyonları
Bu bölümde Turbo C grafik fonksiyonlarının bazıları tanıtılmıştır. Bunların dışında biçok
fonksiyon vardır. Bu fonksiyonlar derleyicinin başvuru kitabından veya derleyicinin yardım
kısmından öğrenilebilir.
Tablo 19.1: graphics.h'te tanımlı bazı grafik fonksiyonları
Fonksiyon
moveto(x,y);
Açıklama
Son noktayı (x,y) noktasına taşır

lineto(x,y);
line(x1,y1,x2,y2);
circle(x,y,r);
arc(x,y,baş_açı,bit_açı,r);
ellipse(x,y,baş_açı,bit_açı,xr,yr);
putpixel(x,y,renk);
rectangle(sol,üst,sağ,alt);
bar(sol,üst,sağ,alt);
bar3d(sol,üst,sağ,alt,derinlik,şapka);
setcolor(renk);
setbkcolor(renk);
outtext(*katar);
outtextxy(x,y,*katar);
settextstyle(font,yön,boyut);
cleardevice();
closegraph();
Son noktadan (x,y) noktasına düz bir
çizgi çizer.
(x1,y1) noktasından (x2,y2) noktasına
düz bir çizgi çizer.
Merkezi (x,y) olmak üzere yarıçapı r
olan bir çember çizer.
Merkezi (x,y) noktasında ve yarıçapı r
olan, baş_açı açısından dan başlayıp
bit_açı açısına kadar bir yay çizer.
Elipsin bir parçası olan yayı, merkezi
(x,y) ve yarıçapları xr, yr olacak biçimde
baş_açı açısındandan başlayarak
bit_açı açısına kadar bir yay çizer.
(x,y) noktasına verilen renkte bir nokta
çizer.
Sol üst köşesi (sol,üst) ve sağ alt köşesi
(sağ,alt) koordinatlarında olacak şekilde
bir dikdörtgen çizer.
İki boyutlu ve taralı bir bar çizer.
Üç boyutlu ön yüzeyi taralı bar çizer.
Şapka 0 ise barın üst kısmı çizilmez.
Çizilen olan şeklin rengini belirler
Arka alanın rengini belirler.
Grafik ekranında katar yazdırır.
Grafik ekranında yazılacak katar'ı, (x,y)
ile belirlenen noktadan başlayarak yazar.
Ekranda yazılacak olan bir katarın
yazıtipini, yönünü ve boyutunu belirler.
yön=0 ise yatay, yön=1 ise dikey yazar.
Ekranı temizler. DOS'taki CLS komutu
gibi.
Grafik ekranını kapatıp normal yazı
ekranına (DOS ekranı) döner.
19.3 Renk Kodları
Grafik ekranında kullanılan renkler 0-15 arasında renk kodları, yada simgesel sabit karşılıkları
ile tanımlıdır. Bu tanımlamaların tamamı graphics.h'de şöyle bildirilmiştir (bkz
graphics.h):
enum COLORS {
BLACK, /* koyu renkler */
BLUE,
GREEN,
CYAN,
RED,

MAGENTA,
BROWN,
LIGHTGRAY,
DARKGRAY,
LIGHTBLUE, /* açık renkler */
LIGHTGREEN,
LIGHTCYAN,
LIGHTRED,
LIGHTMAGENTA,
YELLOW,
WHITE
};
Ayrıca bu kodları liste halinde Tablo 19.2 de bulabilirsiniz.
Tablo 19.2: conio.h ve graphics.h'te tanımlı Standart CGA Video Renk Kodları
Renk (TR) Renk (EN)
Renk
Örneği
Renk Kodu
Siyah BLACK 0
Mavi BLUE 1
Yeşil GREEN 2
? CYAN 3
Kırmızı RED 4
Menekşe MAGENTA 5
Kahverengi BROWN 6
Açık Gri LIGHTGRAY 7
Koyu Gri DARKGRAY 8
Açık Mavi LIGHTBLUE 9
Açık Yeşil LIGHTGREEN 10
Açık ? LIGHTCYAN 11
Açık Kırmızı LIGHTRED 12
Açık Menekşe LIGHTMAGENTA 13
Sarı YELLOW 14
Beyaz WHITE 15
19.4 Örnekler
NOT
Buradaki örnek programlar Turbo C'nin editör ortamında
derlenmiştir.
Program 19.1: Grafik ekranında; bir çizgi, bir çember, bir yay, bir dikdörtgen ve bir elips
çizer
01:
02:
03:
04:
/* 19prg01.c
Çizim ekranında bir çizgi, bir çember,
bir yay, bir dikdörtgen ve bir elips çizer.
*/

05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
#include
#include
int main()
{
int sur = DETECT, gmod;
/* grafik ekranını başlat */
initgraph(&sur,&gmod,"");
line (12, 12, 298, 198);
circle (200, 100, 75);
arc (200, 100, 90, 180, 50);
rectangle (10, 10, 300, 200);
ellipse (320, 240, 0, 180, 50, 70);
return 0;
}
getchar();
closegraph(); /* grafik ekranını kapat */
Program
çıktısı
Program 19.2: outtext, outtextxy, setcolor, settextstyle, setlinestyle fonksiyonları
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
/* 19prg02.c
Bu program ekranda yatay ve dikey iki yazı
yazar ve
farklı kalınlıkta iki çizgi çizer. */
#include
#include
int main()
{
int surucu=DETECT,mod;
initgraph(&surucu,&mod,"C:\\TC");
setcolor(3);
outtext("Merhaba C.");
setcolor(10);
outtextxy(30,40,"Bu yazi YATAY");
setcolor(YELLOW);

22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
return 0;
}
settextstyle(1,1,5);
outtextxy(50,60,"Bu yazi DIKEY");
setcolor(WHITE);
setlinestyle(3,0,1);
line(320,240,500,350);
setcolor(RED);
setlinestyle(1,1,3);
circle(320,240,100);
getchar();
closegraph();
Program
çıktısı
Program 19.3: y=f(x) ile belirlenen bir fonksiyonu çizer
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
/* 19prg03.c
x : [-20, 20] aralığında y= 5 * sin(x)
fonksiyonunun grafiğini çizer. */
#include
#include
#include
int main()
{
int sur = DETECT, grmode;
float x,y,olcek;
int X,Y;
initgraph(&sur, &grmode, "C:\\TC");
setcolor(BLUE);
coordinatları mavi */
line(0,240,640,240);
line(320,0,320,480);
/* x-y
olcek = 15.0; /* Ölçek
değiştirilerek büyütme/küçültme yapılabilir. */
setbkcolor(WHITE);
beyaz */
setcolor(RED);
rengi kırmızı */
/* zemin rengi
/* Fonksiyonun

29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
x=-20.0;
[-20,20] aralığında */
do
{
y = 5*sin(x);
fonksiyonu */
/* x değerleri
/* y=5*sin(x)
X = 320 + x*olcek; /* Lineer
Dönüşüm denklemleri */
Y = 240 - y*olcek;
line(X, Y, X, Y);
çiziliyor... */
return 0;
}
x += 0.01;
}while( x

Makro bildirimleri veya Yönergeleri (direktive) derleme öncesi komutlarıdır. Bunlar tipik
olarak:
• programları değiştirmek
• program parçalarını kaynak programında birleştirmek
• derleme sırasında bazı uyarı mesajlarını aktif veya pasif hale getirmek
için kullanılır. Genelde makro bildirimleri kaynak dosyaların en başında verilir.
C dilinde kullanılan Yönergeler (önişlemci komutları) şunlardır:
#include #define #pragma
#error #undef #ifdef #ifndef
#if #else #elif #endif
20.1 #include Yönergesi
Bu önişlemci verilen dosyanın içeriğini, kullanıldığı yerde kaynak dosyasının içine ekler.
Çoğunlukla derleyiciye ait komut kütüphanelerinde bulunan fonksiyonların prototiplerinin ve
diğer çeşitli tanımlamaların bulunlunduğu (h uzantılı) başlık dosyalarının programa dahil
edilmesinde kullanılır[2]. İki tür kullanımı vardır:
veya
#include
#include "dosya_adı.h"
• Birinci kullanımda dosyanın nerede bulunduğu derleyici için verilen ulaşım yolu ile
belirlenir. Bu yol genellikle include dizini ile son bulur. Başlık dosyalarının saklandığı
include dizini
o Borland firmasına ait Turbo C derleyicisinde : C:\TC\INCLUDE
o Linux ortamında : /usr/include şeklindedir.
• İkinci kullanımlada dosyanın bulunduğu yer aktif dizin olarak kabul edilir. Aksi halde
yol tam olarak verilmelidir.
#include deyimi ile program ilave edilecek dosya C fonksiyonları içerebileceği gibi basit
deyimler de içerebilir. Bunun için bir sınırlandırma yoktur. Hatta uzantıları .h olması bile
gerekmez. Program 20.1 ve Program 20.2'yi inceleyin.
Program 20.1: #include önişlemcisinin kullanımı için bir örnek
01:
02:
03:
04:
05:
06:
07:
08:
09:
/* 20prg01.c: faktoriyel ve kombinasyon
hesaplamaları */
#include
#include "komb.h"
int main()
{

10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
ÇIKTI
int i;
/* 0 dan 10 yekadar olan sayıların
faktoriyelleri */
for(i = 0; i

}
Program 20.2: #include önişlemcisinin kullanımı için başka bir örnek
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
/* 20prg02.c:
Klavyeden girilen bir doğal sayının, kaç
basamaklı
olduğunu bulup ekrana yazar.
*/
#include
int main(){
#include "bildirim.inc"
printf("Bir dogal sayi gir: ");
scanf("%d",&sayi);
if(sayi0){
n /= 10;
b++;
}
printf("%d %d basamakli bir
sayidir.\n",sayi,b);
}
return BASARILI;
Dikkat edilirse Program 20.2 içinde değişkenler tanımlanmamıştır. 11. satırdaki bildirim.inc
dosyası değişken bildirimlerini barındırmaktadır. Bu özellik (veya esneklik), çok büyük ve
profesyonel programlarda kullanılmaktadır.
ÇIKTI
Bir dogal sayi gir: 4578
4578 4 basamakli bir sayidir.
20.2 #define Yönergesi
Bu önişlemci komutu, kaynak dosyada bir isim yerine başka bir isimin yerleştirilmesini
sağlar. Programda kullanılan bu sembolik isimler başta ana program olmak üzere bütün alt
programlarda da aynı değere sahiptir. Yani #define önişlemcisi ile tanımlanan her ne olursa
olsun, tanımlama bütün fonksiyonlarda kullanılabilir. Bir çeşit genel (global) bildirim gibi
davranır. Örneğin:

Program 20.3: #define önişlemcisinin kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
/* 20prg03.c: #define önişlemcisinin kullanımı
*/
#include
#define PROGRAM main()
#define BASLA {
#define BIT }
#define YAZ printf
PROGRAM
BASLA
YAZ("Merhaba C!..\n");
BIT
Program 20.3 derleme işleminden önce #define ile verilen ilk sembolik isimler yerine ikinci
isimler yerleştirildikten sonra program aşağıdaki durmuma gelir:
/* 20prg03.c: #define önişlemcisinin kullanımı */
#include
main()
{
printf("Merhaba C!..\n");
}
Bu önişlemciyi kullanak sembolik sabitler tanımlamak mümkündür. Örneğin:
#define PI 3.1415926
#define IKI_PI 2.0*PI
#define YUZ 100
gibi.
#define önişlemcisinin kullanımı için iyi bir örnek Program 20.4 de verilmiştir. Program
km/s biriminde verilen bir hızı m/s birimine çevirir[4].
Program 20.4: #define önişlemcisinin kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
/* 20prg04.c: km/s biriminde verilen hızı m/s
cinsinden hesaplar */
#include
#define km *1000.0
#define saat *3600.0
main()
{
double yol,zaman,hiz;
yol = 100 km;
zaman = 1.2 saat;
hiz = yol/zaman;

17:
18:
19:
}
printf("HIZ = %lf m/s\n",hiz);
ÇIKTI
HIZ = 23.148148 m/s
5. ve 6. satırda tanımlanan sembolik sabitler km ve saat program içinde kullanıldığında sol
taraflarındaki sayıyı sırasıyla 1000 ve 3600 ile çarparlar. 12. satırdaki yol değişkenine
100*1000.0 değeri atanır. Benzer olarak 13. satırdaki zaman değişkenine 1.2*3600.0 sayısı
atanır. Dikkat edilirse sembolik sabitler kullanıldığında programın okunurluğu artmakta ve
bundan dolayı hata ayıklama kolaylaşmaktadır.
#define önişlemcisi ile parametrik tanımlamalar veya global fonksiyonlar tanımlamak
mümkün olur. Örneğin:
Program 20.5: Makro fonksiyon tanimlama
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
/* 20prg05.c: Makro fonksiyon tanimlama. */
#include
#include
/* makro fonksiyonlar */
#define kare(x) (x*x)
#define topl(x,y) (x+y)
#define carp(x,y) (x*y)
#define hipo(x,y) sqrt(x*x+y*y)
main(void)
{
float a=3.0, b=4.0;
}
ÇIKTI
printf("kare(2) = %f\n",kare(2));
printf("topl(a,b) = %f\n",topl(a,b));
printf("carp(a,b) = %f\n",carp(a,b));
printf("hipo(a,b) = %f\n",hipo(a,b));
kare(2) = 4.000000
topl(a,b) = 7.000000
carp(a,b) = 12.000000
hipo(a,b) = 5.000000
Programda tanımlanan kare(2) ifadesi (2)*(2) şeklinde yorumlar. Benzer durum diğer
makrolar için de geçerlidir.
Makrolar C'de çok sık kullanılır. Örneğin, tek boyutlu bir dizinin boyutu öğrenilmek
istendiğinde aşağıdaki makro kullanılabilir:

#define BOYUT sizeof(DIZI)/sizof(DIZI[0])
...
int a[10], n;
...
n = BOYUT(a);
Son satırdaki işlemle, n değişkeninine (a dizisinin boyutu) 10 değeri atanır.
İşte ilginç bir makro daha. Daha önce anlatılan takas(a,b) fonksiyonu gösterici
kullanmadan aşağıdaki makro ile yazılabilir:
#define takas(x,y) {g=(x); (x)=(y); (y)=g;}
...
int x=22, y=33, g; /* g geçici bir değişken */
...
printf("%d %d\n",x,y); /* 22 33 */
takas(a,b)
printf("%d %d\n",a,b); /* 33 22 */
...
20.3 #undef Yönergesi
#define ile tanımlanan bir isim, orjinal tanımlamaları kaldırmaksızın farklı değerler için
tekrar tanımlanamaz.
#define SIFRE 14576 /* ilk tanimlama */
...
#define SIFRE 22357 /* hata! tanımlama tekrarlandı. */
Eğer #define ile tanımlanan bir ifade yeniden tanımlanmak istenirse, #undef önişlemcisi ile
önceki tanımlama iptal edildikten sonra #define ile yenisi değiştirilir. Yani:
#define SIFRE 14576 /* ilk tanimlama */
...
#undef SIFRE /* ilk tanımlamayı iptal et */
#define SIFRE 22357 /* yeni tanımlama */
20.4 #if, #elif, #else ve #endif Yönergeleri
Bu önişlemciler, makro düzeyinde kontrol deyimleridir. Genel kullanım biçimi:
#if (ifade1)
tanımlama blogu1
#elif (ifade2)
tanımlama blogu2
...
#else
tanımlama bloguN

#endif
şeklindedir. Burada:
• #if makrosu if deyimine
• #elif makrosu else if deyimine
• #else makrosu else deyimine
• #endif makrosu if deyiminin sonuna
karşılık gelmektedir. Bu makrolar, donanıma veya işletim sistemine uygun olarak değişik
makroların tanımlanmasına izin verir. Örneğin:
Program 20.6: Kontrol önişlemcilerinin kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
ÇIKTI
/* 20prg06.c: Kontrol ön işlemcilerinin
kullanımı */
#include
#if(sizeof(int)==2)
#define ISLETIM_SISTEMI "16 bitlik isletim
sistemi."
#else
#define ISLETIM_SISTEMI "32 bitlik isletim
sistemi."
#endif
int main()
{
printf(ISLETIM_SISTEMI);
return 0;
}
32 bitlik isletim sistemi.
Bu program eski DOS işletim siteminde derlenip çalıştırıldığında, program çıktısı şöyle olur:
ÇIKTI
16 bitlik isletim sistemi.
20.5 #ifdef ve #ifndef Yönergeleri
• #ifdef önişlemcisi ile, bir ismin tanımlanmış olup olmadığı
• #ifndef önişlemcisi ile, bir ismin tanımlanmamış olup olmadığı
sorugulanır. Örneğin:
#ifndef SIFRE
#define SIFRE 22357

#endif
gibi.
Program 20.7: Tanımlanmış ise pi sayısını kullanır.
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
/* 20prg07.c: Tanımlanmış ise PI sayısını
kullanır */
#include
#include
#define PI 3.141593
main()
{
double c, r = 21.3;
}
ÇIKTI
#ifdef PI
c = 2.0 * PI * r;
printf("Dairenin cevresi = %lf\n",c);
#else
printf("PI saysisi tanimlanmamis.\n");
#endif
Dairenin cevresi = 133.831862
20.6 #error Yönergesi
Önişlemci bu deyimle karşılaşınca yanındaki mesajı ekrana yazar ve derleme işlemine son
verir. Mesela, yazmış olduğunuz program 32 bitlik bir işletim sistemi (WINDOWS veya
Linux gibi) için tasarlanmışsa ve program 16 bitlik işletim sisteminde (MSDOS gibi)
derlenecekse kullanıcıya buna dair bir uyarı mesajı vermek uygun olur[2-4]. Örneğin:
#if (sizeof(int)==2)
#error Bu program 16 bitlik işletim sisteminde derlenemez !...
#endif
Eğer DOS altında çalışıyorsanız önişlemci derleme işlemine:
Bu program 16 bitlik işletim sisteminde derlenemez !...
mesajı ile son verir. Mesajın tırnak içine alınmadığına dikkat ediniz.
20.7 Önceden Tanımlanmış Sembolik Sabitler
Bazı sembolik sabitler derleyici tarafından önceden tanımlanmıştır. Bu sabitlerden bazıları
Tablo 20.1 de verilmiştir.

Tablo 20.1: Önceden tanımlı bazı sembolik sabitler
Sabit ismi
Açıklama
Önişlemci bu sabit yerine kaynak koddaki o anda bulunan satır
__LINE__
numarasını yerleştirir.
__FILE__
Kaynak dosyanın ismin tutar.
Önişlemci bu sabit yerine derlemenin yapıldığı zaman tarihi (ay gün
__DATE__
yıl formatında) yazar.
Önişlemci bu sabit yerine derlemenin yapıldığı zaman zamanı
__TIME__
(sa:dak:sn gün yıl formatında) yazar.
C dilinde kullanılan kimi anahtar sözcükler standart değildir.
__STDC__
Derleyici eğer yalnızca standart C'nin anahtar sözcüklerini
destekliyorsa bu sabit tanımlı varsayılır.
M_PI
Pi sayısını tutar (M_PI = 3.14159265358979323846). Ayrıca bkz:
math.h
M_E
e sayısını tutar (M_E = 2.7182818284590452354). Ayrıca bkz:
math.h
Rastgele sayı üretec fonksiyonu rand() ile döndürlen en büyük sayıyı
RAND_MAX
tutar.
(32 bit işletim sitemi için: RAND_MAX = 2147483647). Ayrıca bkz:
stdlib.h
Aşağıdaki örnekleri inceleyiniz:
Program 20.8: C dilindeki bazı tanımlı sabitler
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
ÇIKTI
/* 20prg08.c: Sembolik sabitler */
#include
main()
{
printf("Satir No : %d\n",__LINE__);
printf("Dosya adi : %s\n",__FILE__);
printf("Tarih : %s\n",__DATE__);
printf("Saat : %s\n",__TIME__);
}
Satir No : 7
Dosya adi : 20prg08.c
Tarih : Sep 21 2008
Saat : 01:58:56
Program 20.9: C dilindeki bazı tanımlı sabitler
01:
02:
03:
04:
05:
06:
07:
/* 20prg09.c: Sembolik sabitler */
#include
#include
#include
#ifndef __STDC__

08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
#error Bu derleyici ANSI C degil.
#endif
#ifndef RAND_MAX
#error RAND_MAX tanımlı degil.
#endif
main()
{
double r = (double) rand()/RAND_MAX;
double ikiPi = 2.0*M_PI;
double birBoluE = 1.0/M_E;
}
ÇIKTI
printf("r = %lf\n",r);
printf("ikiPi = %lf\n",ikiPi);
printf("birBoluE = %lf\n",birBoluE);
r = 0.840188
ikiPi = 6.283185
birBoluE = 0.367879
Ders 22: Derleme Seçenekleri
• Giriş
• 22.1 Çalıştırılabilir Dosya Üretimi
• 22.2 Turbo C Derleme Seçenekleri
• 22.3 GCC Derleme Seçenekleri
Giriş
Bazen bir kullanıcı derlemek istediği kaynak C programını başka C programları ile beraber
kullanmak, sadece nesne kodu üretmek veya başka bir dilde yazılmış programı, C programı
içinde kullanmak isteyebilir. Bir derleyiciye ait derleme seçenekleri ile bu tip işlemleri
gerçekleştirmek mümkündür.
Bu kısımda derleme ve bağlama işlemi, derleyicilerin sunduğu bazı derleme seçenekleri ve
bunlar yardımıyla birden çok C programının nasıl birleştirileceği anlatılacaktır.
22.1 Çalıştırılabilir Dosya Üretimi
Programlama işlemi, bir programlama diline ait söz dizilimlerini içeren kaynak kodların
yazılması ile başlar. Kaynak kod (source code), C, Fortran veya Pascal gibi yüksek seviyedeki

dillerin deyimleri barındıran bir düz metin dosyasında (plain text file) saklanır. Bu dosyalar
geleneksel uzantılarla birbirinde ayrılabilir, örneğin c programları .c uzantılı, Pascal
programları .pas uzantılı dosyalardır.
Derleyici (compiler), bir programlama dilinde yazılmış olan kaynak kodunu başka bir dile
(coğukez makine dili) çeviren yazılımdır. Her programlama dile kendi derleyicisine sahiptir.
Derleyicinin çevirdiği kaynak kod, hedef kod veya nesne kodu (object code) olarak
adlandırılır. Nesne kodu, bilgisayarın mikroişlemcisi (CPU) için gerekli makina kodlarını ve
işletim sistemi için gerekli program uygulama arayüzlerini (API: Application Programming
Interface) içerir. Nesne kodu çalıştırılabilir bir kod değildir, ama bütün programlama dilleri
için aynıdır. Derleyicilerin ürettikleri nesne kodları genellikle .obj veya .o uzantılı dosyalarda
saklanır.
Sonraki adım, nesne kodunun özel bir bağlayıcı (linker) ile işlenmesidir. Bağlayıcı,
derleyiciler tarafından üretilmiş bir veya daha fazla nesne kodunu birleştirip tek bir
çalıştırılabilir dosya oluşturan yazılımdır. Her sistem kendi bağlayıcısına sahiptir.
Bağlayıcının ürettiği çalıştırılabilir kod Windows ortamında .exe uzantılı dosyalarda saklanır.
Linux ortamında çalıştırılabilir dosyaların çoğunlukla bir uzantısı yoktur.
Kaynak kodunun derlenip çalıştırılabilir dosyanın oluşturulmasına ait işlem basamakları Şekil
22.1'de gösterilmiştir.
Şekil 22.1: Derleme-Bağlama-Çalıştırma işleminin akış diyagramı.
C ve C++ dilleri için iki çeşit kaynak kodu vardır: .c veya .cpp uzantılı ana program ve bazı
bildirimlerin bulunduğu .h veya .hpp uzantılı başlık dosyaları (header files).
C (ve C++) dilinde derleme işlemi iki adım adımda yapılır. Birinci adımıda, derleme öncesi
özel bir ön işlemci (preprocessor) programı devreye girer. Ana programdaki veya başlık
dosyalarındaki diyez ('#') işareti ile başlayan satırlar aslında C (veya C++) diline ait olmayıp
ön işlemci dilidir. Ön işlemci, bu satırlardaki deyimlere bakarak, bir katarı (string) alıp başka
bir katarla değiştir. Örneğin:
#include
satırı ile stdio.h dosyasının metin içeriği programa dahil edilir. Ön işlemci deyimlerinin
tamamı Bölüm 20'de anlatılatılmıştır.
Ön işlemci programı, .c ve .h uzantılı düz metin (text) halindeki kaynak dosyasını okur, ve
çıktı olarak başka bir düz metin dosyası üretir. Bu yeni dosya hiçbir ön işlemci deyimi
içermeyen C (veya C++) derleyicisi tarafından işlenmeye hazır bir dosyadır. İkinci adımda bu
dosya ile kaynak kodaları beraber derlenip sırasıyla nesne kodu ve çalıştırılabilir kod üretilir.
Bu işlemlem Şekil 22.2 de özetlenmiştir.

Şekil 22.2: C ve C++ dilleri için, Ön işlemci-Derleme-Bağlama-Çalıştırma işleminin akış
diyagramı.
22.2 Turbo C Derleme Seçenekleri
Turbo C derleyicisinin sunduğu derleme seçeneklerini görmek için, komut satırında tcc
yazmak yeterlidir. TCC'nin sunduğu derleme seçenekleri Şekil 22.2'de listelenmiştir.
Şekil 22.2: Turbo C'nin derleme seçenekleri.
Seçenekler incelendiğinde standart bir derleme işleminden daha fazlasının yapılabileceği
anlaşılır. Birkaç örnekle seçenekleri anlamaya çalışalım.
Program 22.1, 1 den n ye kadar olan tam sayıların toplamını hesaplayıp ekrana yazar.
Program 22.1: 1 den n ye kadar olan tam sayıların toplamını hesaplar

01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
/* 22prg01.c: 1 den n=10 a kadar olan tam
sayıların toplamını ekrana yazar */
#include
int s(int);
int main()
{
int n = 10;
printf("1 + 2 + ... + %d = %d\n",n,s(n) );
return 0;
}
/* 1 + 2 + ... + n toplamını hesaplar */
int s(int m){
int i,top=0;
}
for (i=1;i tcc 22prg01.c
Bu işlemle 22prg01.exe adlı bir çalıştırılabilir dosya ve 22prg01.obj adlı bir nesne dosyası
üretilir. Dosyalar listelenirse bu yeni dosyalar görülecektir.
C:\TC> dir /w 22prg01.*
22prg01.c 22prg01.exe 22prg01.obj
22prg01.exe dosyasını çalıştırmak için, dosyanın adını yazmak yeterlidir.
C:\TC> 22prg01
1 + 2 + ... + 10 = 55
Sadece asm uzantılı assembly kodu üretmek istendiğinde -S seçeneği kullanılır.
C:\TC> tcc -S 22prg01.c
C:\TC> dir /w 22prg01.*
22prg01.asm 22prg01.c 22prg01.exe 22prg01.obj
Sadece obj uzantılı nesne dosyası üretmek için -c seçeneği kullanılır.
C:\TC> tcc -c 22prg01.c
C:\TC> dir /w 22prg01.*
22prg01.asm 22prg01.c 22prg01.exe 22prg01.obj
Çalıştırılabilir dosyanın adını değiştirmek için -exxx seçeneği kullanılır.
C:\TC> tcc -eyeni 22prg01.c
C:\TC> dir /w yeni*
yeni.exe
C:\TC> yeni
1 + 2 + ... + 10 = 55
Büyük uygulamalarda alt progroramlar başka dosyalarda saklanır ve ana program ile beraber
komut satırında derlenebilir. Aşağıdaki gibi aynı dizin içerisinde bululan herbiri ayrı
dosyalarda saklanan dört fonksiyona ve bir ana programama sahip olduğumuzu varsayalım.
/* topla.c: iki sayinin toplamini
hesaplar */
/* fark.c: iki sayinin farkini
hesaplar */

int topla(int a,int b)
{
return (a+b);
}
/* carp.c: iki sayinin carpimini
hesaplar */
int carp(int a,int b)
{
return (a*b);
}
int fark(int a,int b)
{
return (a-b);
}
/* iki sayinin oranini hesaplar */
int bol(int a,int b)
{
if(b) return (a/b);
return 0;
}
/* ana.c: Ana program */
#include
int topla(int, int);
int fark(int, int);
int carp(int, int);
int bol(int, int);
int main()
{
int x=33, y=22;
printf("topla(%d,%d) = %d\n",x,y,topla(x,y));
printf(" fark(%d,%d) = %d\n",x,y,fark(x,y));
printf(" carp(%d,%d) = %d\n",x,y,carp(x,y));
printf(" bol(%d,%d) = %d\n",x,y,bol(x,y));
}
return 0;
Sadece ana.c dosyası derlendiğinde aşağıdaki gibi bir topla, fark, carp ve bol
fonksiyonlarının tanımsız olduğuna dair hata mesajı ekranda basılır:
C:\TC> tcc ana.c
Turbo C Version 2.01 Copyright (c) 1987, 1988 Borland International
ana.c:
Turbo Link Version 2.0 Copyright (c) 1987, 1988 Borland International
Undefined symbol '_bol' in module ana.c
Undefined symbol '_carp' in module ana.c
Undefined symbol '_fark' in module ana.c
Undefined symbol '_topla' in module ana.c
Fakat derleme şu şekilde yapıldığında hata mesajı ortadan kalkar.
C:\TC> tcc ana.c topla.c fark.c carp.c bol.c
Bu işlemin sonucunda derleyici ana.exe, ana.obj ve topla.obj, fark.obj, carp.obj,
bol.obj dosyalarını üretir. Tabiki tek çalıştırılabilir dosya ana.exe dir. Bu, bütün dosyaların
ayrı ayrı derlenmiş olduğu anlamına gelir. ana.exe dosyası çalıştırıldığında program çıktısı
şöyle olacaktır:
C:\TC> ana
topla(33,22) = 55
fark(33,22) = 11
carp(33,22) = 726
bol(33,22) = 1

Alt programlar çok büyük ve karmaşık işlemler yaptığında, bu şekilde derleme yapmak pek
sağlıklı değildir. Bunun yerine alt programların bulunduğu dosyalar bir kez -c seçeneği ile
derlendiğinde üretilen obj uzantılı dosyalar başka programlar tarafından kullanılabilir.
Şöyleki:
C:\TC> tcc -c topla.c
C:\TC> tcc -c fark.c
C:\TC> tcc -c carp.c
C:\TC> tcc -c bol.c
Ana programla beraber derleme işlemi bize aynı sonucu verecektir:
C:\TC> tcc ana.c topla.obj fark.obj carp.obj bol.obj
Bu sayede ana programda bir değişiklik yapılsa bile alt programrın bir daha derlenmesine
gerek kalmaz. Örneğin ana program şu şekilde bir satır ekleyelim:
/* ana.c: Ana program */
#include
int topla(int, int);
int fark(int, int);
int carp(int, int);
int bol(int, int);
int main()
{
int x=33, y=22;
printf("topla(%d,%d) = %d\n",x,y,topla(x,y));
printf(" fark(%d,%d) = %d\n",x,y,fark(x,y));
printf(" carp(%d,%d) = %d\n",x,y,carp(x,y));
printf(" bol(%d,%d) = %d\n",x,y,bol(x,y));
printf("
ortalama = %f\n",topla(x,y)/2.0);
}
return 0;
Derleme aşağıdaki gibi yapıldığında:
C:\TC> tcc ana.c topla.obj fark.obj carp.obj bol.obj
program çıktısı şöyle olur:
C:\TC> ana
topla(33,22) = 55
fark(33,22) = 11
carp(33,22) = 726
bol(33,22) = 1
ortalama = 27.500000
C:\TC>
Özetle bir fonksiyon birkez derlenip ona ait obj dosyası üretildiğinde, artık o kod bütün
programlar tarafından kullanılabilir demektir. Aşağıdaki derleme işlemi ile obj dosyaları ana
programa bağlanmıştır diyebiliriz:
C:\TC> tcc ana.c topla.obj fark.obj carp.obj bol.obj
Bu durum Şekil 22.3 de tasvir edilmiştir.

Şekil 22.3: Birden çok dosyanın derlenmesi ve birleştirilmesi.
22.3 GCC Derleme Seçenekleri
GCC (GNU Compiler Collection) daha çok Linux ve MAC ortamında kullanılan bir komut
satırı derleyicisidir. GCC'nin Windows ortamında çalıştırılabilen sürümü de mevcuttur, bkz.
gcc.gnu.org. Bu kısımda GCC'nin Linux ortamındaki kullanımından bahsedilecektir. Ancak
bütün işlemler Windows işletim sisteminde de geçerlidir.
GCC derleme seçeneklerini komut satırından görmek için iki yol vardır. Bunlar:
$ man gcc
veya
$ gcc --help
Burada $ işareti Linux komut hazır işaretidir (command prompt). Bu komutlardan birincisi
oldukça büyük, ayrıntılı ve yardım niteliğindedir, örneğin bkz:
www.hmug.org/man/1/gcc.php. İkincisinin sonucu Şekil 22.4 deki gibidir.

Şekil 22.4: GCC'nin derleme seçenekleri.
GCC ile 22prg01.c kaynak kodu şöyle derlenebilir:
$ gcc 22prg01.c
Bu işlem neticesinde sadece a.out adlı çalıştırılabilir bir dosya üretilir. Bu programı
çalıştırmak için:
$ ./a.out
1 + 2 + ... + 10 = 55
Çalıştırılabilir dosyanın adını değiştirmek için -o seçeneği kullanılır.
$ gcc 22prg01.c -o 22prg01
$ ./22prg01
1 + 2 + ... + 10 = 55
Sadece derleme yapmak için (Turbo C'de olduğu gibi) -c seçeneği kullanılır.
$ gcc -c 22prg01.c
Bu işlemin sonucunda 22prg01.o adlı nesne dosyası üretilir. Bu dosya, dosyalar
listelendiğinde görülebilir:
$ ls 22prg01*
22prg01.c 22prg01.o 22prg01*

Bir C kaynak kodu kütüphanesinden bir fonksiyon içeriyorsa, GCC ile bu tür
programlar -lm seçenği ile derlenmelidir. Program 22prg02.c, ilk 10 pozitif tam sayının on
tabanındaki logaritmalarını ve doğal logaritmalarını ekrana gösterir. Program içerisinde
kütüphanesindeki log ve log10 fonkiyonları kullanılmıştır.
Program 22.2: 1 den 10 a kadar olan tam sayıların logaritmaları
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
/* 22prg02.c: 1 den n=10 a kadar olan tam
sayıların logaritmalarını ekrana yazar */
#include
#include
int main()
{
int i;
for(i=1; i

$ gcc -c fark.c
$ gcc -c carp.c
$ gcc -c bol.c
Derlenmiş alt programların ana program ile birleştirlmesi
$ gcc ana.c topla.o fark.o carp.o bol.o -o ana
$ ./ana
topla(33,22) = 55
fark(33,22) = 11
carp(33,22) = 726
bol(33,22) = 1
ortalama = 27.500000
$
Ders 23: Tarih ve Saat Fonksiyonları
• Giriş
• 23.1 time() Fonksiyonu
• 23.2 ANSI C Tarih-Saat Fonksiyonları, Sabitleri ve Yapıları
• 23.3 Mili Saniye ve Mikro Saniye Düzeyinde Çalışmak
Giriş
Bazı uygulamalarda program içerisinde tarih ve saat bilgilerine ihtiyaç duyulabilir. C dilinde,
tarih ve saat fonksiyonlarının bildirimleri, semblik sabitler ve standart yapılar
başlık dosyasında tanımlanmıştır. Bu fonksiyonlar üç temel işlevi yerine getirir:
• Takvim (Tarih) bilgileri
• Yerel Saat
• Saat Dilimleri
Bu bölümde tarih ve saat fonksiyonları incelenmişitir.
23.1 time() Fonksiyonu
time() fonksiyonu 01/01/1970 tarihinden, programın çalıştığı tarihe ve saate kadar geçen
sürenin saniye cinsinden değerini gönderir. Genel bildirimi:
time_t time(time_t *zaman);
şeklindedir. Burada:

• time_t sayısal bir tip (genllikle long int) olup zaman bilgisini temsil eder.
• zaman tarih bilgisini tutan gösterici tipinde bir değişkendir.
NOT
Derleyici tarih bilgisi göstermezse time() fonksiyonu -1
değerini gönderir.
01/01/1970'den bu güne geçen süreyi iki yolla öğrenebiliriz:
1. Geri dönüş değerini kullanarak
2. time_t t;
3. ...
4. t = time(NULL);
5. printf("zaman: %ld\n",t);
6. fonksiyon parametresinden
7. time_t t;
8. ...
9. time(&t);
10. printf("zaman: %ld\n",t);
Şimdi örnek uygulamayı Program 23.1'de görelim:
Program 23.1: time() fonksiyonunun kullanımı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
ÇIKTI
/* 23prg01.c: time() fonksiyonun kullanımı */
#include
#include
int main ()
{
time_t saniye; /* long saniye; anlamında */
saniye = time (NULL);
puts("01/01/1970'den bu gune kadar gecen
sure,");
printf ("Saniye olarak %ld\n", saniye);
/* 1 saat = 60*60 = 3600 sn. */
printf ("Saat olarak %ld\n", saniye/3600);
/* 1 gün = 24 saat = 24*60*60 = 86400 sn. */
printf ("Gun olarak %ld\n", saniye/86400);
return 0;
}
01/01/1970'den bu gune kadar gecen sure,
Saniye olarak 1227606397
Saat olarak 341001
Gun olarak 14208

23.2 ANSI C Tarih-Saat Fonksiyonları, Sabitleri ve
Yapıları
Tablo 23.1'de ANSI C'de başlık dosyasında bildirilen tarih-saat fonksiyonları
listelenmiştir.
Tablo 18.1: time.h'te tanımlı tarih-saat fonksiyonları
Fonksiyon Bildirimi
char *asctime(const struct tm
*zmn_g);
clock_t clock(void);
char *ctime(const time_t
*zaman);
Açıklama
zmn_g göstericinin işaret ettiği veriyi, daha anlaşılabilir
bir formatla katar bilgisine çevirir. zmn_g göstericisi,
gmtime() ve localtime() fonksiyonlarının
döndürdüğü, tm yapısını gösterir. Geri döndürelen
katarın genel formatı:
Www Mmm dd hh:mm:ss yyyy
şeklindedir. Burada Www haftanın günü, Mmm ay bilgisi,
dd ayın günü hh:mm:ss saat bilgisini ve yyyy yıl
bilgisidir.
Zaman tik-tak bilgisini döndürür.
Geriye anlaşılır formatta yerel zamanı tutan bir katar
döndürür. zaman, time_t tipinde bir uzun tamsayıdır.
Katarın formatı: Www Mmm dd hh:mm:ss yyyy
şeklindedir.
double difftime(time_t zaman1,
time_t zaman2);
zaman2 - zaman1 farkını saniye cinsinden hesaplar.
zaman'ı tm yapısına (İngiltere'deki Greenwitch'göre
struct tm *gmtime(const time_t
*zaman);
struct tm *localtime(const
time_t *zaman);
time_t mktime(struct tm
*zaman);
time_t time(time_t *zaman);
GMT cinsinden) çevirir. zaman genellikle time
fonksiyonu ile döndürülür.
zaman'ı tm yapısına (yerel saat cinsinden) çevirir. zaman
genellikle time fonksiyonu ile döndürülür.
tm tipinde, zaman göstericisine ait tarih-saat bilgisini
gösterir.
1 Ocak 1970'den bu ana kadar geçen sürenin zaman
saniye cinsinden hesaplar.
CLK_TCK
clock_t ve time_t
(clock ticks per second) makro sabit. Zaman tik-takları
ve zamanın saniye cinsinden karşılığı arasında ilişkiyi
tanımlar. Bu sabit Turbo C'de
#define CLK_TCK 18.2
şeklinde tanımlanmıştır.
clock() ve time() fonksiyonlarının kullandığı veri
tipleri. Bunlar genellikle genllikle long int tipleridir
ve başlık dosyasında şöyle tanımlıdır.
typedef long clock_t
typedef long time_t
asctime(), gmtime(), localtime() ve mktime() fonksiyonlarının kullandığı tm yapısı
söyledir:

struct tm {
int tm_sec; /* saniye, (0 - 59) */
int tm_min; /* dakika, (0 - 59) */
int tm_hour; /* saat, (0 - 23) */
int tm_mday; /* ayın günü, (1 - 31) */
int tm_mon; /* ay, (0 - 11), 0 = Ocak */
int tm_year; /* yıl - 1900 */
int tm_wday; /* haftanın günü, (0 - 6), 0 = Pazar */
int tm_yday; /* yılın günü,(0 - 365) */
int tm_isdst; /* gündüz (-1/0/1) */
};
Program 23.2:
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
ÇIKTI
/* 23prg02.c: asctime() ve localtime()
fonksiyonlarının kullanımı */
#include
#include
int main()
{
time_t t;
struct tm *zaman_bilgisi;
time (&t);
zaman_bilgisi = localtime (&t);
printf("Su anki tarih ve saat:
%s",asctime(zaman_bilgisi));
return 0;
}
Su anki tarih ve saat: Tue Nov 25 15:19:20 2008
Program 23.3:
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
ÇIKTI
/* 23prg03.c: ctime() fonksiyonunun kullanımı */
#include
#include
main()
{
time_t t;
time(&t);
printf("Su anki tarih ve saat: %s",ctime(&t));
return 0;
}

Su anki tarih ve saat: Tue Nov 25 17:08:02 2008
Program 23.4:
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
/* 23prg04.c: clock() fonksiyonunun kullanımı */
#include
#include
void bekle(int zaman)
{
clock_t son;
}
ÇIKTI
son = clock() + zaman * CLK_TCK;
while( clock() < son) {}
int main()
{
int n;
printf ("Geri sayim basladi...\n");
for (n=10; n>0; n--)
{
printf ("%d\n",n);
bekle(1000);
}
printf ("ATES!\n");
return 0;
}
Geri sayim basladi...
10
9
8
7
6
5
4
3
2
1
ATES!
Program 23.5:
01:
02:
03:
04:
05:
06:
/* 23prg03.c: difftime() fonksiyonunun kullanımı
*/
#include
#include

07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
ÇIKTI
int main ()
{
time_t basla, bit;
char ad[256];
double fark;
time (&basla);
printf ("Lutfen adinizi girin: ");
gets (ad);
time (&bit);
fark = difftime(bit, basla);
printf("Merhaba %s.\n", ad);
printf("Adini yazman %lf saniye
surdu.\n",fark);
return 0;
}
Lutfen adinizi girin: Ahmet
Merhaba Ahmet.
Adini yazman 2.000000 saniye surdu.
Program 23.6:
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
/* 23prg06.c: mktime() fonksiyonunun kullanımı
*/
#include
#include
int main ()
{
time_t t;
struct tm *zaman;
int yil, ay, gun;
char *haftanin_gunu[] = { "Pazar",
"Pazartesi",
"Sali",
"Carsamba",
"Persembe", "Cuma",
"Cumartesi"};
/* tarih bilgisini oku */
printf("Yılı girin: "); scanf ("%d",&yil);
printf("Ayı girin: "); scanf ("%d",&ay);
printf("Gunu girin: "); scanf ("%d",&gun);
/* simdiki zaman bilgisini al */
t = time(NULL);
zaman = localtime(&t);
zaman->tm_year = yil - 1900;
zaman->tm_mon = ay - 1;
zaman->tm_mday = gun;
/* mktime fonksiyonun cagir */

32:
33:
mktime(zaman);
printf("Girilen tarihteki gun
haftanin_gunu[zaman->tm_wday]);
%s.\n",
}
return 0;
ÇIKTI
Yılı girin: 2003
Ayı girin: 8
Gunu girin: 1
Girilen tarihteki gun Cuma.
Program 23.7:
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
ÇIKTI
/* 23prg07.c: gmtime() fonksiyonunun kullanımı
*/
#include
#include
#define TUR (2)
#define ALM (1)
#define ABD (-8)
int main()
{
time_t t;
struct tm *ptm;
time (&t);
ptm = gmtime(&t);
printf("Su anki yerel saatler\n");
printf("Istanbul : %02d:%02d\n", ptm-
>tm_hour + TUR, ptm->tm_min);
printf("Berlin : %02d:%02d\n", ptm-
>tm_hour + ALM, ptm->tm_min);
printf("Los Angeles: %02d:%02d\n", ptm-
>tm_hour + ABD, ptm->tm_min);
return 0;
}
Su anki yerel saatler
Istanbul : 18:34
Berlin : 17:34
Los Angeles: 08:34
Program 23.8:
01: /* 23prg08.c: gerçek zamanı gösterimi */

02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
ÇIKTI
#include
#include
int main()
{
time_t t;
struct tm *zmn;
puts("Cikis icin: CTRL+C");
/* Sonsuz döngü */
while(1)
{
time(&t);
zmn = localtime(&t);
printf("%02d:%02d:%02d\r",
zmn->tm_hour, zmn->tm_min, zmn-
>tm_sec);
}
return 0;
}
Cikis icin: CTRL+C
17:08:43
23.3 Mili Saniye ve Mikro Saniye Düzeyinde Çalışmak
Bazı uygulamalarda saniyenin (s) alt birimleri, salise (sl), mili saniye (ms) ve mikro saniye
(µs), düzeyinde çalışmak gerekebilir. Birçok derleyici, saniyenin belli kesirlerine kadar
erişime izin veren fonksiyonları bünyesinde barındırır. Ancak, bu fonksiyonlar satandart C'de
mevcut değildir.
NOT
1 sl = (1/100) s = 0,01 s
1 ms = (1/1000) s = 0,001 s
1 µs = (1/1000000) s = 0,000001 s
gcc derleyicisinde başlık dosyası içinde tanımlı, gettimeofday() fonksiyonu
ile mikro-saniye düzeyine erişim mümkündür.
Program 23.9:
01:
02:
03:
04:
05:
/* 23prg09.c: saniyenin alt birimleri
Derleyici gcc 4.1.2 */
#include
#include

06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
ÇIKTI
#include
int main()
{
struct timeval tv;
struct timezone tz;
struct tm *tm;
long int sa, dk, sn, us;
double sl, ms;
gettimeofday(&tv,&tz);
tm = localtime(&tv.tv_sec);
sa = tm->tm_hour; /* saat */
dk = tm->tm_min; /* dakika */
sn = tm->tm_sec; /* saniye */
sl = tv.tv_usec/1.0e4; /* salise */
ms = tv.tv_usec/1.0e3; /* mili-saniye */
us = tv.tv_usec; /* mikro-saniye */
printf("%02ld:%02ld:%02ld ; %lf %lf %ld\n",
sa, dk, sn, sl, ms, us);
return 0;
}
13:53:38 ; 65.247900 652.479000 652479
Program çalıştırıldığı andaki saniye 38 değerini göstermektedir. Daha doğrusu, program
çalıştığı anda sistem saatinin saniye göstergesi 38. saniyeden 39. saniyeye geçmektedir.
Çıktıdaki 652479 rakamı, 38. ve 39. saniyeler arası geçen zamanın µs cinsinden değeridir.
Yani, saniyenin alt birimi 38 s + 652479 µs = 38.652479 s. demektir.
Turbo C deleyicisinde, mili-saniye düzeyinde kadar erişim izni vardır. Bunun için, program
içerisinde başlık dosyasında tanımlı ftime() fonksiyonu kullanılabilir.
Program 23.9b:
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
/* 23prg09b.c: saniyenin alt birimleri
Derleyici Turbo C 2.0 */
#include
#include
#include
int main()
{
struct tm *zmn;
struct timeb *tb;
int sa, dk, sn;
double sl, ms;

14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
ÇIKTI
sa = zmn->tm_hour; /* saat */
dk = zmn->tm_min; /* dakika */
sn = zmn->tm_sec; /* saniye */
sl = tb->millitm/10.0; /* salise */
ms = tb->millitm; /* mili-saniye */
ftime(tb);
printf("%02d:%02d:%02d | %lf %lf\n", sa, dk,
sn, sl, ms);
return 0;
}
13:56:16 ; 35.600000 356.000000
Ders 24: Monte Carlo Yöntemleri
• Giriş
• 24.1 Uygulama Alanları
• 24.2 Rastgele Sayılar
• 24.3 ANSI C Fonksiyonları
• 24.4 Basit Monte Carlo Programları
Giriş
Bilimsel uygulamalarda problemler iki kısımda incelenebilir:
• kesin = deterministik (deterministic)
• tahmini = olası (random).
Kesin sistemler, kuralları kanun hükmünde olan matematiksel yasalarla tanımlanabilen
sistemlerdir; Örneğin yerçekimi yasası gibi. Fakat, tahmini sistemlerin kuralları muhtemel
veya raslantısal (stocastic) olan istatiksel yöntemlerle belirlenir; Örneğin havaya atılan bir
metal paranın yazı veya tura gelmesi gibi. Burada raslantıdan kasıt, tahmini sistemlerde,
başlangıç koşulları kesin olarak tayin edilemediği için sonuca dair çözümün tahmin edilmesi
anlamındadır. Yoksa, evrende raslantıya yer yoktur.
Bilgisayar ortamında, yazılımsal (veya donanımsal) olarak rastgele sayılar (random numbers)
üretmek mümkündür. Monte Carlo Yöntemleri, bu rastgele sayıları kullanarak tahmini
sistemleri modelleyen algoritmalardır. Aslında, Monte Carlo, (Fransa) Monako'nun
kumarhaneleriyle ünlü en zengin yerleşim yeridir. (bkz. Wikipedia: Monte Carlo). Bu yüzden,

tahmini sistemlerin modellenmeside kullanılan sayısal analiz yöntemlerine Monte Carlo
(kısaca MC) ismi verilmiştir.
Bu bölümde, yazılımsal olarak üretilen Rastgele Sayılar ve Sayısal Analiz'de kullanılan basit
Monte Carlo Yöntemleri konu edilecektir.
24.1 Uygulama Alanları
Monte Carlo (MC), rastgele sayıları baz alarak tahmini sistemleri modeller. Hatta, bazı kesin
sistemlerde de kullanılabilir; Örneğin rastgele sayılarla Pi sayısını veya bir fonksiyonun
integralini hesaplamak gibi. MC yöntemleri, Fizik ve Mühendislik alanlarında pekçok
uygulama alanı bulmuştur. Bunlardan başlıcaları:
• [Matematik] Sayısal Analiz
• [Fizik] Doğal olayların simülasyonu
• [Fizik] Atom ve Molekül Fiziği, Nükleer Fizik ve özellikle Yüksek Enerji Fiziği
modellerini test eden simülasyonlar
• [Mühendislik] Deneysel aletlerin (örneğin detektör) simülasyonu
• [Biyoloji] Hücre Similasyonu
• [Ekonomi] Borsa Modelleri
• [İstatistik] Dağılım Fonksiyonları
Tahmini sistemleri modelleyebilmek için:
• Rastgele Sayı üretmeyi ve kullanmayı
• Basit MC programlarını oluşturmayı
• İleri düzeyde hazırlanan MC üreteçlerini ve programları kullanmayı
iyi öğrenmek gerekir.
24.2 Rastgele Sayılar
Bilgisayarların en çok uygulandığı alanlardan bir tanesi kuşkusuz doğa olaylarının
modellenmesidir. Bazı durumlarda, bilgisayarın ürettiği rastgele sayılar kullanılarak belirsiz
yani tahmini sistemler modellenebilir. Rastgele sayı özel bir dağılımdan seçilen kargaşık
(caotic) bir sayıdır.

Bilgisayarlar kesin (deterministic) bir yapıda çalıştıkları için gerçek anlamda rastgele sayı
üretemezler. Ancak, uygun algoritmlarla bir bilgisayarın düzgün bir dağılımdan seçilen ve
genllikle [0,1] arasında gerçel değerler alan rastgele sayı üretmesi sağlanabilir. Bilgisayarların
ürettiği bu rastgele sayılar yalancı rastgele sayı (pseudo-random numbers) olarak adlandırılır.
Rastgele sayı üreten bu algoritmalara rastgele sayı üreteci (random number generator) denir.
Günümüz derleyicilerinin bir çoğunda rastgele sayı üreteçleri için hazır kütüphane
fonksiyonları tanımlanmıştır.
Bu fonksiyonlar genellikle doğrusal bir denklem kullanarak, rastgele sayı dizisi üretir. 32-bit
makinalarda, dizinin peryodu en az 2 31 ~ 10 9 (1 milyar) dur. Yani, bir rastgele sayı üreteci
birbirinden farklı 1 milyar farklı sayı üretebilir. Bu kadar çok sayı günümüz bilgisaylarında
bir kaç saniyede kolaylıkla oluşturulabilir.
Rastgele sayı dizisini oluşturacak doğrusal denklemin genel biçimi şöyledir:
x n+1 = ( a x n + b ) mod m
burada mod modüler aritmetik işlemi anlamındadır. Dizinin ilk elemanı, x o , çekirdek (seed)
olarak adlandırılır. a ve b sabitleri, dizi elemanları kargaşık ve düzgün dağılacak şekilde
seçilir.
1960 yılında IBM şirketi aşağıdaki meşhur RANDU algoritmasını kullanmıştır (a = 69069, b
= 0):
x n+1 = ( 69069 x n ) mod 2 31 -1
Daha sonra Park ve Miller, aşağıdaki Minimal Standart algoritmasını önermiştir (a = 16807, b
= 0):
x n+1 = ( 16807 x n ) mod 2 31 -1
Park-Miller algoritması ile oluşturulan rastgele sayı üreteci, aşağıdaki C fonksiyonu ile
kotarılabilir:
/*
* Park-Miller algoritması ile [0,1] arasında
* düzgün dağılmış rastgele sayı üretir.
*/
float rastgele(int *cekirdek)
{
const int im = 2147483647, ia = 16807;
const int iq = 127773, ir = 2836;
const float m = 128.0/im;
int k;
float r;
k = *cekirdek / iq;
*cekirdek = ia*(*cekirdek-k*iq) - ir*k;
if(*cekirdek < 0) *cekirdek += im;
r = m * (*cekirdek/128);
}
return r;
Program 24.1'de, rastgele() fonksiyonu kullanılarak 10 sayı üretilmiştir. Program her
çalıştırıldığında aynı sayılar üretilecektir. Bunun nedeni kümenin ilk elemanı ilk_sayi sabit
olmasıdır.

Program 24.1: 10 rastgele sayı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
/* 24prg01.c
rastgele() fonksiyonu ile 10 adet [0-1]
arasında
rastgel sayı üretir */
#include
float rastgele(int *);
int main()
{
int ilk_sayi, i;
float r;
}
/* dizinin çekirdeği (seed) */
ilk_sayi = 123456789;
for(i=1; i

0.633966
24.3 ANSI C Fonksiyonları
Standart C (ve C++), RANDU ve Minimal Standart'a göre daha verimli çalışan (stdlib.h
başlık dosyasında bildirilen) aşağıdaki iki fonksiyonu kullanıcılarına sunmuştur:
• int rand(void)
0 ile RAND_MAX arasında tamsayı tipinde yalancı rastgele sayı üretilir.
RAND_MAX, stdlib.h'de tanımlı sembolik bir sabittir. Değeri (derleyiciye bağlı olarak)
en büyük int limiti ile sınırlıdır. Bu değer Turbo C (16-bit) derleyicisinde:
#define RAND_MAX 32767
şeklinde, gcc gibi (32-bit) uygulamalarda:
#define RAND_MAX 2147483647
şeklinde tanımlanmıştır.
• void srand(unsigned int cekirdek)
Rastgele sayı üreteci (rand()) için cekirdek değerini belirler.
Aşağıda bu fonksiyonların uygulamaları gösterilmiştir. İnceleyiniz.
Program 24.2:
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
ÇIKTI
/* 24prg02.c
rand() ile 10 adet rastgele tamsayı sayı
üretir */
#include
#include
int main()
{
int i;
/* rand fonksiyonu */
for(i=1; i

1681692777
1714636915
1957747793
424238335
719885386
1649760492
596516649
1189641421
RAND_MAX = 2147483647
Program 24.3:
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
ÇIKTI
/* 24prg03.c
rand() ile 10 adet [0,1] arasında rastgele
gercel sayı üretir */
#include
#include
int main()
{
int i;
/* rand fonksiyonu */
for(i=1; i

10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
ÇIKTI
int i, cekirdek;
/* cekirdeği değiştir */
cekirdek = 31415926;
srand(cekirdek);
/* rand fonksiyonu */
for(i=1; i

0.980876
0.453894
0.115219
0.993930
0.945253
0.023599
0.851912
0.334151
24.4 Basit Monte Carlo Programları
Bu kısımda, rastgele sayılar kullanılarak üç basit MC uygulaması verilmiştir.
• Uygulama 1: Yazı-Tura Simülasyonu
• Uygulama 2: Zar Simülasyonu
• Uygulama 3: MC ile Pi sayısının hesabı
Uygulama 1: Yazı-Tura Simülasyonu
Hilesiz bir para atıldığında, yazı veya tura gelme olasılığı (P, probability) eşit ve kuramsal
olarak P = 1/2 dir. Düşünün ki bir para n kez atılsın ve gelen turaları sayıp ve t ile gösterelim.
Deney sayısı, n, arttıkça t/n oranı kararlı (sabit) kalmaya başlar. Bu durumda, olasılığın
istatiksel tanımı şöyle yapılır:
P(t) = t/n
n sonsuza giderken P(t) değeri P = 1/2 değerine yaklaşır.
Şimdi, [0, 1] aralığından rastgele seçilen sayıları kullanarak, para atma deneyini yapalım.
Rastgele sayı üreteçleri sayıları eşit olasılıkla üretir. r bir rastgele sayı olsun. r < 0.5
durumuna tura, r >= 0.5 durumuna da yazı diyelim. Bu şekilde, bir döngü kullanarak deney
sayısına (n) göre, yazı-tura simulasyonu yapılabilir. Program 24.6, klavyeden girilen n'ye
göre, P(t) ve 1 - P(t) olasılıklarını hesaplar.
Program 24.6: Yazı-Tura Simulasyonu
01:
02:
03:
04:
05:
06:
07:
/* 24prg06.c
MC Yazı-Tura Simulasyonu */
#include
#include
#include

08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
ÇIKTI
/* [0, 1] arası rastgele sayı gönderir */
double rastgele(){
double r = (double) rand()/RAND_MAX;
return r;
}
int main()
{
int i, tura, yazi, n;
double r, p;
/* deney sayısı */
printf("deney sayisini girin: ");
scanf("%d",&n);
/* rastgele sayı üretecini başlat */
srand( time(NULL) );
/* deneyleri başlat */
for(tura=0, i=1; i

11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
}
ÇIKTI
double r = (double) rand()/RAND_MAX;
return r;
int main()
{
int i, j, tura, yazi, n;
double r, p;
/* rastgele sayı üretecini başlat */
srand( time(NULL) );
for(j=1; j

olur. Neden?
Program 24.8: Zar Simulasyonu
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
/* 24prg08.c: MC Zar Simulasyonu
Atılan bir çift zarın toplamının yedi olma
olasılığını hesaplar.
Olasılık kuramına göre, birçift zarın
toplamının 7 olma olasılığı
aşağıdaki formülden hesaplanabilir:
Ptoplam(7) = P(1,6) + P(2,5) + P(3,4) +
P(4,3) + P(5,2) + P(6,1)
Diğer taraftan:
P(1,6) = P(2,5) = P(3,4) = P(4,3) = P(5,2)
= P(6,1) = 1/36'dır.
Buna göre:
Ptoplam(7) = 6*(1/36) = 1/6 = 0.16666..
dır. */
#include
#include
#include
#include
/* [0, 1] arası rastgele sayı gönderir */
double rastgele(){
double r = (double) rand()/RAND_MAX;
return r;
}
int main()
{
int i, j, n, zar1, zar2, yedi;
double p;
/* rastgele sayı üretecini başlat */
srand( time(NULL) );
for(j=1; j

43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
p);
}
/* deneyleri başlat */
for(yedi=0, i=1; i

olarak)
şeklinde hesaplanabilir.
Olayın canlandırılması adına, aşağıda nokta sayısının (n) farklı değerleri için oluşabilecek
desenler gösterilmiştir.
n = 10 nokta n = 100 nokta n = 200 nokta
Program 24.9'da, MC yöntemi ile pi sayısının hesabı gösterilmiştir. Program ayrıca,
hesaplanan pi ile math.h'de tanımlı sabit M_PI arasındaki hatanın yüzde olarak karşılığnı da
ekranda gösterir. Program çıktısı incelendiğinde, hata n = 10 için yüzde 10, n = 1 milyar için
yüzbinde 2 civarındadır.
Program 24.9: MC ile Pi sayısının hesabı
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
/* 24prg09.c:
MC Yöntemi ile pi sayısının hesaplanması */
#include
#include
#include
#include
/* [0, 1] arası rastgele sayı gönderir */
double rastgele(){
double r = (double) rand()/RAND_MAX;
return r;
}
int main()
{
int i, j, n, m;
double x, y, pi, hata;
/* rastgele sayı üretecini başlat */
srand( time(NULL) );
for(j=1; j

25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
ÇIKTI
/* deney sayısı 10'un katları */
n = pow(10, j);
/* deneyleri başlat */
for(m=0, i=1; i pi = 2.8000000 ,
yuzde hata = %10.8732319
100 : 78 --> pi = 3.1200000 ,
yuzde hata = % 0.6873155
1000 : 794 --> pi = 3.1760000 ,
yuzde hata = % 1.0952199
10000 : 7878 --> pi = 3.1512000 ,
yuzde hata = % 0.3058113
100000 : 78625 --> pi = 3.1450000 ,
yuzde hata = % 0.1084592
1000000 : 785728 --> pi = 3.1429120 ,
yuzde hata = % 0.0419961
10000000 : 7853164 --> pi = 3.1412656 ,
yuzde hata = % 0.0104104
100000000 : 78536996 --> pi = 3.1414798 ,
yuzde hata = % 0.0035910
1000000000 : 785380671 --> pi = 3.1415227 ,
yuzde hata = % 0.0022272
C / C++ Derleyicileri
1. Dev-C++
2. Salford (Silverfrost)
3. GCC (GNU Compiler Collection)

4. Turbo C 2.01
5. Eclipse IDE
6. NetBeans IDE
Dev-C++
• Derleyicinin ilk üretildiği tarih: 1991-2009
• Ekran Görüntüsü
Salford (Silverfrost FTN95)
• Derleyicinin üretildiği tarih: ?-2009

• Ekran Görüntüsü
GCC (GNU Compiler Collection)
• Derleyicinin üretildiği tarih: ?-2009
• Ekran Görüntüsü

Turbo C
• Derleyicinin üretildiği tarih: 1987-1988
• Ekran Görüntüsü