C Programlama Dili

Kurs Notları

Kaan ASLAN

C ve Sistem Programcıları Derneği

Güncelleme Tarihi: 12/07/2003

Bu kurs notları Kaan ASLAN tarafından yazılmıştır. Kaynak belirtilmek koşuluyla her türlü alıntı yapılabilir.

---------------------------------------------------------------------------------------------------------------------------------------------------

C Programlama Dilinin Tarihsel Gelişimi

C Programalama Dili 1970-1971 yıllarında AT&T Bell Lab.'ta UNIX İşletimn Sisteminin geliştirilmesi sürecinde
bir yan ürün olarak tasarlandı. AT&T o zamanlar Multics isimli bir işletim sistemi projesinde çalışıyordu. AT&T
bu projeden çakildi ve kendi işletim sistemlerini yazma yoluna saptı. Bu işletim sistemine Mulctics'ten kelime
oyunu yapılarak UNIX ismi verildi. UNIX DEC firmaısnının PDP-7 makinalarında ilk kez yazılmıştır.

O zamanlar işletimsistemleri sembolik Makine dilinde yazılıyordu. Ken Thompson (grup lideri) işleri
kolaylaştırmak için B isimli bir programlama dilciği tasarladı. Sonra Dennis Ritchie bunu geliştirrek C haline
getirdi. C Programlama dili UNIX proje ekibindeki Dennis Ritchie tarafından geliştirilmiştir.
UNIX İşletim Sistemi 1973 yılında sil baştan yeniden C ile yeniden yazılmıştır. O zamana kadar bir işletimsistemi
yüksek seviyeli bir dilde yazılmış değildi. Bunedenle UNIX'in C'de yazılması bir devrim niteliğindir. UNIX
sayesinde C Programalam Dili 1970'lerde tanınmaya başladı. 1980-81 yıllarında IBM ilk kişisel bilgisayarı çıkarttı.

C Programlama Dili kişisel bilgisayarlarda kullanılan en yaygın dil oldu.

1978 yılında Dennis Ritchie ve Brian Kernigan tarafından “The C Programming Language” kitabı yazıldı. Bu kitap
üm zamanların en önemli bilgisayar kitaplarından biridir. (Hatta HelloWorld programı ilk kez burada yazılmıştır.)
C Programlama dili ilk kez 1989 yılında ANSI tarafından standardize edildi. ISO 1990 yılında ANSı stanadrşlarını
alarak (bölüm numaralandırmasını değiştirerek) ISO standardı olarak onayladı. Bu standardın resmi ismi ISO/IEC
9899: 1990'dı. Bu standartlar kısaca C90 ismiyle bilinmektedir. C 1999 yılında bazı özelliker eklenerek yeniden
standardize edildi. Bu standartlara da ISO/IEC 9899: 1999 denilmektedir ve kısaca C99 olarak bilinir. C99
derleyici yazan firmalar ve kurumlar tarafından çok fazla destek görmedi. C'ye nihayet 2011 yılında bazı özellikler
eklenmiştir. Bu son standartlar ISO/IEC 9899:2011 kod adıyla yayınlanmıştır. Buna da kısaca C11 denilmektedir.



Bu kursta klasik C olan C90 ele alınmaktadır. C99 ve C11'deki yeni özellikler "Sistem Programlama Ve C İleri C
Uygulamaları" kursunda ele alınacaktır. C denildiğinde default olarak akla C90 gelmelidir.
Anahtar Notlar: Bu kurs C Programlama Dilini her yönüyle anlatan bir kurstur. Bu kurstan sonra aşağıdaki kursalara katıllınabilir:
- Sistem Programlama ve İleri C Uygulamaları (I) (kesinlikle tavsiye edilir)
- C++ (kesinlikle tavsiye edilir)
- Qt ile C++'ta Programlama (pencereli Windows ve Linux programları yazmak için)
- UNIX/Linux Sistem Programalama
- Windows Sistem Programalama
- Sistem Programlama ve İleri C Uygulamaları (II)
- PIC mikrodenetleyicileri ile programlama (biraz elektonik bilgisi tabanı gerekir).

1

- PIC mikrodenetleyicileri ile programlama (biraz elektonik bilgisi tabanı gerekir).

C Programlama Dili şu an itibari ile Tiobe Index'e göre dünyanın en fazla kullanılan programlama dilidir.
Programalama Dillerinin Sınıflandırılması
Programlama dilleri teorisyenler tarafından genellikle üç biçimde sınıflandırılmaktadır:
1) Seviyelerine Göre Sınıflandırma
2) Kullanım Alanlarına Göre Sınıflandırma
3) Programlama Modeline Göre Sınıflandırma
Seviyelerine Göre Sınıflandırma
Seviye (level) bir programlama dilinin insan algısına yakınlığının bir ölçüsüdür. Yüksek seviyeli diller insana
yakın yani kolay dillerdir. Alçak seviyeli diller makinaya yakın fakat zor öğrenilen dillerdir. Olabilecek en aşağı
seviyeli dil saf makina dilidir (machine language). Bu dil yalnızca 1'lerden ve 0'lardan oluşur. Görsel diller,
veritabanı dilleri vs. çok yüksek seviyeli dilledir. Java, C#, Pascal, Basic, PHP vs. diller yüksek seviyeli dillerdir. C
Programlama Dili orta seviyeli bir dildir. Yani makinaya diğer dillerden daha yakındır.
Kullanım Alanlarına Göre Sınıflandırma
Programlama dilleri bazı konularda bazı iddialara sahiptir. Bzı dillerde web işlemleri yapmak daha kolayken, bazı
dillerde veritabanı işlemleri yapmak daha kolaydır. İşte bir dilin hangi tür uygulamalarda kullanılabileceğine
yönelik sınıflandırnadır bu.
Bilimsel ve Mühendislik Diller: Bu tür diller bilimsel ve mühendislik problemlerin çözülmesi için birincil olarak
tercih edilen dillerdir. Örneğin C, C++, Fortran, Pascal, Java, C#, Matlab vs.
Veritabanı Dilleri: Bunlar veritabanlarının oluşturulması ve idaresinde tercih edilen dillerdir. SQL, Foxpro, Dbase
vs. gibi...
Web Dilleri: İnteraktif web sayfalarını oluşturabilmek için tercih edilen dillerdir. Örneğin Java, C#, PHP, Python
gibi...
Yapay Zeka Dilleri: İnsan düşüncesini eşitli boyutlarda taklit eden programlara yapay zeka programları denir. Bu
programların yazılması için tercih edilen dillere yapay zeka dilleri denir. Örneğin C, C++, Java, C#, Lisp, Prolog vs.
gibi
Görsel ve Animasyonm Dilleri: Animasyon programları için kullanılan yüksek seviyeli script dilleridir. Action
Script gibi...
Sistem Programlama Dilleri: Sistem Programlama yapmak için kullanılan dilledir. Tipik olarak C, C++ ve
sembolikmakina dilleri sistem programlama dilleridir.
Anahtar Notlar: Sistem programları bilgisayar donanımı ile arayüz oluşturan, uygulma programlarını çeşitli
bakımlardan hizmet veren, aşağı seviyeli taban programlardır. Örneğin: İşletim sistemleri, editörler, derleyiciler ve
bağlayıcılar, haberleşme programları vs.
Programlama Modeline Göre Sınıflandırma
Programlama modeli o dilde programı hangi teknikle yazdığımıza ilişkindir. Bazı dillerin bazı tekniklerin
kullanılmasını açıkça desteklemektedir. Temel olarak (fakat daha fazla olabilir) programlama dillerini
2

prograramlama modellerine (programming paradigm) 4 biimde sınıflandırabiliriz:
1) Prosedürel Programlama Dilleri: Bu diller prosedürel programlama modelini destekleyen dillrdir. Örneğin C
prosedürel bir programlama dilidir. Prosedürel teknikte program altprogramların (prosedürlerin) birbirlerini
çağırmasıyla yazılır. Bunun dışında klasik Pascal, Basic, Fortran vs. gibi diller prosedürel dillerdir.
2) Nesne Yönelimli Programlama Dilleri: Bu diller nesne yönelimli programlama modelini (object oriented
programming) uygulayabilecek yetenkte dillerdir. Bu modelde program sınıflar oluşturarak yazılır. C++, C'nin
nesne yönelimli versiyonudur. Pek prosedürel dilin daha sonra nesne yönelimli versiyonları oluşturulmuştur.
Örneğin Object Pascal, VB.NET. C#, Java temelde nesne yönelimli dillerdir.
3) Fonksiyonel Programlama Dilleri: Bu tür diller fonksiyonel programlama modelini (functional programming
paradigm) açıkça destekleyen dillerdir. Örneğin Haskell, F#, R, Scheme, Erlang. Fonksiyonel teknikte programlar
sanki formül yazarmış gibi yazılırlar.
4) Çok Modelli Programlama Dilleri: Bu dillerde birden fazla programlama modeli kullanılabilmektedir.
Örneğin C++'ta hem prosedürel hem de nesne yönelimli teknik kullanılabilir. C++ çok modelli (multi paradigm)
bir programlama dilidir. Yeni özelliklerle C# ve Java'da artık çok modelli olmuştur.
Temel Kavramlar
İşletim Sistemi (Operating System): İşletim sistemi makinanın donanımını yöneten temel bir sistem yazılımıdır.
Bir kaynak yöneticisi gibi çalışır. Yönettiği tipik donanımsal kaynaklar şunlardır: İşlemci, RAM, Disk, Yazıcı,
Network kartı ve haberleşme sistemi. Eğer işletim sistemi olmasaydı bilgisayar hiç kolay kullanılamazdı. İşletim
sistemi temel pek çok hizmeti bizim için sağlamaktadır. Kullanıcı ile makine donanımı arasında köprü kurmaktadır.
İşletim sistemi insan vücudu gibi çeşitli alt sistemlere sahiptir. Bu alt sistemler karşılıklı etkileşim halindedir.
İşletim sistemlerini kabaca çekirdek (kernel) ve kabuk (shell) olmak üzere iki katmana ayırabiliriz. Çekirdek
makinanın donanımını yöneten motor kısımdır. Kabuk kullanıcı ile ilişki kurankısımdır. (Örneğin Windows'un
masaüstü kabuk durumundadır). Tipik olarak (fakat her zaman değil) biz işletim sisteminin üzerinde çalışırız.
En çok kullanılan Masaüstü işletim sistemleri Windows, Linux (UNIX türevi sistemler), Mac OS X sistemleridir.
En çok kullanılan mobil işleim sistemleri de Android, IOS, Windows Mobile sistemleridir.
Çevirici Programlar, Derleyiciler ve Yorumlayıcılar:
Bir programlama dilinde yazılmış olan programı eşdeğer olarak başka bir dile dönüştüren programlara çevirici
programlar (translators) denilmektedir. Burada asıl programın diline kaynak dil (source language), dönüştürülecek
dile hedef dil (target language) denilmektedir. Bir çevirici programda hedef dil alçak seviyeli bir dilse (sembolik
Makine dili, ara kod ya da saf makine dili) böyle çevirici programlara derleyici (compiler) denir.
Yorumlayıcılar (interpreters) kaynak kodu doğrudan okuyup o anda çalıştırırlar. Bir hedef kod üretmezler.
Dolayısıyla bunlar çevirici program durumunda değillerdir. Bazı diller için yalnızca derleyiciler kullanılır (Örneğin
C gibi). Bazıları için yalnızca yorumlayıcılar kullanılır (örneğin PHP, Perl gibi), Bazı dillerin derleyicileri de
yorumlayızıları da vardır (örneğin Basic gibi). Genel olarak yorumlayıcı yazmak derleyici yazmaktan daha
kolaydır. Derleyiciler kodun daha hızlı çalışmasına yol açarlar. Yorumlayıcılarda kaynak kod gizlenemez.
Açık Kaynak Kod ve Özgür Yazılım
1980'li yılların ortalarında Richard Stallman, FSF (Free Software Foundation) isimli bir dernek kurdu ve özgür
yazılım (free software) kavramını ortaya attı. Özgür yazılım kabaca, yazılan programların kaynak kodlarını
sahiplenmemek, başkalarının da onu devam ettirmesini sağlamak anlamına gelir. Birisi özgür yazılım lisansına
sahip bir ürünü değiştirdiği ya da özelleştirdiği zaman onu o da açmak zorundadır. Fakat alıcı varsa bunlar parayla
da satılabilir. Açık kaynak kod (open source) aşağı yukarı (fakat tamamen değil) özgür yazılımla aynı anlama
3

gelmektedir.
Her yazılımın bir lisansı vardır. Fakat çeşitli yazılım akımları için çeşitli lisanslar kalıp olarak oluşturulmuştur.
Örneğin Özgür yazılımın ana lisansı GPL(Gnu Public Licence)'dir. Fakat GPL'ye benzer pek çok lisans vardır
(BSD, Apachie, MIT, ...).
Richard Stallman FSF'yi kurduğunda GNU isimli bir proje başlattı. Bu projenin amacı bedava, açık kaynak kodlu
bir işletim sistemi ve geliştirme araçları yazmaktı. Gerçekten de gcc derleyicisi, ld bağlayıcısı ve diğer pek çok
utility program bu proje kapsamında yazıldı.
Linux işletim sistemi GNU malzemeleri kullanılşarak Linus Torwalds'ın önderliğinde geniş bir ekip tarafından
geliştirilmştir ve sürdürülmektedir. Linux aslında bir çekirdek geliştirme projesidir. Bugün Linux diye dağıtılan
sistemlerde binlerce açık kaynak kodlu yazılım bulunmaktadır. Yani Linux adeta GNU projesinin işletim sistemi
gibi olmuştur (maalesef GNU projesinin öngörülen işletim sistemi bir türlü son haline getirilememiştir.) Bu
nedenle bazı kesimler bu işletim sisteminin isminin Linux değil GNU/Linux olması gerektiğini söylemektedir.
Çok kullanılan C Derleyicileri
Pek çok derleyicisi olsa da bugün için en önemli iki derleyici Microsoft'un C derleyicileri ve gcc derleyicileridir.
Ekiden Borland derleyicileri de çok kullanılıyordu. Intel firmasının da ayrı bir C derleyicisi vardır. UNIX/Linux
sistemlerinde gcc derleyicileri çok yoğun kullanılırken, Windows sistemlerinde Microsoft C derleyicileri yoğun
kullanılmaktadır. Gcc'nin Windows portuna MinGW denilmektedir.
IDE Kavramı
Normal olarak derleyiciler komut satırından çalıştırılan programlardır. Yani biz programı editör denilen bir
ortamda yazarız. Bunu save ederiz. Sonra da komut satırından derleriz. Bu tarz çalışma biraz zahmetli olduğu için
IDE (Integrated Development environment) denilen özel yazılımlardan faydalanılır. IDE'lerin editörleri vardır,
menüleri vardır ve birtakım araçları vardır. IDE derleyici değildir. Derleyicinin dışındaki yazılım geliştirmeyi
kolaylaştıran araçlar toplamıdır.
Bugün pek çok IDE seçenek olarak bulunmaktdır. Microsoft'un ünlü IDE'sinin ismi “Visual Studio”dur.
Kursumuzda ağırlıklı bu IDE kullanılacaktır. Eclipse, Netbeans, MonoDevelop gibi open source IDE'ler de vardır.
Apple'ın da X-Code denilen kendi bir IDE'si vardır.
IDE derleyici değildir. IDE'ye “derle” denildiği zaman IDE gerçek derleyiciyi çağırır. Biz bilgisayarımıza bir IDE
yüklediğimizde yalnızca IDE değil, onun kullanacağı derleyici de yüklenecektir. Tabi IDE olmadan yalnızca
drleyiciyi de yükleyebiliriz.
Visual Studio paralı bir IDE'dir. Ancak Microsoft “Express Edition” ismiyle bu IDE'nin bedava bir versiyonunu da
oluşturmuştur. Bu kurs için ve genel olarak C programlama için Express Edition yeterlidir.
Visual Studio Windows sistemlerinde kullanılabilen bir IDE'dir. Oysa Eclipse ve Netbeans IDE'leri corss
platform'dur. Linux sistemlerinde IDE olarak QtCreator, Eclipse, Netbeans ya da MonoDevelop tercih edilebilir.
Şu anda Visual Studio IDE'sisn son versiyonu “Visual Studio 2013”tür.
Sayı Sistemleri
Biz günlük hayatımızda 10'luk sistemi kullanmaktayız. 10'luk sistemde sayıları ifade etmek için 10 sembol
kullanılır:
0 1 2 3 4 5 6 7 8 9 (toplam 10 tane)
4

Aslında 10'luk sistemdeki sayıların her bir basamağı 10'un kuvvetlerini temsil eder. Örneğin:
123 = 3 * 100 + 2 * 101 + 1 * 102
10'luk sistemde her bir basamağ “digit” denilmektedir.
Makina ikilik sistemi kullanır. Çünkü sayıların elektriksel olarak ifade edilmeleri ikilik sistemde çok kolaydır ve
standartlaşma böyle oluşmuştur. Elektroniğin bu alanına dijital elektronik denilmektedir.
İkilik sistemde toplam 2 sembol vardır:
0 ve 1 (toplam 2 tane)
İkilik sistemdeki bir sayı ikinin kuvvetleriyle çarpılarak elde edilir. Örneğin:
1010 = 0 * 20 + 1 * 21 + 0 * 22 + 1 * 23
İkilik sistemdeki her bir basmağa bit (binary digit'ten kısaltma) denilmektedir. Örneğin:
10100010 sayısı 8 bitlik bir sayıdır.
Bilgisayarımızın belleği de yalnızca bitleri tutar. Yani bellkekteki herşey bit'lrden oluşmaktadır. Bit en düşük
bellek birimidir.
8 bite byte denilmektedir. Kilo 102luk sistemde 1000 katı anlamına gelir (örneğin 1 Kilometre 1000 metredir.)
Fakat bilgisayar bilimlerinde kilo olarak 1000 anlamlı gözükmemektedir. Çünkü 1000 sayısı 10'un kuvvetidir. İşte
bilgisayar bilimlerinde kilo 1024 katı anlamına gelir (1024, 2'nin 10'uncu kuvvetidir ve 1000'e de benzemektedir.).
Mega da kilonun 1024 katıdır. Bu durumda 1 MB = 1024 * 1024 byte'tır. Giga da mega'nın 1024 katıdır.
Bilgisayarın belleğindeki her şey 2'lik sistemdeki sayılardan oluşur: Komutlar, yazılar, sayılar hep aslında ikilik
sistemde bulunurlar.
Tamsayıların 2'lik Sistemde İfade Edilmesi
Tamsayılar için iki sistem söz konusudur: İşaretsiz sistem ve işaretli sistem. İşaretsiz (unsigned) sistemde tamsayı
ya pozitif ya da sıfır olabilir. Fakat negatif yorumlanamaz. İşaretli (signed) sistemde tamsayı negatif de olabilir.
Örneğin aşağıdaki 8 bit sayı işaretsiz tamsayı olarak yorumlanırsa kaçtır?
1000 1010 = 138
8 bitle işaretsiz tamsayı sisteminde ifade edilecek en küçük sayı 0, en büyük sayı 255'tir.
0000 0000
.........
1111 1111

--> 0
--> 255

2 byte (16 bit) ile işaretsiz sistemde ifade edilebilecek en küçük sayı 0, en büyük sayı 65535'tir.
0000 0000 0000 0000 --> 0
.... .... .... ....
1111 1111 1111 1111 --> 65535
5

İşaretli tamsayıları ifade etmek için tarih boyunca 3 sistem denenmiştir. Bugün ikiye tümleme sistemi denilen
sistem en iyi sistem olarak kullanılmaktadır. Bu sistemin özellikleri şöyledir:
- Sayının en solundaki bit işaret bitidir. Bu bit 1 ise sayı negatif, 0 ise pozitiftir.
- Negatif ve pozitif sayılar birbirlerinin ikiye tümleyenidirler.
- Bu sistemde bir tane sıfır vardır.
Bir sayının ikiye tüöleyene sayının 1'e tümleyenine 1 eklenerek elde edilir (Syının 1'e tümleyeni 1'lerin 0, 0'ların 1
yapılmasıyla elde edilir.) Örneğin:
Sayı: 1011 1010
1'e tümleyeni: 0100 0101
2'ye tümleyeni: 0100 0101 + 1 = 0100 0110
Bu işlemin klay bir yolu vardır: Sayının sağında sola doğru ilk 1 görene kadar (ilk 1 dahil olmak üzere) aynısı
yazılarak ilerlenir. Sonra 0'lar 1, 1'ler 0 yapılarak devam edilir. Örneğin:
Sayı: 1010 1100
2'ye tümleyeni: 0101 0100
Örneğin:
Sayı: 1111 1111
2'ye tümleyeni: 0000 0001
Sayının 2'ye tümleyeninin 2'ye tümleyeni sayının kendisine eşittir. Örneğin:
Sayı: 1111 1111
2'ye tümleyni: 0000 0001
2'ye tümleynin 2'ye tümleyeni: 1111 1111
Bu sistemde negatif ve pozitif sayılar birbirlerinin 2'ye tümleyenidirler. Örneğin:
0000 1010 --> +10
1111 0110 --> -10
Bu sistemde negatif bir sayı yazmak istersek önce onun pozitiflisini yazıp sonra 2'ye tümleyenini alarak yazabiliriz.
(Tabi doğrudan yazabiliyorsak ne mutlu bize.) Örneğin, bu sistemde -1 yazmak isteyelim:
0000 0001 --> +1
1111 1111 --> -1
Bu sistemde birisi bize “bu sayı kaç” diye sorduğunda şöyle yanıtı bulabiliriz: Önce sayının işaret bitine bakıp
onun pozitif mi yoksa negatif mi olduğunu belirleriz. Sayı pozitif ise doğrudan hesaplarız. Negatif ise, sayının
ikiye tümleyeni alırız. Ondan faydalanarak sayıyı belirleriz. Örneğin, aşağıdaki sayı işaretli tamsayı sisteminde
kaçtır?
1111 0101
Sayı negatif, 2'ye tümleyenini alaım:
0000 1011
6

bu +11 olduğuna göre demek ki o sayı -11'dir.
Bu sistemde 1 tane sıfır vardır. Bu sistemde 2 tuhaf sayı vardır ki bunların 2'ye tümleyenleri yoktur (yani
kendisiyle aynıdır). Bunlar tüm bitleri 0 olan sayı ve ilk biti 1, diğer bitleri 0 olan sayıdır:
0000 0000 (2'ye tümleyeni yok)
1000 0000 (2'ye tümleyeni yok)
İşte bu ilk sayı 0'dır, diğeri ise -128'dir. Yani 8 bit içerisinde işaretli tamsayı sisteminde yazılabilecek en büyük
pozitif ve en küçük negatif sayılar şöyledir:
0111 1111 --> +127
1000 0000 --> -128
Peki 2 byte (16 bit) içerisinde yazılabilecek en büyük ve en küçük işaretli sayılar nelerdir?
0111 1111 1111 1111 --> +32767
1000 0000 0000 0000 --> -32768
Peki 4 byte (32 bit) içerisinde yazılabilecek en büyük ve en küçük işaretli sayılar nelerdir?
0111 1111 1111 1111 1111 1111 1111 1111 --> +2147483647
1000 0000 0000 0000 0000 0000 0000 0000 --> -2147483648
Soru: Aşağıdaki 1 byte'lık sayı işaretli ve işaretsiz tamsayı sistemlerinde kaçtır?
1111 1111
Cevap: İşaretsiz sistemde +255, işaretli sistemde -1'dir.
Peki bu sistemde örneğin 1 byte içerisindeki en büyük pozitif sayıya 1 toplarsak ne olur? Bir kere zaten sınırı aşmış
oluruz. Peki aşınca ne olur?
0111 1111 --> +127
0000 0001
--------------1000 0000 --> -128
Peki 2 toplasaydık ne olurdu? Yanıt: 1000 0001 = -127
Demek ki bu sistemde pozitif sınırı yanlışlıkla aşarsa kendimi negatif yüksek sayılarda buluruz. Buna
programlamada üstten taşma (overflow) denilmektedir. Taşma alttan da (underflow) olabilir. Örneğin -128'den 1
çıkartırsak +127 elde ederiz.
Gerçek Sayıların (Noktalı Sayıların) 2'lik Sistemde İfade Edilmesi
Noktalı sayıları 2'lik sistemde ifade edebilmek için tarih boyunca iki tür format grubu kullanılmıştır. Sabit noktalı
(fixed point) formatlarda noktanın yeri sabittir. Onun solunda sayının tam kısmı, sağında noktadan sonraki kısım
utulur. Örneğin 12.567 bu tür formatlarda şöyle tutulmaktadır:
Tabi sayının tam ve noktalı kısımları burada 10'luk sistemde değil, 2'lik sistemde tutulmaktadır.
Sabit noktalı formatlar pek verimli değildir. Çünkü dinamik değildir. Yani sayının tam kısmı büyük fakat noktalı
kısmı küçükse ya da tersi durumda sayı ifade edilemez. Halbuki yeteri kadar yer vardır. Bunun için kayan noktalı
7

(floating point) formatlar geliştirilmiştir. Bugün bilgisayarlarımızda bu formatlar kullanılmaktadır. Kayan noktalı
formatlarda sayı sanki noktası yokmuş gibi yazılır. Noktanın yeri ayrıca format içerisinde belirtilir. Örneğin:

Sayının noktası kaldırılmış olan haline mantis (manissa) denir. Noktanın yerini belirten kısmına ise genellikle üstel
kısım (exponential part) dnilmektedir. Çeşitli kaynak noktalı formatlar olsa da bugün hemen tüm sistemlerde
IEEE'nin 754 numaralı formatı kullanılmaktadır.
Tabi 2'lik sistemde sayının noktadan sonraki kısmı 2'nin negatif kuvvetleriyle çarpılarak oluşturulmaktadır. Bu da
yuvarlama hatası (rounding error) bir hatanın oluşmasına zemin hazırlar. Yuvarlama hatası noktalı bir sayının tam
olarak ifade edilemeyip ona yakın bir sayının ifade edilmesiyle oluşan bir hatadır. Yuvarlama hatası elimine
edilemez. Olsa olsa onun etkisi aazaltılabilir. Bunun için de sayının daha geniş olarak ifade edilmesi yoluna gidilir.
Örneğin C, C# ve Java'da float türü 4 byte'lık gerçek sayı türünü, double türü 8 byte'lık gerçek sayı türünü temsil
eder. Ve C programcıları bu nedenle en çok double türünü kullanırlar.
Anahtar Notlar: İlk elektronik bilgisayarlar 40'lı yıllarda yapıldı. Bunlar da vakum tüpler kullanılıyordu. Sonra transistör icad edildi.
50'li yıllarda bilgisayarlar transistörlerle yapılmaya başlandı. 70'li yıllarda entegre devre (integrated circuit) teknolojisi geliştirilince artık
bilgisayarların işlem birimi entegre devre olarak yapılmaya başlandı. Bunlara mikroişlemci dediler. Kişisel bilgisayarlar bunlardan sonra
gelişti.

Yuvarlama hataları her noktalı sayıda değil bazı sayılarda ortaya çıkar. Sayı ilk kez depolanırken de oluşabilir.
İşlem sonucunda da oluşabilir. Bu nedenle programlama dillerinde gerçek sayıların “eşit mi”, “eşit değil mi”
biçiminde karşılaştırılması iyi bir teknik değildir.
Yazıların 2'lik Sistemde İfade Edilmesi
Yazılar karakterlerden oluşur. Yazının her karakteri bir byte kodlanabilir. Böylece aslıunda yazı 2'lik sistemde
sayılarla ifade edilmiş olur. İşte hangi karakterin hangi sayıyla ifade edileceğini belirlemek için ASCII (American
Standard Code Information Interchange) tablosu denilen bir tablo yaygın bir biçimde kullanılmaktadır. ASCII
tablosu orijinal olarak 7 bitti. Sonra bu 8'bite çıkartıldı. ASCII tablosunun uzunluğu 256 satırdır. Bu 256 satır ile
tüm karakterler ifade edilemez. (Japonlar ne yapsın?). ASCII tablosunun ilk 128 karakteri standarttır. Diğer 128
karakteri ülkelere göre değişmektedir. Böylece ASCII tablosunun çeşitli varyasyonları oluşmuştur. Bunlara code
page denilmektedir. Ancak son 15 yıldır artık karakterlerin 2 byte ile kodlanması yaygınlık kazanmaya başlamıştır.
UNICODE denilen tablo 2 byte'lık ulaslarası kabul görmüş en önemli tablodur. Ve bugün artık en yoğun kullanılan
tablo haline gelmiştir.
16'lık Sayı Sistemi (Hexadecimal system)
16'lık sayı sisteminde toplam 16 sembol vardır:
0123456789ABCDEF
16'lık sistem bilgisayar bilimlerinde 2'lik sistemin basit ve yoğun bir gösterimini sağlamak için kullanılır. 16'lık
sistemdeki her hex digit 4 bit ile ifade edilebilir:
8

0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F

0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111

16'lık sistemdeki bir sayıyı 2'lik sisteme dönüştyürmek için her hex digit için 4 bit yazılır. Örneğin:
C4A8 = 1100 0100 1010 1000
Tam ters işlem de yapılabilir. Örneğin:
1001 0101 1100 0010 = 95C2
8'lik Sayı Sistemi (Octal System)
Sekizlik sisemde her bir octal digit 3 bitle açılır. Örneğin:
0
1
2
3
4
5
6
7

000
001
010
011
100
101
110
111

Örneğin 8'lik sistemdeki 756 sayısı 111 101 110 biçiminde 2'lik sisteme dönüştürülebilir.
Bilgisayarın Basit Mimarisi
Bir bilgisayar sisteminde üç önemli birim vardır: CPU, RAM ve Disk. İşlemleri yapan elektronik devrelerin
bulunduğu bölüme CPU denir. Bugün CPU'lar entegre devre biçiminde üretilmektedir ve onlara mikroişlemci de
denilmektedir. CPU ile elektriksel olarak bağlantılı olan ve CPU2nun çalışması sırasında sürekli kullanılan
belleklere Ana Bellek (Main Memory) ya da Birincil Bellek (Primary Memory) denilmektedir. Bunlar RAM
teknolojisiyle üretildiklerinden bunlara RAM de denir. Bir programın çalışması için ana belleğe yüklenmesi gerekir.
Bilgisayarın güç kaynağı kesildiğinde ana bellekte bilgiler kaybolur. Bu durumda güç kaynağı kesilince bilgileri
tutan birime ihtiyaç duyulmuştur. İşte onlara İkincil Bellekler (Secondary Storage Devices)" denilmektedir. Bugün
kullandığımız diskler, flash EPROM'lar, EEPROM bellekler ves. hep ikincil belleklerdir.

9

Bir program diskte bulunur. Onu çalıştırmak istediğimizde işletim sistemi onu diskten alır, birincil belleğe yükler
ve orada çalıştırır. Örneğin :
a = b + c;
gibi bir ifadede a, b ve c RAM'dedir. CPU önce a ve b'yi RAM'den çeker. Toplama işlemini yapar, sonucu yeniden
RAM'deki c'ye yazar.
Dil Nedir?
Dil olgusunun tek bir cümleyle tanımını yapmak kolay değildir. Fakat “iletişimde kullanılan semboller kümesi”
biçiminde tanımlanabilir. Diller kabaca doğal diller ve yapay diller (ya da kurgusal diller) olmak üzere ikiye ayrılır.
Doğal dillerde sentaks kesin ve açık olarak ifade edilemez. İstisnalar vardır ve bunlar kurala dönüştürülememktedir.
Yapay dilelr ise insanlar tarafından tasarlanmış kurgusal dillerdir. Programlama dilleri yapay dillerdir.
Bir dilin bütün kurallarına gramer denir. Gramerin iki önemli alt alanı vardır: Sentaks ve semantik. Doğal dillerin
fonetik gibi, morfoloji gibi başka kurallar kümesi olsa da sentaks ve semantik bütün dillerde olan en önemli
olgudur. Bir olguya dil diyebilmek için kesinlikle sentaks ve semantik kuralların bulunuyor olması gerekir.
Bir dil aslında yalın elemanlardan oluşur. (örneğin doğal dillerdeki sözcükler). Buelemanlar gelişigüzel dizilemez.
İşte sentaks dildeki öğelerin doğru yazılmasına ve doğru dizilmesine ilişkin kurallardır. Örneğin aşağıda bir sentaks
hatası yapılmıştır:
i am school going to
Aşağıda yine bir sentaks hatası yapılmıştır:
if a == 2)(
Doğru yazılmış öğelerin ne anlam ifade ettiğine ilişkin kurallara semantik denilmektedir. Yani örneğin “I am going
to school” sentaks olark düzgün bir sünledir. Fakat ne denilmek istenmektedir. Bu semantiktir. Benzer biçimde:
if (a == 10)
printf(“evet\n”);
Sentaks olarak geçerlidir. Semantik olarak “a 10'a eşitse ekrana evet yazdır” anlamına gelir.
Bilgisayar Dilleri (Computer Languages) ve Programalam Dilleri (Programming Languages)
Bilgisayar bilimlerinde kullanılan, insanlar tarafından tasarlanmış ve grameri matematiksel olarak ifade edilebilen
dillere bilgisayar dilleri denir. Bilgisayar bilimlerinde kullanılan ve sentaks ve semantik yapıya sahip her olgu bir
bilgisayar dilidir. (html, xml vs.). Bir bilgisayar dili özellikle akış öğesi de içerisiyorsa bir programlama dilidir. Her
programlama dili bilgisayar dilidir. Fakat tersi her zaman doğru değildir. (C, C++, Java, C# vs)”
10

C dili bir programlama dilidir.
Bir C Programını Oluşturmak
Bir C programının çalıştırılabilir program haline getirilmesi için genel olarak aşağıdaki adımlar uygulanır:
1. Kaynak dosyanın oluşturulması:
Kaynak dosya metin düzenleyici bir programla yazılır. C dilinin kurallarına göre yazılan dosyanın uzantısı
geleneksel olarak “.c” dir.
2. Kaynak dosyanın derleyici program (compiler) tarafından derlenmesi:
Derleyici program kullanılarak .c uzantılı dosya derlenir. Derleme işlemi yazılan programın C dilinin kurallarına
uygunluğunun belirlenmesi işlemidir. Derleme işlemi her zaman başarılı olmayabilir. Derleme işlemi başarılıysa
derleyici program ismine amaç dosya (object file) denilen bir dosya üretir. Amaç dosyalar işletim sitemine göre
değişiklik gösterebilir. Örneğin Windows sistemleri için amaç dosya uzantısı “.obj” dur. Unix/Linux sitemleri için
amaç dosyanın uzantısı genel olarak “.o” dur.
Derleyiciler komut satırından kolayca çalıştırılabilen programlardır. Başka programlar tarafından çağrılabilmeleri
için basit bir kullanıma sahiptirler.
3. Amaç dosya(lar) bağlayıcı (linker) program tarafından birleştirilerek çalıştırılabilir (executable) dosya
oluşturulur.
Anahtar Notlar: Windows sistemlerinde çalıştırılabilir dosyalar “.exe” uzantılıdır. Unix/Linux sistemlerinde
uzantınıın önemi yoktur. Özel bir biti set edilmiş dosyalar Unix/Linux sistemleri için çalıştırılabilir dosya olarak
algılanır.
Windows sistemlerinde derleme ve bağlama işlemi
Windows sistemlerinde genel olarak kullanılan Microsoft firmasınının cl isimli derleyicisidir. Bu program bağlama
işlemini de yapabilmektedir.
Anahtar Notlar: Windows sistemlerinde komut yorumlayıcı program üzerinde “cd” komutu ile dizin geçişleri
yapılabilir. (cd c:\Users\csd\Desktop\Test)
cl derleyici programının hem derleme hem de bağlama işlemini yapabildiği basit bir kullanımı şu şekildedir:
cl hello.c
Üretilen hello.exe programı aşağıdaki gibi çalıştırılabilir.
hello
Unix/Linux Sistemlerinde Derleme ve Bağlama İşlemi
Unix/linux sistemlerinde derleyici program olarak çoğunlukla “gcc” kullanılmaktadır. Unix/Linux sistemleri için
bu program parasız olarak kurulabilmektedir.
Anahtar Notlar: Bir çok Linux dağıtımı bulunmaktadır. Bunlardan lisanssız olarak kullanılabilen çeşitli
dağıtımlar da mevcuttur. (Ubuntu, Mint, Debian, Open Suse vs). Bu sistemler sanal makine programlarına da
kurulabilir. (Virtualbox vs.)
11

gcc programıyla derlemeve bağlama işlemi basit olarak aşağıdaki biçimde yapılabilir.
gcc -o hello hello.c
Burada “hello” isimli çalıştırılabilir bir dosya üretilecektir. Bu sistemlerde programın çalıştırılması terminal
penceresinde aşağıdaki gibi yapılabilir.
./hello
Visual Studio IDE'sinde Derleme ve Çalıştırma İşlemleri
Visual Studio IDE'si ile bir programı derleyip çalıştırmak için sırasıyla şunların yapılması gerekir:
1) Öncelikle bir proje oluşturmak gerekir. Projeler tek başlarına değil “Solution” denilen kapların içerisinde
bulunur. Dolayısıyla bir proje yaratırken aynı zamanda bir solution da yaratılır. Proje yaratmak için
File/New/Project seçilir. Karşımıza “New Project” dialog penceresi çıkar. Burada template olarak “Visual C++”
“Win32 Console Application” seçilir. Sonra Proje dizininin yaratılacağı dizin ve Proje ismi belirlenir. “Create
Directory for Solution” seçenk kutusu default çarpılanmış durumda olabilir. Bunun çarpısı kaldırılabilir. Bu
durumda solution bilgileri ile proje bilgileri aynı klasörde tutulacaktır. Bu dialog penceresi kapatılınca karşımıza
yeni bir dialog penceresi gelir. Burada “Empty Project” seçilmelidir. SDL seçenk kutusu da unchecked yapılabilir.
2) Solution yaratıldıktan sonra bununla ilgili işlem yapabilmek için “Solution Expolorer” denilen bir pencere
kullanılır. Solution Explorer View menüsü yoluyla,, araç çubuğı simgesiyle ya da Ctrl + Alt + L kısayol tuşuyla
açılabilir. Solution Explorer “yuvalanabilir (dockable)” bir penceredir. Solution Explorer bir “treeview” kontrolü
içermektedir.
3) Artık projeye bir kaynak dosyanın eklenmesi zamanı gelmiştir. Bunun için “Project/Add New Item” menüsü ya
da Solution Explorer'da projenin üzerinde bağlam menüsünden “Add/New Item” seçilir. Karşımıza “Add New
Item” dialog penceresi gelir. Burada kaynak dosyaya isim vererek onu yaratırız. Dosya uzantısının .c olması
gerekmektedir. Artık programı dosyaya yazabiliriz.
4) Programı derlemek için “Build/Compile” seçilir. Link işlemi için “Build/Build Solution” ya da “Build/Build
XXX” seçilir (Buradaki XXX projenin ismidir). Programı çalıştırmak için “Debug/Start Without Debugging” ya da
Ctrl+F5 tuşlarına basılır. Sonraki bir aşama seçilirse zaten öncekiler de yapılır. Böylece programı derleyip, bağlaıp
çalıştırabilmek için tek yapılacak şey Ctrl+F5 tuşlarına basmaktır.
5) Projeyi tekrar açabilmek için “File/Open/Project-Solution” seçilir. Projenin dizinine gelinir ve .sln dosyası
seçilir.
6) IDE'den çıkmadan projeyi kapatmak için “File/Close Solution” seçilir.
Atom (Token) Kavramı
Bir programlama dilindeki anlamlı en küçük birime atom (token) denir. Program aslında atomların yan yana
gelmesiyle oluşturulur. (Atomlar doğal dillerdeki sözcüklere benzetilebilirler). Örneğin “merhaba dünya”
programını atomlarına ayıralım:
#include <stdio.h>
int main(void)
{
printf(“Merhaba Dunya\n”);
12

return 0;
}
Atomlar:
# include
<
) {
printf
return
0

(
;

stdio.h
>
int
“Merhaba Dunya”
)
}

main
;

(

void

Atomlar daha fazla parçaya ayrılamazlar. Atomları altı gruba ayırabiliriz:
1) Anahtar Sözcükler (Keywords/Reserved Words): Dil için özel anlamı olan, değişken olarak kullanılması
yasaklanmış sözcüklerdir. Örneğin if, for, int, return gibi...
2) Değişkenler (Identifiers/Variables): İsmini bizim istediğimiz gibi verebildiğimiz atomlardır. Örneğin: x, y, count,
printf gibi...
3) Sabitler (Literals/Constants): Bir değer ya b,ir değişkenin içerisinde bulunur ya da doğrudan yazılır. İşte
doğrudan yazılan sayılara sabit denir. Örneğin:
a = b + 10;
ifadesinde a ve b birer değişken atom, 10 ise sabit atomdur.
4) Operatörler (Operators): Bir işleme yol açan, işlem sonucunda bir değer üretilmesini sağlayan atomlara operatör
denir. Örneğin:
a = b + 10;
Burada + ve = bierer operatördür.
5) String'ler (Strings): Programlama dillerinde iki tırnak içerisine yazılmış yazılar iki tırnaklarıyla tek bir atom
belirtirler. Bunlara string denir. Örneğin: “Merhaba Dunya\n” gibi...
6) Ayıraçlar (Delimeters/Punctuators): Yukarıdakşi grupların dışında kalan, ifadeleri ayırmak için kullanılan tüm
atomlar ayıraç atomdur. Örneğin ; gibi, } gibi...
Sentaks Gösterimleri
Programlama dillerinin sentakslarını betimlemek için en çok kullanılan yöntem BNF notasyonu ve türevleridir.
Ancak biz kurusumuzda açısal parantez, köşeli parantez tekniğini kullanacağız. Açısal parantezler içerisinde
yazılanlar mutlaka bulunması zorunlu öğeleri, köşeli parantez içerisindekiler “yazılmasa da olur (optional)” öğeleri
belirtir. Örneğin:
[geri dönüş değerinin türü] <fonksiyon ismi>([parametre bildirimi])
{
/* ... */
}
Açısal ve köşeli parantezlerin dışındaki tüm atomlar aynı biçimde bulundurulmak zorundadır.
Merhaba Dunya Programının Açıklaması
13

C programlarının başında genellikle aşağıdaki satır bulunur:
#include <stdio.h>
Bu bir önişlemci (preprocessor) komutudur. Bu komut açısal parantez içerisindeki dosyanın içeriğininn derleme
sırasında komutun yerleştirildiği yere kopyalanacağını beliritr. (Yani bu satırı silip onun yerine stdio.h isimli
dosyanın içeriğini oraya yerleştirmek aynı etkiye yol açar). Neden bu dosyanın içeriğinin bulunmasına gereksinim
duyulduğu ileride açıklanacaktır.
C programları kabaca fonksiyonlardan (functions) oluşur. Altprogramlara C'de fonksiyon denilmektedir. Bir
fonksiyonun tanımlanması (definition) o fonksiyonun bizim tarafımızdan yazılması anlamına gelir. Çağrılması (call)
onun çalıştırılması anlamına gelir. “Merhaba Dunya” programında main fonksiyonu tanımlanmıştır. Fonksiyon
tanımlamanın genel biçimi şöyledir:
[geri dönüş değerinin türü] <fonksiyon ismi> ([parametre bildirimi])
{
/* ... */
}
Anahtar Notlar: Genel biçimlerdeki /* ... */ gösterimi “burada birşeyler var, fakat biz şimdilik onlarla ilgilenmiyoruz” anlamına
gelmektedir.

İki küme parantezi arasındaki bölgeye blok denilmektedir. C'de her fonksiyonun bir ana bloğu vardır. C
programları main isminde bir fonksiyondan çalışmaya başlar. main bitince program da biter. Örnek programımızda
main fonksiyonunda printf isimli bir fonksiyon çağrılmıştır. Printf standart bir C fonksiyonudur. Standart C
fonksiyonu demek, tüm C derleyicilerinde bulunmak zorunda olan, derleyicileri yazanlar tarafından zaten yazılmış
olarak bulunan fonksiyonlar demektir. Bir fonksiyon çağırmanın genel biçimi şöyledir:
<fonksiyon ismi>([argüman listesi]);
printf fonksiyonu iki tırnak içerisindeki yazıları imlecin (cursor) bulundauğu yerden itibaren ekrana yazar. İmleç
program çalıştığında sol üst köşededir. printf imleci yazının sonunda bırakır. “\n” “imleci aşağıdaki satırın başına
geçir” anlamına gelir.
return deyimi fonksiyonu sonlandırır. Eğer return yoksa fonksiyon kapanış küme parantezine geldiğinde sonlanır.
Bir C programında istenildiği kadar çok fonksiyon tanımlanabilir. Bunların sırasının bir önemi yoktur. Main
fonksiyonunun da özel bir yerde bulunması gerekmez. Fakat program her zaman main fonksiyonundan çalışmaya
başlar.
C'de iç içe fonksiyon tanımlanamaz. Her fonksiyon diğerinin dışında tanımlanmak zorundadır. Örneğin:
#include <stdio.h>
foo()
{
printf("I am foo\n");
}
main()
{
foo();
}

14

Anahtar Notlar: Örneklerimizde fonksiyon isimleri uydurulurken foo, bar, tar gibi, func gibi isimler
kullanılacaktır. Bu isimlerin hiçbir özel anlamı yoktur.
İfade (Expression) Kavramı
Değişkenlerin, sabitlerin ve operatörlerin herbir birleşimine (kombinasyonuna) ifade denir. Örneğin:
x
30
x + 30
x + 30 – y
foo()
birer ifadedir. Görüldüğü gibi tekbaşına bir değişken ve sabit ifade belirtir, fakat tek başına bir operatör ifade
belirtmez.
Nesne (Object) Kavramı
Bellekte yer kaplayan ve erişilebilir olan bölgeler nesne denir. Örneğin programlama dillerindeki değişkenler tipik
birer nesnedir. Bir ifade ya bir nesne belirtir ya da nesne belirtmez. Örneğin:
100 bir ifadedir fakat nesne belirtmez. Örneğin:
x bir ifadedir ve nesne belirtir. Örneğin:
x + 10 bir ifadedir, nesne belirtmez.
Sol Taraf Değeri (Left Value) ve Sağ Taraf Değeri (Right Value)
Nesne belirten ifadelere sol taraf değeri (lvalue), belirtmeyene ifadeleri sağ taraf değeri (rvalue) denilmektedir.
Örneğin:
10 --> sağ taraf değeri
x --> sol taraf değeri
x + 10 --> sağ taraf değeri
Sol taraf değeri denmesinin nedeni atama operatörünün solunda bulunabilmesindendir. Sağ taraf değeri denmesinin
sebebi atama operatörünün solunda bulunamamasındandır (tipik olarak sağında bulunduğu için).
C'nin Veri Türleri
Tür (type) bir nesnenin bellekte kaç byte yer kaplayacağını ve onun içerisindeki 0'ların ve 1'lerin nasıl
yorumlanacağını anlatan temel bir kavramdır. Her nesnin C'de bir türü vardır. Ve bu tür programın çalışması
sırasında değişmez. (Aslında yalnızca nesnelerin değil genel olarak her ifadenin bir türü vardır. Bundan ileride
bahsedilecektir.)
C'nin temel türleri aşağıdaki tabloda gösteriöektedir:
Tür
Belirten Uzunluk (byte)
Sınır Değerler (Windows)
Anahtar Sözcükler Windows (UNIX/Linux)
[signed] int

4 (4)

[-2147483648, +2147483647]
15

unsigned [int]

4 (4)

[0, +4294967295]

[signed] short [int]

2 (2)

[-32768, +32767]

unsigned short [int] 2 (2)

[0, +65535]

[signed] long [int]

4 (8)

[-2147483648, +2147483647]

unsigned long [int]

4 (8)

[0, +4294967295]

char

1 (1)

[-128, +127] [0, +255]

signed char

1 (1)

[-128, +127]

unsigned char

1 (1)

[0, +255]

float

4 (4)

[±3.6*10-38, ±3.6*10+38]

double

8 (8)

[±1.8*10-308, ±1.8*10+308]

long double

8 (8)

[±1.8*10-308, ±1.8*10+308]

[signed] long long

8 (8)

[-9223372036854775808, +9223372036854775807]

unsigned long long
(C99 ve C11
ve C++11)

8 (8)

[0, +18446744073709551615]

_Bool
(C99, C11)

1 (1)

true, false

- int türü işaretli bir tamsayı türüdür. int türünün uzunluğu sistemden sisteme değişebilir. Standartlarda en az 2 byte
olması zorunlu tutulmuştur. Ancak derleyicileri yazanların isteğine bırakılmıştır.
- C'de her tamsayı türünün işaretli ve işaretsiz versiyonları vardır. int türünün işaretsiz biçimi unsigned int türüdür.
Yalnızca unsigned demekle unsigned int demek aynı anlamdadır.
- Standartlara göre short türü ya int türü kadardır ya da int türünden küçüktür. Örneğin DOS'ta int türü de short türü
de 2 byte uzunluktadır. Oysa Windows'ta ve UNIX/Linux sistemlerinde int türü 4 byte, short türü 2 byte
uzunluktadır.
- short türünün işaretsiz biçimi unsigned short türüdür.
- long türü standartlara göre ya int türü kadar olmak zorundadır ya da ondan büyük olmak zorundadır. 32 ve 64 bit
Windows sistemlerinde long türü int türü aynı uzunluktadır (4 byte). 32 bit UNIX/Linux sistemlerinde long türü 4
byte, 64 bit UNIX/Linux sistemlerinde 8 byte'tır.
- long türünün işaretsiz biçimi unsigned long türüdür.
- char türü standartlara göre her sistemde 1 byte olmak zorundadır. (Bu türün ismi belki byte olsaydı daha iyiydi).
char ismi her ne kadar karakteri çağrıştırıyorsa da bunun karkterle bir ilgisi yoktur. char türü C'de 1 byte uzunlukta
bir tamsayı türüdür. C'de yalnızca char denildiğinde bunun sisgned char mı, yoksa unsignd char mı olacağı
derleyicileri yazanların isteğime bırakılmıştır. Örneğin Windows ve UNIX/Linux sistemlerindeki derleyicilerde
char denildiğinde signed char anlaşılmaktadır (fakat bu durum ayarlardan da değiştirilebilmektdir).
- C'de gerçek sayı türlerinin işaretli ve işaretsiz biçimleri yoktur. Onlar zaten her zaman default işaretlidir.
- float türü en az 4 byte olması öngörülen bir gerçek sayı (noktalı sayı) türüdür. float türünün yuvarlama hatalarına
direnci zayıftır. Bu nedenle float yerine programcılar daha çok double türünü tercih ederler.
16

- double türü standartlara göre en az float kadar olmak zorundadır. Yani float türüyle aynı duyarlıkta olabilir ya da
ondan daha geniş olabilir.
- long double türü en az double kadar olmak zorundadır. double ile aynı uzunlukta olabilir ya da ondan daha uzun
olabilir.
- Birden fazla sözcükten oluşan türler için bu sözcüklerin yerleri değiştirilebilir (örneğin signed long int yerine int
signed long denilebilir.)
- C'de en fazla kullanılan tamsayı türü int, en fazla kullanılan gerçek sayı türü double türüdür. Programcının
öncelikle bunları tercih etmelidir. Özel durum varsa diğerlerini düşünmelidir.
- C99'da long long isimli bir tamsayı türü daha eklendi. Bu türün long türünden daha uzun olması öngörülmüştür.
Standartlara göre bu tür ya long türüyle aynı uzunluktadır ya da ondan daha uzundur.
- C'ye C99'la birlikte nihayet bir bool türü de eklenmiştir. Fakat klasik C'de böyle bir tür yoktur.
Derleyicilerin Hata Mesajları
Derleyicilerin hata mesajları üçe ayrılmaktadır:
1. Uyarılar (Warnings): Uyarılar gerçek hatalar değildir. Program içerisindeki program yapmış olabileceği olası
mantık hatalarına dikkati çekmek için verilirler. Uyarılar derleme işleminin başarısızlığına yol açmazlar. Ancak
programcıların uyarılara çok dikkat etmesi gerekir. Çünkü pek çok uyarıda derleyici haklı bir yere dikkat
çekmektedir.
2. Gerçek Hatalar (Errors): Bunlar dilin sentaks ve semantik kurallarına uyulmaması yüzünden verilirler.
Bunların mutlaka düzeltilmesi gerekir. Bir programda bir tane bile “error” olsa program başarılı olarak derlenemez.
3. Ölümcül Hatalar (Fatal Errors): Dereleme işleminin bile devam etmesini engelleyen ciddi hatalardır. Normal
olarak bir programda ne kadar hata olursa olsun tüm kod gözden geçirilir. Tüm hatalar en sonında listelenir. Fakat
bir ölümcül hata oluştuğunda artık derleme işlemi sonlandırılır. Ölümcül hatalar genellikle sistemdeki ciddi
sorunlar yüzünden ortaya çıkmaktadır (örneğin diskte yeterli alan olmayabilir, ya da sistemde yeterli RAM
bulunmuyor olabilir.)
Verilen hata mesajlarının metinleri derleyiciden derleyiciye değişebilir. Ayrıca bir hata durumunda bir derleyici
buna birmesaj verirken diğeri daha fazla mesaj verebilir.
C Programlarının Geçerliliği
Standartlar bir C programının geçerliliği ve derlenip derlenmeyeceği konusunda şunları söylemektedir:
1. Standartlarda belirtilen sentaks ve semantik kurallara uygun programlar kesinlikle derlenmek zorundadır.
2. Standartlara uygun bir program başarılı olarak derlendikten sonra birtakım mesajlar (diagnostics) da verilebilir.
(Tabi bu durumda bu mesajlar uyarı mesajları olacaktır)
3. Sentaks ve semantik kurllara uyulmadığı her durumda derleyici bu durumu belirten bir mesaj (diagnostic)
vermek zorundadır. Bu mesaj error ya da warning olabilir.
4. Geçersiz bir program yine de başarılı olarak derlenebilir. Ya da tersten şöyle düşünebiliriz: “Bir programın
başarılı olarak derlenmesi onun geçerli olduğu anlamına gelmez”.
Özellikle 4. Madde C programcıları tarafından maalesef bilinmemektedir. Bazı programcılar sırf derleyici
programılarını derledi diye programlarının geçerli olduğunu sanmaktadırler. Böyle bir program başka C
derleyicileri tarafından derlenmeyebilir.
17

Taşınabilirlik (Portability) Nedir?
Taşınabilirlik bir programlama dilinde yazılmış olan programın başka bir sisteme götürüldüğünde orada derlenerek
sorunsuz çalışabilmesine denilmektedir. Taşınabilirlik bu anlamda bir standadizasyonun bulunmasını gerektirir.
Çünkü derleyicileri yazanlar hep aynı kuralları kabul etmişlerse taşınabilirlik oluşabilir. C Programlama dili
oldukça taşınabilir bir dildir. Burada söz konusu edilen taşınabilirlik kaynak kodun taşınabilirliğidir. Yoksa biz
derlenip exe yapılmış bir programı başka bir sisteme götürüp orada çalıştıramayız. Ancak bunun mümkün olduğu
ortamlar da vardır (.NET ve Java gibi). Bu ortamlarda derlenmiş olan kod yeniden derlenmeden başka sistemlere
götürüldüğünde çalıştırılabilmektedir.
Bildirim ve Tanımlama Kavramları (Declaration & Definitions)
C, C++, C# ve Java gibi katı tür kontrolünün uygulandığı dillerde (strongly typed languages) bir değişken
kullanılmadan önce derleyiciye tanıtılmak zorundadır. Kullanılmadan önce değişkenlerin derleyiciye tanıtılması
işlemine bildirim (declaration) denilmektedir. Bir bildirim yapıldığında eğer derleyici bildirilen değişken için
bellekte bir yer ayırıyorsa o bildirim aynı zamanda bir tanımlama (definition) işlemidir. Yani tanımlama
derleyicinin yer ayırdığı bildirim işlemleridir. Bildirim daha geneldir. Her tanımlama bir bildirimdir fakat her
bildirim bir tanımlama değildir. Kurusumuzda aksi belirtilmediği sürece bildirimler aynı zamanda tanımlama
işlemi olarak kubul edilmelidir.
Bildirim işleminin genel biçimi şöyledir:
<tür> <değişken listesi>;

Örneğin:
int a;
long b, c, d;
double x, y;

Değişken listyesi bir'den fazla değişkenden oluşuyorsa onları ayırmak için ',' atomu kullanılır. Atomlar arasında
istenildiği kadar boşluk karakteri bırakılabildiğine göre aşağıdaki bildirim d geçerlidir.
long b
,
c,

d;

C'de (C90) bildirimler 3 yerde yapılabilir:
1) Blokların başlarında. Yani blok açıldığında henüz hiçbir fonksiyon çağrısı yapılmadan bildirimler yapılmalıdır.
Blok başlarında bildirilen değişkenlere yerel değişkenler (local variables) de denilmektedir.
2) Tüm blokların dışında. C'de tüm blokların dışında bildirilen değişkenlere global değişkenler (global variables)
de denilmektedir.
3) Fonksiyonların parametre parantezleri içerisinde. Böyle bildirilmiş olan değişkenlere “parametre değişkenleri
(parameters)” denilmektedir.
Değişken isimlendirmede şu kurallar söz konusudur:
- C büyük harf-küçük harf duyarlılığı olan (case sensetive) bir programlama dilidir. Yani büyük harflerle küçük
harfler tamamen farklı karakterlermiş gibi ele alınırlar.
18

- Değişkenler boşluk içermez. Değişken isimleri sayısal karakterlerle başlatılamaz. Ancak alfabetik karakterlerle ya
da _ ile başlatılıp sayısal devam ettirilebilirler.
- Değişken isimlendirmede yalnızca İngilizce büyük harfler, küçük harfler, sayısal karakterler ve alt tire
karakterleri kullanılabilir. (Yani değişkenlere Türkçe isimler veremeyiz).
- C standartlarına göre değişken uzunlukları için derleyiciler minimum 32 karakteri dikkate almak zorundadır. Bu
limit en az 32 olmak koşuluyla derleyiciden derleyiciye değişebilir. Fakat daha uzun değişken isimleri derleyici
tarafından geçerli olarak değerlendirilir. ncak en az ilk 32 karakter ayırıcı olarak dikkate alınacaktır.
- Anahtar sözcükler de değişken ismi olarak kullanılamazlar
Değişkenlere İlkdeğer Verilmesi (Initialization)
Bildirim sırasında bildirim işleminin bir parçası olarak değişkenlere değer vermeye ilkdeğer verme (initialization)
denilmektedir. Örneğin:
int a, b = 10, c;

burada a ve c'ye ilkdeğer verilmemiştir, fakat b'ye verilmiştir. İlkdeğer vermekle ilk kez değer vermek çoğu zaman
aynı etkiye yol açsa da gramatik olarak aynı şey değildir. Örneğin:
int a = 0;
int b;
b = 10;

/* ilkdeğer verme işlemi */
/* ilkdeğer verme işlemi değil, ilk kez değer verme işlemi */

İçerisine heniz değer atanmamış yerel değişkenlrin içerisinde rastgele değerler vardır. C terminolojisinde buna çöp
değer (garbage value) denilmektedir. Halbuki ilkdeğer verilmemiş global değişkenlerin içerisinde kesinlikle sıfır
değeri bulunur.
Nesnelerin İçerisindeki Değerlerin printf Fonksiyonuyla Yazdırılması
printf fonksiyonunda iki tırnak içerisindeki karakterler ekrana yazdırılır. Fakat iki tırnağın içerisinde % karakteri
varsa, printf bu % karakterini ve yanındaki bir ya da birkaç karakteri format karakteri olarak kabul eder. printf %
karakterini ve onu izleyen formak karaktrlerini ekrana yazdırmaz. Bunlar yer tutucudur. Bunların yerine iki
tırnaktan sonraki ifadelrin değerleri yazdırılır. İki tırnak içerisindeki her format karakteri sırasıyla iki tırnaktan
sonraki argümanlarla eşleştirilir. Formak karakterleri yerine bunların değerleri yazdırılır. Örneğin:
#include <stdio.h>
main()
{
int a = 10, b = 20;
printf("a = %d, b = %d\n", a, b);
printf("a = %d, b = %d\n", b, a);
printf("%d%d\n", a, b);

/* a = 10, b = 20 */
/* a = 20, b = 10 */
/* 1020 */

}

% karakterinin yanındaki format karakterleri nelerdir? Format karakterleri yazdırılacak ifadenin türüne bağlıdır.
Ayrıca format karakterleri yazdırma işleminin nasıl yapılacağını da (örneğin kaçlık sistemde) belirler. Temel
format karakterleri ve anlamları şöyledir:

19

Format Karakterleri Anlamı
%d

int, short ve char türlerini 10'luk sistemde yazdırır

%ld

long int türünü 10'luk sistemde yazdırır

%x, %X

int, short ve char türlerini hex sistemde yazdırır

%lx, %lX

long int ve unsigned long int türlerini hex sistemde yazdırır

%u

unsigned int, unsigned short ve unsigned char türlerini 10'luk sistemde yazdırır

%lu

unsigned long int türünü 10'luk sistemde yazdırır

%f

float ve double türlerini 10'luk sistemde yazdırır

%c

char, short ve int türlerini karakter görüntüsaü olarak yazdırır

%o

char, short ve int türlerini octal sistemde yazdırır

%lo

long ve unsigned long türlerini octal sistemde yazdırır

printf %f formatında default olarak noktadan sonra 6 basamak yazdırır. Yazdırılacak değer noktadan sonra 6
basamaktan fazlaysa yuvarlama yapılır. eğer printf ile noktadan sonra istediğimiz kadar basamak yazdırmak
istiyorsak %.nf formatı kullanılmalıdır (burada n yerine bir sayı olmalıdır. Örneğin %.10f gibi).
scanf Fonksiyonuyla Klavyeden Okuma Yapılması
scanf fonksiyonun kullanımı printf fonksiyonuna çok benzemektedir. Yine scanf fonksiyonunun bir format kısmı
vardır. Bu format kısmını içerisine okunan değerin yerleştirileceği nesne adresleri izler. scanf'te iki tırnak içerisinde
yalnızca formak karakterleri bulunmalıdır. Bu fonksiyon iki tırnak içerisindekileri ekrana yazdırmaz. scanf'te iki
tırnak içerisindeki format karakterlerinin dışındaki karakterler tamamen başka anlama gelirler. scanf
fonksiyonunda değerin yerleştirileceği nesnelerin başında & operatörü bulunmalıdır. (Bu & operatörü bir adres
operatörüdür. Nesnenin adresini elde etmekte kullanılır. Örneğin:
#include <stdio.h>
main()
{
int a;
printf("sayi giriniz:");
scanf("%d", &a);
printf("Girilen deger: %d\n", a);
}

scanf kullanırken şunlara dikkat etmek gerekir:
- İki tırnak içerisinde yalnızca format karakteri bulunmalıdır. Orada boşuk karakterleri ya da \n karakteri
bulunmamalıdır.
- Değişkenlerin önündeki & operatörü unutulmamalıdır.
Scanf fonksiyonuyla bir'den fazla değer girilirken girişler arasında istenildiği kadar boşluk karakterleri bırakılabilir.
Örneğin:
#include <stdio.h>
main()
{
int a;

20

int b;
printf("Iki sayi giriniz:");
scanf("%d%d", &a, &b);
printf("a = %d, b = %d\n", a, b);
}

printf fonksiyonundaki format karakterleri scanf fonksiyonunda klavyeden girişi belirlemektedir. Yani örneğin biz
pir int değeri printf ile %x kullanarak yazdırırsak bu değer 16'lık sistemde ekrana yazdırılır. Fakat bir int değeri
scanf ile %x ile okumak istersek klavyeden yaptığımız girişin 16'lık sistemde olduğu kabul edilir. Örneğin:
#include <stdio.h>
main()
{
int a, b;
printf("Bir sayi giriniz : ");
scanf("%x", &a);
printf("a = %d\n", a);
}

printf fonksiyonunda hem float hem de double türleri %f ile yazdırılır. Ancak scanf fonksiyonunda float %f ile,
double %lf ile okunur. Örneğin:
#include <stdio.h>
main()
{
float f;
double d;
printf("float bir deger giriniz:");
scanf("%f", &f);
printf("double bir deger giriniz:");
scanf("%lf", &d);
printf("f = %f, d = %f\n", f, d);
}

Sınıf Çalışması
İsmi a, b, c olan double türden 3 değişken tanımlayınız. Sonra a ve b için klavyeden scaf fonksiyonuyla okuma
yapınız. Bu ikisinin toplamını c'ye atayınız ve c'yi yazdırınız.
Çözümü
#include <stdio.h>
main()
{
double a, b, c;
printf("a degerini giriniz :");
scanf("%lf", &a);
printf("b degerini giriniz :");
scanf("%lf", &b);
c = a + b;

21

printf("c = %f\n", c);
}

Fonksiyonların Geri Dönüş Değerleri (return value)
Bir fonksiyon çağrıldığında akış fonksiyona gider. Fonksiyonun içerisindeki kodlar çalışır. Fonksiyonun çalışması
bitince akış kalınan yerden devam eder. İşte fonksiyonun çalışması bittiğinde onu çağıran fonksiyona ilettiği değer
geri dönüş değeri denilmektedir. Fonksiyonun geri dönüş değerinin de bir türü vardır. Bu tür tanımlama sırasında
fonksiyonun isminin soluna yazılır. Örneğin:
double foo()
{
/* ... */
}
long bar()
{
/* ... */
}
Fonksiyonun geri dönüş değeri yerine birşey yazılmazsa sanki int yazılmış gibi işlem görür. Yani örneğin:
foo()
{
/* ... */
}
ile
int foo()
{
/* ... */
}
tamamen aynı anlamdadır. C99 ve C11'de geri dönüş değerinin yazılmaması seçeneği kaldırılmıştır. C'nin bu yeni
versiyonlarında fonksiyonların geri dönüş değerlerinin türleri yazılmak zorundadır.
Örneğin:
result = foo() * 2;
Burada önce foo fonksiyonu çağrılır, geri dönüş değeri elde edilir, ikiyle çarpılır ve result değişkenine atanır.
Fonksiyonun geri dönüş değeri return deyimiyle oluşturulur. return deyiminin genel biçimi şöyledir:
return [ifade];
Programın akışı return anahtar sözcüğünü gördüğünde önce ifadenin değeri hesaplanır, sonra fonksiyon bu değerle
sonlandırılır. Yani return deyiminin iki işlevi vardır:
1) Fonksiyonu sonlandırır
2) Geri dönüş değerini oluşturur
22

Örneğin:
#include <stdio.h>
int foo()
{
printf("Foo\n");
return 100;
printf("test\n");

/* unreachable code! */

}
int main()
{
int result;
result = foo() * 2;
printf("%d\n", result);
}
Anahtar Notlar: Linux Sanal makinaya nasıl kurulur? Öncelikle sanal makina programını bilgisayarımıza yüklememiz gerekir. Bunun
için iki önemli seçenek vardır. Birincisi VMWare firmasının VMWare programı, ikincisi open source VirtualBox programı. VMWare
normalde paralı bir programdır. Fakat bunun VMWare Player isminde bedava bir sürümü de vardır. Sanal makinaya Linux kurulur
(örneğin Mint sürümü). Kuruum doğrudan ISO dosyasıyla yapılabilir. Kurulum sırasında bizden bir user name ve password istenecktir
(Örneğin derste yaptığımız kurulumda user name = csd ve password = csd1993 verdirk.)

C'de bir fonksiyonun geri dönüş değeri olduğu halde return ile belli bir değere geri dönülmezse geri dönüş değeri
olarak çöp bir değer elde edilir. (Halbuki C# ve Java gibi bazı dillerde fonksiyonların geri dönüş değeri varsa
return kullanmak zorunludur.)
C'de main fonksiyonun geri dönüş değeri int olmak zorundadır. Yani örneğin void, long vs. olamaz. Ayrıca main
fonksiyonunda hiç return kullanmazsak sanki 0 ile geri dönmüş gibi işlem görür. Yani main fonksiyonunda return
kullanmamakla ana bloğun sonunda 0 ile geri dönmek aynı anlamdadır. Örneğin:
#include <stdio.h>
int main()
{
printf("I am main\n");
return 0;

/* bu olmasaydı da aynı anlam oluşacaktı */

}

Fonksiyonun geri dönüş değeri yerine void anahtar sözcüğü yazılırsa bu durum fonksiyonun geri dönüş değerinin
olmadığı anlamına gelir. Böyle fonksiyonlara void fonksiyonlar denir. void fonksiyonlarda return kullanılabilir
fakat yanına ifade yazılamaz. void fonksiyonlarda return kullanılmamışsa fonksiyon ana blok sonlanınca sonlanır.
Örneğin:
#include <stdio.h>
void foo()
{
printf("foo\n");
}
int main()
{

23

printf("I am main\n");
foo();
return 0;
}

Fonksiyonun geri dönüş değeri return işlemi sırasında önce geçici bir değişkene aktaraılır, oradan alınarak
kullanılır. Örneğin:
return 100;
----> temp = 100;
...
result = foo() * 2---> result = temp * 2;
Aslında return işlemi geçici değişkene yapılan atama işlemidir. Fonksiyonun geri dönüş değerinin türü de geçici
değişkenin türüdür. Geçici değişken derleyici tarafından return işlemi sırasında yaratılır, kullanım bittiğinde yok
edilir. return işlemi de bir çeşit atama işlemidir.
Değişkenlerin Faaliyet Alanları (Scope)
Bir değişkenin derleyici tarafından tanınabildiği program aralığına faaliyet alanı (scope) denilmektedir.
Değişkenler belirli faliyet alanlarına sahiptir. C'de 3 çeşit faaliyet alanı vardır:
1) Blok faaliyet alanı (block scope)
2) Fonksiyon faaliyet alanı (function scope)
3) Dosya faaliyet alanı (file scope)
Bir fonksiyonun bir ana bloğu olmak zorundadır. O ana bloğun içerisinde istenildiği kadar çok iç içe ya da ayrık
blok açılabilir. Örneğin:
void foo()
{
{
...
{
...
}
}
{
...
}
}
C'de (C++, C# ve Java'da da öyle) iç içe fonksiyon bildirilemez. Örneğin:
void foo()
{
...
void bar()
{
...
}
...

/* geçersiz */

24

}
Blok faaliyet alanı yalnızca bir blokta ve o bloğun kapsadığı bloklarda tanınma alanıdır. Fonksiyon faaliyet faaliyet
alanı tek bir fonksiyonun her yerinde tanınma aralığıdır. Dosya faaliyet alanı bir dosyanın her yerinde tanınma
aralığıdır.
Yerel Değişkenlerin Faaliyet Alanları
Yerel değişkenler blok faaliyet alanı kuralına uyarlar. Yerel değişken hangi blokta bildirilmişs yalnızca o blokta ve
bloğun kapsadığı bloklarda kullanılabilir. Örneğin:
void foo()
{
int a;
{
int b;
/* a ve b burada kullanılabilir */
}
/* a burada kullanılabilir, b kullanılamaz */
}

Örneğin:
#include <stdio.h>
int main()
{
int a;
{
int b;
b = 20;
a = 10;
printf("a = %d, b = %d\n", a, b);
}
printf("a = %d\n", a);
printf("b = %d\n", b);

/* geçerli */
/* geçerli */
/* error! */

return 0;
}

C'de aynı faaliyet alanına sahip birden fazla aynı isimli değişken tanımlanamaz. Farklı faaliyet alanlarına sahip
aynı isimli değişkenler tanımlanabilir. Bu durumda örneğin, iç içe yerel bloklarda aynı isimli değişkenler
tanımlanabilir. Örneğin:
#include <stdio.h>
void foo()
{
int a;
{
int a;
/* ... */
}
/* ... */
}

/* geçerli */

25

int main()
{
int a;

/* geçerli */

return 0;
}

C'de bir blokta bir'den fazla değişken faaliyet gösteriyorsa o blokta o değişken ismi kullanıldığında dar faaliyet
alanına sahip olan değişkene erişilir. Örneğin:
#include <stdio.h>
int main()
{
int a;
a = 10;
{
int a;
a = 20;
printf("%d\n", a);/* 20 */
}
printf("%d\n", a);

/* 10 */

return 0;
}

Global Değişkenlerin Faaliyet Alanı
Bildirimleri fonksiyonların dışında yapılan değişkenlere global değişkenler denir. Global değişkenler dosya faaliyet
alanına (file scope) sahiptir. Yani tüm fonksiyonlarda tanınırlar.
#include <stdio.h>
int a;
void foo()
{
a = 10;
}
int main()
{
a = 20;
printf("%d\n", a);
foo();
printf("%d\n", a);

/* 20 */
/* 10 */

return 0;
}

Bir global değişkenle aynı isimli yerel değişkenler tanımlanabilir. Çünkü bunlar farklı faaliyet alanlarına sahiptir.
Tabi ilgili blokta bu değişken ismi kullanıldığında dar faaliyet alanaına sahip olana (yani yerel olana) erişilir.
26

Örneğin:
#include <stdio.h>
int a;
void foo()
{
int a;
a = 10;

/* yerel olan a */

}
int main()
{
a = 20;
/* global olan a */
printf("%d\n", a);
/* 20 */
foo();
printf("%d\n", a);
/* 20 */
return 0;
}

C'de derleme işleminin bir yönü vardır. Bu yön yukarıdan aşağıya doğrudur. Derleyicinin önce değişkenin
bildirimini görmesi gerekir. Bu nedenle bir global değişkeni aşağıda bildirip daha yukarıda kullanamayız. Örneğin:
#include <stdio.h>
void foo()
{
a = 10;
}

/* geçersiz! */

int a;
int main()
{
a = 10;
/* geçerli */
printf("%d\n", a);
/* geçerli */
return 0;
}

Bu durumda global değişkenler için en iyi bildirim yeri programın tepesidir.
Fonksiyonların Parametre Değişkenleri
Fonksiyonlar onları çağıran fonksiyonlardan değerler alabilirler. Bunlara fonksiyonların parametre değişkenleri
(parameters) denilmektedir. Parametre değişkenlerini bildirmenin C'de iki yolu vardır: Eski biçim (old style) ve
yeni biçim (modern style). Biz kursumuzda hiç eski biçimi kullanmayacağız. Bu eski biçim çok eskiden
kullanılıyordu. Yeni biçim ortaya çıkınca programcılar bunu kullanmaz oldular. C standartları oluşturulduğunda
her iki biçimi de destekledi. Eski biçim C++'ta C99'da ve C11'de desteklenmemektedir.
Eski biçimde parametre bildirimi yapılırken önce parametre parantezlerinin içerisine parametre değişkenlerinin
isimleri aralarına virgül atomu getirilerek listelenir. Daha sonra henüz ana blok açılmadan bunların bildirimleri
yapılır. Örneğin:
void foo(a, b, c)
int a;

27

long b, c;
{
...
}

Yeni biçimde parametre değişkenleri parametre parantezinin içerisinde tür belirtilerek bildirilir. Örneğin:
void foo(int a, long b, long c)
{
...
}

Yeni biçimde parametre değişkenleri aynı türden olsa bile her defasında tür belirten atomları yeniden belirtmek
gerekir. Örneğin:
void foo(int a, b)
{
/* ... */
}

/* geçersiz! */

bildirimin şöyle yapılması gerekirdi:
void foo(int a, int b)
{
/* ... */
}

/* geçerli */

Parametreli bir fonksiyon çağrılırken parametre sayısı kadar argüman kullanılır. Örneğin:
foo(10, 20);
Argümanlar ',' operatörü ile birbirlerinden ayrılmaktadır. Argüman olarak herhangi birer ifade (expression)
kullanılabilir. Örneğin:
foo(a + b - 10, c + d + 20);
Anahtar Notlar: Bir fonksiyon çağrılırken parametre parantezinin içerisine yazılan ifadelere argüman (argument), fonksiyonun parametre
değişkenlerine kısaca parametre (parameter) denilmektedir.

Parametreli bir fonksiyon çağrıldığında önce argümanların değerleri hesaplanır. Sonra argümanlardan parametre
değişkenlerine karşılıklı bir atama yapılır. Sonra programın akışı fonkisyona geçer. Örneğin:
#include <stdio.h>
void foo(int a, int b)
{
printf("a = %d, b = %d\n", a, b);
}
int main()
{
int x = 10, y = 20;
foo(x, y);
foo(x + 10, y + 20);
foo(100, 200);
return 0;

28

}

Fonskiyonların parametre değişkenleri faaliyet alanı bakımından sanki ana bloğun başınd tanımlanmış değişkenler
gibi işlem görür. Yani fonksiyonların parameyre değişkenleri o fonksiyonda tanınabilmektedir. Aynı faaliyet
alanına sahip aynı isimli değişken tanımlanamayacağına göre aşağıdaki bildirim de geçerli değildir:
void foo(int a, int b)
{
long a;
/* geçerli değil! */
...
}
Fakat:
void foo(int a, int b)
{
...
{
long a;
// geçerli */
...
}
...
}
Bir fonksiyon parametreleriyle aldığı değere işlemler uygulayıp sonucu geri dönüş değeri olarak verebilir. Örneğin:
#include <stdio.h>
int add(int a, int b)
{
return a + b;
}
int mul(int a, int b)
{
return a * b;
}
int main()
{
int result;
result = add(10, 20);
printf("%d\n", result);
result = mul(10, 20);
printf("%d\n", result);
return 0;
}

Bazı Matematiksel Standart C Fonksiyonları
C'de temel bazı matemetik işlemleri yapan çeşitli standart C fonksiyonları vardır. Bu fonksiyonları kullanırken
<math.h> dosyası include edilmelidir.
29

- sqrt fonksiyonu double bir parametreye sahiptir, parametresi ile aldığı değerin karekökünü geri dönüş değeri
olarak verir.
double sqrt(double val);
Örneğin:
#include <stdio.h>
#include <math.h>
int main()
{
double val;
double result;
printf("Lutfen bir sayi giriniz:");
scanf("%lf", &val);
result = sqrt(val);
printf("%f\n", result);
return 0;
}

pow fonksiyonu üs almak için kullanılır. Parametrik yapısı şöyledir:
double pow(double base, double e);
Bu fonksiyon birinci parametresiyle belirtilen değerin ikinci parametresiyle belirtilen kuvvetini alır ve onu geri
dönüş değeri olarak verir. Örneğin:
#include <stdio.h>
#include <math.h>
int main()
{
double result;
result = pow(3, 4);
printf("%f\n", result);
return 0;
}

log fonksiyonu e tabanına göre log10 fonksiyonu 10 tabanına göre logaritma alır:
double log(double val);
double log10(double val);
Örneğin:
#include <stdio.h>
#include <math.h>
int main()
{
double result;

30

result = log10(1000);
printf("%f\n", result);
return 0;
}

sin, cos, asin, acos, tan, atan fonksiyonları trigonometrik işlemleri yapar. Bu fonksiyonlardaki açılar radyan
cinsinden girilmelidir. Örneğin:
#include <stdio.h>
#include <math.h>
int main()
{
double result;
result = sin(3.141592653589793238462643 / 6);
printf("%f\n", result);
result = cos(3.141592653589793238462643 / 3);
printf("%f\n", result);
result = sin(3.141592653589793238462643 / 4) / cos(3.141592653589793238462643 / 4);
printf("%f\n", result);
result = tan(3.141592653589793238462643 / 2);
printf("%f\n", result);
result = tan(3.141592653589793238462643 / 4);
printf("%f\n", result);
return 0;
}

exp fonksiyonu e üzeri işlemi yapmaktadır.
Sabitler (Literals)
Program içerisinde doğrudan yazılan sayılara sabit denir. C'de yalnızca nesnelerin değil, aynı zamanda sabitlerin de
türü vardır. Sabitin türü onun niceliğiyle ve sonuna getirilen eklerle ilgilidir. Kurallar şöyledir:
1) Sayı nokta içermiyorsa ve sayının sonunda hiçbir ek yoksa sabit int, long ve unsigned long türlerinin hangisinin
sınırları içerisinde ilk kez kalıyorsa o türdendir. Örneğin:
0 ---> int
100 ---> int
long türünün 8 byte int türünün 4 byte olduğunu varsayalım:
123 ---> int
3000000000 ---> long
Eğer sayı 16'lık ya da 8'lik sistemde belirtilmişse sabit int, unsigned int, long ve unsigned long türlerinin hangisinin
sınırları içerisinde ilk kez kalıyorsa sabit o türdendir.
2) Sayı nokta içermiyorsa ve sayının sonuna küçük harf ya da büyük harf L getirilmişse sabit long ve unsigned
long türlerinin hangisinin sınırları içerisinde ilk kez giriyorsa o türdendir. Örneğin:
31

100L ---> long
0L ---> long
3) Sayı nokta içermiyorsa ve sayının sonunda küçük harf ya da büyük harf U varsa sabit unsigned int ve unsigned
long türlerinin hangisinin sınırları içerisinde ilk kez kalıyorsa o türdendir. Örneğin:
123U ---> unsigned int
1000u ---> unsigned int
4) Sayı nokta içermiyorsa ve sayının sonunda küçük harf ya da büyük harf UL ya da LU varsa (UL, Ul, uL, LU, Lu,
ul, lu) sabit unsigned long türündendir.
100ul ---> unsigned long
1LU ---> unsigned long
5) Sayı nokta içeriyorsa ve sayının sonında hiçbir ek yoksa sabit double türdendir. Örneğin:
123.65 ---> double
0.5 ---> double
Pek çok programlama dilinde olduğu gibi C'de de noktanın solunda ya da sağında birşey yoksa sıfır olduğu
varsayılır. Örneğin:
.10 ---> double
10 ---> int
10. ---> double
6) Sayı nokta içeriyorsa ve sayının sonunda küçük harf ya da büyük harf F varsa sabit float türdendir. Örneğin:
12.34F ---> float
10F ---> geçersiz
10.f ---> float
7) Sayı nokta içeriyorsa ve sonunda küçük harf ya da büyük harf L varsa sabit long double türdendir. Örneğin:
100.23L ---> long double
10.l ---> long double
.10L ---> long double
10L ---> long
8) Tek tırnak içerisine bri karakter yerleştirilirse bu bir sayı belirtir. O karakterin karakter tablosundaki sıra
numarasını belirtir. (Örneğin tipik olarak ASCII.) Örneğin 'a' bir sabit belirtir. Yani aslında 'a' bir sayıdır. ASCII
tablosu kullanılıyorsa 97 anlamındadır. Örneğin:
x = 'A' + 1;
Burada x'e 66 atanmaktadır. 66 da 'B' nin ASCII kodudur.
Anahtar Notlar: ASCII tablosunda önce büyük hrfler, sonra küçük harfler gelir. Büyük harflerle küçük harfler arasında 6 farklı karakter
vardır. Bu özellikle 'a' - 'A' farkının 32 etmesi için düşünülmüştür.
Anahtar Notlar: UNICODE tablonun ilk 128 elemanı standart ASCII tablosusun aynısıdır. ikinci 128'lik elemanı ASCII Latin-1 code
page'i ile aynıdır.

32

C'de tek tırnak içerisine int türünün byte uzunluğu kadar karakter yazılabilir (Örneğin şu andaki yaygın sistemlerde
int türü 4 byte uzunluğundadır. Bu nedenle tek tırnak içerisine 4 karakter yazılabilir.) Tek tırnak içerisine bir'den
fazla karakter yazılırsa bunun hangi sayı anlamına geleceği derleyicileri yazanların isteğine bırakılmıştır. Yani C'de
örneğin 'ab' ifadesi geçerlidir. Fakat bunun hangi sayıyı belirttiği derleyiciden derleyiciye değişebilir. Genellikle
tek tırnak içerisinde tek bir karakter yerleştiririz.
C'de tek tırnak içerisine yerleştirilen sabitler int türdendir (halbuki C++'ta char türdendir.)
Karakter tablolarındaki tüm karakterler görüntülenebilir değildir. Bu tür görüntülenemeyen karakterleri (nonprintable characters) ekrana basmak istediğimzde ekranda birşey göremeyiz. Bazı olaylar gerçekleşir. Tek tırnak
içerisinde önce bir ters bölü ve sonra özel bazı karakterler bazı görüntülenemeyen özel karakterleri belirtir.
Bunların listesi şöyledir:
Karakter

Anlamı

'\a'

Alert (ekrana gönderildiğinde beep sesi çıkar)

'\b'

Back Space (ekrana gönderildiğinde sanki geri tuşuna basılmış gibi imleç bir
geriye gider)

'\f'

Form Feed (bu karakter yazıcıya gönderildiğinde bir sayfa atar)

'\n'

New Line (ekrana gönderildiğinde imleç aşağı satırın başına geçer)

'\r'

Carriage Return (ekrana göndeildiğinde imleç aynı satırın başına geçer)

'\t'

Tab (ekrana gönderildiğinde imleç bir tab atar)

'\v'

Vertical Tab (ekrana gönderildiğinde düşey zıplama yapar)

Bu ters bölü karakterleri iki tırnak içerisinde tek bir karakter belirtirler. Örneğin:
printf("ali\tveli\nselami\tayse\n");

Ters bölü karakterinin kendisi '\\' ile belirtilir. '\' ifadesi geçersizdir. Örneğin:
#include <stdio.h>
int main()
{
printf("c:\temp\a.dat\n");
printf("c:\\temp\\a.dat\n");
return 0;
}

Tek tırnak karakterinin karakter sabiti ''' biçiminde yazılamaz. '\'' biçiminde belirtilir. Fakat çift tırnak içerisinde tek
tırnak soruna yol açmaz. Örneğin:
#include <stdio.h>
int main()
{
char ch = '\'';
printf("%c\n", ch);
printf("Turkiye'nin baskenti Ankara'dir\n");
/* geçerli */
printf("Turkiye\'nin baskenti Ankara\'dir\n"); /* geçerli */

33

return 0;
}

İki tırnak karakterine ilişkin karakter sabiti '\”' ile belirtilir. Fakat tek tırnak içerisinde iki tırnak soruna yol açmaz.
Ancak iki tırnak içerisinde iki tırnak soruna yol açar. Örneğin:
#include <stdio.h>
int main()
{
char ch1 = '\"';
char ch2 = '"';

/* geçerli */
/* geçerli */

printf("%c, %c\n", ch1, ch2);
printf("\"Ankara\"\n"); /* geçerli */
return 0;
}

Karakter sabitleri tek tırnak içerisinde önce bir ters bölü sonra oktal digit'ler belirtilerek de yazılabilir. Örneğin '\7'
karakteri '\a' karakteri ile ASCII tablosunda aynı değer sahiptir. Örneğin:
#include <stdio.h>
int main()
{
char ch = '\11';
printf("Ankara%cIzmir\n", ch);
return 0;
}

Karaktre sabitleri tek tırnak içerisinde önce bir ters bölü sonra küçük harf bir x sonra da hex digit'ler belirtilerek de
yazılabilir. Örneğin '\x1B' gibi. Örneğin:
#include <stdio.h>
int main()
{
printf("Ankara\x9Izmir\n");
return 0;
}

İki tırnak içerisinde oktal ve hex sistemde karakterleri yazarken dikkat etmek gerekir. Çünkü derleyici anlamlı en
uzun karakter kümesinden ters bölü karakterlerini oluşturur. Yani örneğin “6Ankara\x91Adana” stringinde ters
bölü karakteri '\x9' biçiminde değil '\x91A' biçiminde ele alınır. Fakat “6Ankara\x9\x31\x41\x64\x61na\n"
istediğimizi yapabilir.
9) C'de short, unsigned short, char, signed char ve unsigned char türünden karakter sabitleri yoktur. Örneğin:
#include <stdio.h>
int main()
{
printf("6Ankara\x9\x31\x41\x64\x61na\n");

34

return 0;
}
Anahtar Notlar: C'de tek tırnak içerisinde yazılan sabitlere karakter sabitleri denir fakat bunlar int türdendir. Yani örneğin C'de 'a' bir
karakter sabitidir fakat int türdendir. Oysa C++'ta tek tırnak içerisindeki karakterler (eğer tek tırnak içerisinde tek karakter varsa) char
türdendir.

Tamsayıların 10'luk, 8'lik ve 16'lık Sistemde Belirtilmesi
C'de bir sayı yazdığımızda onu default olarak 10'luk sistemde yazdığımız anlaşılır. eğer sayıyı 0x ya da 0X ile
başlatarak yazarsak sayının 16'lık sistemde yazılmış olduğukabul edilir. Örneğin:
int a, b;
a = 100;
b = 0x64;
Eğer sayıyı başına 0 getirerek yazarsak 8'lik sistem anlaşılır. Örneğin:
a = 0144;
Sabitin kaçlık sistemde yazıldığının sabit türüyle bir ilgisi yoktur. Örneğin 0x64 sabiti yine int türden 0x64L sabiti
long türdendir. Ayrıca C90'da float, double ve long double türleri 16'lık ve 8'lik sistemde belirtilemezler. Ancak
C99'da 16'lık sistemde belirtilebilirler.
Gerçek Sayıların Üstel Biçimde Belirtilmesi
float, double ve long double türden sabitler üstel biçimde yazılabilirler. Üstel biçimin genel biçimi şöyledir:
<noktalı ya da noktasız sayı><e ya da E>[±]<üs>;
Örneğin 1e20, 1.2e-50, -2.3e+15 gibi...
Sayıyı üstel biçimde belirtmişsek sayı sonuna ek almamışsa double türdendir. Örneği 1E20 sabiti double türdendir.
Ancak 1E20F float, 1E20L long double türdendir.
Üsetel biçim özellikle çok büyük ve çok küçük sayıları ifad etmek için kullanılır.
C90'da ve C99'da ikilik sistemde sayılar belirtilememektedir.
Operatörler
Bir işleme yol açan ve işlem sonucunda bir değer üretimesini sağlayan atomlara operatör denir. Operatörlerin
teknik olarak tanımlamak için onları sınıflandıracağız. Operatörler üç biçimde sınıflandırılabilir:
1) İşlevlerine Göre Sınıflandırma
2) Operand Sayılarına Göre
3) Operatörün Konumuna Göre
1) İşlevlerine Göre Sınıflandırma: Bu sınıflandırma operatörün hangi tür işlem yaptığına yönelik bir
sınıflandırmadır. Tipik olarak operatör şu sınıflardan birine ilişkin olabilir:
- Aritmetik Operatörler (Arithmetic Operators): Bunlar +, -, * ve / gibi dört işleme yönelik operatörlerdir.
35

- Karşılaştırma Operatörleri (Comparision / Relational Operators): Bunlar karşılaştırma için kullanılan
operatörledir. Örneğin >, <, >=, <= gibi.
- Mantıksal Operatörler (Logical Operators): Bunlar AND, OR, NOT gibi mantıksal işlem yapan operatörlerdir.
- Bit Operatörleri (Bitwise Operators): Bunlar sayıların karşılıklı bitleri üzerinde işlem yapan operatörlerdir.
- Adres Operatörleri (Pointer Operators): Bunlar adres işlemi yapan operatörlerdir.
Özel Amaçlı Operatörler (Special Purpose Operators): Bunlar çeşitli konulara ilişkin özel işlem yapan
operatörlerdir.
2) Operand Sayılarına Göre Sınıflandırma: Operatörün işleme soktuğu ifadelere operand denilmektedir.
Örneğin a + b ifadesinde + operatördür, a ve b bunun operandlarıdır. Operatörler tek operand, iki operand ve üç
operand alabilir. Tek operand alan operatörlere İngilizce “unary”, iki operand alan operatörlere “binary” ve üç
operand alan operatörler “ternary” operatör denilmektedir. Örneğin ! tek operandlı (unary bir operatördür ve !a
biçiminde kullanılır. / iki operandlı bir operatördür.
3) Operatörün Konumuna Göre Sınıflandırma: Operatör operandlarının önünde, sonunda ya da arasında
bulunabilir. Opeandlarının önüne getirilerek kullanılan operatörlere “önek (prefix) operatörler, arasına getirilerek
kullanılan operatörlere “araek (infix) operatörler” ve operandlarının sonuna getirilerek kullanılan operatörlere
“sonek (postfix)” operatörler denilmektedir.
Bir operatörü teknik olarak tanımlayabilmek için öncelikle yukarıdaki üç sınıflandırma biçiminde de nereye
düştüğünün belirtilmesi gerekir. Örneğin “! operatörü tek operandlı önek (unary prefix) mantıksal operatördür” gibi.
Ya da “/ operatörü iki operandlı araek (binry indfix) aritmetik operatördür” gibi...
Operatörler Arasındaki Öncelik İlişkisi
Bir ifadedeki operatörler belli bir sırada seri olarak yapılır. Örneğin:
a = b + c * d;
İ1: c * d
İ2: b + İ1
İ3: a = İ2
Derleyiciler ifadedeki işlemi yapacak makine komutlarını seri olarak üretirler. Run time sırasında işlemci onları
sırasıyla çalıştırır.
Operatörler arasındaki öncelik ilişkisi “Operatörlerin Öncelik Tablosu” denilen bir tabloyla betimlenmektedir.
Operatörlerin Öncelik Tablosunun basit bir biçimi aşağıdaki gibidir:
()

Soldan-Sağa

* /

Soldan-Sağa

+ -

Soldan-Sağa

=

Sağdan-Sola

Tablo satırlardan oluşur. Üst satırdaki operatörler alt satırdaki operatörlerden daha yüksek önceliklidir. Aynı
satırdaki operatörler eşit önceliklidir. Aynı satırdaki operatörler “Soldan-Sağa” ya da “Sağdan-Sola” eşit öncelikli
36

olabilirler. “Soldan-Sağa” öncelik demek, ifade içerisinde “o satırda solda olan önce yapılır” demektir. “SağdanSola” ise “ifade içerisinde o satırda sağda olan önce yapılır” demektir.
Tablonun en yüksek öncelik grubunda fonksiyon çağırma operatörü ve öncelik parantezi vardır. Örneğin:
result = foo() + bar() * 2;
İ1: foo()
İ2: bar()
İ3: İ2 * 2
İ4: İ1 + İ3
İ5: result = İ4
Parantezler öncelik kazandırmak için kullanılabilirler. Örneğin:
a = (b + c) * d;
İ1: b + c
İ2: İ1 * d
İ3 = a = İ2
*, /, + ve - Operatörleri
Bu operatörler iki operandlı araek (binary infix) aritmetik operatörlerdir. Temel dört işlemi yaparlar.
% Operatörü
İki operandlı araek aritmetik operatördür. Bu operatör soldaki oprandın sağdaki operanda bölümünden elde edilen
kalan değerini verir. Öncelik tablosunda * ve / ile aynı gruptadır.
()

Soldan-Sağa

* /%

Soldan-Sağa

+ -

Soldan-Sağa

=

Sağdan-Sola

Örneğin:
#include <stdio.h>
int main()
{
int result;
result = 10 % 4 - 1;
printf("%d\n", result);
return 0;
}

% operatörünün her iki operandının da tamsayı türlerine ilişkin olması zorunludur. Örneğin 15.2 % 2 ifadesi geçerli
değildir. Negatif sayının prozitif sayıya bölümünden elde edilen kalan negatiftir. (Örneğin -10 % 4 ifadesi -2
sonucunu verir).
37

İşaret - ve İşaret + Operatörleri
+ ve - sembolleri hem toplama ve çıkarma operatörleri için hem de işret - ve işaret + işlemleri için kullanılmaktadır.
Aynı sembollere sahip olsalar da bu operatörlerin birbirleriyle hiçbir ilgisi yoktur. Örneğin:
a = -3 - 5;
Burada soldaki - işaret eksi operatörü, sağdaki ise çıkartma operatörüdür. İşaret + ve işaret - operatörleri tek
operandlı önek aritmetik operatörlerdir. Öncelik tablosunun ikinci düzeyinde Sağdan-Sola grupta bulunurlar.
()

Soldan-Sağa

+ -

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

=

Sağdan-Sola

Örneğin:
a = -3 - 5;
İ1:-3
İ2: İ1 - 5
İ3: a = İ2
Örneğin:
a = - - b + 2;
İ1: -b
İ2: -İ1
İ3: İ2 + 2
İ4: a = İ3
İşaret - operatörü operandının negatif değerini üretir. İşaret + operatörü ise operandıyla aynı değeri üretir. (Yani
aslında birşey yapmaz.). Örneğin:
#include <stdio.h>
int main()
{
int result;
result = - - - - - - - - - - - - - - - -3 - 5;
printf("%d\n", result);
return 0;
}

Tanımsız, Belirsiz ve Derleyiciye Bağlı Davranışlar
C standartlarında bazı kodların tanımsız davranışa yol açacağı (undefined behavior) belirtilmiştir. Tanımsız
davranışa yol açan kodlamalar derleme aşamasında bir soruna yol açmazlar. Ancak programın çalışma zamanı
38

sırasında programın çökmesine, yanlış çalışmasına yol açabilirler. Bazen tanımsız davranışa yol açan kodlar hiçbir
soruna yol amayabilirler. Programcının böylesi farkında olması ve bunlardan uzak durması gerekir.
Yine standartlarda bazı durumlar için belirsiz davranışın (unspecified behavior) oluşacağı söylenmiştir. Belirsiz
davranışa yol açan kodlarda birkaç seçenek vardır. Derleyici yazanlar bu seçenklerden birini tercih etmiş
durumdadırlar. Ancak hangi seçeneği tercih ettiklerini belirtmek zorunda değillerdir. Derleyici hangi seçeneği
seçmiş olursa olsun bu kodun çökmesine yol açmaz. Ancak belirsiz davranışa yol açan kodlar taşınabilirliği
bozarlar. Yani bu programlar başka sistemlerde derlendiğinde farklı sonuçlar elde edilebilir. En iyisi belirsiz
davranış sonucunda farklı sonuçların oluşacağı tarzda kodlardan kaçınmaktadır.
Standartlarda bazı durumlardaki belirlemeler derleyiciyi yazanların isteğine bırakılmıştır (implementation defined
behavior). Fakat derleyici yazanlar bunu referans kitaplarında açıkça belirtmek zorundadır.
Örneğin tahsis edi,lmemiş bir alan erişilmesi tanımsız davranışa yol açan bir işlemdir. C'de fonksiyon
çağrıldığındanda parametre aktarımının soldan sağa mı ya da sağdan sola mı yapılacağı belirsiz davranışa sahiptir.
Büyük tamsayı türünden işaretli küçük tamsayı türüne dönüştürme yapıldığında bilgi kaybının nasıl olacağı
derleyiciyi yazanların isteğine bırakılmıştır.
++ ve -- Operatörleri
Bu operatörler tek operandlı önek ve sonek kullanılabilen operatörlerdir. Yani ++a ya da a++ biçiminde
kullanılabilirler. ++ operatörüne artırma (increment), -- operatörüne eksiltme (decrement) operatörü denilmektedir.
++ operatörü “operand içerisindeki değeri 1 artır”, -- operatörü “operand içerisindeki değeri 1 esksilt” anlamına
gelir. Örneğin:
#include <stdio.h>
int main()
{
int a;
a = 3;
++a;
printf("%d\n", a);

/* 4 */

a = 3;
--a;
printf("%d\n", a);

/* 2 */

return 0;
}

++ ve -- operatörleri öncelik tablosunun ikinci düzeyinde sağdan sola grupta bulunurlar.
()

Soldan-Sağa

+ - ++ --

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

=

Sağdan-Sola

Bu operatörlerin önek ve sonek kullanımları arasında farklılık vardır. Her iki kullanımda da artırma ya da eksiltme
tablodaki öncelikle yapılır. Önek kullanımda sonraki işleme nesnenin artırılmış ya da eksiltilmiş değeri sokulurken,
sonek kullanımda artırılmamış ya da eksiltilmemiş değeri sokulur. Örneğin:
39

#include <stdio.h>
int main()
{
int a, b;
a = 3;
b = ++a * 2;
printf("a = %d, b = %d\n", a, b);

/* a = 4, b = 8 */

a = 3;
b = a++ * 2;
printf("a = %d, b = %d\n", a, b);

/* a = 4, b = 6 */

return 0;
}

Örneğin:
#include <stdio.h>
int main()
{
int a, b;
a = 3;
b = ++a;
printf("a = %d, b = %d\n", a, b);

/* a = 4, b = 4 */

a = 3;
b = a++;
printf("a = %d, b = %d\n", a, b);

/* a = 4, b = 3 */

return 0;
}

Örneğin:
#include <stdio.h>
int main()
{
int a, b, c;
a = 3;
b = 2;
c = ++a * b--;
printf("a = %d, b = %d, c = %d\n", a, b, c); /* a = 4, b = 1, c = 8 */
return 0;
}

Şüphesiz bu operatörler tek başlarına başka bir operatör olmaksızın kullanılıyorsa, bunların önek ve sonek
biçimleri arasında bir fark oluşmaz. Yani örneğin:
++a;
ile
40

a++;
arasında bir fark oluşmaz.
C'de bir nesne bir ifadede ++ ya da -- operatörüyle kullanılmışsa artık aynı ifadede bir daha o nesnenin
görülmemesi gerekir. Aksi halde tanımsız davranış oluşur. Örneğin aşağıdaki gibi ifadeleri kullanmamalıyız.
Burada ne olacağı belli değildir:
b = ++a + a;
b = ++a + ++a;
b = ++b;
b = a + a++;
++ ve -- operatörlerinin operandlarının nesne belirtmesi gerekir. Örneğin:
++3;

ifadesi geçerli değildir. Ya da örneğin:
b = ++(a - 2);

iafdesi de geçersizdir. Çünkü a - 2 bir nesne belirtmemektedir.
Bu operatörlerden elde edilen ürün nesne belirtmez. Örneğin:
b = ++a--;

gibi bir ifade geçersizdir. Burada a--'den elde edilen ürün nesne belirtmez.
Karşılaştırma Operatörleri
C'de 6 karşılaştırma operatörü vardır:
<, >, <=, >=
==, !=
Bu operatörlerin hepsi iki operandlı araek (binary infix) operatörlerdir. Öncelik tablosunda karşılaştırma
operatörleri aritmetik operatörlerden daha düşük önceliklidir:
()

Soldan-Sağa

+ - ++ --

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

< > <= >=

Soldan-Sağa

== !=

Soldan-Sağa

=

Sağdan-Sola

Bu operatörler önerme doğruysa 1 değerini, yanlışsa 0 değerini üretirler. Bu operatörlerin ürettiği bu değerler int
türdendir ve istenirse başka işlemlere sokulabilirler. Örneğin:
41

#include <stdio.h>
int main()
{
int a = 3, b;
b = (a > 2) + 1;
printf("%d\n", b);

/* 2 */

return 0;
}

Karşılaştırma operatörleri kendi aralarında iki öncelik grubunda bulunmaktadır. Örneğin:
result = a == b > c;
İ1: b > c
İ2: a == İ1
İ3: result = İ2

Örneğin:
#include <stdio.h>
int main()
{
int a = 3, b;
b = a++ == 3;
printf("a = %d, b = %d\n", a, b);
return 0;
}

Örneğin:
#include <stdio.h>
int main()
{
int a = 20, b;
b = 0 < a < 10;
/* dikkat bu ifade a'nın 0 ile 10 arasında olduğuna bakamaz */
printf("a = %d, b = %d\n", a, b);
return 0;
}

Mantıksal Operatörler
C'de üç mantıksal operatör vardır:
! (NOT)
&& (AND)
|| (OR)
! operatörü öncelik tablosunun ikinci düzeyinde Sağdan-Sola grupta bulunur. && ve || operatörleri karşılaştırma
operatörlerinden daha düşük önceliklidir:
42

()

Soldan-Sağa

+ - ++ -- !

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

< > <= >=

Soldan-Sağa

== !=

Soldan-Sağa

&&

Soldan-Sağa

||

Soldan-Sağa

=

Sağdan-Sola

Anahtar Notlar: C'nin tüm tek operandlı (unary) operatörleri öncelik tablosunun ikinci düzeyinde Sağdan-Sola grupta bulunmaktadır.

! operatörü tek operandlı önek, && ve || operatörleri iki operandlı araek operatörlerdir.
AND, OR ve NOT işlemleri operand olarak Doğru, Yanlış Değerlerini alır. Bu mantıksal işlemler aşağıdaki gibi
etki gösterirler:
A

B

A AND B A OR B

Doğru

Doğru

Doğru

Doğru

Doğru

Yanlış

Yanlış

Doğru

Yanlış

Doğru

Yanlış

Doğru

Yanlış

Yanlış

Yanlış

Yanlış

A

NOT A

Doğru

Yanlış

Yanlış

Doğru

C'de bool türü yoktur. Peki Doğru ve Yanlış'lar nasıl ifade edilmektedir?
İşte !, && ve || operatörleri önce operandlarını Doğru ya da Yanlış olarak yorumlarlar. Sıfır dışı değerler (tamsayı
da gerçek sayı türünden) C'de Doğru olarak, sıfır değeri Yanlış olarak ele alınır. Bu operatörler yine Doğru sonuç
için 1 değerini, yanlış sonuç için 0 değerini üretirler. Örneğin:
-2.3 && 10.2
0 || 10
10.2 && 0
0.2 && 0.2

=> 1
=> 1
=> 0
=> 1

Tabi genellikle mantıksal operatörler doğrudan sayısal değerlerle değil, karşılaştırma operatörlerinin çıktıklarıyla
işleme sokulurlar. Örneğin:
result = a > 10 && a < 20;
Burada iki koşul da doğruysa && operatörü 1 değerini üretecektir. Aksi halde 0 değeri üretilecektir. Örneğin:
43

#include <stdio.h>
int main()
{
int a;
int result;
printf("a:");
scanf("%d", &a);
result = a > 10 && a < 20;
printf("%d\n", result);
return 0;
}
Anahtar Notlar: Microsoft'un C derleyicileri belirli bir versiyondan sonra bazı standart C fonksiyonları için “Unsafe” uyarısı vermektedir.
Üstelik de proje yaratılırkenm SDL Check disable edilmemişse bu uyarı error'e dönüştürülmektedir. Bu “Unsafe” uyarıları ne anlama gelir?
Kısaca bu uyarılarda “bu fonksiyonlar esasen standart C fonksiyonlarıdır fakat tasarımlarında küçük birtakım kusurlar vardır”. Evet her ne
kadar Microsoft bunda haklıysa da yine de bu fonksiyon çağırılarını Uyarı olarak değerlendirmesi hoş değildir. Eğer programcı bu uyarı
mesajlarından kurtulmak istiyorsa iki yol deniyebilir. Birincisi Proje ayarlarından C/C++/Preprocessor kısmına gelip “Preprocesssor
Definitions” listesine _CRT_SECURE_NO_WARNINGS makrosunu eklemektir. İkincisi de Proje ayarlarından C/C++/General tabına
gelip Uyarı “düzeylerini (Warning Level)” 2'ye çekmektir.
Anahtar Notlar: Eğer proje yaratılırken yanlışlıkla SDL Check çarpısı kaldırılmamışsa bu işlem sonradan da yapılabilir. Bunun için proje
ayarlarına gelinir. C/C++/General tabından “SDL Checks” disable edilir.
Anahtar Notlar: Linux ortamında C ile program geliştirmek için hiç IDE kullanılmayabilir. Program iyi bir Editör'de (Örneğin Kate)
yazılıp, komut satırında aşağıdaki gibi derlenebilir:
gcc -o sample sample.c
Şöyle çalıştırılabilir:
./sample
IDE olarak Linux sistemlerinde şu seçenler dikkate değerdir:
- MonoDevelop (Mono-core ve MonoDevlop paketleri kurulmalı)
- QtCreator
- Eclipse (C/C++ için)
- Netbeans (C/C++ için)
MonoDevelop çalışma biçimi olarak Visual Studio'ya en fazla benzeyen IDE'dir ve kullanımı çok basittir.
Anahtar Notlar: UNIX/Linux sistemlerinde komut satırı çalışması hala en yaygın çalışma biçimidir. Çünkü bu sistemler ağırlıklı olarak
server amaçlı kullanılmaktadır (Server kullanım oranı %60-70 civarı, Client kullanım oranı %1-%2 civarındadır.) Linux komutlarının belli
bir düzeyde öğrenilmesi tavsiye edilir. Bunun için pek çok kitap vardır.

Kısa devre özelliği “eğer işlemler hiç bu özellik olmadan yapılsaydı” ile aynı sonucu oluşturur. Yani kısa devre
özelliği aslında öncelik tablosunda belirtilen sırada işlemlerin yapılması durumunda elde edilecek olan değerin
daha hızlı elde edilmesini sağlar.
&& ve || operatörleri aynı ifade içerisinde bulunuyorsa her zaman sol taraftaki operatörün sol tarafı önce yapılır.
Duruma göre diğer taraflar yapılmaktadır. Örneğin:
result = foo() || bar() && tar();

Burada önce foo yapılır. foo sıfır dışı ise başka hiçbir şey yapılmaz ve sonuç 1 olarak elde edilir. Eğer foo sıfır ise
44

bu durumda bar yapılır. bar da sıfır ise tar yapılmaz. Örneğin:
result = foo() && bar() || tar();

Burada önce foo yapılır. foo sıfır ise bar yapılmaz fakat tar yapılır. foo sıfır dışı ise bar yapılır. bar da sıfır dışı ise
tar yapılmaz.
Atama Operatörü
Atama operatörü iki operandlı araek özel amaçlı bir operatördür. Bu operatör sağdaki ifadenin değerini soldaki
nesneye yerleştirir. Atama operatörü de bir değer üretmektedir. Eğer atama operatörü ifadenin son operatörü
değilse ondan elde edilen değeri diğer operatörlere sokabiliriz. Atama operatörü sol taraftaki nesneye atanmış olan
değeri üretir. Atama operatörünün öncelik tablousunda Sağdan-Sola grupta bulunduğuna dikkat ediniz. Örneğin:
a = b = 10;
İ1: b = 10 => 10
İ2: a = İ1 => 10
Örneğin:
a = (b = 10) + 20;
İ1: b = 10
İ2: İ1 + 20
İ3: a = İ2
Atama operatörünün sol tarafındaki operand nesne belirtmek zorudadır (yani LValue olmak zorundadır). Örneğin:
a + b = c;
10 = 20;

/* geçersiz! */
/* geçersiz! */

Aşağıdaki gibi bir ifade de geçerlidir:
foo(a = 10);
Burada önce a = 10 ifadesinin değeri hesaplanır, sonra bu değer foo fonksiyonunun parametre değişkenine atanır.
İşlemli Atama Operatörleri (Compound Assignment Operators)
C'de bir grup +=, -=, *=, /=, %=, .... gibi işlemli atama operatörü vardır. a <op>= b ifadesi ile a = a <op> b ifadesi
tamamen eşdeğerdir. Örneğin:
a += 2;
a *= 3;

/* a = a + 2; */
/* a = a * 3; */

İşlemli atama operataörlerinin hepsi öncelik tablosunda atama operatörüyle Sağdan-Sola aynı öncelik grubunda
bulunmaktadır:
()

Soldan-Sağa

+ - ++ -- !

Sağdan-Sola

* /%

Soldan-Sağa
45

+ -

Soldan-Sağa

< > <= >=

Soldan-Sağa

== !=

Soldan-Sağa

&&

Soldan-Sağa

||

Soldan-Sağa

= += -= *= /= %=, ... Sağdan-Sola
Örneğin:
a *= 2 + 3;
İ1: 2 + 3;
İ2: a *= İ1;

Virgül Operatörü
Virgül atomu aynı zamanda iki operandlı araek bir operatör belirtir. Virgül operatörü iki farklı ifadeyi tek ifade gibi
ifade etmek için kullanılır. Örneğin:
a = 10, b = 20 tek bir ifadedir. Çünkü virgül de bir operatördür. Virgül operatörü özel bir operatördür. Klasik
öncelik tablosu kuralına uymaz. Ancak öncelik tablosunda tablonun sonuna yerleştirilmiştir:
()

Soldan-Sağa

+ - ++ -- !

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

< > <= >=

Soldan-Sağa

== !=

Soldan-Sağa

&&

Soldan-Sağa

||

Soldan-Sağa

= += -= *= /= %=, ... Sağdan-Sola
,

Soldan-Sağa

Virgül operatörünün sağında ne olursa olsun önce onun sol tarafındaki ifade tamamen yapılıp bitirilir. Sonra
sağındaki ifade tamamen yapılı bitirilir. Virgül operatörü de bir değer üretir. Virgül operatörünün ürettiği değer sağ
tafındaki ifadenin değeridir. Virgülün solundaki ifadenin değer üretmekte bir etkisi yoktır. Örneğin:
a = (b = 10, 20 + 30);

Burada parantezler olmasaydı virgül operatörünün sol tarafındaki operand a = b = 10 ifadesi olacaktı. Parantezler
virgül operatörünü diğer operatörlerden ayrıştırmaktadır. Burada önce parantez içi yapılır. Parantez içerisinde
virgül operatörü vardır. Onun da önce sol tarafı sonra sağ tarafı yapılır. Virgül operatörünün hepsinden elde edilen
değer sağ tarafındaki ifadenin değeridir. Yani yukarıdaki örnekte a'ya 50 atanacaktır.
Bir'den fazla virgül operatörü de kombine edilebilir. Örneğin:
x = (foo(), bar(), tar());

46

İ1: foo(), bar()
İ2: İ1, tar()
İ3: x = İ2

Her virgülü de virgül operatörü sanmamak gerekir. Örneğin:
int a, b, c;
Buradaki virgüller ayıraç görevindedir. Örneğin:
foo(a, b);
Buradaki virgül de argüman ayıracı görevindedir. Ancak ekstra bir parantez virgülü operatör durumuna sokar.
Örneğin:
foo((a, b), c);
Burada fonksiyonun iki parametre değişkeni vardır. Birinci parametre değişkenine b, ikincisine c kopyalanır.
Noktalı Virgülün İşlevi
Noktalı virgül ifadeleri birbirlerinden ayırarak onların bağımsız bir biçimde ele alınmasını sağlar. Örneğin:
a = 10 + 20;
b = 30 + 40;
Burada a = 10 + 20 ile b = 30 + 40'ın bir ilişkisi yontur. Bunlar iki ayrı ifade belirtirler. İfadeleri ayırmak için
kullanılan bu tür atomlara sonlandırıcı (terminator) denilmektedir. Eğer noktalı virgül unutulursa derleyici önceki
ifadeyle sonraki ifadeyi tek bir bağımsız ifade olarak ele alır o da sentaks bakımından soruna yol açar. Örneğin:
a = 10 + 20
b = 30 + 40;

/* noktalı virgül unutulmuş */

Burada derleyiciye göre tek bir ifade vardır o da anlamsızdır.
Bazı dillerde sonlandırıcı olarak : bazılarında da \n kullanılabilmektedir. Örneğin BASIC'te aslında \n karakteri
(ENTER tuşuna basılınca elde edilen karakter) sonlandırıcı görevindedir. Tabibudurumda her satıra tek bir ifade
yazılmak zorundadır.
Deyimler (Statements)
Bir programdaki çalıştırma birimlerine deyim denir. Imperative dillerin teorisinde program deyimlerin çalışmasıyla
çalışır. Deyim deyimi içerebilir. Deyimler 5 gruba ayrılmaktadır:
1) Basit Deyimler (Simple Statements): Bir ifadenin sonuna ; getirilirse artık o atom grubu bir deyim olur. Bu tür
deyimlere basit deyimler denir. Yani basit deyimler “ifade;” biçimindeki deyimlerdir. Örneğin:
x = 10;
foo();
birer basit deyimdir. Görüldüğü gibi ifade kavramı noktalı birgülü içermemektedir. İfadenin sonuna noktalı virgül
konulunca o deyim olur.
47

2) Bileşik Deyimler (Compund Statements): C'de bir bloğun içerisine sıfır tane ya da daha fazla deyim
yerleştirilirse o bloğun tamamı da bir deyim olur. Bunlara bileşik deyim denilmektedir. Bileşik deyimi diğer
deyimleri içeren deyimler gibi (yani büyük kutu gibi) düşünebiliriz. Örneğin:
ifade1;
{
ifade2;
{
ifade3;
ifade4;
}
ifade5;
}
ifade6;
Burada dışarıdan bakıldığında 3 deyim vardır: İkisi basit biri bileşik deyim. Bileşik deyimin içerisinde 3 tane
deyim bulunmaktadır.
3) Kontrol Deyimleri (Control Statements): if gibi, for gibi, while gibi akış üzerinde etkili olan özel deyimlere
kontrol deyimleri denilmektedir. Zaten ilerleyen bölümde bu kontrol deyimleri tek tek ele alınıp incelenecektir.
4) Bildirim Deyimleri (Declaration Statements): Bildirim yapmakta kullanılan sentaks yapıları da aslında deyim
belirmektedir. Bunlara bildirim deyimleri denir. Örneğin:
int a, b;
int x;
a = 10;
b = 20;
Burada iki bildirim deyimi, iki de basit deyim vardır.
5) Boş Dyimler (Null Statements): Solunda ifade olmayan noktalı virgüllere boş deyim denilmektedir. Örneğin:
x = 10;;
Buradaki ilk noktalı virgül ifadeyi deyim yapan sonlandırıcıdır. Fakat ikinci noktalı virgülün solunda bir ifade
yoktur. Boş deyimler “hiçbirşey;” gibi düşünülebilir. Boş deyim bir etkiye yol açmasa da yine de bir deyim olarak
değerlendirilir. yukarıdki örnekte tolam iki deyim vardır.
Her deyim çalıştığında birşeyler olur:
1) Bir basit deyimin çalıştırılması demek o deyimi oluşturan ifadenin yapılması demektir.
2) Bir bileşik deyimin çalıştırılması demek onu oluşturan deyimlerin tek tek çalıştırılması demektir. Örneğin:
{
ifade1;
{
ifade2;
ifade3;
48

}
ifade4;
}
Burada bu bileşik deyim çalıştırıldığında önce ifade1; basit deyimi çalıştırılır. Sonra içerideki bileşik deyim
çalıştırılır. Bu da ifade2; ve ifade3; basit deyimlerinin çalıştırışması anlamına gelir. Sonra da ifade4; basit deyimi
çalıştırılır. Özetle bir bileşik deyim çalıştırıldığında onu oluşturan deyimler yukarıdan aşağıya doğru çalıştırılır.
Aslında her fonksiyon ana bloğuyla bir bileşik deyim belirtir. Bir fonksiyon çağrıldığında o fonksiyonun ana
bloğuna ilişkin bileşik deyim çalıştırılır. O halde her şey main fonksiyonun çağrılmasıyla başlar. Bir C programının
çalıştırılması demek main fonksiyonunun çağrılması demektir. main fonksiyonu programı yükleyen işletim sistemi
tarafından çağrılır.
3) Bir kontrol deyimi çalıştırıldığında nelerin olacağı izleyen bölümde ele alınmaktadır.
4) Bir bildirim deyimi çalıştırıldığında bildirilen değişkenler için yer ayrılır.
5) Boş deyim karşısında derleyiciler hiçbir şey yapmaz.
Kontrol Deyimleri
Programın akışı üzerinde etkili olan deyimler kontrol deyimleri denir. Burada C'deki kontrol deyimleri başlıklar
haliden ele alınacaktır.
if Deyimi
if deyiminin genel biçimi şöyledir:
if (<ifade>)
<deyim>
[
else
<deyim>
]
if anahtar sözcüğünden sonra parantezler içerisinde bir ifadenin bulunması zorunludur. if deyimi doğruysa ve
yanlışsa kısımlarından oluşur. Doruysa ve yanlışsa kısımlarında tek bir deyim bulunmak zorundadır. Eğer
programcı bu kısımlarda birden fazla deyim bulundurmak istiyorsa onu bileşik deyim olarak ifade etmelidir (yani
bloklamalıdır). if deyiminin yanlışsa kısmı bulunmak zorunda değildir. if deyiminin tamamı tek bir deyimdir.
if deyimi şöyle çalışır: Önce if parantezi içerisindeki ifadenin sayısal değeri hesaplanır. Bu değer sıfır dışı ise if
deyiminin doğruysa kısmı, sıfır ise yanlışsa kısmı çalıştırlır. Örneğin:
#include <stdio.h>
int main(void)
{
int a;
printf("Bir sayi giriniz:");
scanf("%d", &a);
if (a > 0)
printf("pozitif\n");
else
printf("negatif ya da sifir\n");

49

printf("son\n");
return 0;
}

Örneğin:
#include <stdio.h>
#include <math.h>
int main(void)
{
double a, b, c;
double delta;
printf("a:");
scanf("%lf", &a);
printf("b:");
scanf("%lf", &b);
printf("c:");
scanf("%lf", &c);
delta = b * b - 4 * a * c;
if (delta < 0)
printf("Kok yok!\n");
else {
double x1, x2;
x1 = (-b + sqrt(delta)) / (2 * a);
x2 = (-b - sqrt(delta)) / (2 * a);
printf("x1 = %f, x2 = %f\n", x1, x2);
}
return 0;
}

İf deyiminin doğruysa kısmı bulunmak zorundadır. Ancak yanlışsa kısmı bulunmak zorunda değildir. Örneğin:
if (ifade1)
ifade2; ifade3;
Burada if deyiminin doğruysa kısmında yalnızca ifade; deyimi vardır. ifade3; deyimi if dışındadır. Örneğin:
if (ifade1) {
ifade2;
ifade3;
}
ifade4;
Burada ifade4; deyimi if dışındadır. Derleyici if deyiminin doğruysa kısmı bittiğinde else anahtar sözcüğünün olup
olmadığına bakar. eğer else anahtar sözcüğü yoksa if deyimi bitmiştir. Örneğin:
#include <stdio.h>
int main(void)

50

{
int a;
printf("Bir sayi giriniz:");
scanf("%d", &a);
if (a > 0)
printf("pozitif\n");
printf("son\n");
return 0;
}

if deyiminin yanlışlıkla boş deyim ile kapatılması sık rastalanan bir hatadır. Örneğğin:
if (a > 0);
/* dikkat yanlışlıkla yerleştirilmiş boş deyim */
printf("pozitif\n");

Boş deyim için bir şey yapılmıyor olsa da boş deyim yine bir deyimdir.
Yalnızca yanlışsa kısmı olan bir if olamaz. Fakat bunu aşağıdaki gibi yapay bir biçimde oluşturabiliriz:
if (ifade1)
;
else
ifade2;
Tabi bunun yerine soruyu ters çevirmek daha iyi bir tekniktir:
if (!ifade1)
ifade2;
Aşağıdaki if cümlesinde derleyici hatayı nasıl tespit edecektir?
if (ifade1)
ifade2;
ifade3;
else
ifade4;
Bu bize if deyiminin doğruysa kısmında birden fazla deyim olduğu halde bloklama yapılmamış hatası izlenimini
vermektedir. Oysa derleyiciye göre ifade’den sonra if deyimi bitmiştir. Dolayısıyla if olmadan kullanılan bir else
söz konusudur. Örneğin Microsoft derleyicileri bu durumda şu error mesajını vermektedir: “illegal else without
matching if”.
İç içe if Deyimleri (Nested if Statements)
Bir if deyiminin doğruysa ya da yanlışsa kısmında başka bir ifa deyimi bulunabilir. Örneğin:

51

Bu akış diagramının if cümlesi şöyle yazılabilir:
if (ifade1)
if (ifade2) {
ifade3;
ifade4;
}
else
ifade5;
else
ifade6;

İki if için tek bir else varsa else hangi if’e ilişkindir. Örneğin:
if (ifade1) if (ifade2) ifade3; else ifade4;

Görünüşe bakılırsa burada iki durum da sanki mümkünmüş gibidir. else birinci if’in else kısmı da olabilir (yani
ikinci if else’siz olabilir), ikinci if’in else’i de olabilir (yani birinsi if else’sizdir). Bu duruma “dangling else”
denilmektedir. Burada else içteki if’e ilişkindir. Deneyimli programcılar bile aşağdaki gibi hatalı kod
yazabilemktedir:
if (ifade1)
if (ifade2)
ifede3;
else
ifade4;

Burada else’in gerçekten birinci if’e ilişkin olması isteniyorsa bilinçli bloklama yapılmalıdır:
if (ifade1) {
if (ifade2)
ifede3;
}
else
ifade4;

Ayrık Koşullar
Bir grup koşuldan herhangi birisi doğruyken diğerlerinin doğru olma olasılığı yoksa bu koşullara ayrık koşullar
52

denilmektedir. Örneğin:
a > 0
a < 0

koşulları ayrıktır. Örneğin:
a == 0
a > 0
a < 0

koşulları ayrıktır. Örneğin:
a == 1
a == 2
a == 3

koşulları ayrıktır. Fakat:
a > 0
a > 10

koşulları ayrık değildir.
Ayrık koşulların ayrık if’lerle ifade edilmesi kötü bir tekniktir. Örneğin:
if (a > 0)
printf("pozitif\n");
if (a < 0)
printf("negatif\n");

Burada a > 0 ise a < 0 olma olasılığı yoktur. Fakat gereksiz bir biçimde yine bu koşul yapılacaktır. Ayrık koşulların
else if’lerle ifade edilmesi gerekir. Örneğin:
if (a > 0)
printf("pozitif\n");
else
if (a < 0)
printf("negatif\n");

Burada artık a > 0 ise gereksiz bir biçimde a < 0 işlemi yapılmayacaktır.
Bazen else-if durumu bir merdiven haline gelebilir. Örneğin:
if (a == 1)
printf("bir\n");
else if (a == 2)
printf("iki\n");
else if (a == 3)
printf("uc\n");
else if (a == 4)
printf("dort\n");
else
printf("hic biri\n");

else if merdivenlerinde olasılığı yüksek olanları yukarıya yerleştirmek daha iyi bir tekniktir.
53

Klavyeden Karakter Okumak
Klavyeden scanf fonksiyonuyla %c formatıyla karakter okuyabiliriz. Örneğin:
#include <stdio.h>
int main(void)
{
char ch;
printf("bir karakter giriniz:");
scanf("%c", &ch);
printf("girilen karakter: %c\n", ch);
return 0;
}

Fakat karakter okumak için getchar isimli standart bir C fonksiyonu da vardır:
int getchar(void);

Fonksiyon bir tuşa basılıp ENTER tuşuna basılana kadar bekler. Basılan tuşun karakter tablosundaki sıra
numarasına geri döner. Geri dönüş değeri aslında bir byte’lık karakterin kod numarasıdır. Tipik olarak char türden
bir nesneye atanabilir. Örneğin:
#include <stdio.h>
int main(void)
{
char ch;
ch = getchar();
printf("girilen karakter: %c\n", ch);
return 0;
}

stdin dosyasından okuma yapan fonksiyonlar tamponlu (buffered) bir çalışmaya sahiptir. Bu çalışma -bazı detayları
olmakla birlikte- kabaca şöyledir: getchar fonksiyonuyla biz bişeyler girdiğimizde girdiğimiz karakterler ve ilave
olarak \n karakteri önce bir tampona aktarılır. Sonra oaradan sırasıyla alınır. (En son ‘\n’ alınacaktır.) Eğer
tamponda karakter varsa getchar klavyden birşey istemez. Tampondan alır. Ancak tamponda hiçbir karakter
kalmamaışsa getchar klavyeden değer ister. Örneğin:
#include <stdio.h>
int main(void)
{
char ch;
ch = getchar();
printf("girilen karakter: %c\n", ch);
ch = getchar();
printf("girilen karakter: %c\n", ch);
return 0;
}

54

Burada birinci getchar’da biz k karaktereine basıp ENTER tuşuna basmış olalım. Tamponda k\n karakterleri
bulunacaktır. Birinci getchar k’yı alacak ikincisi hiç beklemeden ‘\n’ karakterini alacaktır.
Sınıf Çalışması: Klavyeden getchar fonksiyonuyla bir karakter okuyunuz. Karakter ‘a’ ise ali, ‘b’ ise burhan, ‘c’
ise cemal ‘d’ ise demir, ‘e’ ise ercan ve bunların dışında bir karakterse hiçbiri yazısını bastırınız.
Çözüm:
#include <stdio.h>
int main(void)
{
char ch;
ch = getchar();
if (ch == 'a')
printf("ali\n");
else if (ch == 'b')
printf("burhan\n");
else if (ch == 'c')
printf("cemal\n");
else if (ch == 'd')
printf("demir\n");
else if (ch == 'e')
printf("ercan\n");
else
printf("hicbiri\n");
return 0;
}
Anahtar Notlar: Standartlar asgariyi belirlemek için oluşturulmuştur. Standartlara uygun bir C derleyicisinin ekstra özellikleri olabilir.
Bunlara eklenti (extension) denilmektedir. Eklentiler sentaksa ilişkin olabileceği gibi kütüphaneye ilişkin de olabilir. Eklenti özellikleri
kullanırken dikkatli olmalıyız. Çünkü bunlar her derleyicide bulunmak zorunda olmayan özelliklerdir. Bu durumda kodumuzun
taşınabilirliği (portability) zarar görür. Ancak bazı eklentiler çok yaygın bir biçimde desteklenmektedir. Hatta bu eklentileri bazı
programcılar standart özellik dahi sanabilmektedir.

Klavyeden karakter okuyan diğer bir fonksiyon da getch fonksiyonudur. getch standart bir C fonksiyonu değildir.
Pek çok C derleyicisind bulunan bir eklenti fonksiyondur. Microsoft C derleyicilerinde ve gcc derleyicilerinde bu
fonksiyon bulunmaktadır. Fonksiyonun parametrik yapısı şöyledir:
#include <conio.h>
int getch(void);

Bu fonksiyon ENTER tuşuna gereksinim duymaz ve tuşu basar basmaz alır. Basılan tuş görüntülenmez (biz
istersek görüntüleriz). Örneğin:
#include <stdio.h>
#include <conio.h>
int main(void)
{
char ch;
printf("bir karakter giriniz:");
ch = getch();

55

printf("\ngirilen karakter: %c\n", ch);
return 0;
}

Bazen programcılar bu fonksiyonu bir tuşa basılana kadar akışı bekletmek için de kullanmaktadır. Örneğin:
#include <stdio.h>
#include <conio.h>
int main(void)
{
printf("Press any key to continue...\n");
getch();
printf("ok\n");
return 0;
}

Diğer bir karakter okuyan eklenti fonksiyon getche fonksiyonudur. Bu fonksiyonun getch’tan farkı basıldığı
zaman basılan tuşun da görüntülenmesidir.
putchar Fonksiyonu
putchar standart bir C fonksiyonudur. Bu fonksiyon parametresiyle aldığı sayıya karşılık gelen karakter
tablosundaki karakter görüntüsünü ekrana yazdırır. Örneğin:
char ch = ‘a’;
putchar(ch);

Burada ekrana a karakteri çıkar. Yani:
putchar(ch);

ile:
printf(“%c”, ch);

aynı etkiyi oluşturur. Örneğin:
#include <stdio.h>
#include <conio.h>
int main(void)
{
char ch;
while ((ch = getch()) != 'q')
putchar(ch);
return 0;
}

Örneğin:
#include <stdio.h>

56

int main(void)
{
char ch;
while ((ch = getchar()) != '\n')
putchar(ch);
putchar('\n');
return 0;
}

Döngü Deyimleri
Bir program parçasının yinelemeli olarak çalıştırılmasını sağlayan kontrol deyimlerine döngü (loop) denir. C’de 2
döngü deyimi vardır: while döngüleri ve for döngüleri. while döngüleri de kendi aralarında “kontrolün başta
yapıldığı while döngüleri” ve “kontrolün sonda yapıldığı while döngüleri (do-while döngüleri)” olmak üzere ikiye
ayrılır.

Kontrolün başta yapıldığı while döngüleri
Bu biçimdeki while döngüleri pek çok programlama dilinde benzer biçimde bulunmaktadır. Genel biçimi şöyledir:
while (<ifade>)
<deyim>
while anahtar sözcüğünden sonra parantezler içerisinde bir ifade bulunmak zorundadır. Döngü içerisinde tek bir
deyim vardır. O yinelenecek olan deyimdir.
while döngüsü şöyle çalışır: while parantezi içerisindeki ifadenin sayısal değeri hesaplanır. Bu değer sıfır dışı bir
değerse doğru kabul edilir ve döngü deyimi çalıştırılıp başa dönülür. Bu ifade sıfır ise while deyimi sonlanır. while
döngüleri paranztez içerisindeki ifade sıfır dışı olduğu sürece yinelenen döngülerdir. Örneğin:
#include <stdio.h>
int main(void)
{
int i = 0;
while (i < 10) {
printf("%d\n", i);
++i;
}

57

return 0;
}

Örneğin:
#include <stdio.h>
int main(void)
{
int i = 10;
while (i) {
printf("%d\n", i);
--i;
}
return 0;
}

Bir değeri atayıp, atanan değeri karşılaştırmak için parantezler kullanılmalıdır. Örneğin:
#include <stdio.h>
#include <conio.h>
int main(void)
{
char ch;
while ((ch = getch()) != 'q')
printf("%c", ch);
return 0;
}

while parantezi içerisindeki ifadede virgül operatörü kullanılabilir. Örneğin:
#include <stdio.h>
#include <conio.h>
int main(void)
{
char ch;
while (ch = getch(), ch != 'q')
putchar(ch);
putchar('\n');
return 0;
}

Burada önce ch = getch() ifadesi yapılır, sonra ch != ‘q’ ifadesi yapılır. Test işlemine ch != ‘q’ ifadesi sokulur.
Anahtar Notlar: ENTER tuşuna basıldığında normal olarak “Carriage Return (CR)” karakterinin sayısal değeri elde edilir. CR
karakterini ekrana yazdırdığımızda imleç bulunduğu satırın başına geçer. Fakat getchar fonksiyonunda karakter girdikten sonra basılan
ENTER tuşu için getchar tampona CR değil “LF (Line Feed)” karakterini yerleştirmektedir. LF karakterini ekrana yazdırmak
istediğimizde imleç aşağı satırın başına geçer. getch ve getche fonksiyonlarında ENTER tuşuna bastığımızda CR karakterini elde edriz.
ENTER tuşu niyet olarak aşağı satırın başına geçmek amacıyla klavyeye yerleştirilmiş olsa da onun asıl kodu CR’dir. ENTER’a
bastığımızda CR yerine LF karakterinin elde edilmesi girdi alan fonksiyonların yaptığı bir şeydir. CR karakteri (13 nolu ASCII karakter)
C’de ‘\r’ ile, LF karakteri de (10 numaralı ASCII karakteri) C’de ‘\n’ ile temsil edilir.

58

while döngülerinin de yanlışlıkla boş deyim kapatılması durumuyla karşılaşılmaktadır. Örneğin:
#include <stdio.h>
#include <conio.h>
int main(void)
{
char ch;
while (ch = getch(), ch != 'q');
putchar(ch);
putchar('\n');
return 0;
}

Burada artık döngünün içerisinde boş deyim vardır.
while parantezinin içerisinde ++ ve -- operatörlerinin kullanılması kafa karıştırabilmektedir. Örneğin:
#include <stdio.h>
int main(void)
{
int i = 0;
while (++i < 10)
printf("%d ", i); /* 1'den 9'a kadar */
putchar('\n');
return 0;
}

while parantezinde sonek bir ++ ya da -- varsa önce artırım ya da eksiltim uygulanır fakat sonraki operatöre
nesnenin artırılmamış ya da eksiltilmemiş değeri sokulur. Örneğin:
#include <stdio.h>
int main(void)
{
int i = 0;
while (i++ < 10)
printf("%d ", i); /* 1'den 10'a kadar */
putchar('\n');
return 0;
}

Örneğin:
#include <stdio.h>
int main(void)
{
int i = 10;
while (--i)

59

printf("%d ", i); /* 9'dan 1'e kadar */
putchar('\n');
return 0;
}

Örneğin:
#include <stdio.h>
int main(void)
{
int i = 10;
while (i--)
printf("%d ", i); /* 9'dan 0'a kadar */
putchar('\n');
return 0;
}

Burada while parantezi içerisindeki ifadeyi while (i-- != 0) biçiminde değerlendirmek gerekir. Yani burada önce i
bir eksiltilir fakat teste i’nin eksiltilmemiş değeri sokulur. Başka bir deyişle:
while (i--) {
//...
}

ile,
while (i-- != 0) {
//...
}

eşdeğer etkiye sahiptir.
while ile sonsuz döngü aşağıdaki gibi oluşturulabilir:
while (1) {
/* ... */
}

Kontrolün Sonda Yapıldığı while Döngüleri (do-while Döngüsü)
Kontrolün sonda yapıldığı while döngüsünün genel b içimi şöyledir:
do
<deyim>
while (ifade);

while parantezinin sonundaki noktalı virgül boş deyim belirtmez. Bu noktalı virgül sentaksın bir parçasıdır ve
orada bulunmak zorundadır. Kontrolün sonda yapıldığı while döngüleri kontrolün başta yapıldığı while
döngülerinin ters yüz edilmiş bir biçimidir. Ancak başına bir de do anahtar sözcüğü getirilmiştir. do-while
döngülerinde döngü deyimi en az bir kez yapılmaktadır. Örneğin:
#include <stdio.h>

60

int main(void)
{
int i;
i = 0;
do {
printf("%d\n", i);
++i;
} while (i < 10);

/* 0...9 */

return 0;
}

Kontrolün başta yapıldığı while döngülerine kontrolün sonda yapıldığı while döngülerine göre çok fazla
gereksinim duyulur. Fakat bazen kontrolün sonda yapıldığı while döngülerini kullanmak daha anlamlı
olabilmektedir. Örneğin:
#include <stdio.h>
int main(void)
{
char ch;
ch = ' ';
while (ch != 'e' && ch != 'h') {
printf("(e)vet/(h)ayir?");
ch = getch();
printf("%c\n", ch);
}
if (ch == 'e')
printf("evet secildi\n");
else
printf("hayir secildi\n");
return 0;
}

Burada kontrolün sonda yapıldığı while döngüsü daha uygundur:
#include <stdio.h>
#include <conio.h>
int main(void)
{
char ch;
do
{
printf("(e)vet/(h)ayir?");
ch = getch();
printf("%c\n", ch);
} while (ch != 'e' && ch != 'h');
if (ch == 'e')
printf("evet secildi\n");
else
printf("hayir secildi\n");
return 0;
}

61

Karakter Test Fonksiyonları
C’de başı “is” ile başlayan isxxx biçiminde isimlendirilmiş bir grup standart fonksiyon vardır. Bunlara karakter test
fonksiyonları denilmektedir. Bu fonksiyonların hepsi parametre olarak bir karakter alır ve int türden bir geri dönüş
değeri verir. Bu fonksiyonlar parametreleriyle aldıkları karakterleri test ederler. Test doğruysa sıfır dışı bir değere
yanlışsa sıfır değerine geri dönerler. Bu fonksiyonların listesi şöyledir:
isupper (büyük harf mi?)
islower (küçük harf mi?)
isdigit (‘0’ ile ‘9’ arasındaki karakterlerden biri mi?)
isxdigit (hex karakterlerden biri mi?)
isalpha (alfebetik karakterlerden biri mi?)
isalnum (alfabetik ya da nümerik (alfanümerik) karakterlerden biri mi?)
isspace (boşluk karakterlerinden biri mi? (Space, tab, new line, carriage return, vertical tab))
isascii (ASCII tablosunun ilk yarısındaki karakterlerden biri mi?)
iscntrl (İlk 32 kontrol karakterinden biri mi?)
ispunct (noktalı virgül, nokta vs. gibi karakterlerden biri mi)
Bu fonksiyonları kullanırken <ctype.h> dosyası include edilmelidir.
Anahtar Notlar: Önce atama yapıp sonra atanan değerin karşılaştırılmasını istiyorsak parantez kullanmalıyız. Örneğin:
if ((ch = getch()) != ‘q’) {
...
}

Örneğin:
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
int main(void)
{
char ch;
while ((ch = getch()) != 'q') {
printf("%c\n", ch);
if (isupper(ch))
printf("buyuk harf\n");
else if (islower(ch))
printf("kucuk harf\n");
else if (isdigit(ch))
printf("digit karakter\n");
else if (isspace(ch))
printf("bosluk karakterlerinden biri\n");
else if (ispunct(ch))
printf("noktalama karakterlerinden biri\n");
else
printf("diger bir karakter\n");
}
return 0;
}

Anahtar Notlar: UNIX/Linux sistemlerinde getch ve getche fonksiyonları yalnızca curses kütüphanesinde bulunmaktadır. Bu nedenle o
kütüphanenin kurulması gerekir. Benzer biçimde gcc’nin Windows portunda da bu fonksiyonlar bulunmamaktadır.

Karakter test fonksiyonlarını biz de yazabiliriz. Örneğin isupper şöyle yazılabilir:
62

#include <stdio.h>
int myisupper(char ch)
{
if (ch >= 'A' && ch <= 'Z')
return 1;
return 0;
}
int myislower(char ch)
{
if (ch >= 'a' && ch <= 'z')
return 1;
return 0;
}
int myisalpha(char ch)
{
if (myisupper(ch) || myislower(ch))
return 1;
return 0;
}
int main(void)
{
char ch;
printf("Karakter: ");
ch = getchar();
if (myisalpha(ch))
printf("alfabetik\n");
else
printf("alfabetik degil\n");
return 0;
}

Karakter test fonksiyonları ancak karakter 0-127 arasındaysa doğru çalışmaktadır. Bu fonksiyonlar ASCII
karkterlerinin ilk 7 bitini dikkate almaktadır.
Büyük Harf Küçük Harf Dönüştürmesi Yapan Standart C Fonksiyonları
toupper fonksiyonu eğer parametresi ile belirtilen karakter küçük bir karakterse onun büyük karşılığıyla geri döner
fakat küçük harf karakter değilse aynısı i,le geri döner. tolower fonksiyonu da benzer biçimde parametresi ile aldığı
karakter büyük harf ise onun küçük harf karşılığıyla değilse onun aynısıyle geri dönmektedir. Bu fonksiyonları da
kullanmadan önce <ctype.h> dosyasının include edilmesi gerekir. Örneğin:
#include <stdio.h>
#include <ctype.h>
int main(void)
{
char ch;
printf("Karakter giriniz:");
ch = getchar();
ch = toupper(ch);
printf("%c\n", ch);

63

return 0;
}

Anahtar Notlar: Karakter test fonksiyonları ve toupper ile tolower fonksiyonları C90 ekleriyle lokal spesifik özelliğe sahip olmuştur.
Yani uygun lokal set edilmişse bunlar o dile göre de çalışabilir. Default lokal İngilizce olduğu için bunların da default davranışı standart
İngilizce karakterler dikkate alınarak yapılır.

toupper ya da tolower kullanımına tipik bir örnek de şöyle olabilir:
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
int main(void)
{
char ch;
do
{
printf("(e)vet/(h)ayir?");
ch = tolower(getch());
printf("%c\n", ch);
} while (ch != 'e' && ch != 'h');
if (ch == 'e')
printf("evet secildi\n");
else
printf("hayir secildi\n");
return 0;
}

for Döngüleri
for döngüleri aslında while döngülerinin daha genel bir biçimidir. for döngülerinin genel biçimi şöyledir:
for ([ifade1];[ifade2];[ifade3])
<deyim>

for anahtar sözcüğünden sonra parantezler içerisinde iki noktalı virgül bulunmak zorundadır. Bu for döngüsünü üç
kısma ayırır. Bu üç kısımda da ifade tanımına uyan herhangi birer ifade kullanılabilir.
for döngüsü şöyle çalışır:

64

for döngüsünün birinci kısmındaki ifade döngüye girişte bir kez yapılır. Bir daha da yapılmaz. Döngü ikinci
kısımdaki ifade sıfır dışı olduğu sürece yinelenir. İkinci kısımdaki ifade sıfır dışı ise önce döngü deyimi yapılır.
Sonra üçüncü kısımdaki ifade yapılır ve yeniden kontrole girer.
for döngülerinin en çok kullanılan kalıbı şöyledir:
for (ilkdeğer; koşul; artırım)
<deyim>
Örneğin:
#include <stdio.h>
int main(void)
{
int i;
for (i = 0; i < 10; ++i)
printf("%d\n", i);
return 0;
}

Örneğin:
#include <stdio.h>
int main(void)
{
int i;
for (i = 0; i < 10; ++i)
printf("%d ", i);
printf("\n");
return 0;
}

Örneğin:
#include <stdio.h>
int main(void)

65

{
int i;
for (i = 0; i < 10; i += 2)
printf("%d ", i);
printf("\n");
return 0;
}

Örneğin:
#include <stdio.h>
#include <math.h>
int main(void)
{
double x;
for (x = 0; x < 6.28; x += 0.1)
printf("Sin(%.3f)=%.3f\n", x, sin(x));
return 0;
}

Örneğin:
#include <stdio.h>
int main(void)
{
int i;
for (i = 10; i >= 0; --i)
printf("%d ", i);
printf("\n");
return 0;
}

Şüphesiz üçüncü kısımda yapılan artırım ya da eksiltimlerin önek ya da sonek olması arasında bir fark yoktur.
1’den 100’e kadar sayıların toplamı şöyle bulunabilir:
#include <stdio.h>
int main(void)
{
int i, total;
total = 0;
for (i = 1; i <= 100; ++i)
total += i;
printf("%d\n", total);
return 0;
}

Bir döngünün döngü deyimi başka bir döngü olabilir. Bu duruma iç içe döngüler (nested loops) denilmektedir.
Örneğin:
66

#include <stdio.h>
int main(void)
{
int i, k;
for (i = 0; i < 3; ++i)
for (k = 0; k < 3; ++k)
printf("(%d, %d)\n", i, k);
return 0;
}

for döngülerinin de yanlışlıkla boş deyim ile kapatılması durumuyla karşılaşılmaktadır. Örneğin:
#include <stdio.h>
int main(void)
{
int i;
for (i = 0; i < 10; ++i);
printf("%d\n", i);

/* Dikkat boş deyim */

return 0;
}

for döngüsünün üç kısmına da ifade tanımına uyan her şey yerleştirilebilir. Örneğin:
#include <stdio.h>
int main(void)
{
int i;
i = 0;
for (printf("birinci kisim\n"); i < 3; printf("ucuncu kisim\n")) {
printf("dongu deyimi\n");
++i;
}
return 0;
}

for döngüsünün birinci kısmındaki ifade yazılmayabilir. Buradaki ifadeyi yukarı alsak da değişen birşey olmaz.
Örneğin:
for (i = 0; i < 10; ++i) {
...
}

ile
i = 0;
for (; i < 10; ++i) {
...
}

tamamen işlevsel olarak eşdeğerdir. Örneğin:
67

#include <stdio.h>
int main(void)
{
int i;
i = 0;
for (; i < 10; ++i)
printf("%d ", i);
printf("\n");
return 0;
}

for döngüsünün üçüncü kısmı da yazılmayabilir. Aslında üçüncü kısmındaki ifade döngü değiminin sonuna
yerleştirilirse değişen bir şey olmaz. Örneğin:
for (i = 0; i < 10; ++i) {
...
}

ile
i = 0;
for (; i < 10; ) {
...
++i;
}

işlevsel olarak eşdeğerdir. Örneğin:
#include <stdio.h>
int main(void)
{
int i;
i = 0;
for (; i < 10;) {
printf("%d ", i);
++i;
}
printf("\n");
return 0;
}

Birinci ve üçüncü kısmı olmayan for döngüleri tamamen while döngüleriyle eşdeğerdir. Yani:
for (;ifade;) {
...
}

ile
while (ifade) {
...
}

tamamen eşdeğerdir.
68

Şüphesiz for döngüsü olmasaydı while döngüsünden for elde edebilirdik. Yani:
ifade1;
while (ifade2) {
<deyim>
ifade3;
}

aslında aşağıdaki for döngüsüyle eşdeğerdir:
for (ifade1; ifade2; ifade3)
<deyim>
#include <stdio.h>
int main(void)
{
int i;
i = 0;
while (i < 10) {
printf("%d\n", i);
++i;
}
for (i = 0; i < 10; ++i)
printf("%d\n", i);
return 0;
}

for döngüsünün ikinci kısmı da boş bırakılabilir. Bu durumda döngü koşulunun her zaman sağlandığı kabul edilir.
Yani döngünün ikinci kısmına birşey yazmamakla buraya sıfır dışı bir değer yazmak aynı anlamdadır. Örneğin:
#include <stdio.h>
int main(void)
{
int i;
for (i = 0;; ++i)
/* sonsuz döngü (infinite loop) */
printf("%d\n", i);
return 0;
}

for döngüsünün üç kısmında da virgül operatörü zenginlik katmak için kullanılabilir. Örneğin:
#include <stdio.h>
int main(void)
{
int i, total;
for (i = 1, total = 0; i <= 100; total += i, ++i)
;
printf("%d\n", total);
return 0;
}

69

Burada döngünün birinci kısmını i = 1, total = 0 ifadesi oluşturmaktadır. Üçüncü kısmını ise total += i, ++i ifadesi
oluşturmaktadır.
Anahtar Notlar: Bir problemi kesin çözüme götüren adımlar topluluğuna algoritma (algorithm) denilmektedir. Algoritmaları hız
bakımından ya da kaynak kullanımı bakımından karşılaştırabiliriz. Baskın ölçüt hızdır ve default olarak hız akla gelmektedir. Bazen bir
problemin algoritması probleminin yapısı gereği çok uzun bilgisayar zamanı alabilmektedir. Bu durumda makul iyi bir çözümle
yetinilebilir. Problemi kesin çözüme götürmeyen ancak iyi bir çözüm vaat eden adımlar topluluğuna sezgisel yöntem (heuristic)
denilmektedir.

Önce C++'a sonra da C99 sokulmuş olan for döngülerinde önemli bir özellik vardır. C++'ta ve C99'da for
döngülerinin birinci kısmıunda bildirim yapılabilir. Bu prtaiklik sağlamaktadır. Örneğin:
#include <stdio.h>
int main(void)
{
for (int i = 0; i < 10; ++i)
printf("%d\n", i);
return 0;
}

Birden fazla değişkenin de aynı türden olmak koşuluyla bu biçimde bildirimi yapılabilir. Örneğin:
for (int i = 0, k = 100; i + k >= 50; ++i, k -= 2) {
...
}

Bu biçimde bildirilen değişkenler ancak for döngüsünün içerisinde kullanılabilir. C++ ve C99'un standartlarına
göre,
for (bildirim; ifade2; ifade3)
<deyim>

ile,
{
bildirim;
for (;ifade2; ifade3)
<deyim>
}

eşdeğerdir.
Biz kursumuzda C90 gördüğümüz için bu özelliği kullanmayacağız. Ancak bu özellik pek çok C90 derleyicisinde
ekstra bir eklenti olarak bulunmaktadır.
break Deyimi
break deyiminin genel biçimi şöyledir:
break;

break deyimi yalnızca döngülerin ya da switch deyiminin içerisinde kullanılılır. Programın akışı break deyimini
gördüğünde döngü deyiminin kendisi sonlandırılır, akış sonraki deyimle devam eder. (Yani break adeta döngü
dışına goto yapmak gibi etki gösterir.). Örneğin:
70

#include <stdio.h>
int main(void)
{
int val;
for (;;) {
printf("Sayi giriniz:");
scanf("%d", &val);
if (!val)
break;
printf("%d\n", val * val);
}
return 0;
}

Asal sayı testi aşağıdaki gibi yapılabilir:
#include <stdio.h>
int isprime(int val)
{
int i, result;
result = 1;
for (i = 2; i < val; ++i)
if (val % i == 0) {
result = 0;
break;
}
return result;
}
int main(void)
{
int i;
for (i = 2; i < 1000; ++i)
if (isprime(i))
printf("%d ", i);
printf("\n");
return 0;
}

Yukarıdaki asallık testi aşağıdaki gibi iyileştirilebilir:
#include <stdio.h>
#include <math.h>
int isprime(int val)
{
int i, result;
double n;
if (val % 2 == 0)
return val == 2;
n = sqrt(val);
result = 1;
for (i = 3; i <= n; i += 2)
if (val % i == 0) {

71

result = 0;
break;
}
return result;
}
int main(void)
{
int i;
for (i = 2; i < 1000; ++i)
if (isprime(i))
printf("%d ", i);
printf("\n");
return 0;
}

İç içe döngülerde break yalnızca kendi döngüsünden çıkar. Örneğin:
#include <stdio.h>
#include <conio.h>
int main(void)
{
int i, k;
for (i = 0; i < 10; ++i)
for (k = 0; k < 10; ++k) {
printf("(%d, %d)\n", i, k);
if (getch() == 'q')
break;
}
return 0;
}

Yukarıdaki örnekte 'q' tuşuna basıldığında her iki döngüden de çıkılması isteniyorsa dış döngü için de ayrıca break
kullanılmalıdır. Örneğin:
#include <stdio.h>
#include <conio.h>
int main(void)
{
int i, k;
char ch;
for (i = 0; i < 10; ++i) {
for (k = 0; k < 10; ++k) {
printf("(%d, %d)\n", i, k);
if ((ch = getch()) == 'q')
break;
}
if (ch == 'q')
break;
}
return 0;
}

Sınıf Çalışması: Klavyeden int türden bir n değeri alınız ve aşağıdaki deseni çıkartınız:
72

*
**
***
****
*****
....
******....***** (n tane)
Çözüm:
#include <stdio.h>
int main(void)
{
int i, k, n;
printf("Bir sayi giriniz:");
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
for (k = 1; k <= i; ++k)
putchar('*');
putchar('\n');
}
return 0;
}

Sınıf Çalışması: Klavyeden int türden bir sayı okuyunuz ve onun asal çarpanlarını yan yana yazdırınız. Örneğin:
Sayi giriniz: 28
2 2 7

İpucu: önce sürekli ikiye bölünerek ilerlenir. ikiye bölünmeyince bu sefer üçe bölünerek ilerlenir, bölünmediği
zaman dörde bölünerek ilerlenir ve böyle devam ettirilir.
Çözüm:
#include <stdio.h>
int main(void)
{
int n, i;
printf("Bir sayi giriniz:");
scanf("%d", &n);
i = 2;
while (n != 1) {
if (n % i == 0) {
printf("%d ", i);
n /= i;
}
else
++i;
}
putchar('\n');
return 0;
}

73

continue Deyimi
continue deyimi break deyimine göre daha seyrek kullanılır. Genel biçimi şöyledir:
continue;

Programın akışı continue anahtar sözcüğünü gördüğünde döngünün içindeki deyim sonlandırılır. Böylece yeni bir
yenilemeye geçilmiş olur. break döngü deyiminin kendisini sonlandırırken, continue döngü içerisindeki yinelenen
deyimi sonlandırır. Örneğin:
#include <stdio.h>
int main(void)
{
int i;
for (i = 0; i < 10; ++i) {
if (i % 2 == 0)
continue;
printf("%d\n", i);
}
return 0;
}

Burada ekrana yalnızca tek sayılar basılacaktır. continue deyimi yalnızca döngüler içerisinde kullanılabilir.
Sabit İfadeleri (Constant Expressions)
Yalnızca sabit ve operatörlerden oluşan ifadelere sabit ifadeleri (constant expressions) denilmektedir. Örneğin:
10
10 + 20
10 + 20 - 30 / 2

birer sabit ifadesidir. Aşağıdaki ifadeler sabit ifadesi değildir:
x
x + 10
10 - 20 - foo()

Sabit ifadelerinin net sayısal değerleri derleme aşamasında belirlenebilir. C'de kimi durumlarda sabit ifadeleri
zorunludur. Örneğin global değişkenlere verilen ilkdeğerlerin sabit ifadesi olması gerekir. Örneğin:
int x = 10;
int y = x + 10;
void foo()
{
int a = 10;
int b = a + 10;
/* ... */
}

/* geçerli */
/* geçersiz! */

/* geçerli, b yerel */

switch Deyimi
switch deyimi bir ifadenin çeşitli sayısal değerleri için çeşitli farklı işlemlerin yapılması amacıyla kullanılır. Genel
74

biçimi şöyledir:
switch (<ifade>) {
case <s.i>:
....
case <s.i>:
....
case <s.i>:
....
[default:
....
]
}

switch anahtar sözcüğünden sonra derleyici parantezler içerisinde bir ifade bekler. switch deyimi case
bölümlerinden oluşur. case anahtar sözcüğünü bir sabit ifadesi ve sonra da ':' atomu izlemek zorundadır. switch
deyiminin default bölümü olabilir. switch deyiminin tamamı tek bir deyimdir. switch deyimi şöyle çalışır: Önce
switch parantezinin içerisindeki değer hesaplanır. Sonra bu değere eşit olan bir case bölümü var mı diye bakılır.
Eğer böyle bir case bölümü varsa akış o case bölümüne aktarılır. eğer böyle case bölümü yoksa fakat switch
deyiminin default bölümü varsa akış default bölüme aktarılır. default bölüm de yoksa akış switch deyimine girdiği
gibi çıkar. Akış bir case bölümüne aktarıldığında artık diğer case etiketlerinin bir önemi kalmaz. Akış aşağıya
doğru switch deyiminin sonuna kadar akar. (Buna "fall through" denilmektedir.). break deyimi döngülerin yanı sıra
switch deyimini de kırmak için kullanılmaktadır. Genellikle her case bölümü break ile sonlandırılır. Böylece
yalnızca o case bölümü yapılmış olur.
Örneğin:
#include <stdio.h>
int main()
{
int a;
printf("Bir sayi giriniz:");
scanf("%d", &a);
switch (a) {
case 1:
printf("bir\n");
break;
case 2:
printf("iki\n");
break;
case 3:
printf("uc\n");
break;
case 4:
printf("dort\n");
break;
default:
printf("hicbiri\n");
break;
}
printf("son\n");
return 0;
}

case bölümlerinin sıralı olması ve default sonda olması zorunlu değildir. Bazen farklı case değerleri için aynı
75

işlemlerin yapılması istenebilir. Bunun tek yolu aşağıdaki gibidir. Daha pratik yolu yoktur:
case 1:
case 2:
ifade;
break;

Örneğin:
#include <stdio.h>
#include <conio.h>
int main()
{
char ch;
for (;;) {
printf("CSD>");
ch = getch();
printf("%c\n", ch);
if (ch == 'q')
break;
switch (ch) {
case 'r':
case 'd':
printf("delete command\n");
break;
case 'c':
printf("copy command\n");
break;
case 'm':
printf("move command\n");
break;
default:
printf("bad command!\n");
break;
}
}
return 0;
}

Aynı değere ilişkin birden fazla case bölümü bulunamaz. Örneğin:
case 1 + 1:
...
break;
case 2:
...
break;

/* geçersiz! */

Zaten case ifadelerinin sabit ifadesi olma zorunluluğu buradan gelmektedir. Eğer case ifadeleri sabit ifadesi
olmasaydı bu durum derleme aşamasında denetlenemezdi.
case bölümlerine istenildiği kadar çok deyim yerleştirilebilir. İç içe switch deyimleri söz konusu olabilir.
case bölümlerinin hemen switch bloğunun içerisinde bulundurulması zorunlu değildir. Yani case bölümleri daha
diplerde de bulunabilir.
switch (a) {
case 1:

76

/*.... */
if (ifade) {
case 2:
/* .... */
}
break;
}

switch parantezi içerisindeki ifade tamsayı türlerine ilişkin olmak zorundadır. case ifadeleri de gerçek sayı
türünden sabit ifadesi olamaz. Tamsayı türlerine ilişkin olmak zorundadır.
Sınıf Çalışması: Klavyeden gün, ay ve yıl için ü.ç değer isteyiniz. Ay bilgisi yazı ile olacak biçimde tarihi gün-ayyıl biçiminde yazdırınız. Örneğin:
Gün:10
Ay: 12
Yil: 1994
10-Aralik-1994

Çözüm:
#include <stdio.h>
int main()
{
int day, month, year;
printf("Gun:");
scanf("%d", &day);
printf("Ay:");
scanf("%d", &month);
printf("Yil:");
scanf("%d", &year);
printf("%02d-", day);
switch (month) {
case 1:
printf("Ocak");
break;
case 2:
printf("Subat");
break;
case 3:
printf("Mart");
break;
case 4:
printf("Nisan");
break;
case 5:
printf("Mayis");
break;
case 6:
printf("Haziran");
break;
case 7:
printf("Temmuz");
break;
case 8:
printf("Agustos");
break;

77

case 9:
printf("Eylul");
break;
case 10:
printf("Ekim");
break;
case 11:
printf("Kasim");
break;
case 12:
printf("Aralik");
break;
}
printf("-%02d\n", year);
return 0;
}

Sayıların printf Fonksiyonuyla Formatlanması
printf fonksiyonunda format karakterinden hemen önce bir sayı getirilirse, o sayı kadar alan ayrılır ve o alana sayı
sağa dayılı olarak yazdırılır. Eğer o alana sayının sola dayalı olarak yazdırılması isteniyorsa sayının başına karakteri getirilir. Örneğin:
#include <stdio.h>
int main()
{
double f = 12.3;
int a = 123;
printf("%-10d%f\n", a, f);
return 0;
}

Eğer format karakterinden önceki sayı, yazdırılacak sayının basamk sayısından küçükse bu durumda o sayının bir
önemi kalmaz. Sayının hepsi yazdırılır.
Birtakım sayıların bıçakla kesilmiş gibi hizalanması için bu özellik kullanılmaktadır:
#include <stdio.h>
int main()
{
int i;
for (i = 1; i <= 100; ++i)
printf("%-10d%d\n", i, i *i);
return 0;
}

eğer format karakterinden önce + kullanılıyorsa (örneğin "%+10d" gibi, "%+d" gibi) sayının işareti her zaman
yazdırlır. Örneğin:
#include <stdio.h>
int main()
{
int i;

78

i = -123;
printf("%+d\n", i);
i = 123;
printf("%+d\n", i);

/* -123 */
/* +123 */

return 0;
}

Format karakterinden öncekki sayının başına 0 getirilirse (örneğin "%010d" gibi) geri kalan boş alan sıfırla
doldurulur. Örneğin:
day = 7;
month = 6;
year = 2009;
printf("%02d/%02d/%04d", day, month, year); /* 07/06/2009 */

float ve double türleri default olarak noktadan sonra 6 basamak yazdırılır:
#include <stdio.h>
int main()
{
double d;
d = 3.6;
printf("%f\n", d);
d = 3;
printf("%f\n", d);

/* 3.600000 */
/* 3.000000 */

return 0;
}

printf fonksiyonunda "%n.kf " "toplam n tane alan ayır, noktadan sonra k basamak yazdır" anlamına gelir. Eğer
sayının tam kısmı için yeterli alan belirtilmemişse sayının hepsi yazdırılır. Şüphesiz noktadan sonraki k basamak
için yuvarlama yapılmaktadır. Eğer sayının tam kısmı ile ilgilenilmiyorsa "%.kf" biçiminde format belirtilebilir.
Örneğin:
printf("%.10f\n", f);

/* sayının tam kısmının hepsini yazdır, fakat noktadan sonra 10 basamak yazdır */

Örneğin:
#include <stdio.h>
int main()
{
double d;
d = 12345.6789;
printf("%10.2f\n", d); /*
12345.68 */
printf("%4.2f\n", d); /*12345.68 */
d = 12.78;
printf("%.0f\n", d);
return 0;
}

goto Deyimi
79

goto deyimi programın akışını belli bir noktaya koşulsuz olarak aktarmak amacıyla kullanılır. Genel biçimi şöyledi:
goto <etiket>;
....
<etiket>:

programın akışı goto anahtar sözcüğünü gördüğünde akış koşulsuz olarak etiket ile belirtilen noktaya aktarılır.
Etiket (label) isimlendirme kuralına uygun herhangi bir isim olabilir. Bazı programcılar okunabilirlik için goto
etiketlerini büyük harflerle harflendirirler.
Eskiden ilk yüksek seviyeli diller makina dillerinin etkisi altındaydı. Bu dillerde neredeyse goto kullanmak
zorunluydu. Sonraları goto'lar kodun takip edilebilirlğini bozması nedeniyle dillerden dışlanmaya başladılar. Pek
çok deyim goto'suz bloklu bir tasarıma sahip oldu. Bugün goto deyiminin kullanımı birkaç durum dışında tavsiye
edilmemektedir. Fakat tipik olarak goto kullanılmasının anlamlığı olduğu birkaç durum vardır.
Aşağıdaki örnekte goto ile bir döngü oluşturulmuştur. Kesinlikte goto'lar döngü oluşturmak amacıyla
kullanılmamalıdır. Bu nedenle aşağıdaki örnek goto kullanımının anlamlı olduğu bir durum için değil, onun
çalışma mekanizmasını açıklamak için verilmiştir:
#include <stdio.h>
int main()
{
int i = 0;
REPEAT:
printf("%d\n", i);
++i;
if (i < 10)
goto REPEAT;
return 0;
}

goto etiketi yalnızca goto işlemi sırasında etkili olur. Onun dışında bu etiketin bir işlevi yoktur. goto etiketinin
bulundurulması ona goto yapılmasını zorunla hale getirmez. (Ancak kendisine goto yapılmamış etiketler için
derleyiciler uyarı verebilmektedir.)
goto etiketlerini bir deyim izlemek zorundaıdr. Örneğin:
void foo(void)
{
....
XX:
/* geçersiz! */
}

Fakat:
void foo(void)
{
....
XX:
/* geçerli */
;
}

goto etiketleri fonksiyon faaliyet alanına sahiptir. Yani aynı fonksiyon içerisinde aynı isimli tek bir goto etiketi
bulunabilir.
80

goto deyimi ile başka bir fonksiyona atlama yapılamaz. Aynı fonksiyon içerisinde başka bir bölgeye atlama
yapılabilir.
goto ile iç bir bloğa atlama yapılırken dikkat edilmelidir. Çünkü o bloktaki değişkenler için ilkdeğerleme işlemleri
yapılmamış olabilir. Örneğin:
if (ifade)
goto XX;
{
int i = 10;
XX:
....
}

Burada atlanan noktada i çöp değere sahip olabilir. Başka bir dyeişle C'de iç bloğa goto yapıldığında o iç bloğun
başında bildirilmiş değişkenler çöp değerlerdedir. Örneğin aşağıdaki programı çalıştırdığımızda ekrana çöp değer
basılacaktır:
#include <stdio.h>
int main()
{
goto TEST;
{
int i = 10;
TEST:
printf("%d\n", i);
}
return 0;
}

Şüphesiz aynı etikete fonksiyonun farklı yerlerinden birden fazla kez goto yapılabilir.
goto deyiminin aşağıdaki üç durumda kullanılması tavsiye edilmektedir:
1) İç içe döngülerden ya da döngü içerisindeki switch deyiminden tek hamlede çıkmak için. Örneğin:
#include <stdio.h>
#include <conio.h>
int main(void)
{
int i, k;
for (i = 0; i < 10; ++i) {
for (k = 0; k < 10; ++k) {
printf("(%d, %d)\n", i, k);
if (getch() == 'q')
goto EXIT;
}
}
EXIT:
return 0;
}

Örneğin:
81

#include <stdio.h>
#include <conio.h>
int main()
{
char ch;
for (;;) {
printf("CSD>");
ch = getch();
printf("%c\n", ch);
switch (ch) {
case 'r':
case 'd':
printf("delete command\n");
break;
case 'c':
printf("copy command\n");
break;
case 'm':
printf("move command\n");
break;
case 'q':
goto EXIT;
default:
printf("bad command!\n");
break;
}
}
EXIT:
return 0;
}

2) goto ters sırada kaynak boşaltımı amacıyla kullanılabilir:
3) Bazı özel durumlarda goto kullanılmazsa algortima çok çetrefil hale gelebilir. Yani goto bazı durumlarda kodu
kısaltmakta ve okunabilirliği artırmaktadır.
Rastgele (Rassal) Sayı Üretimi
Bilgisayarda rassal sayılar aritmetik yöntemlerle üretilirler. Bu biçimde üretilmiş rassal sayılara sahte rassal sayılar
(pseudo random numbers) denilmektedir. Sahte rassal sayı üretmek için pek çok yöntem bulunuyor olsa da
bunların hemen hepsi bir başlangıç sayısı alınıp, onun üzerinde belirle işlem yapıp yeni sayı elde edilmesi ve aynı
işlemlerin bu yeni sayı üzerinde devam ettirilmesi biçiminde elde edilmektedir. Örneğin bir sayıdan başlayıp onun
karesini alıp ortadaki n basamağını alırsa bu n basamak rassaldır. Örneğin ilk sayı 123 olsun
123
512
621
856
....
Bu biçimde elde edilen sayılar rassaldır. Tabi burada ilk değer aynı ise her defasında aynı dizilim bulunur.
Programın ger çalışmasında farklı bir dizilimin elde edilmesi için bu ilkdeğerin her çalışmada farklı alınması
gerekir.
C'de rassal sayı üretimi için iki standart fonksiyon vardır: srand ve rand. Fonksiyonların parametrik yapıları
şöyledir:
82

#include <stdlib.h>
int rand(void);
void srand(unsigned int seed);

rand fonksiyonu her çağrıldığında 0 ile RAND_MAX değeri arasında rastgele bir sayıyla geri dönmektedir.
RAND_MAX değerinin kaç olacağı derleyicileri yazanların isteğine bırakılmıştır. Bu değer her derleyicide farklı
olabilir (pek çok derleyicide 32767 ya da 2147483647'dir.) Elde böyle bir fonksiyon varsa herhangi bir aralıkta
rassal sayı elde edilebilir. Örneğin:
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i, val;
for (i = 0; i < 20; ++i) {
val = rand() % 10;
printf("%d ", val);
}
printf("\n");
return 0;
}

Bu program her çalıştıtıldığında aynı dizilimi bize verir. Aynı dizilim bize verilmesi sayıların rassal olmadığı
anlamına gelmez. Tabi genellikle program her çalıştığında farklı bir dizilimin verilmesi istenir.
srand fonksiyonu rassal sayı üreticisinin kullandığı ilkdeğeri değiştirmek amacıyla kullanılır. Bu değere
terminolojide tohum değer (seed value) denilmektedir. Programın her çalışmasında farklı bir dizilimin elde
edilmesi için programın her çalışmasında srand'ın farklı bir değerle çağrılması gerekir. İşte bu bilgisayarın
içerisindeki saatle sağlanır. İleride ele alınacak olan time fonksiyonu bize bilgisayarın saatine bakarak bize
01/01/1970'ten fonksiyonun çağrıldığı zamana kadar kaç saniye geçtiğini verir. Bu fonksiyon için <time.h>
dosyasının include edilmesi gerekir. Fonksiyon sıfır parametresiyle çağrılmalıdır. Örneğin:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
int i, val;
srand(time(0));
for (i = 0; i < 10; ++i) {
val = rand() % 10;
printf("%d ", val);
}
printf("\n");
return 0;
}

srand(time(0)) çağrısı programın başında yalnızca bir kez yapılmaktadır. Bazen programcılar yanlışlıkla bu çağrıyı
da döngüsünün içerisine yerleştirirler. Bu durum çoğu kez aynı hep aynı değerin elde edilmesine yol açar. srand
fonksiyonu hiç çağrılmazsa tohum değer hep aynı sayıdan başlar.
Olasılığın görelilik tanımı (büyük sayılar yasası): Yazı tura işlemindeki limit
83

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
double head, tail, headRatio, tailRatio;
unsigned long i;
unsigned long n;
srand(time(0));
head = tail = 0;
n = 1000000000;
for (i = 0; i < n; ++i)
if (rand() % 2 == 0)
++head;
else
++tail;
headRatio = head / n;
tailRatio = tail / n;
printf("Head Ratio = %f, Tail Ratio = %f\n", headRatio, tailRatio);
return 0;
}

Zarda 6 gelme olasılığı nedir?
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
double six, sixRatio;
unsigned long i;
unsigned long n;
srand(time(0));
six = 0;
n = 1000000000;
for (i = 0; i < n; ++i)
if (rand() % 6 + 1 == 6)
++six;
sixRatio = six / n;
printf("Head Ratio = %f\n", sixRatio);
return 0;
}

Sınıf Çalışması: Bir döngü içerisinde getch fonksiyonuyla karakter bekleyiniz. Her tuşa baısldığında "Ali", "Veli",
"Selami", "Ayşe", "Fatma isimlerinden birini rastgele yazdırınız. 'q' tuşuna basıldığında program sonlansın.
Çözüm:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>

84

int main()
{
srand(time(0));
while (getch() != 'q') {
switch (rand() % 5) {
case 0:
printf("Ali\n");
break;
case 1:
printf("Veli\n");
break;
case 2:
printf("Selami\n");
break;
case 3:
printf("Ayse\n");
break;
case 4:
printf("Fatma\n");
break;
}
}
return 0;
}

Sınıf Çalışması: Her tuşa basıldığında 16 büyük harf karakterden oluşan bir dizilimi ekrana bastırınız (Yalnızca
İngilizce karakterler kullanılacaktır.). 'q' tuşuna basıldığında program sonlansın.
GDSUSLYERVFXWTER
KREYDSBSKAIEIRIT
...
Çözüm:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
int main()
{
int i;
srand(time(0));
while (getch() != 'q') {
for (i = 0; i < 16; ++i)
putchar('A' + rand() % 26);
putchar('\n');
}
return 0;
}

Farklı Türlerin Birbirlerine Atanması
C'de tüm aritmektik türler birbirlerine atanabilir. Ancak atama işleminde bilgi kaybı söz konusu olabilir. Eğer bilgi
kaybı söz konusu oluyorsa, bilginin nerisinin kaybedildiği stadartlarda belirtilmiştir.
85

Bir atamada kaynak ve hedef tür vardır. Örneğin:
a = b;
Burada kaynak tür b'nin türüdür, hedef tür a'nın türüdür. Standartlarda farklı türlerin birbirlerine atanması bir tür
dönüştürme faaliyeti gibi ele alınmıştır. Standartlara göre atama işleminde kaynak türle hedef tür birbirlerinden
farklıysa önce kaynak tür hedef türe dönüştürülür, sonra atama yapılır. Yani farklı türlerin birbirlerine atanması
aslında farklı türlerin birbirlerine dönüştürülmesiyle aynı anlamdadır.
Aşağıda farklı türlerin birbirlerine atanması sırasında ne olacağı tek tek açıklanmıştır (else-if gibi değerlendiriniz)
1) Eğer kaynak türün içerisindeki değer hedef türün sınırları içerisinde kalıyorsa bilgi kaybı söz konsu olmaz.
Örneğin:
long a = 10;
short b;
b = a;
2) Eğer kaynak tür bir tamsayı türünden (signed char, unsigned char, signed short, unsigned short, signed int,
unsigned int, signed long, unsigned long) hedef tür de işaretsiz bir tamsayı türündense sayının yüksek anlamlı
byte'ları atılır, düşük anlamlı byte'ları atanır. Örneğin:
#include <stdio.h>
int main()
{
long a = 12345678;
unsigned short b;
b = a;
printf("%u\n", b);

/* 0xBC614E */

/* 24910 = 0x614E */

return 0;
}

3) Eğer kaynak tür bir tamsayı türünden (signed char, unsigned char, signed short, unsigned short, signed int,
unsigned int, signed long, unsigned long) hedef tür de işaretli bir tamsayı türündense bilgi kaybının nasıl olacağını
(yani nerenin atılacağı) derleyiciyi yazanların isteğine bırakılmıştır (implementation dependent). Ancak
derleyicilerin hemen hepsi bu durumda yine sayının yüksek anlamlı byte değerlerini atar. Örneğin:
#include <stdio.h>
int main()
{
long a = 7654321;
short b;
b = a;
printf("%d\n", b);

/* 0x74CBB1 */

/* 0xCBB1 = -13391 */

return 0;
}

4) Eğer kaynak ile hedef tür aynı tamsayı türünün işaretli ve işaretsiz biçimlerinden oluşuyorsa sayının bit kalıbı
değişmez, yalnızca işaret bitinin anlamı değişir. Örneğin:
#include <stdio.h>

86

int main()
{
int a = -1;
unsigned int b;
b = a;
printf("%u\n", b); /* 4294967295 */
return 0;
}

5) Eğer kaynak tür küçük işaretli bir tamsayı türü hedef tür de büyük işaretsiz bir tamsayı türü ise bu durumda
dönüştürme iki aşamada yürütülür. Önce küçük işaretli tür, büyük türün işaretli biçimine dönüştürülür, sonra büyük
türün işaretli biçiminden büyük türün işaretsiz biçimine dönüştürme yapılır. Örneğin:
#include <stdio.h>
int main()
{
signed char a = -1;
unsigned int b;
b = a;
printf("%u\n", b); /* 4294967295 */
return 0;
}

6) Eğer kaynak tür bir gerçek sayı türündense (float, double, long double) hedef tür bir tamsayı türündense sayının
noktadan sonraki kısmı atılır, tam kısmı elde edilir. Eğer sayının noktadan sonraki kısmı atıldıktan sonra elde
edilen tam kısım hala hedef türün sınırları içerisinde kalmıyorsa tanımsız davranış (undefined behavior) oluşru.
Örneğin:
#include <stdio.h>
int main()
{
double a;
int b;
a = 3.99;
b = a;
printf("%d\n", b);

/* 3 */

a = -3.99;
b = a;
printf("%d\n", b);

/* -3 */

return 0;
}

7) Eğer kaynak tür bir tamsayı türü hedef tür gerçek sayı türüyse ve sayı tam olarak tutulamıyorsa, kaynak tür ile
belirtilen değere en yakın büyük ya da en yakın küçük değer elde edilir. Örneğin:
#include <stdio.h>
int main()
{
long a;
float b;

87

a = 123456789;
b = a;
printf("%.0f\n", b);

/* 123456792 */

return 0;
}

8) Eğer kaynak tür ve hedef tür de gerçek sayı türündense bu durumda bilgi kaybının niteliğine bakılır. eğer
basamaksal bir kayıp (magnitute kaybı) varsa tanımsız davtranış oluşur. Basamksal değil de mantis kaybı varsa
yine kaynak tür ile belirtilen değere en yakın büyük ya da en yakın küçük değer elde edilir.
İşlem Öncesi Otomatik Tür Dönüştürmeleri
Yalnızca değişkenlerin ve sabitlerin değil, her ifadenin de bir türü vardır. Bir operatörün opendaları farklı
türlerdense önce derleyici onları aynı türe dönüştürür, sonra işlemi yapar. İşlem sonucunda elde edilen türü bu
dönüştürülen ortak tür türündendir. İşlem öncesi otomatik tür dönüştürmesinin özet kuralı "küçük tür büyük türe
dönüştürülür, sonuç büyük türünden çıkar" biçimindedir. Örneğin:
int a;
long b;

...
a + b işleminde a long türüne dönüştürülür, ondan sonra toplama yapılır. a + b ifadesinin türü long olur.
İşlem öncesi otomatik tür dönüştürmeleri geçici nesne yoluyla yapılmaktadır. Yani dönüştürülmek istenen değer
önce dönüştürülecek türden geçici bir nesneye atanır, işleme o sokulur, sonra o nesne yok edilir:
long temp = a;
temp + b
temp yok ediliyor
İşlem öncesi otomatik tür dönüştürmelerinin bazı ayrıntıları vardır:
1) Eğer bölme işleminde iki operand da tamsayı türündense sonuç tamsayı türünden çıkar. Bu durumda bölme
yapılır, sayının noktadan sonraki kısmı atılır. Örneğin:
#include <stdio.h>
int main()
{
double a;
a = 10 / 4;
printf("%f\n", a);

/* 2.0 */

return 0;
}

Fakat örneğin:
#include <stdio.h>
int main()
{
double a;
a = 10 / 4.;

88

printf("%f\n", a);

/* 2.5 */

return 0;
}

2. Eğer operandlardan her ikisi de int türünden küçükse (örneğin char-char, char-short, short-short gibi) Bu
durumda önce her iki operand da bağımsız olarak int türüne dönüştürülür, sonuç int türünden çıkar. Bu kurala "int
türüne yükseltme kuralı (integral promotion)" denilmektedir. Örneğin:
#include <stdio.h>
int main()
{
int a;
short b = 30000;
short c = 30000;
a = b + c; /* 60000, sonuç int türden */
printf("%d\n", a);
return 0;
}

Bu kuralın şöyle bir ayrıntısı da vardır: Eğer ilgili sistemde short ile int aynı uzunluktaysa ve operandlardan biri
unsigned short türündense dönüştürme int türüne doğru değil unsigned int türüne doğru yapılır.
3) Operandlardan biri tamsayı türünden, diğeri gerçek sayı türündense dönüştürme her zaman gerçek sayı türüne
doğru yapılır. Örneğin long ile float işleme sokulursa sonuç float türden çıkar.
4) Operandlar aynı tamsayı türünün işaretli ve işaretsiz biçimine ilişkinse dönüştürme her zaman işaretsiz türe
doğru yapılır (örneğin int ile unsigned int işleme sokulsa sonuç unsigned int türünden çıkar.)
İşlem öncesi tür dönüştürmeleri aşağıdaki gibi de açıklanabilir:
1. İşleme giren operandlardan en az biri gerçek sayı türlerindense (if-else if şeklinde düşünülmelidir): Eğer
operandlardan biri long double türündense diğer operand long double türüne dönüştürülür. Eğer operandlardan bir
tanesi double türündense diğer operand double türüne dönüştürülür. Eğer operandlardan bir tanesi float türündense
diğer operand float türüne dönüştürülür. Bu tanımlamadan şu kural çıkartılabilir. İşleme giren operandlardan bir
tanesi gerçek sayı türünden, diğeri tamsayı türünden ise tamsayı türünden operand o gerçek sayı türüne
dönüştürülerek işlem yapılmaktadır.
2. İşleme giren operandlar tam sayı türlerindense: Operandlardan en az bir tanesi short int, unsigned short int, char,
signed char, unsigned char türlerinden biri ise öncelikle değerler int türüne dönüştürülür. Buna tamsayıya
yükseltme (integer/integral promotion) denilmektedir. Daha sonra algoritma şu şekildedir.
Eğer operandlardan bir tanesi unsigned long türündense diğer operanda unsigned long türüne dönüştürülür.
Eğer operandlardan bir tanesi signed long türündense diğeri long türüne dönüştürülür.
Eğer operandlardan bir tanesi unsigned int türündense diğeri unsigned int türüne dönüştürülür.
Tür Dönüştürme Operatörü
Bazen bir değişkeni işleme sokarken onun sanki başka tür olarak işleme girmesini isteyebiliriz. Örneğin:
89

int a = 10, b = 4;
double c;
c = a / b;

Burada kırpıolma olacak ve c'ye 2 değeri atanacaktır. Şüphesiz biz a ya da b'den en az birini double olarak bildirip
sorunu çözebiliriz. Ancak a ve b'nin int olarak kalması da gerekiyor olabilir. İşte bunun için tür dönüştürme
operatörü kullanılmaktadır. Tür dönüştürme operatörünün genel biçimi şöyledir:
(<tür>) operand

Buadaki parantez öncelik parantezi değildir, opğeratör görevindedir. Tür dönüştürme operatörü tek operandlı önek
bir operatördür. Öncelik tablosununun ikinci düzeyinde sağdan sola grupta bulunur:
()

Soldan-Sağa

+ - ++ -- ! (tür)

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

< > <= >=

Soldan-Sağa

== !=

Soldan-Sağa

&&

Soldan-Sağa

||

Soldan-Sağa

= += -= *= /= %=, ... Sağdan-Sola
,

Soldan-Sağa

Örneğin:
a = (long) b * c;
İ1: (long)b
İ2: İ1 * c
İ3: a = İ2

Örneğin:
a = (long)(a * b);
İ1: a * b
İ2: (long)İ1
İ3: a = İ2;

Örneğin:
#include <stdio.h>
int main()
{
int a = 10, b = 4;
double c;
c = (double)a / b;
printf("%f\n", c);

90

return 0;
}

Örneğin:
a = (double)(long) b * c;
İ1: (long)b
İ2:(double)İ1
İ3:İ2 * c
İ4: a = İ3

Tür dönüştürmesi yine geçeici nesne yoluyla yapılmaktadır. Yani derleyici önce dönüştürülmek istenen tür
türünden geçici bir nesne yaratır. Dönüştürülmek istenen ifadeyi oraya atar. Sonra işleme onu sokar. En sonunda da
geçici nesneyi yok eder.
Örneğin:
#include <stdio.h>
int main()
{
int n;
int i, val, total;
double avg;
printf("Kac sayi gireceksiniz:");
scanf("%d", &n);
total = 0;
for (i = 1; i <= n; ++i) {
printf("%d. Sayiyi giriniz:", i);
scanf("%d", &val);
total += val;
}
avg = (double)total / n;
/* dikkat! */
printf("Ortalama = %f\n", avg);
return 0;
}

Nesnelerin Ömürleri
Bir programda yaratılan nesnelerin hepsi program sonuna kadar bellekte kalmaz. Bazı nesneler programın
çalışmasının belli bir aşamasında yaratılır, bir süre faaliyet gösterir, sonra yok edilir. Ömür (duration) bir nesnenin
bellekte tutulduğu zaman aralığına denilmektedir. Bir nesne potansiyel en uzun ömür programın çalışma zamanı
kadar (run time) olabilir. Bir nesnenin ömrü statik ya da dinamik olabilir. Statik ömür demek ömürün çalışma
zamanına eşit olması demektir. Statik ömürlü nesneler program çalışmak üzere belleğe yüklendiğinde yaratılır,
program sonlanana kadar bellekte kalır. Dinamik ömürlü nesnelerde ömür programın çalışma zamanından küçüktür.

91

Global Nesnelerin Ömürleri
Global nesneler statik ömürlüdür. Yani bunlar programın çalışma zamanı boyunca bellekte yer kaplarlar. Global
nesneler belleğin Data ve BSS denilen bölümlerinde tutulmaktadır.
Yerel Değişkenlerin Ömürleri
Yerel nesneler dinamik ömürlüdür. Programın akışı nesnenin bildirildiği bloğa girdiğinde o blokta bildirilmiş bütün
yerel nesneler yaratılır, akış o bloktan çıktığında o blokta bildirilmiş bütün yerel nesneler otomatik yok edilir. Yerel
değişkenler belleği "stack" denilen bir bölümünde yaratılmaktadır. Stack'te yaratım ve yokedim çok hızlı yapılır.
Parametre Değişkenlerinin Ömürleri
Parametre değişkenleri de dinamik ömürlüdür. Fonksiyon çağrıldığında yaratılırlar, fonksiyon çalıştığı sürece
bellekte kalırlar. Fonksiyonun çalışması bittiğinde yok edilirler. Parametre değişkenleri de stack denilen bölümde
yaratılmaktedır.
Önişlemci Kavramı (Preprocessor)
Aslında bir C derleyicisi iki modülden oluşamaktadır: "Önişlemci Modülü" ve "Derleme Modülü". Önişlemci
modülü kaynak kodu alır, onun üzerinde bazı işlemler uygular. Sonra onu derleme modülüne verir. Asıl derleme
işlemi derleme modülü tarafından gerçekleştirilmektedir.

Pek çok programlama dilinde böyle bir önişlemci modülü yoktur.
C'de '#' karakteri ile başlayan satırlar önişlemciye ilişkindir. Yani önişlemci yalnızca başı '#' ile başlayan satırlarla
ilgilenmektedir. '#' atomunu önişlemci komutu denilen bir anahtar sözcük izler. '#' ile bu anahtar sözcük arasında
boşluk karakterleriş bırakılabilir. Fakat önişlemci komutları tekbir satırda bulunmak zorundadır. Önişlemci komutu
önişlemciye ne yapması gerektiğini anlatır. 20'ye yakın önişlemci komutu vardır. Ancak en çok kullanılanı
#include ve #define komutlarıdır. Kursumuzun bu bölümünde bu iki komut ele alınacaktır. Diğerleri kursumuzun
sonlarına doğru ele alınacaktır.
#include Komutu
#include komutun açısal parantezler içerisinde ya da iki tırnak içerisinde bir dosya ismi izlemek zorundadır.
Örneğin:
92

#include <stdio.h>
#include "a.c"
#include komutu kaynak kodun tepesinde bulunmak zorunda değildir. Herhangi bir yerd ebulunabilir. Fakat bir
satırı sadece kendisi kaplamak zorundadır. Önişlemci #include komutunu gördüğünde dosyayı diskten okur ve
onun içindekilerini komutun yazılı olduğu yere yapıştırır. Tabi bunu geçici bir dosya açarak yapmaktadır. Derleme
modülüne de bu geçici dosyayı verir. Derleme modülü kodu aldığında artık orada #include görmez. Onun içeriğini
görür. #include komutu ile include ettiğimiz dosyanın içerisinde C'ce anlamlı şeyler olmalıdır. Örneğin:
/* test.c */
int a;
/* sample.c */
#include <stdio.h>
int main()
{
#include "test.c"
a = 10;
printf("%d\n", a);
return 0;
}

Eğer dosya açısal parantezler içerisinde include edilirse bu durumda dosya derleyicinin belirlediği bir dizinde
aranır. Derleyici install edilirken başlık dosyaları bir dizine çekilmektedir. Açısal ile dosya ismi belirtilirken o
dizine bakılır. C'nin standart başlık dosyalarının açısal parantzeler içerisinde include edilmesi uygundur. eğer
dosya ismi iki tırnak içerisnde belirtilirse derleyiciler onu önce bulunulan dizinde (ya da projenin yüklü dizinde)
arar eğer orada bulamazlarsa sani açısal parantez ile belirtilmiş gibi derleyicinin belirlediği dizine de bakılır. Bu
durumda bizim kendi dosyalarımız iki tırnak içerisinde include etmemiz daha uygundur. Çünkü onlar muhtemelen
kendi dizinimizde bulunacaktır.
C standartları #include komutunun semantiğini ana hatlarıyla belirtip çoğu şeyi derleyicileri yazanların isteğine
bırakmıştır. Yani dosya ismi açısal parantez ile belirtildiğinde nerelere bakılacağı, iki tırnak içerisinde
belirtildiğinde nerelere bakılacağı hep derleyicileri yazanların isteğine bırakılmıştır.
Pek çok derleyicide include dosyaları aranırken programcının istediği dizinlere de bakılması sağlanmıştır. Örneğin
Visual Studio IDE'sinde Projeye ayarlarında "C+C++/General/Additional Include Directories" seçenekleri ile
önişlemcinin bizim belirlediğimiz dizilere de bakması sağlanabilir. gcc derleyicilerinde -I seçeneği ile dizin
eklenebilmektedir. Örneğin:
gcc -I /home/csd/Study/C -o sample sample.c
include edilen bir dosyanın içerisinde de #include komutları bulunabilir. Önişlemci bunların hepsini düzgün
biçimde açabilmektedir. Örneğin biz pek çok dosyayı "myheaders.h" dosyası içerisinde include etmiş olalım:
/* myheaders.h */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

Asıl programımızda yalnızca "myheaders.h" dosyasını include edebiliriz:
93

/* sample.c */
#include "myheaders.h"
...

Fakat include işlemlerinde döngüsellik olamaz. include edilecek dosyanın ismi ve uzuntası herhangi bir biçimde
olabilir. Ancak C'de gelenek uzantının .h biçiminde olmasıdır.
#define Komutu
#define komutu text editörlerdeki "find and replace" işlemine benzer bir işlem yapmaktadır. Komutun genel biçimi
şöyledir:
#define STR1

STR2

Örneğin:
#define MAX
#define MIN

100
100 - 20

#define anahtar sözcüğünden sonra boşluk karakterleri atılır ve ilk boşluksuz yazı kümesi elde edilir. Buna STR1
diyelim. Sonra önişlemci yine boşlukları atar ve satır sonuna kadarki tüm karakterleri elde eder. Buna da STR2
diyelim. Sonra kaynak kodda STR1 gördüğü yere STR2 yazısını yerleştirir. Sonucu derleme modülüne verir.
Örneğin:
#include <stdio.h>
#define MAX

100 - 50

int main()
{
int a;
a = MAX * 2;
printf("%d\n", a);
return 0;
}

Burada #define komutunda STR1 MAX, STR2 de 100 - 50'dir. Önişlemci MAX atomlarını 100 - 50 ile yer
değiştirir. Derleme modülüne kod aşağıdaki gibi verilir:
...stdio.h içeriği...
int main()
{
int a;
a = 100 - 50 * 2;
printf("%d\n", a);
return 0;
}

Dolayısıyla bu program çalıştırıldığında ekrana 0 basılır.
Önişlemci hesp yapmaz. Bir yazıyı başka bir yazıyla yer değiştirir. Örneğin:
94

#include <stdio.h>
#define MAX

(100 - 50)

int main()
{
int a;
a = MAX * 2;
printf("%d\n", a);
return 0;
}

Burada ekrana 100 basılacaktır.
STR1 olarak yalnızca değişken ve anahtar sözcük atom kullanılır. Örneğin:
#define +
#define 100
#define beep()
#define MAX

200
putchar('\a')
+

/* geçerli değil */
/* geçerli değil */
/* geçerli */
/* geçerli */

Aşağıdaki kod tamamen geçerlidir:
#include <stdio.h>
#define ana
main
#define tam
int
#define eger
if
#define yazf
printf
#define geridon return
tam ana()
{
tam a = 100;
eger(a == 100)
yazf("tamam\n");
geridon 0;
}

Bir yazıyıya karşılık bir sayı karşı düşürülmesi durumunda bu yazıya sembolik sabit (symbolic constans) ya da
makro (macro) denilmektedir. Örneğin:
#define MAX

100

Buarada MAX bir sembolik sabittir.
STR2'de başka makrolar bulundurulabilir. Önişlemci açımı özyinelemeli yapar. Yani açtığı makroyu yeniden açar.
Ta ki açılacak bi,rşey kalmayana kadar. Örneğin:
#include <stdio.h>
#define MAX
#define MIN

100
(MAX - 50)

int main()
{
int a;

95

a = MIN;
printf("%d\n", a);
return 0;
}

Burada MIN yerine önce (MAX - 50) yerleştirilir. Sonra bu da yeniden önişlemciye sokulur. Böylece (100 - 50)
elde edilir. Burada #define'ların sırası farklı olsaydı da değişen birşey olmayacaktı. Yani önişlemci #define satırları
üzerinde değişiklik yazpmaz.
#define önişlemci komutu ile iki tırnak içerisindeki yazılarda değişiklik yapamayız. Örneğin:
#include <stdio.h>
#define MAX

100

int main()
{
printf("MAX");

/* MAX çıkar */

return 0;
}

Örneğin:
#include <stdio.h>
#define CITY
int main()
{
printf(CITY);

"Ankara"

/* Ankara çıkar */

return 0;
}

Aşağıdaki makro geçerlidir:
#define MYHEADER
#include MYHEADER

<stdio.h>

#define komutu #include komutunda değişiklik yapabilmektedir.
Eğer STR2 yazılmazsa bu durumda STR1 görülen yere boşluk yerleştirilir. Yani STR1 silinir. Örneğin aşağıdaki
kodda derleme sorunu oluşmaz:
#include <stdio.h>
#define in
int main()
{
in
in in in in
return 0;
}

#define komutu nereye yerleştirilmişse onun aşağısında etkili olur. Örneğin:
96

#include <stdio.h>
int main()
{
int i;
for (i = 0; i < SIZE; ++i) {
/* ... */
}
#define SIZE

/* geçersiz! */

100

for (i = 0; i < SIZE; ++i) {
/* ... */
}
return 0;
}

#define komutunda yerel, global gibi bir kavram yoktur. Komut nereye yazılmışsa dosyanın sonuna kadarki
bölgede geçerli olur.
Önişlemci #include komutu ile bir başlık dosyasını açtığında o dosyanın içini de önişleme sokar. Yani oradaki
#define'lar, #include'lar da etki gösterir. Böylece biz birtakım sembolik sabit tanımlamalarını bir başlık dosyasında
yapabiliriz. Onu include ettiğimizde o makrolar etkili olur.
C standartlarına göre bir makro sabit ikinci kez farklı bir biçimde define edilirse tanımsız davranış oluşur. Örneğin:
#define MAX
...
#define MAX

100
200

Burada pek çok derleyici ikinci komuta kadar birincisini etkin yapar, ikincikomuttan sonra ikincisinin etkin olduğu
düşünür. Fakat aslında derleyicinin burada ne yapacağı belli değildir. Bundan kaçınmak gerekir. Tabi makronun
aynı biçimde birden fazla kez tanımlanması soruna yol açmaz.
Ayrıca #define komutunun parametreli bir kullanımı da vardır. Bu konı kursumuzun sonlarına doğru ele alınacaktır.
Sembolik sabitler geleneksel olarak büyük harflerle isimlendirilmektedir. Bu onların program içerisinde
ayrımsanmasını kolaylaştırmaktadır.
#define Komutuna Neden Gereksinim Duyulmaktadır?
#define komutu kaynak kod üzerinde bazı değişiklikler yapılmasına olanak sağlar. Fakat kurusumuzun bu
noktasında bu tür değişikliklerden nasıl fayda sağlanacağı açıklanmayacaktır. #define komutu okunabilirliği
artırmak için sıkça kullanılır. Örneğin bir personel takip programında aşağdaki gibi bir satır bıuşunuyor olsun:
if (n > 732) {
...
}

Bu mu daha onunabilirdir (readable), yoksa aşağıdaki mi?
#define PERSONEL_SAYISI
...

732

if (n > PERSONEL_SAYISI) {
...

97

}

İşte programımızda çeşitli sayıları yazısal biçimde ifade edersek okunabilirliği artırmış oluruz. #define komutu kod
üzerinde değişiklikleri daha az zahmetle yapmamızı sağlar. Örneğin bir programın pek çok yerinde 100 sayısı
kullanılıyor olsun. Biz bunu 200 ile yer değiştirmek isteyelim. Eğer 100'ü define edersek bunu tek yerden
yapabiliriz:
#include <stdio.h>
#define SIZE

100

int main()
{
int i;
for (i = 0; i < SIZE; ++i) {
/* ... */
}
for (i = 0; i < SIZE; ++i) {
/* ... */
}
/* ... */
return 0;
}

Fonksiyon Prototipleri
Derleme işleminin bir yönü vardır ve bu yön yukarıdan aşağıya doğrudur. Derleyici çağrılan bir fonksiyonu
gördüğünde çağrılama noktasına kadar bu fonksiyonun geri dönüş değerinin türünü tespit etmek zorundadır. Eğer
çağrılan fonksiyon çağıran fonksiyonun daha yukarısında tanımlanmışsa çağrılam noktasına kadar derleyici bu
tespit yapmış olur. Fakat eğer çağrılan fonksiyon çağıran fonksiyonun daha altında tanımlanmışsa bu durumda
derleyici çağrılma noktasına kadar fonksiyonun geri dönüş değerinin türünü tespit edememiştir.
Eğer derleyici çağrılma noktasına kadar fonksiyonun geri dönüş değerinin türünü tespit edememişse bu durumda
fonksiyonun int geri dönüş değerine sahip olduğunu varsayarak kodu üretir. Eğer fonksiyonunun daha sonra başka
bir geri dönüş değerine sahip olduğunu derleyici görürse geri dönüp ürettiği kodu düzeltmez. Bu durum error
oluşturur. Fakat derleyici daha sonra fonksiyonun int geri dönüş değerine sahip olarak tanımlandığı görürse sorun
oluşmaz.
Örneğin:
#include <stdio.h>
int main()
{
foo();

/* geçersiz */

return 0;
}
void foo(void)
{
/* ... */
}

Fakat örneğin:
98

#include <stdio.h>
int main()
{
foo();

/* geçerli */

return 0;
}
int foo(void)
{
/* ... */
}

Örneğin:
#include <stdio.h>
int main()
{
double result;
result = div(10, 2.5);

/* error! */

return 0;
}
double div(double a, double b)
{
return a / b;
}

İşte derleyiciye bir fonksiyonun geri dönüş değeri ve parametreleri hakkında bilgi veren bildirimlere "fonksiyon
prototipleri" denilmektedir. Eğer çağrılan fonksiyon çağıran fonksiyonun daha aşağısında tanımlanmışsa biz
çağırma işleminin yukarısına fonksiyon prototipini yerleştirmeliyiz. Prototip bildiriminin genel biçimi şöyledir:
[geri dönüş değerinin türü] <fonksiyon ismi>([parametre bildirimi]);

Örneğin:
double divide();
double divide(double a, double b);
divide(void);

geçerli prototip bildirimleridir. Prototipte parametre bildirimi yapmak iyi bir tekniktir. Çünkü derleyici bu durumda
çağrılma ifadesinde parametre kontrolü ve uygun tür dönüştürmesini yapar. Prototip bildiriminde parametre
değişkenlerinin yalnızca türleri belirtilebilir. Örneğin:
double divide(double, double);

Fakat parametre değişkenlerinin isimlerini yazmak okunabilirliği artırır. Örneğin aşağıdakilerden hangisi daha
okunabilirdir?
double usal(double, double);
double usal(double taban, double us);

Parametre değişkenlerinin isimlerinin hiçbir önemi yoktur. Hatta istenirse bazı parametre değişkenlerine isim verili
bazılarına verilmeyebilir. Tabi iyi teknik tüm parametre değişkenlkerinin isimlendirilmesidir.
99

Protoipteki geri dönüş değeri ve parametre türleriyle tanımlamadakilerin tam olarak aynı olması gerekir. Aksi
halde kod geçerli olmaz. Örneğin:
#include <stdio.h>
double divide(float x, double y);
int main()
{
double result;
result = divide(10, 2.5);
printf("%f\n", result);
return 0;
}
double divide(double a, double b)
{
return a / b;
}

/* geçersiz! */

Fakat parametre değişkenlerinin isimlerinin aynı olması zorunluluğu yoktur.
Fonksiyon tanımlamasının ilk satırı alınıp kopyalanır ve sonuna noktalı virgül getirilirse prototip elde edilir.
Örneğin:
double divide(double a, double b)
{
return a / b;
}

Bu fonksiyonun prototipi şöyledir:
double divide(double a, double b);

Aynı protipi birden fazla kez bildirmek sorun oluşturmaz. Örneğin:
double div(double, double);
double div(double a, double b);
double div();

Bunların hepsi bir arada bulunabilir.
Küçük olmayan projelerde ve kodlarda fonksiyonlar nerede tanımlamış olursa olsun onların prototiplerini kaynak
kodun tepesine yerleştirmek ya da bir başlık dosyasına yerleştirip onu include etmek iyi bir tekniktir.
Eğer biz fonkisyonun prototini ya da tanımlamasını daha yukarıda oluşturmuşsak bu durumda çağrılma ifadesinde
derleyici argümanları sayıca ve türce kontrol eder. Örneğin:
#include <stdio.h>
void foo(int a, int b);
int main()
{
foo(100);

/* geçersiz! */

return 0;
}

100

void foo(int a, int b)
{
/* ... */
}

Prototip bir bildirimdir, tanımlama değildir. Yani prototip oluşturduğunuzda biz fonksiyonu yazmış (tanımlamış)
olmayız. Yalnızca derleyiciye bir ön bildirimde bulunmuş oluruz.
Prototip bildiriminde parametre parantezinini boş bırakılmasıyla oraya void yazılması farklı anlamlara gelmektedir.
eğer parametre parantezi boş bırakılırsa bu durum derleyicinin çağrılam ifadelerinde argüman kontrolü
yapmayacağı anlamına gelir. Örneğin:
void foo();

Böyle bir bildirimde biz foo'yu istediğimiz kadar çok argümanla çağırabiliriz. Derleyici bir kontrol uygulamaz.
Ancak parametre parantezinin içine void yazılırsa bu durum fonksiyonun parametre almadığı anlamına gelir.
Örneğin:
void foo(void);

Biz artık foo'yu argümanla çağıramayız.
Anahtar Notlar: Aslınd abu durum un tarihsel bazı gerekçeleri vardır. Eskiden C'de fonksiyon prototipleri yoktu. Zaten parametre
parantezlerinin içi boş bırakılmak zorundydı. Sonra C'ye prototi kavramı eklendiği zaman eski kodlar geçerli olsun diye bu semantik
muhafaza edildi. Eskiden yapılan parametre parantezinin içinin boş bırakıldığı bildirimlere prototip değil "fonklsiyon bildirimi"
deniliyordu.

Fonksiyon tanımlamasında parametre parantezinin içinin boş bırakılmasıyla void yazılması arasında bir farklılık
yoktur. Her iki durum da fonksiyonun parametreye sahip olmadığı anlamına gelir. Yani:
void foo()
{
...
}

ile,
void foo(void)
{
...
}

tanımlamaları tamamen eşdeğerdir.
Fonksiyon prototip bildirimeleri nerede yapılamlıdır? Protip bildirimleri yerel ya da global düzeyde yapılabilir.
Yine eğer yerel düzeyde yapılacaksa C90'da blokların başlarında yapılması zorunludur (Tabi C99 ve C++'ta
blokların herhangi bir yerinde yapılabilir.) Eğer prototip bildirimi global düzeyde yapılırsa tüm dosya bundan
etkilenir. Yerel düzeyde yapılrsa yalnızca o bloktaki kullanım bundan etkilenir. Yani başka bloklarda sanki
bildirim hiç yapılmamış gibi etki gösterir. Örneğin:
#include <stdio.h>
void bar(void)
{
void foo(int a, int b);

101

foo(10, 20);

/* prototip etki gösterir */

}
int main()
{
foo(10, 20);

/* geçersiz! sanki protip yokmuş gibi etki gösterir*/

return 0;
}
void foo(int a, int b)
{
/* ... */
}

Fakat hemen her zaman fonksiyon prototip bildirimi glob al düzeyde yapılmaktadır.
Derleyici bir fonksiyonun prototipini ya da tanımlamasını görmeden onun çağrıldığı görürse sanki onun prototipi
aşağıdaki gibi yazılmış varsayar:
int some_function();
Bir fonksiyonun prototip bildirimin yaılmış olması onu çağırmayı zorunlu hale getirmez.
Standart C Fonksiyonlarının Prototipleri
Kaynak programımızda olmayan bir fonksiyonu çağırsak bile derleme aşamasından başarıyla geçilir. Eğer prototip
yoksa derleyici fonksiyonun geri dönüş değerinin türünü int varsayar. Tabi bu durumda argüman kontrolü yapmaz.
Eğer prototip varsa derleyici geri dönüş değerinin türünü anlar. Her iki durumda da derleme işlemi başarıyla geçilir.
Fakat derleyici object kod içerisine linker için bir mesaj yazar. Mesajda "sevgili linker, ben bu fonksiyonu
bulamadım. Sen onu diğer objectg modüllerde ve kütüphane dosyalarında ara. Bulursan oradan al. Bulamazsan
seninde elinden birşey gelmez. Ne yapalım...". Bu mesajı okuyan linker fonksiyonu diğer modüllerde ve
kütüphanelerde arar.
Aslında link işlemi tek bir object modülle yapılmak zorunda değildir. Birden fazla object modül ve kütüphane
dosyaları birlikte link edilip tek bir exe dosya elde edilebilir.

Uzantısı Windows'ta .lib ve .dll olan, UNIX/Linux sistemlerinde .a ve .so olan dosyalara kütüphane dosyaları denir.
Kütüphaneler statik ve dinamik olmak üzere ikiye ayrılmaktadır. Uzantısı Windows'ta .lib, UNIX/Linux'ta .a olan
dosyalara statik kütüphane dosyaları, uzantısı Windows'ta .dll, UNIX/Linux'ta .so olan dosyalara dinamik
kütüphane dosyaları denilmektedir. Kütüphanelerin içerisinde derlenmiş halde fonksiyonlar bulunmaktadır.
Eğer bir fonksiyon linker tarafından statik kütüphanelerde bulunursa oradan çekilir ve .exe dosyanın içerisine
yazılır. Eğer fonksiyon dinamik kütüphane içerisinde bulunursa linker fonksiyonu oradan çekip exe dosyaya
yazmaz. Linker exe dosya içerisine işletim sistemi için şöyle bir nor yazmaktadır: "Sevgili işletim sistemi bu
programı çalıştırırken bu programın kullandığı dinamik kütüphaneleri de bul onları da belleğe yükle ki benim
102

fonksiyonlarım çalışsın". Görüldüğü gibi statik link işleminde exe dosya zaten her şeyi içermektedir. Programı
artık başka bir makinaya götürürken statik kütüphane dosyasını götürmememize gerek yoktur. Ancak dinamik link
işleminde biz exe dosyayla birlikte onun kullandığı dinamik kütüphane dosyalarını da hedef makinaya taşımamaız
gerekir.
C'nin standart fonksiyonları da kütüphaneler içerisinde derlenmiş bir biçimde bulunmaktadır. Dolayısıyla bunlar
linker tarafından ele alınırlar. C derleyicileri standart C fonksiyonlarının farkında değildir. Yani printf
fonksiyonuna bizim foo fonksiyonuna yaptığından farklı bir muamele uygulamaz. Biz printf fonksiyonunu
çağırdığımızda derleyici onu kaynak dosyada bulamayacağı için linker'a havale eder. Linker da onu baktığı
kütüphane dosyalarında bulur. Aslında linker de standart C fonksiyonlarının farkında değildir. O yalnızca
belirlenen kütüphanelere bakmaktadır. Standart C fonksiyonlarının yalnızca biz programcılar standart olduğunun
farkındayızdır. Tabi onların kütüphane içerinde bulunduğundan emin oluruz.
Standart C fonksiyonlarını derleyici tanımadığına göre onların geri dönüş değerlerinin türlerini ve parametrik
yapılarını bilmez. Onlar çağrıldığında onların prototipini görmezse geri dönüş değerlerini int kabul eder. O halde
standart C fonksiyonarının da prototiplerinin bulundurulması gerekir. Örneğin aşağıdaki programda sqrt
fonksiyonun prototipi bulundurulmadığı için program başarılı derlenip link edilmiştir. Fakat yaznlış çalışır:
#include <stdio.h>
int main()
{
double result;
result = sqrt(10);
printf("%f\n", result);
return 0;
}

Halbuki prototip eklersek doğru çalışacaktır:
#include <stdio.h>
double sqrt(double);
int main()
{
double result;
result = sqrt(10);
printf("%f\n", result);
return 0;
}

Buradan çıkan sonuç "standart fonksiyonlarının da prototiplerinin bulundurulması" gerektiğidir.
İşte standart C fonksiyonlarının prototipleri gruplanarak çeşitli başlık dosyalarına yerleştirilmiştir. Biz onları elle
yazmak yerine o dosyaları include edebiliriz. Örneğin bütün matematiksel fonksiyonların prototipleri <math.h>,
bütün klavye, ekran ve dosya fonksiyonlarının prototipleri <stdio.h>, genel amaçlı fonksiyonların prototipleri
<stdlib.h> dosyası içerisindedir. Başlık dosyaalarında fonksiyonların tanımlamaları yoktur. Yalnızca prototipleri
vardır. Fonksiyonlar derlenmiş bir biçimde kütüphanede bulunmaktadır.
Adres Kavramı
CPU'nun doğrudan bağlı olduğu ana bellek (yani RAM) byte'lardan oluşmaktadır. Her byte da 8 bitten oluşur.
Belleğin her bir byte'ına ilk byte 0 olmak üzere bir numara verilmiştir. Buna ilgili byte'ın fiziksel adresi denir.
103

Bayte'ların fiziksel adresleri geleneksel olarak 16'lık sistemde gösterilmektedir. Örneğin:

Bellketeki nesnelerin de adresleri vardır. Çünkü onlar da yaşam süresi içerisinde RAM'de bir yerlerde
bulunmaktadır. Örneğin:

Her nesnenin bir fiziksel adresi vardır. Bir byte'tan büyük olan nesnelerin fiziksel adresleri onların en düşük adres
numaralarıyla belirtilir. Örneğin b'nin fiziksel adresi 001B0101'dir, c'nin 001B00103'tür. Şüphesiz yerel nesneler
dinamik ömürlü olduğu için, yerel nesneler için ayrılan alan onların ömürleri bittiğinde artık başka yerel nesneler
için kullanılabilir.
Yazılımsal adres bilgisi iki bileşnli bir bilgidir. Adresin sayısal ve tür bileşenleri vardır:

Adresin sayısal bileşeni nesnenin bellekteki fiziksel adres numarasını belirtir. Tür bileşeni ise o fiziksel adresteki
nesnenin türünü ifade eder. Örneğib:

104

Bundan sonra kursumuzda "adres" denildiğinde yazılımsal adres kavramı anlaşılmalıdır. (Donanımsal ya da
fiziksel adres kavramı tek bileşenlidir ve yalnızca sayı belirtir.)
C'de adresler tamamen ayrı bir tür belirtmektedir. Nasıl int, long, double gibi türler varsa adresleri tutabilen türler
de vardır. C'de adres türleri (pointer types) adresin tür bileşeni ile ifade edilir. Adres türleri C'de adresin tür bileşeni
ile ifade edilir. Yani örneğin bu türe "adres" denmez de "int türden adres (pointer to int)", "long türden adres" denir.
C'de nasıl int türden, long türden, double türden sabit kavramı varsa adres sabiti kavramı da vardır. T türünden
adres sabiti tür dönüştürme operatörü ile oluşturulur. Genel biçimi şöyledir:
(<tür bileşeni> *) <sayısal bileşen>

Adresin sayısal bileşeni fiziksel adres numarası belirtir. Tür bileşeni ise o fiziksel adresteki bilginin türünü
belirtmektedir.
Örneğin:
(int *)0x001B1010

Bu ifade int türden adres sabiti belirtir. Örneğin:
(double *)0x001C2000

Bu ifade double türden adres sabiti anlamına gelir.
Genel biçimdeki yıldız adres anlamına gelir. Adres sabitlerini yazarken tür bileşeninin 16'lık sistemde belirtilmesi
zorunlu değildir. Fakat gelenek bu yöndedir.
C'de nasıl int türünü tutan, long türünü tutan, double türünü tutan nesneler bildirilebiliyorsa adres bilgilerini tutan
da nesneler bildirilebilir. Bunlara gösterici (pointer) denir.
Diziler (Arrays)
Elemanları aynı türden olan ve bellekte ardışıl bir biçimde bulunan veri yapılarına dizi denir (bu tanım
ezberlenmelidir). Aralarında fiziksel ya da mantıksal ilişki bulunan birden fazla nesneni oluşturduğu topluluğa veri
yapısı (data structure) denilmektedir. Dizi bir veri yapısıdır. Çünkü dizi dediğimizde birden fazla eleman (özel
olarak bir eleman da olabilir) söz konusu edilir. Dizi elemanlarının hepsi aynı türdendir. Dizi elemanları bellekte
ardışıl bir biçimde tutulur. Yani bir elelmandan sonra hiç boşluk olmadan diğer elemana geçilir. Halbuki örneğin:
int a, b;

105

gibi bir bildirimde a ve b'nin bellekte ardışıl tutulacağının bir garantisi yoktur.
Dizi bildiriminin genel biçimi şöyledir:
<tür> <dizi ismi><[<uzunluk>]>;

Örneğin:
int a[10];
long b[20];
char c[5];

gibi.
Küme parantezi içerisindeki uzunluk belirten ifadenin tamsayı türlerine ilişkin sabit ifadesi olması zorunludur.
Örneğin:
int a[3 + 2];
int n = 5;
int b[n];

/* geçerli */
/* geçerli değil */

Derleyicinin dizi uzunluğunu daha derleme aşamasında bilmesi gerekir. Bu nedenle dizi unluklarının sabit ifadesi
olması zorunlu tutulmuştur.
Bir dizinin ismi o dizinin tamamını temsil eder. Örneğin:
int a[10];

bildiriminde a 10 elemanlı bir dizi nesnesidir. Dizi türleri sembolik olarak önce tür sonra bir köşeli parantez
içerisinde uzunluk ifadesiyle temsil edilmektedir. Örneğin yukarıda a'nın türü int[10] biçiminde ifade edilir. int[10]
"10 elemanlı int türden dizi" anlamına gelir. Örneğin:
char s[20];

Burada s, char[20] türündendir.
Dizi bildirimi ile normal nesne bildirimi birlikte yapılabilir. Örneğin:
int a[10], b, c[5];

Bu bildirimin eşdeğeri şöyledir:
int a[10];
int b;
int c[5];

Dizi Elemanlarına Erişim ve [] Operatörü
Dizi elemanlarına [] operatörüyle erişilir. Köşeli parantezlerin içerisine tamsayı türlerine ilişkin bir indeks ifadesi
yazılmak zorundadır. Bu ifade sabit ifadesi olmak zorunda değildir. Dizinin ilk elemanı sıfırıncı ideks'li elemanıdır.
Bu durumda son eleman (n elemanlı bir dizide) n - 1'inci indeksteki eleman olur. Örneğin:
int a[10];

a[3] ifadesi int türdendir. a ifadesi ise int[10] türündendir.
106

Örneğin:
#include <stdio.h>
int main(void)
{
int a[10];
int i;
for (i = 0; i < 10; ++i)
a[i] = i * i;
for (i = 0; i < 10; ++i)
printf("%d ", a[i]);
printf("\n");
return 0;
}

Dizi Elemanlarına İlkdeğer Verilmesi
Bir dizinin elemanlarına değer atanmamışsa elemanların içerisinde ne vardır? Dizi yerel ise dizinin tüm
elemanlarında çöp değer, globalsa sıfır bulunur.
Dizi elemanlarına ilkdeğer küme parantezleri ile verilir. Küme parantezlerinin içerisinde değerler ',' atomu ile
ayrılarak yazılır. Örneğin:
int a[3] = {1, 2, 3};

Verilen ilkdeğerler dizi elemanlarına sırasıyla yerleştirilmektedir:

Dizinin uzunluğundan fazla elemanına değer veremeyiz. Örneğin:
int a[3] = {1, 2, 3, 4};

/* geçersiz! */

Fakat dizinin az sayıda elemanına ilkdeğer verebiliriz. Bu durumda geri kalan elemanlar dizi ister yerel yerel olsun,
ister global olsun derleyici tarafından sıfırlanır. Örneğin:
int a[5] = {1, 2 };

/* Dizinin 2, 3 ve 4'üncü indeksli elemanları sıfırdır */

İlkdeğer verirken küme parantezlerinin içi boş bırakılamaz. Örneğin:
int a[] = {};

Örneğin yerel bir dizinin tüm elemanlarını sıfırlamanın en kolay şöyledir:
int a[10] = {0};

107

C'de (C90 ve C99 ve C11'de) küme parantezleri içerisinde verilenm ilkdeğerlerin sabit ifadesi olması zorunludur
(ancak C++'ta sabit ifadesi olmayabilir). Örneğin:
int n = 10;
int a[3] = {5, n, 15};

/* geçersiz! */

Bazı derleyiciler bir eklenti olarak küme parantezleri içerisinde sabit ifadesi olmayan ilkdeğer ifadelerini kabul
edebilmektedir. Fakat bu standart bir özellik değildir.
Diziye ilkdeğer verilirken küme parantezlerinin içi boş bırakılabilir. Bu durumda derleyici verilen ilkdeğerleri
sayar ve dizinin o uzunlukta açılmış olduğunu kabul eder. Örneğin:
int a[] = {1, 2, 3};

/* geçerli */

Burada a dizisi 3 elemanlıdır.
Tabi diziye ilkdeğer verilmiyorsa uzunluk belirtmek zorunludur. Örneğin:
int a[];

/* geçersiz! */

C'de virgüllerle ayrılmış listelerde genel olarak (ileride başka konularda da karşılaşılacak) son elemandna sonra ','
atomu bulundurulabilir. Bu yasak değildir. Örneğin:
int a[3] = {1, 2, 3, };
int b[] = {1, 2, 3, };

/* geçerli */
/* geçerli */

C90'da dizinin istediğimiz bazı elemanlarına ilkdeğer veremeyiz. Böyle bir sentaks yoktur. Ancak C99'da bu
aşağıdaki sentaksla mümkündür:
int a[10] = {10, [4] = 100, 200, [9] = 300};

C99'a göre burada dizinin sıfırıncı indeksli elemanında 10, 4'üncü indeksil elemanında 100, 5',nci indeksli
elemanında 200 ve 9'uncu indeksli elemanında 300 vardır. Diğer elemanlarda sıfır bulunur. Bu özellik bazı C90
derleyicilerinde bir eklenti (extension) olarak desteklenmektedir.
Bir Dizi İçerisindeki En Büyük (ya da En Küçük) elemanın Bulunması Algoritması
Bu problemin tek bir algoritmik çözümü vardır. Dizinin ilk elemanı enbüyük kabul edilip bir nesnede saklanır.
Sonra geri kalan tüm elemanlara bakılır, daha büyüğü varsa nesne içerisindeki değer yer değiştirilir. Örneğin:
#include <stdio.h>
#define SIZE

10

int main(void)
{
int a[SIZE] = { 10, 4, 6, 34, 32, -34, 39, 21, 9, 22 };
int i, max;
max = a[0];
for (i = 1; i < SIZE; ++i)
if (a[i] > max)
max = a[i];
printf("Max = %d\n", max);

108

return 0;
}

Sınıf Çalışması: Yukarıdaki dizide en büyük ve en küçük eleman arasındaki farkı ekrana yazdırınız
Çözüm:
#include <stdio.h>
#define SIZE

10

int main(void)
{
int a[SIZE] = { 10, 4, 6, 34, 32, -34, 39, 21, 9, 22 };
int i, max, min;
min = max = a[0];
for (i = 1; i < SIZE; ++i)
if (a[i] > max)
max = a[i];
else if (a[i] < min)
min = a[i];
printf("Degisim Araligi = %d\n", max - min);
return 0;
}

Dizilere İlişkin Çeşitli Algoritmik Örnekler
Bir dizinin eleman toplamaı ve ortalaması şöyle bulunabilir:
#include <stdio.h>
#define SIZE

5

int main(void)
{
int a[SIZE];
int i, total;
double avg;
for (i = 0; i < SIZE; ++i) {
printf("%d. indeksli elemani giriniz:", i);
scanf("%d", &a[i]);
}
total = 0;
for (i = 0; i < SIZE; ++i)
total += a[i];
avg = (double)total / SIZE;
printf("%f\n", avg);
return 0;
}

Sınıf Çalışması: int türden bir dizi içerisindeki en fazla yinelenen değeri bulunuz (mod değeri). Test için aşağıdaki
diziyi kullanınınz:
int a[SIZE] = { 3, 7, 3, 6, 6, 8, 7, 8, 6, 4 };

109

İpucu: İç içe iki döngü kullanılabilir. Her değerin kaç tane tekrarlandığı bulunur ve bir değişkende saklanır, daha
fazlası varsa yer değiştirilir. (Dizinin k'ıncı elemanından kaç tane olduğuna bakmak için baştan başlamaya gerek
yoktur. k'ıncı indeksten başlamak yeterlidir. Çünkü zaten k'ıncı indekstenn önce o elemandan varsa biz onun
sayısını bulmuş durumda oluruz).
Çözüm:
#include <stdio.h>
#define SIZE

10

int main(void)
{
int a[SIZE] = { 3, 7, 3, 6, 6, 8, 7, 8, 6, 4 };
int i, k;
int count, max_count, max_count_val;
max_count = 0;
for (i = 0; i < SIZE; ++i) {
count = 1;
for (k = i + 1; k < SIZE; ++k)
if (a[i] == a[k])
++count;
if (count > max_count) {
max_count = count;
max_count_val = a[i];
}
}
printf("Mod = %d\n", max_count_val);
return 0;
}

Sınıf Çalışması: int türden bir diziyi ters yüz ediniz ve elemanları yazdırınız
Çözüm:
#include <stdio.h>
#define SIZE

10

int main(void)
{
int a[SIZE] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int i, temp;
for (i = 0; i < SIZE / 2; ++i) {
temp = a[SIZE - i - 1];
a[SIZE - i - 1] = a[i];
a[i] = temp;
}
for (i = 0; i < SIZE; ++i)
printf("%d ", a[i]);
printf("\n");
return 0;
}

Dizilerin sıraya dizilmesine İngilizce "sorting" denilmektedir ve 20'den fazla sıraya dizme yöntemi vardır. En basit
yöntemlerden biri kabarcık sıraalaması (bubble sort) yöntemidir. Bu yöntemde dizinin yan yana elemanları
110

karşılaştırılır, duruma göre yer değiştirilir. Tabi bu işlem bir kez yapılmaz. Bu işlem bir kez yapıldığında en büyük
eleman sona gider. Örneğin:

Bu işlemi ikinci yaptığımızda sona kadar değil, bir önceye kadar gitmemiz yeterli olur. Böylece iç içe iki döngüyle
algoritma gerçekleştirilebilir:
#include <stdio.h>
#define SIZE

10

int main(void)
{
int a[SIZE] = { 10, 23, -5, 34, 77, 100, 32, 87, 22, 44};
int i, k;
int temp;
for (i = 0; i < SIZE - 1; ++i)
for (k = 0; k < SIZE - 1 - i; ++k) {
if (a[k] > a[k + 1]) {
temp = a[k];
a[k] = a[k + 1];
a[k + 1] = temp;
}
}
for (i = 0; i < SIZE; ++i)
printf("%d ", a[i]);
printf("\n");
return 0;
}

Seçerek Sıralama (Selection Sort) yönetminde dizinin en küçük elemanı bulunur, ilk elemanla yer değiştirilir.
Örneğin:

Sonra dizi daraltılarak aynı işlem onun için de yapılır:

111

Algoritmada iki döngü bulunur. Dıştaki döngü diziyi daraltmakta kullanılır. İçteki döngü en küçük elemanı bulur:
#include <stdio.h>
#define SIZE

10

int main(void)
{
int a[SIZE] = { 10, 23, -5, 34, 77, 100, 32, 87, 22, 44};
int i, k;
int min, minIndex;
for (i = 0; i < SIZE - 1; ++i) {
min = a[i];
minIndex = i;
for (k = i + 1; k < SIZE; ++k)
if (a[k] < min) {
min = a[k];
minIndex = k;
}
a[minIndex] = a[i];
a[i] = min;
}
for (i = 0; i < SIZE; ++i)
printf("%d ", a[i]);
printf("\n");
return 0;
}

Yazıların char Türden Dizilerde Saklanması
Aslında yazı dediğimiz şey karakterlerden oluşan bir dizidir. Bilindiği gibi karakterler de aslında karakter
tablosunda birer sayı belirtir. Bir yazının karakter numaralarını bir dizide saklarsak yazıyı saklamış oluruz.
Programa dili ne olursa olsun yazılar arka planda hep böyle saklanmaktadır. Şüphesiz yazıları saklamak için en iyi
tür char türüdür. char türü her sistemde 1 byte uzunluğundadır.
Genellikle yazılar char türden dizilerin başından başlarlar fakat onların sonuna kadar devam etmezler. Yani
genellikle yazılar yerleştirildikleri diziden küçük olurlar. Bu durumda yazının sonunu belirlemek gerekir. İşte C'de
bunun için null karakter kullanılmaktadır. null karakter '\0' ile temsil edilir. Karakter, tablonun sıfır numaralı
karakteridir ve sayısal değeri de sıfırdır. null karakterin bir görüntü karşılığı yoktur, zaten tabloya böyle bir amaç
için yerleştirilmiştir.
C'de bir char türden bir diziye yazı yerleştireceksek yazının sonuna (dizinin sonuna değil) '\0' karakteri koymalıyız.
Çünkü C'de herkes tarafından yapılan böyle bir anlaşma vardır. Bu durumda n elemanlı charf türden bir diziye en
112

fazla n - 1 elemanlı bir yazı yerleştirilebilir. Örneğin:
#include <stdio.h>
int main(void)
{
char s[10];
int i;
s[0] = 'a';
s[1] = 'l';
s[2] = 'i';
s[3] = '\0';
for (i = 0; s[i] != '\0'; ++i)
putchar(s[i]);
putchar('\n');
return 0;
}

Aynı işlem ilşkdeğer verilerek de yapılabilirdi:
#include <stdio.h>
int main(void)
{
char s[10] = { 'a', 'l', 'i', '\0' };
int i;
for (i = 0; s[i] != '\0'; ++i)
putchar(s[i]);
putchar('\n');
return 0;
}

Burada diziye ilk değer verildiği için derleyici gerei kalan elemanları sıfırlar. Null karakter zaten sıfır olduğu için
aşağıdaki iki bildirim eşdeğer olur:
char s[10] = { 'a', 'l', 'i', '\0' };
char s[10] = { 'a', 'l', 'i'};

char türden bir dizide null karakter görene kadar ilerlemek için şu kalıp kullanılabilir:
for (i = 0; s[i] != '\0'; ++i) {
...
}

gets Fonksiyonu
gets standart bir C fonksiyonudur. Aşağıdaki gibi kullanılır:
gets(<dizi ismi>);

gets fonksiyonu kalvyeden bir yazı girilip ENTER tuşuna basılana kadar bekler. Girilen yazının karakterlerini tek
tek verdiğimiz char türden diziye yerleştirir, yazının sonuna '\0' karakterini de ekler. gets dizinin diğer elemanlarına
hiç dokunmaz.
Örneğin:
113

#include <stdio.h>
int main(void)
{
char s[100];
int i;
gets(s);
for (i = 0; s[i] != '\0'; ++i)
putchar(s[i]);
putchar('\n');
return 0;
}

puts Fonksiyonu
puts fonksiyonu bir dizinin ismini (yani adresini) parametre olarak alır '\0' görene kadar tüm karakterleri yan yana
basar, en sonunda imleci aşağı satırın başına geçirerek orada bırakır. Örneğin:
#include <stdio.h>
int main(void)
{
char s[100];
int i;
gets(s);
puts(s);
return 0;
}

Sınıf Çalışması: Klavyeden gets fonksiyonuyla bir diziye bir yazı giriniz. Girilen yazının kaç karakterli olduğunu
(yani yazının uzunluğunu) yazdırınız.
Çözüm:
#include <stdio.h>
int main(void)
{
char s[100];
int i;
printf("Yazi giriniz:");
gets(s);
for (i = 0; s[i] != '\0'; ++i)
;
printf("%d\n", i);
return 0;
}

Sınıf Çalışması: Klavyeden gets fonksiyonuyla bir diziye bir yazı giriniz. Girilen yazıyı tersten yazdırınız.
Çözüm:
114

#include <stdio.h>
int main(void)
{
char s[100];
int i;
printf("Yazi giriniz:");
gets(s);
for (i = 0; s[i] != '\0'; ++i)
;
for (--i; i >= 0; --i)
putchar(s[i]);
putchar('\n');
return 0;
}

Bir dizideki yazıyı büyük harfe dönüştüren örnek:
#include <stdio.h>
#include <ctype.h>
int main(void)
{
char s[100];
int i;
printf("Yazi giriniz:");
gets(s);
for (i = 0; s[i] != '\0'; ++i)
s[i] = toupper(s[i]);
puts(s);
return 0;
}

Sınıf Çalışması: char türden bir dizi ve bir de char türden değişken bildiriniz. gets fonksiyonu ile klavyeden diziye
okuma yapınız. Sonra da getchar fonksiyonu ile char nesneye okuma yapınız. Yazı içerisinde o karakterden kaç
tane olduğunu yazdırınız.
Çözüm:
#include <stdio.h>
int main(void)
{
char s[100];
char ch;
int i, count;
printf("Yazi giriniz:");
gets(s);
printf("Bir karakter giriniz:");
ch = getchar();
for (count = 0, i = 0; s[i] != '\0'; ++i)
if (s[i] == ch)
++count;
printf("%d\n", count);

115

return 0;
}

printf Fonksiyonu İle Yazıların Yazdırılması
printf fonksiyonunda %s format karakterine karşılık char türden bir dizi ismi (aslında adres) gelmelidir. Bu
durumda printf null karakter görene kadar karakterleri yazar. Örneğin:
#include <stdio.h>
int main(void)
{
char s[100];
printf("Yazi giriniz:");
gets(s);
printf("Girilen yazi: %s\n", s);
return 0;
}

Yani:
puts(s);

ile,
printf("%s\n", s);

eşdeğerdir.
char Türden Dizilere İki Tırnak İfadesi ile İlkdeğer Vermek
C'de char türden bir diziye iki tırnak ile ilkdeğer verilebilir. Örneğin:
char s[10] = "ankara";

Burada yazının karakterleri tek tek diziye yerleştirilir, sonuna null karakter eklenir. Tabi dizinin geri akalan
elemanları da yine sıfırlanacaktır. Örneğin:
#include <stdio.h>
int main(void)
{
char s[100] = "ankara";
printf("%s\n", s);
return 0;
}

İki tırnak ile ilkdeğer verilirken dizi uzunluğu yine belirtilmeyebilir. Örneğin:
char s[] = "ankara";

Burada derleyici null karakteri de hesaba katar. Yani dizi 7 uzunlukta açılmış olacaktır. Aşağıdaki ilkdeğer verme
geçersizdir:
116

char s[4] = "ankara";

/* geçersiz! */

Burada verilen ilkdeğerler dizi uzunluğundan fazladır. Aşağıdaki durum bir istisnadır:
char s[6] = "ankara";

/* geçerli, fakat null karakter eklenmeyecek */

Standartlara göre iki tırnak içerisindeki karakterlerin sayısı tam olarak dizi uzunluğu kadarsa bu durum geçerlidir.
Ancak '\0' karakter derleyici tarafından bu istisnai durumda diziye eklenmez.
İki tırnağın içi boş olabilir. Bu durumda yalnızca null karakter ataması yapılır. Örneğin:
char s[] = "";

/* geçerli */

Dizi tek elemanlıdır ve o elemanda da '\0' karakter vardır.
Standartlara göre '\0' karakteri kesinlikle hangi karakter dönüştürme tablosu kullanılıyor olursa olsun o tablonun
sıfır numaralı karakteridir. Yani null karakterin sayısal değeri sıfırdır. Başka bir deyişle:
s[n] = 0;

ile
s[n] = '\0';

tamamen aynı etkiyi yapar. Eğer char dizisi yazısal amaçlı kullanılıyorsa '\0' kullanmak iyi bir tekniktir.
char türden diziye iki tırnakla daha sonra değer atayamazyız. Yalnızca ilkdeğer olarak bunu yapabiliriz. Örneğin:
char s[10];
s = "ankara";

/* geçersiz! */

Koşul Operatörü (Conditional Operator)
Koşul operatörü C'nin üç operandlı (ternary) tek operatörüdür. Operatör "? :" temsil edilir. Genel kullanımı
şöyledir:
op1 ? op2 : op3

Burada op1, op2 ve op3 birer ifadedir. Koşul operatörü if deyimi gibi çalışan bir operatördür. Operatörün çalışması
şöyledir: Önce soru işaretinin solundaki ifade (op1) yapılır. Bu ifade sıfır dışı bir değerse yalnızca soru işareti ile
iki nokta üstü üste arasındaki ifade (op2) yapılır, sıfırsa iki nokta üst üstenin sağındaki ifade yapılır. Koşul
operatörü bir operatör olduğu için bir değer üretir. Yani bu değer bir nesneye atanabilir, başka işlemlere sokulabilir.
Koşul operatörünün ürettiği değer duruma göre op2 ya da op3 ifadelerinin değeridir. Örneğin:
result = val > 0 ? 100 + 200 : 300 + 400;

Burada val > 0 ise yalnızca 100 + 200 ifadesi yapılır ve koşul operatöründen bu değer elde edilir. Değilse 300 +
400 yaılır ve koşul operatöründen bu değer elde edilir. Burada yapılan aşağıdaki ile eşdeğerdir:
if (val > 0)
result = 100 + 200;
else
result = 300 + 400;

117

Örneğin:
#include <stdio.h>
int main(void)
{
int val;
int result;
printf("Bir sayi giriniz:");
scanf("%d", &val);
result = val > 0 ? 100 + 200 : 300 + 400;
printf("%d\n", result);
return 0;
}

Koşul operatörü elde edilen değerin bir nesneye atanacağı ya da b aşka bir ifadede kullanılacağı durumlarda tercih
edilmelidir. Aşağıdaki örnek koşul operatörünün kötü bir kullanımına işaret eder:
a > 0 ? foo() : bar();

Burada koşul operatörünün kullanılması kötü bir tekniktir. Koşul operatörünün üç durumda kullanılması tavsiye
edilir:
1) Bir karşılaştırma sonucunda elde edilen değerin bir nesneye atanması durumunda. Örneğin:
max = a > b ? a : b;

Örneğin:
for (i = 1900; i < year; ++i)
tdays += isleap(i) ? 366 : 365;

Burada isleap(i) sıfır dışı ise tdays'e 366 değilse 365 eklenmektedir. Aşağıda belli bir tarihin hangi güne karşı
geldiğini bulan programı görüyorsunuz:
#include <stdio.h>
int isleap(int year)
{
return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
}
int totaldays(int day, int month, int year)
{
int i;
long tdays = 0;
int montab[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
for (i = 1900; i < year; ++i)
tdays += isleap(i) ? 366 : 365;
montab[1] = isleap(year) ? 29 : 28;
for (i = 0; i < month - 1; ++i)
tdays += montab[i];
tdays += day;

118

return tdays;
}
void printday(int day, int month, int year)
{
long tdays;
tdays = totaldays(day, month, year);
switch (tdays % 7) {
case 0:
printf("Pazar\n");
break;
case 1:
printf("Pazartesi\n");
break;
case 2:
printf("Sali\n");
break;
case 3:
printf("Carsamba\n");
break;
case 4:
printf("Persembe\n");
break;
case 5:
printf("Cuma\n");
break;
case 6:
printf("Cumartesi\n");
break;
}
}
int main(void)
{
printday(10, 9, 1993);
return 0;
}

2) Koşul operatörü fonksiyon çağrılarında argüman olarak kullanılabilir. Böylece elde edilen değer fonksiyonun
parametre değişkenine atanmış olur. Örneğin:
foo(val % 2 == 0 ? 100 : 200);

Bunun if eşdeğeri şöyledir:
if (val % 2 == 0)
foo(100);
else
foo(200);

Örneğin:
#include <stdio.h>
int main(void)
{
int val;
printf("Bir sayi giriniz:");

119

scanf("%d", &val);
printf(val % 2 == 0 ? "Cift\n" : "Tek\n");
return 0;
}

3) Koşul operatörü return deyiminde de kullanılabilir. Örneğin:
return a % 2 == 0 ? 100 : 200;

Bu ifadenin eşdeğer if karşılığı şöyledir:
if (a % 2 == 0)
return 100;
else
return 200;

Koşul operatörü özel bir operatördür. Öncelik tablosundaki klasik kurallara tam uymaz. Ancak öncelik tablosunda
hemen atama ve işlemli atama operatörlerinin yukarısında sağdan-sola grupta bulunur:
()

Soldan-Sağa

+ - ++ -- ! (tür)

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

< > <= >=

Soldan-Sağa

== !=

Soldan-Sağa

&&

Soldan-Sağa

||

Soldan-Sağa

?:

Sağdan-Sola

= += -= *= /= %=, ... Sağdan-Sola
,

Soldan-Sağa

Koşul operatörünün operandları şöyle ayrıştırılır: Soru işaretinden sola doğru gidilir. Koşul operatöründen daha
düşük öncelikli operatör görülene kadarki ifade koşul operatörünün birinci operandını oluşturmaktadır. Soru işareti
ile iki nokta üst üsete arasındaki ifade koşul operatörünün ikinci operandını oluşturur. İki nokta üst üstenin
sağındaki ifade koşul operatörünün üçüncü operandını oluşturmaktadır. Örneğin:

Parantezler koşul operatörünün opearanlarını ayrıştırmakta kullanılabilir. Örneğin:
a = (b > 0 ? 100 + 200 : 300) + 400;

Burada artık üç operatör vardır: Atama, koşul ve +. Yani + 400 koşul operatörünün dışındadır. b > 0 koşulu
sağlansa da sağlanmasa da 400 ile toplama yapılacaktır.
120

Koşul operatörü de iç içe kullanılabilir. Örneğin:
result = a > b ? a > c ? a : c : b > c ? b : c;

Burada üç sayının en büyüğü bulunmaktadır. Tabi bu ifade karmaşık gözüktüğü için parantezler gerekmiyor olsa
da sadelk oluşturmak için kullanılabilir. Örneğin:
result = a > b ? (a > c ? a : c) : (b > c ? b : c);

sizeof Operatörü
sizeof bir derleme zamanı (compile time) operatörüdür. Parantezlerinden dolayı acemi C programcıları onu
fonksiyon sanabilmektedir. Operatörler derleme aşamasında derleyici tarafından kod üretilmesi için ele alınırlar.
Oysa fonksiyonlar programın çalışma zamanı sırasında akışın oraya gitmesiyle işlem görürler.
sizeof operatörünün kullanım biçimleri şöyledir:
sizeof <ifade>
sizeof(<tür>)
sizeof <dizi ismi>

sizeof operatörünün operandı bir ifade ise, derleyici o ifadeyi yapmaz. Yalnızca o ifadenin türüne bakar. sizeof
ifadenin türünün o sistemde kaç byte yer kapladığını belirtir. Derleyici sizeof operatörünü gördüğünde derleme
aşamasında oraya sabir yerleştirir. Yani sanki sizeof yerine biz bir sabit yazmışız gibi işlem görür. sizeof operatörü
tek operandlı önek bir operatördür ve öncelik tablosunun ikinci düzeyinde sağdan sola grupta bulunur:
()

Soldan-Sağa

+ - ++ -- ! sizeof

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

...

...

Dolayısıyla,
sizeof a + b
ifadesinde a'nın sizeof'u b ile toplanır. Fakat:
sizeof (a + b)

iafdesinde a + b'nin sizeof'u elde edilmektedir. Programcılar genellikle sizeof operatörünü hep parantezlerle
kullanmaktadır. Örneğin:
#include <stdio.h>
int main(void)
{
int n;
n = sizeof 1.2 + 5;
printf("%d\n", n);

/* 13 */

121

n = sizeof (1.2 + 5); /* 8 */
return 0;
}

sizeof operatörünü gören derleyici onun yerine o ifadenin türünün kaç byte olduğuna ilişkin sabit bir değer
yerleştiri. Yerleştirdiği sabit size_t türündendir (tipik olarak unsigned int).
n = sizeof 1.2 + 5;

ifadesi derleyici tarafından şu biçime dönüştürülür:
n = 8u + 5;

Şüphesiz sizeof operatörünün operandı fonksiyon çağrısıysa fonksiyon işletilmez, onun geri dönüş değerinin türüne
bakılır, o değer elde edilir:
#include <stdio.h>
double foo(void)
{
printf("Im am foo\n");
return 1500.2;
}
int main(void)
{
int n;
n = sizeof(foo());
printf("%d\n", n);
return 0;
}

Burada ekrana foo yazısı basılmaz, yalnızca 8 yazısı basılır.
void değerin sizeof'u yoktur. Dolayısıyla sizeof operatörünün operandı void türden olamaz.
sizeof operatörünün operandı doğrudan bir tür ismi olabilir. Bu durumda parantezler kullanılmak zorundadır.
Örneğin:
#include <stdio.h>
int main(void)
{
int n;
n = sizeof(int);
printf("%d\n", n);

/* 4 */

return 0;
}

sizeof operatörünün operandı bir dizi ismi olabilir. Bu durumda sizeof o dizinin bellekte kapladığı byte miktarını
bize verir. Örneğin:
#include <stdio.h>

122

int main(void)
{
int a[4] = { 1, 2 };
char s[] = "ali";
printf("%u\n", sizeof a);
printf("%u\n", sizeof s);

/* 16 */
/* 4 */

return 0;
}

Pekiyi sizeof operatörüne neden gereksinim duyulmaktadır? Bilindiği gibi C'de char dışındaki tüm türlerin
uzunlukları derleyiciye bağlı olarak değişebilmektedir. Kodun taşınabilirliğini sağlamak için bazı durumlarda
sizeof operatörünü kullanmak zorunda kalabiliriz. sizeof operatörüne olan gereksinim ileriki konularda açıkça
görülecektir.
Göstericiler (Pointers)
Adres bilgilerinin saklanması için kullanılan nesnelere gösterici (pointer) denir. Bir adres bilgisi C'de int, long
türlerde tutulamaz. Ancak gösterici denilen türlerde tutulabilir. Benzer biçimde göstericiler de adi birer int, long
türleri tutamazlar. Ancak adres tıtarlar.
Gösterici bildiriminin genel biçimi şöyledir:
<tür> *<gösterici ismi>;

Örneğin:
int *p;
long *t;
double *d;

Buradaki * adres türünü temsil eder. Çarpma gibi bir anlama gelmez.
Bir gösterici her türden adres bilgisini tutamaz. Yalnızca tür bileşeni belirli olan olan adres bilgilerini tutar. Genel
olarak:
T *p;

gibi bir bildirimde p göstericisi tür bileşeni T olan adresleri tutabilir. Örneğin:
*pi;

int

Burada pi int türünden göstericidir. int türden gösterici demek, tür bileşeni int olan adresleri tutan gösterici
demektir.
Anahtar Notlar: İngilizce T türünden gösterici "pointer to T" biçiminde yazılıp okunmaktadır.

Gösterici bildiriminde * farklı bir atomdur. Dolayısıyla öncesinde sonrasında birden fazla boşluk karakteri
bulunabilir. Örneğin:
int

*

pi;

/* geçerli */

Bazı programcılar * atomunu türe yapıştırmaktadır:
int*

pi;

/* geçerli */

123

Fakat gelenek (zaten daha mantıksal olduğu için) * atomunun gösterici ismine yapıştırılmasıdır:
int *pi;

* atomu dekleratöre ilişkindir, türe ilişkin değildir. Örneğin aşağıdaki bildirim geçerlidir:
int *pi, a;

Burada pi int türden bir göstericidir fakat a, adi bir int nesnedir. Örneğin:
int *pi, *a;

Burada hem pi hem de a int türden göstericidir:
int a, b[10], *c;

Burada a adi bir int, b 10 elemanlı bir int dizi, c ise inttürdne bir göstericidir.
Bir göstericiye aynı türden bir adres bilgisi yerleştirilir:
int *pi;
pi = (long *) 0x1FC0;
pi = 0x1FC0;

/* geçersiz! tür yanlış*/
/* geçersiz! adi bir int */

Benzer biçimde biz nümerik türlere adres bilgisi atayamazyız. Örneğin:
int a;
a = (int *) 0x1FC0;

/* geçersiz! */

Dizi İsimlerinin Otomatik Adreslere Dönüştürülmesi
C'de bir dizinin ismi dizinin taamamını temsil eder. Dizi isimleri işleme sokulduğunda otomatik olarak derleyici
tarafından adrese dönüştürülür. Yani dizi isimleri aslında adres belirtmektedir. Dizi isimleriyle belirtilen adresin tür
bileşeni dizinin aynı türden, sayısal bileşeni dizinin bellekteki başlangıcına ilişkin fiziksel adres numjarasından
oluşur:

Burada a ismini işleme soktuğumuzda otomatik olarak bu dizinin başlangıç adresine ilişkin adres sabiti gibi işleme
girer.
Medemki dizi isimleri adres belirtmektedir, o halde bir dizi ismini biz aynı türden bir göstericiye atayabiliriz.
Örneğin:
124

int *pi;
int a[3];
pi = a;

/* geçerli */

Örneğin:
int *pi;
char s[10];

pi = s;

/* geçersiz! s char türden adres belirtir */

Örneğin:
int a[10];
int b;
b = a;

/* Geçersiz! a bir adres bilgisidir ve göstericiye yerleştirilebilir */

Bir göstericiye bir adres bilgisi atandığında aslında gösterici yalnızca adresin sayısal bileşenini tutar. (Tabi bu
durum göstericiye adi bir sayı atıyabileceğemiz anlamına gelmiyor).
Bir göstericiye bir adres adres bilgisi atandığında o göstericinin o adresi gösterdiği söylenir. Örneğin:

Burada pi göstericisi a dizisinin başlangıç adresini göstermektedir.
& (Address Of) Operatörü
& sembolü C'de "address of" isimli bir adres operatörü belirtir. & tek operandlı önek bir operatördür. Öncelik
tablosunun ikinci düzeyinde sağdan sola grupta bulunmaktadır:
()

Soldan-Sağa

+ - ++ -- ! sizeof & Sağdan-Sola
* /%

Soldan-Sağa

+ -

Soldan-Sağa

...

...

& operatörü operand olarak bir nesne alır. Operatör bize nesnenin bellekteki yerleşim adresini verir. & operatörü
ile çekilen adresin sayısal bileşeni operand olan nesnenin bellekteki fiziksel adres numarasıdır. Tür bileşeni ise
125

nesnenin türüyle aynı türdendir. Örneğin:

Dizi isimleri zaten adres belirtmektedir. Bu nedenle yanlışlıkla dizi isimlerine & uygulamamak gerekir. Fakat adi
nesnelerin adreslerini almak için & operatörü kullanmak gerekir.
& operatörüyle elde ettiğimiz adresler ancak aynı türdne bir göstericiye atanbilir.
int a;
int *pi;
char *pc;
pi = &a;
pc = &a;

/* geçerli */
/* geçersiz! */

& operatörünün operandı bir nesne olabilir. Nesne belirtmeyen bir ifade olamaz. Çünkü yalnızca nesnelerin
adresleri vardır. Örneğin:
#define MAX

100

int *pi;
pi = &100;
pi = &MAX;

/* geçersiz! */
/* geçersiz! */

* (Indirection) Operatörü
* tek operandlı önek bir adres operatörüdür. * operatörünün operandı bir adres bilgisi olmak zorundadır. *
operatörü operandı olan adresteki nesneye erişmekte kullanılır. * operatörüyle elde edilen nesnenin türü operanda
olan adresin türüyle aynı türdendir. Örneğin:

pi göstericini kullandığımızda onun içerisindeki adres bilgisini kullanıyor oluruz. Ancak *pi ifadesi pi adresindeki
nesneyi belirtir. Bu da şekilde görüldüğü gibi a'dır. Burada *pi ifadesi int türdendir. Çünkü pi adresi int türdendir.
Örneğin:
#include <stdio.h>

126

int main(void)
{
int a = 100;
int *pi;
pi = &a;
printf("%d\n", *pi);
*pi = 150;
printf("%d\n", a);

/* 100 */
/* 150 */

return 0;
}

Örneğin:
#include <stdio.h>
int main(void)
{
char ch;
char *pc;
pc = &ch;
*pc = 'x';
putchar(ch);
return 0;
}

Örneğin:
#include <stdio.h>
int main(void)
{
int a[3] = { 10, 20, 30 };
int *pi;
pi = a;
*pi = 100;
printf("%d\n", a[0]);
return 0;
}

Buradada yapılan işlemleri şekilsel olarak şöyle ifade edilebilir:

p bir adres belirtiyor olsun. Aşağıdaki gibi bir atamadan bellekteki kaç byte etkilenir:
127

*p = 0;
İşte p eğer char türdense p adresinden itibaren 1 byte etkilenir. p int türdense 4 byte, double türdense 8 byte
etkilenecektir.
Aşğıdaki gibi bir gösterici bildirimi yapılmış olsun:
int *pi;

Buaradan iki şey anlaşılır:
1) Burada pi int * türündendir. (pi'yi kapatıp sola baktımızda int * görüyoruz).

2) pi göstericisini * operatörü ile kullanırsak int bir nesne elde ederiz (*pi'yi kapatıp sola baktığımızda int
görüyoruz).

C'de adres türleri sembolik olarak T * ile ifade edilir. Örneğin:
char *pc;
Burada pc'nin türü char * biçimindedir. *pc ise char türdendir.
* operatörü öncelik tablosunun ikinci düzeyinde sağdan sola grupta bulunur:
()

Soldan-Sağa

+ - ++ -- ! sizeof & *

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

...

...

Örneğin:
a = *pi * 50;
Burada:
İ1: *pi
İ2: İ1 * 50
İ3: a = İ2
* operatörünün operandı gösterici olmak zorunda değildir. Adres belirten herhangi bir ifade olabilir. Yani *
operatörünün operandı şunlar olabilir.
128

1) Bir gösterici (*pi gibi)
2) Bir adres sabiti. Örneğin:
*(int *) 0x1FC0 = 100;
3) & operatörü elde edilmiş bir adres (*&a gibi)
4) Bir dizi ismi olabilir. Örneğin:
int a[] = {1, 2, 3};
*a = 100;
/* geçerli */

5) String ifadeleri (henüz görmedik)
& ve * operatörlerinin sağdan sola aynı grupta olduğuna dikkat ediniz. Örneğin:
int a = 100;
*&a = 200;
printf("%d\n", a);

Burada:
İ1: &a
İ2: *İ1
İ3: İ2 = 200
Örneğin:
#include <stdio.h>
int main(void)
{
int a = 100;
*&a = 200;
printf("%d\n", a);
return 0;
}

Örneğin:
#include <stdio.h>
int main(void)
{
int a[3] = { 10, 20, 30 };
int i;
*a = 100;
for (i = 0; i < 3; ++i)
printf("%d\n", a[i]);
return 0;
}

129

Adreslerin Artırılması ve Eksiltilmesi
Adres bilgileri tamsayı türlerine ilişkin değerlerle toplama ve çıkartma işlemine sokulabilir. Yani, p bir adres
bilgisi n de bir tamsayı türünden olmak üzere p + n ve p - n ifadeleri geçerlidir (Ancak n - p ifadesi geçerli değildir).
Bir adxres bilgisine bir tamsayıyı topladığımızda ya da bir adres bilgisinden bir tamsayı çıkarttığımızda elde edilen
ürün yine aynı türden bir adres bilgisi olur. Örneğin pi int türünden bir adres bilgisi (int *) olsun:
pi + 1

ifadesi int türden bir adres bilgisi belirtir. C'de bir adres bilgisi 1 artırıldığında ya da 1 eksiltildiğinde adresin
sayısal bileşeni o adresin türünün uzunluğu kadar artar ya da eksilir. Yani örneğin int türden bir göstericiyi 1
artırdığımızda içindeki adres 32 bit sistemlerde 4 artacaktır. char türden bir gösterici bir adtırdığımızda içindeki
adres 1 artacaktır.
Bu durumda dizi elemanları ardışıl olduğuna göre biz dizinin başlangıç adresini aynı türden bir göstericiye
yerleştirip sonra o göstericiyi artırarak dizinin tüm elemanlarına erişebiliriz:

Örneğin:
#include <stdio.h>
int main(void)
{
int a[3] = { 10, 20, 30 };
int *pi;
int i;
pi = a;
printf("%d\n", *pi);
++pi;
printf("%d\n", *pi);
++pi;
printf("%d\n", *pi);

/* 10 */
/* 20 */
/* 30 */

return 0;
}

* operatörünün opeandı adres türünden olmak zorudadır. Örneğin:
130

int a = 0x1Fc0;
*a = 10;

/* geçersiz! */

char türden bir dizinin adresini char türden bir göstericiye atadıktan sonra göstericiyi artıra artıra yazının tüm
karakterlerine erişebiliriz. Örneğin:
#include <stdio.h>
int main(void)
{
char s[] = "ankara";
char *pc;
pc = s;
while (*pc != '\0') {
putchar(*pc);
++pc;
}
putchar('\n');
return 0;
}

Köşeli parantez (Index) Operatörü
Köşeli parantez operatörü tek operandlı sonek bir operatördür. Köşeli parantezler içerisinde tamsayı türlerine iliikin
bir ifade bulunmak zorundadır. Köşeli parantez operatörü öncelik tablosunun tepe grubunda (..) operatörü ile
soldan sağa aynı gruptadır:
() []

Soldan-Sağa

+ - ++ -- ! sizeof & *

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

...

...

Köşeli parantez operatörünün operandı bir adres bilgisi olmak zorundadır. p bir adres belirten ifade olmak üzere:
p[n] ile *(p + n) aynı anlamdadır. p[n] ifadesi p adresinden n ilerideki nesneyi temsil eder.
Dizi isimleri dizilerin başlangıç adresini belirttiği için dizi elemanlarına köşeli parantez operatörü ile
erişilebilmektedir. Örneğin:
int a[3] = {10, 20, 30};
a[2] ifadesi a adresinden 2 ilerinin (yani 2 * sizeof(*a) kadar byte ilerinin) içeriği anlamına gelir. Yani a[2] ile *(a
+ 2) aynı anlamdadır.
Pekiyi p[0] ne anlama gelir? Bu ifade p adresinden 0 ilerinin içeriği anlamına gelir. *(p + 0) ile ve dolayısyla *p ile
aynı anlamdadır.
Biz köşeli parantez operatörünü göstericilerle, dizi isimleriyle ve diğer adres belirten ifadelerle kullanabiliriz.
Örneğin:
131

#include <stdio.h>
int main(void)
{
char s[] = "ankara";
char *pc;
int i;
pc = s;
for (i = 0; pc[i] != '\0'; ++i)
putchar(pc[i]);
putchar('\n');
return 0;
}

Köşeli parantez içerisindeki ifade negatif bir değer de belirtebilir. Örneğin:
#include <stdio.h>
int main(void)
{
int a[3] = { 10, 20, 30 };
int *pi;
pi = a + 2;
printf("%d\n", pi[-2]);

/* 10 */

return 0;
}

Göstericilere İlkdeğer Verilmesi
Göstericilere de bildirim sırasında '=' atomu ile ilkdeğer verebiliriz. Örneğin:
int *pi = (int *)0x1FC0;

Burada adres p'ye atanmaktadır. Bildirimdeki yıldız operatör görevinde değildir. Tür belirtmek için
kullanılmaktadır. Başka bir örnek:
int a = 123;
int *pi = &a;

Örneğin:
#include <stdio.h>
int main(void)
{
int a[3] = { 10, 20, 30 };
int *pi = a;
// p'ye dizinin başlangıç adresi atanıyor
int i;
for (i = 0; i < 3; ++i)
printf("%d ", pi[i]);
printf("\n");
return 0;
}

132

Fonksiyon Parametresi Olarak Göstericilerin Kullanılması
Bir fonksiyonun parametresi bir gösterici olabilir. Örneğin:
void foo(int *pi)
{
...
}

Bir fonksiyonun parametresi bir gösterici ise biz o fonksiyonu aynı türden bir adres bilgisi ile çağırmalıyız.
Örneğin:
int a = 10;
...
foo(a);
foo(&a);

// geçersiz!
// geçerli

Örneğin:
#include <stdio.h>
void foo(int *pi)
{
*pi = 200;
}
int main(void)
{
int a = 123;
foo(&a);
printf("%d\n", a);
return 0;
}

Burada foo fonksiyonuna a'nın içindeki değer değil, a'nın adresi geçirilmiştir. Böylece fonksiyon içerisinde *pi
dediğimizde aslında bu ifade main fonksiyonundaki a'ya erişir.

C'de bir fonksiyonun başka bir fonksiyonun yerel değişkenini değiştirebilmesi için onun adresini alması gerekir.
Bunun için de fonksiyonun parametre değişkeninin gösterici olması gerekir. (Aslında tüm dillerde böyledir. Çünkü
makinanın çalışma prensibinde durum böyledir.)
İki yerel nesnenin içerisindeki değerleri değiştiren swap isimli bir fonksiyon yazmak isteyelim. Acaba bu
fonksiyonu aşağıdaki gibi yazabilir miyiz?
133

#include <stdio.h>
void swap(int a, int b)
{
int temp = a;
a = b;
b = temp;
}
int main(void)
{
int x = 10, y = 20;
swap(x, y);
printf("x = %d, y = %d\n", x, y);
return 0;
}

Yanıt hayır! Çünkü burada swap x ve y'nin içindekilerini değiştirmiyor, parametre değişkeni olan a ve b'nin
içindekileri değiştiriyor. Bunun sağlanabilmesi için yerel nesnelerin adreslerinin swap fonksiyonuna aktarılması
gerekir. Bu durumda swap fonksiyonunun paremetre değişkenleri birer gösterici olmalıdır:
#include <stdio.h>
void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
int main(void)
{
int x = 10, y = 20;
swap(&x, &y);
printf("x = %d, y = %d\n", x, y);
return 0;
}

Dizilerin Fonksiyonlara Parametre Yoluyla Aktarılması
Dizi elemanları bellekte ardışıl bir biçimde tuutlduğuna göre biz bir diziyi yalnızca onun başlangıç adresi yoluyla
fonksiyona aktarabiliriz. Böylece dizinin başlangıç adresini alan fonksiyon * ya da [ ] operatörü ile dizinin her
elemanına erişebilir. Dizilerin fonksiyonlara parametre yoluyla aktarılmasında mecburen göstericilerden
faydalanılmaktadır.
#include <stdio.h>
void foo(int *pi)
{
int k;
for (k = 0; k < 10; ++k) {
printf("%d ", *pi);
++pi;
}
printf("\n");
}

134

void bar(int *pi)
{
int k;
for (k = 0; k < 10; ++k)
printf("%d ", pi[k]);
printf("\n");
}
int main(void)
{
int a[10] = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
foo(a);
bar(a);
return 0;
}

Yukarıdaki fonksiyonlar dizinin uzunluğununun 10 olduğunu biliyor durumdalar. Biz bu fonksiyonlara ancak 10
elemanlı dizilerin başlangıç adreslerini yollayabiliriz. eğer dizilerle çalışan fonksiyonların daha genel olmasını
istiyorsak o fonksiyonlara ayrıca dizinin uzunluğunu geçirmemiz gerekir. Örneğin:
#include <stdio.h>
void foo(int *pi, int size)
{
int k;
for (k = 0; k < size; ++k) {
printf("%d ", *pi);
++pi;
}
printf("\n");
}
void bar(int *pi, int size)
{
int k;
for (k = 0; k < size; ++k)
printf("%d ", pi[k]);
printf("\n");
}
int main(void)
{
int a[10] = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
int b[5] = { 1, 2, 3, 4, 5 };
foo(a, 10);
bar(b, 5);
return 0;
}

Örneğin:
#include <stdio.h>
int getmax(int *pi, int size)
{
int max = pi[0];
int i;

135

for (i = 1; i < size; ++i)
if (pi[i] > max)
max = pi[i];
return max;
}
int main(void)
{
int a[5] = { 23, -4, 21, 34, 32 };
int max;
max = getmax(a, sizeof(a)/sizeof(*a));
printf("%d\n", max);
max = getmax(a, 3);
printf("%d\n", max);
return 0;
}

Burada getmax int bir dizinin en büyük elemanına geri dönmektedir.
double bir dizinin standart sapmasını hesaplayan fonksiyon şöyle yazılabilir:
#include <stdio.h>
#include <math.h>
double getavg(double *pd, int size)
{
double total;
int i;
total = 0;
for (i = 0; i < size; ++i)
total += pd[i];
return total / size;
}
double get_stddev(double *pd, int size)
{
double avg, total;
int i;
avg = getavg(pd, size);
total = 0;
for (i = 0; i < size; ++i)
total += pow(pd[i] - avg, 2);
return sqrt(total / (size - 1));
}
int main(void)
{
double a[5] = { 1, 1, 1, 1, 2 };
double result;
result = get_stddev(a, 5);
printf("%f\n", result);
return 0;

136

}

Örneğin bir diziyi kabarcık sıralaması (bubble sort) yöntemiyle sıraya dizen fonksiyon şöyle yazılabilir:
#include <stdio.h>
void bsort(int *pi, int size)
{
int i, k;
for (i = 0; i < size - 1; ++i)
for (k = 0; k < size - 1 - i; ++k)
if (pi[k] > pi[k + 1]) {
int temp = pi[k];
pi[k] = pi[k + 1];
pi[k + 1] = temp;
}
}
void disp_array(int *pi, int size)
{
int i;
for (i = 0; i < size; ++i)
printf("%d ", pi[i]);
printf("\n");
}
int main(void)
{
int a[] = { 4, 8, 2, 21, 43, 10, -5, 87, 9, 68 };
bsort(a, 10);
disp_array(a, 10);
return 0;
}

Sınıf Çalışması: 10 elemanlı int türden bir dizi tanımlayınız. Bu dizinin elemanlarını ters yüz eden aşağıdaki
prototipe sahip fonksiyonu yazarak test ediniz:
void rev_array(int *pi, int size);
Çözüm:
#include <stdio.h>
void rev_array(int *pi, int size)
{
int i, temp;
for (i = 0; i < size / 2; ++i) {
temp = pi[i];
pi[i] = pi[size - i - 1];
pi[size - i - 1] = temp;
}
}
void disp_array(int *pi, int size)
{
int i;
for (i = 0; i < size; ++i)

137

printf("%d ", pi[i]);
printf("\n");
}
int main(void)
{
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
rev_array(a, 10);
disp_array(a, 10);
return 0;
}

Gösterici Parametrelerinin Alternatif Biçimi
C'de bir fonksiyonun parametre değişkeni bir gösterici ise bu alternatif olarak dizi sentaksıyla da
belirtilebilmektedir. Bu alternatif sentaksta köşeli parantezlerin içi boş bırakılabilir. Fakat köşeli parantezlerin
içerisine bir uzunluk yazılsa bile bunun hiçbir özel anlamı yoktur. Yani köşeli parantezlerin içinin boş
bırakılmasıyla, onun içerisine bir uzunluk yazılması arasında bir fark yoktur. Örneğin:
void foo(int *pi)
{
...
}
bildirimi ile aşağıdaki tamamen eşdeğerdir:
void foo(int pi[])
{
...
}
bununla da aşağıdaki eşdeğerdir:
void foo(int pi[10])
{
...
}
Tabii bu eşdeğerlik yalnızca fonksiyon parametresi söz konusu olduğunda geçerlidir. Yani:
int pi[];
int pi[10];

/* geçersiz! Dizi uzunluğu belirtilmemiş! */
/* pi gösterici değil 10 elemanlı bir dizi */

Kaynak Kodun Okunabilirliği ve Anlaşılabilirliği
Kaynak kodun bakıldığında (ileride bizim tarafımızdan ya da başkaları tarafından) kolay anlaşılması önemlidir.
Buna genel olarak okunabilirlik (readabilty) denilmektedir. Okunabilirliği sağlamak için bazı temel öğelere dikkat
etmek gerekir:
1) Kaynak kodda bazı kritik noktalara açıklama (yorum) yerleştirilebilir. Örneğin:
if (delta >=
...
}

0) {

/ * kök var mı? */

138

Çok fazla açıklama bilgisi de okunabilirliği azaltmaktadır. Uygun yerlere, çok uzun olmayan ve genellikle soru
cümleleri biçiminde açıklama yapmak uygun olur.
2) Değişkenlere anlamlı ve telaffuz edilebilir isimler verilmelidir. İsimlendirme Türkçe olabilir. Ancak şu da
unutulmamalıdır ki, maalesef uluslararası düzeyde herkes İngilizce isimlendirme beklemektedir. Fakat kodumuzu
örneğin Internet ortamında uluslararası paylaymayacaksak isimlendirmeleri Türkçe yapabiliriz. Örneğin döngü
değişkenleri için i, j, k, l, m, n gelenekseldir (Fortran zamanlarından gelme bir gelenek). Tabi bazen n, count gibi
isimler kullanılabilir.
3) Global değişkenlerin özel bir önekle (örneğin g_xxx biçiminde) başlatılması uygun olabilir. Örneğin g_count
gibi.
4) Değişken isimlendirmesinde harflendirme (capitalization) önemlidir. Harflendirme bir sözcük uzun olan
isimlerin yazılış biçimlerini belirlemek anlamına gelir. Tipik olarak programda dillerinde üç harflendirme tarzı
vardır:
a) Pascal Tarzı Harflendirme (Pascal casting): Burada her sözcüğün ilk harfi büyük yazılır (bu tarz Pascal dilinde
çok kullanıldığı için Pascal tarzı denilmektedir). Örneğin:
CreateWindow
GetWindowText
NumberOfStudents
...
b) Klasik C Tarzı (C Style): Bu tarzda isimlerde büyük harf kullanılmaz. Sözcükleri ayırmak için alt tire kullanılır.
Örneğin:
create_window
get_window_text
number_of_students
Bu tarz UNIX/Linux sistemlerinde C programlama dilinde baskın olarak kullanılmaktadır.
c) Deve Notasyonu (Camel casting): Bu tarzda ilk sözcüğün tamamı küçük harflerle sonraki sözcüklerin yalnızca
ilk harfleri büyük harflerle belirtilir. C++ QT framework'ünde, Java'da bu biçim tercih edilmektedir.
Biz kursumuzda global değişkenleri g_ ile başlatarak harflendireceğiz. Fonksiyon isimlerini Klasik C Tarzında,
yerel ve parametre değişkenlerini deve notasyonunda harflendireceğiz.
Windows altında C programcıları fonksiyon isimlerini genel olarak Pascal tarzı harflendirmektedir.
5) Okunabilirliği sağlamada en önemli unsurlardan biri de kaynak kodun genel düzenidir. Bunun için birkaç tarz
kullanılmaktadır. Biz kursumuzda Ritchie/Kernighan tarzını kullanıyoruz. Bu tarzın anahtar noktaları şunlardır:
a) Fonksiyonlar en soldaki sütuna dayalı olarak tanımlanırlar. Fonkisyon tanımlamaları arasında bir satır boşluk
bırakılır.
b) Bildirim satırlarından sonra bir satır boşluk bırakılır. Örneğin:

139

c) Üst üste birden fazla SPACE kullanılmaz. Bir SPACE yetmezse TAB kullanılır. Üst üste birdeb fazla TAB
kullanılabilir.
d) Blok içleri bir TAB içeriden yazılır. Örneğin:

e) İki operandlı operatörlerle operandlar arasında bir SPACE boşluk bırakılır. Ancak tek operandlı operatörlerle
operand arasında boşluk bırakılmaz. (İstisna olarak iki operandlı nokta ve ok operatörleriyle operandlar arasında
boşluk bırakılmaz.) Örneğin:

f) Anahtar sözcüklerden sonra 1 SPACE boşluk bırakılır. Ancak fonksiyon isimlerinden sonra bırakılmaz. Örneğin:

140

g) Yazıdaki paragraf duygusu programlamada boş satır bırakılarak verilir. Yani konudan konuya geçerken bir satır
boşluk bırakılmalıdır.
h) if deyiminin yazımı şöyledir:
Bloksuz biçim:

Bloklu biçim:

else-if Merdiveni:

141

i) for deyimi şöyle yazılır:
Bloksuz biçim:

Bloklu biçim:

j) while deyimi şöyle yazılır:
Bloksuz biçim:

Bloklu biçim:

k) switch deyimi şöyle yazılır:
142

l) Sembolik sabitleri yazarken STR1'ler ve STR'ler alta alta gelmelidir. Bunun için yeterli tablama yapılabilir.
Örneğin:

m) goto etiketleri büyük harflerle oluşturulmalıdır ve bir TAB geride bulunmalıdır. Örneğin:

n) Virgül atomundan önce boşluk bırakılmaz, sonra bir SPACE boşluk bırakılır. Örneğin:

Yazıların Fonksiyonlara Parametre Yoluyla Aktarılması
Yazıları fonksiyonlara parametre yoluyla aktarmak için yalnızca onların başlangıç adreslerinin fonksiyona
143

geçirilmesi yeterlidir. Ayrıca onların uzunluklarının fonksiyonlara aktarılması gereksizdir. Çünkü yazıların
sonunda null karakter olduğu için yazının başlangıç adresini alan fonksiyon null karakter görene kadar ilerleyerek
yazının tüm karakterlerini elde edebilir. Tabi bu durumda fonksiyonun parametre değişkeni char türden gösterici
olmalıdır. null karakter görene kadar yazının tüm karakterlerini dolaşmak için iki kalıp kullanılabilir:
1)
while (*str != '\0') {
/* ... */
++str;
}

2)
for (i = 0; str[i] != '\0'; ++i) {
/* ... */
}

Örneğin aslında puts fonksiyonu bizden char türden bir adres alıp null karakter görene kadar karakterleri ekrana
yazdırmaktadır. Aynı fonksiyonu biz de şöyle yazabiliriz:
#include <stdio.h>
void myputs(char *str)
{
while (*str != '\0') {
putchar(*str);
++str;
}
putchar('\n');
}
int main(void)
{
char s[] = "ankara";
myputs(s);
puts(s);
myputs(s + 2);
puts(s + 2);
return 0;
}

Sınıf çalışması: Başlangıç adresiyle verilen bir yazıyı tersten yazdıran putrev fonksiyonu yazınız:
void putsrev(char *str);
Çözüm:
#include <stdio.h>
void putsrev(char *str)
{
int i;
for (i = 0; str[i] != '\0'; ++i)
;
for (--i; i >= 0; --i)
putchar(str[i]);

144

putchar('\n');
}
int main(void)
{
char s[] = "ankara";
putsrev(s);
return 0;
}

Sınıf Çalışması: Bir yazı içerisinde belli bir karakterden kaç tane olduğunu bulan ve o sayıya geri dönen aşağıdaki
prototipe sahip sonksiyonu yazınız:
int getch_count(char *str, char ch);
Çözüm:
#include <stdio.h>
int getch_count(char *str, char ch)
{
int count = 0;
while (*str != '\0') {
if (*str == ch)
++count;
++str;
}
return count;
}
int main(void)
{
char s[] = "ankara";
int result;
result = getch_count(s, 'a');
printf("%d\n", result);
return 0;
}

Fonksiyonların Geri Dönüş Değerlerinin Adres Olması Durumu
Bir fonksiyonun geri dönüş değeri bir adres bilgisi olabilir. Bu durumda T bir tür belirtmek üzere geri dönüş değeri
T * biçiminde belirtilmelidir. Örneğin:
int *foo(void)
{
/* ... */
}
Burada foo fonksiyonu int türden bir adrese geri döner. Tabi böyle bir fonksiyonun geri dönüş değeri aynı türden
bir göstericiye atanmalıdır. Örneğin:
int *pi;
...
145

pi = foo();
Örneğin bir dizideki en büyük elemanın adresiyle geri dönen getmax_addr isimli bir fonksiyonu yazacak olalım:
#include <stdio.h>
int *getmax_addr(int *pi, int size)
{
int *pmax = &pi[0];
int i;
for (i = 1; i < size; ++i)
if (pi[i] > *pmax)
pmax = &pi[i];
return pmax;
}
int main(void)
{
int a[10] = { 34, 21, 87, 45, 32, 67, 93, 22, 9, 2 };
int *pmax;
pmax = getmax_addr(a, 10);
printf("%d\n", *pmax);
return 0;
}

Yukarıdaki örnekte dizinin en büyük elemanını değiştirmek isteyelim:
#include <stdio.h>
int *getmax_addr(int *pi, int size)
{
int *pmax = &pi[0];
int i;
for (i = 1; i < size; ++i)
if (pi[i] > *pmax)
pmax = &pi[i];
return pmax;
}
void disp_array(int *pi, int size)
{
int i;
for (i = 0; i < size; ++i)
printf("%d ", pi[i])
;
printf("\n");
}
int main(void)
{
int a[10] = { 34, 21, 87, 45, 32, 67, 93, 22, 9, 2 };
int *pmax;
disp_array(a, 10);
*getmax_addr(a, 10) = 1000;
disp_array(a, 10);
return 0;

146

}

Anahtar Notlar: C'de bir adresin sayısal bileşeni printf fonksiyonunda %p format karakteriyle yazdırılır. Örneğin:
char s[10];
printf("%p\n", s);
C'de Standart String Fonksiyonları
C'de ismi str ile başlayan strxxx biçiminde bir grup standart fonksiyon vardır. Bu fonksiyonlara string
fonksiyonları denir. Bu fonksiyonlar bir yazının başlangıç adresini parametre olarak alırlar, onunla ilgili faydalı
işlemler yaparlar. Bu fonksiyonların prototipleri <string.h> dosyası içerisinde bulunmaktadır.
strlen fonksiyonu
strlen fonksiyonu bir yazının karakter uzunluğunu bulmak için kullanılmaktadır:
unsigned int strlen(char *str);
Fonksiyon parametre olarak char türden bir yazının başlangıç adresini alır, geri dönüş değeri olarak bu yazının
karakter uzunluğunu verir.
Anahtar Notlar: strlen fonksiyonun orijinal prototipi şöyledir:
size_t strlen(const char *str);
size_t türü ve const göstericiler ileride ele alınacaktır.

Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[100];
unsigned n;
printf("Bir yazi giriniz:");
gets(s);
n = strlen(s);
printf("%u\n", n);
return 0;
}

strlen fonksiyonu aşağıdaki gibi yazılabilir:
#include <stdio.h>
#include <string.h>
unsigned mystrlen(char *str)
{
int i;
for (i = 0; str[i] != '\0'; ++i)
;

147

return i;
}
unsigned mystrlen2(char *str)
{
int count = 0;
while (*str != '\0') {
++count;
++str;
}
return count;
}
int main(void)
{
char s[100];
unsigned n;
printf("Bir yazi giriniz:");
gets(s);
n = mystrlen(s);
printf("%u\n", n);
n = mystrlen2(s);
printf("%u\n", n);
return 0;
}

strcpy Fonksiyonu
Bu fonksiyon char türden bir dizi içerisindeki yazıyı başka bir diziye kopyalamakta kullanılır. Prototipi şöyledir:
char *strcpy(char *dest, char *source);

Fonksiyon ikinmci parametresiyle belirtilen adresten başlayarak null karakter görene kadar (null karakter de dahil)
tüm karakterleri birinci parametresi ile başlayan adresten itibaren kopyalar. Birinci parametresiyle verilen adresin
aynısına geri döner. Uygulamada geri dönüş değerine ciddi bir biçimde gereksinim duyulmamaktadır.
Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[32] = "ankara";
char d[32];
strcpy(d, s);
puts(d);
return 0;
}

Örneğin:
148

#include <stdio.h>
#include <string.h>
int main(void)
{
char s[32] = "ankara";
char d[32];
strcpy(d, s + 2);
puts(d);

/* kara */

return 0;
}

strcpy fonksiyonu aşağıdaki gibi yazılabilir:
#include <stdio.h>
#include <string.h>
char *mystrcpy(char *dest, char *source)
{
int i;
for (i = 0; (dest[i] = source[i]) != '\0'; ++i)
;
return dest;
}
char *mystrcpy2(char *dest, char *source)
{
char *temp = dest;
while ((*dest = *source) != '\0') {
++dest;
++source;
}
return temp;
}
int main(void)
{
char s[32] = "ankara";
char d[32];
mystrcpy(d, s);
puts(d);
mystrcpy2(d, s);
puts(d);
return 0;
}

strcat Fonksiyonu
Bu fonksiyon bir yazının sonuna başka bir yazıyı eklemek için kullanılır. Prototipi şöyledir:
char *strcat(char *dest, char *source);
Fonksiyon ikinci parametresiyle belirtilen adresten başlayarak null karakter görene kadar tüm karakterleri (null
karakter de dahil) birinci parametresiyle belirtilen yazının sonuna null karakter ezerek kopyalar. Fonksiyon birinci
149

parametre ile belirtilen adresin aynısına geri döner.
Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[32] = "ankara";
char d[32] = "izmir";
strcat(d, s);
printf("%s\n", d);
return 0;
}

strcat fonksiyonu şöyle yazılabilir:
#include <stdio.h>
#include <string.h>
char *mystrcat(char *dest, char *source)
{
int i, k;
for (i = 0; dest[i] != '\0'; ++i)
;
for (k = 0; (dest[k + i] = source[k]) != '\0'; ++k)
;
return dest;
}
char *mystrcat2(char *dest, char *source)
{
char *temp = dest;
while (*dest != '\0')
++dest;
while ((*dest = *source) != '\0') {
++dest;
++source;
}
return temp;
}
int main(void)
{
char s[32] = "ankara";
char d[32] = "izmir";
mystrcat(d, s);
printf("%s\n", d);
mystrcat2(d, s);
printf("%s\n", d);
return 0;

/* izmirankaraankara*/

}

Sınıf Çalışması: 1000 elemanlık char türden s imli bir dizi ve bunun yanı sıra 32 elemanlık k isimli bir dizi
150

tanımlayınız. Bir döngü içerisinde gets fonksiyonuyla k dizisine okuma yapınız. Oradan da okunanları s dizisinin
sonuna ekleyiniz. Ta ki gets fonksiyonunda kullanıcı hiçbirşey girmeyip yalnızca ENTER tuşuna basana kadar.
Döngüden çıkınca s dizisini yazdırınız.
Çözüm:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[1000];
char k[32];
s[0] = '\0';
for (;;) {
printf("Isim giriniz:");
gets(k);
if (*k == '\0')
break;
strcat(s, k);
}
puts(s);
return 0;
}

strcmp Fonksiyonu
strcmp fonksiyonu iki yazıyı karşılaştırmak amacıyla kullanılır. Karşılaştırma şöyle yapılır: Yazıların karakterleri
eşit olduğu sürece devam edilir. İlk eşi,t olmayan karaktere gelindiğinde o karakterlerin hangisi karakter tablosunda
daha büyük numaraya sahipse o yazı o yazıdan büyüktür. ASCII tablosu için şöyle örnekler verebiliriz:
- "ali" yazısı "Ali" yazısından büyüktür.
- "ali" yazısı "aliye" yazısından küçüktür.
- "almanya" yazısı "ali" yazısından büyüktür.
strcmp fonksiyonunun prototipi şöyledir:
int strcmp(char *s1, char *s2);
Fonksiyon birinci yazı ikinci yazıdan büyükse pozitif herhangi bir değer, küçükse negatif herhangi bir değer ve
eşitse sıfır değerine geri döner.
Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[64];
char passwd[] = "maviay";
printf("Enter password:");
gets(s);
if (!strcmp(s, passwd))
printf("Ok\n");

151

else
printf("Invalid password\n");
return 0;
}

Fonksiyonu şöyle yazabiliriz:
#include <stdio.h>
#include <string.h>
int mystrcmp(char *s1, char *s2)
{
while (*s1 == *s2) {
if (*s1 == '\0')
break;
++s1;
++s2;
}
return *s1 - *s2;
}
int main(void)
{
char s[64];
char passwd[] = "maviay";
printf("Enter password:");
gets(s);
if (!mystrcmp(s, passwd))
printf("Ok\n");
else
printf("Invalid password\n");
return 0;
}

strcmp fonksiyonun büyük harf küçük harf duyarlılığı olmadan karşılaştırma yapan stricmp isimli bir versiyonu da
vardır. Ancak stricmp standart bir fonksiyon değildir. Fakat Microsoft derleyicilerinde, Borland derleyicilerinde ve
gcc derleyicilerinde bir eklenti biçiminde bulunmaktadır. stricmp fonksiyonu şöyle yazılabilir:
#include <stdio.h>
#include <string.h>
int mystricmp(char *s1, char *s2)
{
while (tolower(*s1) == tolower(*s2)) {
if (*s1 == '\0')
break;
++s1;
++s2;
}
return tolower(*s1) - tolower(*s2);
}
int main(void)
{
char s[64];
char passwd[] = "maviay";
printf("Enter password:");

152

gets(s);
if (!mystricmp(s, passwd))
printf("Ok\n");
else
printf("Invalid password\n");
return 0;
}

NULL Adres Kavramı (NULL Pointer)
NULL adres derleyici tarafından seçilmiş bir sayısal bileşene sahip olan özel bir adrestir. NULL adres C'de geçerli
bir adres kabul edilmez. Başarısızlığı anlatmak için kullanılır. NULL adresin sayısal değeri standartlara göre
derleyiciden derleyiciye değişebilir. Yaygın derleyicilerin hepsinde NULL adres 0 sayısal bileşenine sahip (yani
belleğin tepesini belirten) adrestir. Fakat NULL adres standartlara göre farklı sistemlerde farklı biçimde olabilir.
C'de 0 değerini veren tamsayı türlerine ilişkin sabit ifadeleri NULL adres sabiti olarak kullanılır. Örneğin:
5-5
0
1-1
gibi ifadeler aynı zamanda NULL adres sabiti anlamına gelmektedir. Biz bir göstericiye bu değerleri atadığımızda
derleyici o sistemde hangi sayısal bileşen NULL adres belirtiyorsa göstericiye onu atar. Yani buradaki 0, 0 adresini
temsil etmez. O sistemdeki NULL adresi temsil eder. Örneğin:
int *pi = 0;
Burada pi göstericisine int bir sıfır atanmıyor. O sistemde NULL adres neyse o değer atanıyor.
NULL adres sabitini (yani sıfır değerini) her türden göstericiye atayabiliriz. Bu durumda o göstericinin içerisinde
"NULL adres" bulunur. Örneğin:
char *pc = 0;
pc'nin içerisinde NULL adres vardır. NULL adres sabitinin türü yoktur. NULL adres sabiti (yani sıfır sayısı) her
türden göstericiye atanabilir. Yukarıdaki örnekte pc göstericisi char türündendir. Fakat içerisinde NULL adres
vardır.
Örneğin bir sistgemde NULL adresin sayısal bileşeni 0xFFFF olsun. Biz bu sistemde göstericiye NULL adres
atayabilmek için, göstericiye 0xFFFF atayamayız. Yine düz sıfır atarız. Bu düz sıfır zaten o sistemdeki NULL
adres anlamına gelir. Örneğin:
char *pc = 0;
Burada pc'ye sıfır adresi atanmıyor, o sistemdeki NULL adres olan 0xFFFF sayısal bileşenine sahip olan adres
atanıyor.
Anahtar Notlar: Standartlara göre NULL adres sabiti aynı zamanda sıfır değerinin void * türüne dönüşsütülmüş biçimi de olabilir. Yani (void *)0 da
NULL adres anlamına gelir.

Bir adresin NULL olup olmadığı == ve != operatörleriyle öğrenilebilir. Örneğin:
if (pi == 0) {
153

...
}
Burada pi'nin içerisindeki adresin sayısal bileşeninin sıfır olup olmadığına bakılmamaktadır. O sistemdeki NULL
adres olup olmadığına bakılmaktadır. Örneğin ilgili sistemde NULL adres 0xFFFF sayısal değerine ilişkin olsun.
Ve pi'in içerisinde NULL adres olduğunu varsayalım:
if (pi == 0) {
...
}
Burada if deyimi doğrudan sapar.
if parantezinin içerisinde yalnızca bir adres ifadesi varsa bu adresin NULL adres olup olmadığına bakılır. Eğer
adres NULL adres ise if deyimi yanlıştan sapar, NULL adres değilse doğrudan sapar. Örneğin:
if (pi) {
...
}
else {
...
}
Bu örnekte ilgili sistemde NULL adresin 0xFFFF olduğunu düşünelim. Yukarıdaki if deyimi yanlıştan sapacaktır.
Çünkü bu özel durumda adresin sayısal bileşeninin sıfır olup olmadığına değil, NULL adres olup olmadığına
bakılmaktadır. Benzer biçimde C'de ! operatörünün operandı bir adres bilgisiyse bu operatör adres NULL adres ise
1 değerini, NULL adres değilse 0 değerini üretir.
* ya da köşeli parantez operatörleriyle NULL adresin içeriği elde edilmeye çalışılırsa bu durum tanımsız davranışa
(undefined behavior) yol açar.
C'de NULL adres sabiti daha okunabilir ifade edilsin diye NULL isimli bir sembolik sabitle temsil edilmiştir:
#define NULL

0

Programcılar genellikle NULL adres sabiti için düz sıfır kullanmak yerine NULL sembolik sabitini kullanırlar.
Örneğin:
if (pi == NULL) {
...
}
NULL sembolik sabiti <stdio.h> v e pek çok başlık dosyasında bulunmaktadır. NULL sembolik sabitini int türden
bir sıfır olarak değil, NULL adres sabiti olarak kullanmalıyız.
strchr Fonksiyonu
Bu fonksiyon bir yazı içerisinde bir karakteri aramak için kullanılır. Eğer karakter yazı içerisinde bulunursa
fonksiyon karakterin ilk bulunduğu yerin adresiyle geri döner. Eğer bulunamazsa NULL adresle geri döner. Bu
fonksiyon null karakteri de arayabilmektedir.
char *strchr(char *str, char ch);
154

Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = "ankara";
char *str;
str = strchr(s, 'k');
if (str == NULL)
printf("karakter yok!..\n");
else
printf("Buldu:%s\n", str);
return 0;
}

strchr fonksiyonu şöyle yazılabilir:
#include <stdio.h>
char *mystrchr(char *str, char ch)
{
while (*str != '\0') {
if (*str == ch)
break;
++str;
}
if (*str == '\0' && ch != '\0')
return NULL;
return str;
}
int main(void)
{
char s[] = "ankara";
char *str;
str = mystrchr(s, 'k');
if (str == NULL)
printf("karakter yok!..\n");
else
printf("Buldu:%s\n", str);
return 0;
}

strrchr Fonksiyonu
Fonksiyon tamamen strchr fonksiyonu gibidir. Ancak ilk bulunan karakterin değil son bulunan karakterin adresiyle
geri döner. Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = "izmir";
char *str;

155

str = strrchr(s, 'i');
if (str == NULL)
printf("karakter yok!..\n");
else
printf("Buldu:%s\n", str);
return 0;
}

strrchr fonksiyonu şöyle yazılabilir:
#include <stdio.h>
#include <string.h>
char *mystrrchr(char *str, char ch)
{
char *result = NULL;
while (*str != '\0') {
if (*str == ch)
result = str;
++str;
}
if (ch == '\0')
return str;
return result;
}
int main(void)
{
char s[] = "izmir";
char *str;
str = mystrrchr(s, 'i');
if (str == NULL)
printf("karakter yok!..\n");
else
printf("Buldu:%s\n", str);
return 0;
}

strncpy Fonksiyonu
Bu fonksiyon bir yazının ilk n karakterini başka bir diziye kopyalar. Prototipi şöyledir:
char *strncpy(char *dest, char *source, unsigned n);
Bu fonksiyonda eğer n değeri strlen(source) değerinden küçük ya da eşitse fonksiyon null karakteri hedef diziye
eklemez. Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = "izmir";
char d[32] = "ankara";

156

strncpy(d, s, 3);
puts(d);
/* izmara */
return 0;
}

Eğer n değeri strlen(source) değerinden büyükse ya da eşitse hedefe null karakter de kopyalanır. Üstelik geri kalan
miktar kadar null karakter kopyalanır. Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = "izmir";
char d[32] = "ankara";
strncpy(d, s, 30);
puts(d);
/* izmir çıkacak fakat 24 tane null karakter d'ye eklenecek */
return 0;
}

Fonksiyon yine strcpy de olduğu gibi, kopyalamanın yapıldığı hedef adrese geri döner.
strncpy fonksiyonu şöyle yazılabilir:
#include <stdio.h>
#include <string.h>
char *mystrncpy(char *dest, char *source, unsigned n)
{
char *temp = dest;
while (n-- > 0) {
*dest = *source;
if (*source != '\0')
++source;
++dest;
}
return temp;
}
int main(void)
{
char s[] = "izmir";
char d[32] = "ankara";
mystrncpy(d, s, 30);
puts(d);
/* izmir çıkacak fakat 24 tane null karakter d'ye eklenecek */
return 0;
}

strncat Fonksiyonu
Bu fonksiyon bir yazının sonuna başka bir yazının ilk n karakterini ekler. Prototipi şöyledir:
char *strncat(char *dest, char *source, unsigned n);
157

Fonksiyon her zaman null karakteri ekler. Ancak n > strlen(source) ise null karakteri ekleyip işlemini sonlandırır.
(Yani strcpy'de olduğu gibi geri kalan miktar kadar null karakter eklemez.) Başka bir deyişle eğer n > strlen(source)
ise fonksiyon tamamen strcat gibi çalışır. Fonksiyon yine birinci parametresiyle belirtilen adresin aynısına geri
döner. Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = "izmir";
char d[32] = "ankara";
strncat(d, s, 3);
puts(d);
/* ankaraizm */
return 0;
}

Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = "izmir";
char d[32] = "ankara";
strncat(d, s, 100);
puts(d);
/* ankaraizmir çıkar fakat dizi taşması olmaz */
return 0;
}

strncat fonksiyonu şöyle yazılabilir:
#include <stdio.h>
#include <string.h>
char mystrncat(char *dest, char *source, unsigned n)
{
char *temp = dest;
while (*dest != '\0')
++dest;
while ((*dest = *source) != '\0' && n > 0) {
++dest;
++source;
--n;
}
/* if (n == 0) */
*dest = '\0';
return temp;
}
int main(void)
{
char s[] = "izmir";
char d[32] = "ankara";

158

mystrncat(d, s, 50);
puts(d);
/* ankaraizmir çıkar fakat dizi taşması olmaz */
return 0;
}

strncmp Fonksiyonu
Bu fonksiyon iki yazının ilk n karakterinmi karşılaştırmakta kullanılmaktadır. Fonksiyonun prototipi şöyledir:
int strncmp(char *s1, char *s2, unsigned n);
Fonksiyonun üçüncü parametresi ilk kaç karakterin karşılaştırılacağını belirtir. n sayısı büyükse iki yazıdan
hangisinde null karakter görülürse işlem biter. Fonksiyonun geri dönüş değeri yine strcmp fonksiyonunda olduğu
gibidir.
Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char passwd[] = "maviay";
char s[64];
printf("Enter password:");
gets(s);
if (!strncmp(passwd, s, strlen(s)))
printf("Ok\n");
else
printf("invalid password\n");
return 0;
}

Adres Operatörleriyle ++ ve -- Operatörlerinin Birlikte Kullanılması
1) * Operatörüyle Kullanım
a) ++*p Kullanımı: Burada *p bir artırılır. Yani bu ifade *p = *p + 1 ile eşdeğerdir.
#include <stdio.h>
int main(void)
{
int a = 10;
int *pi = &a;
++*pi;
printf("%d\n", a);

/* 11 */

return 0;
}

b) *++p Durumu: Burada önce p bir artırılır sonra artırılmış adresin içeriğine erişilir. Örneğin:
159

#include <stdio.h>
int main(void)
{
int a[2] = { 10, 20 };
int *pi = a;
*++pi = 30;
printf("%d\n", a[1]);

/* 30 */

return 0;
}

c) *p++ Durumu: Burada p bir artırılır ancak ++ sonek durumunda olduğu için artırılmış adresin içeriğine erişilir.
Örneğin:
#include <stdio.h>
char *mystrcpy(char *dest, char *source)
{
char *temp = dest;
while ((*dest++ = *source++) != '\0')
;
return temp;
}
int main(void)
{
char s[] = "ankara";
char d[32];
mystrcpy(d, s);
puts(d);

/* ankara */

return 0;
}

Görüldüğü gibi strcpy işlemi aşağıdaki gibi kompakt yazılabilmektedir:
while ((*dest++ = *source++) != '\0')
;

Burada her defasında *source değeri *dest değerine atanır ve source ile dest bir artılmış olur.
2) [] Operatörü İle Kullanım
a) ++p[n] Durumu: Burada p[n] bir artırılır. Yani bu ifade p[n] = p[n] + 1 ile eşdeğerdir.
b) p[n]++ Durumu: Burada p[n] bir artırılır ancak sonraki operatöre p[n]'in artırılmamış değeri sokulur.
c) p[++n] Durumu: Burada n bir artırılır ve artırılmış indeksteki elemaana erişilir.
d) p[n++] Durumu: Burada n bir artırılır fakat p[n] sonraki işleme sokulur. Örneğin:
3) & Operatörü İle Kullanım
160

& adres operatörü ile ++ ve -- operatörleri birlikte kullanılamazlar. Çünkü & operatörünün ürettiği değer nesne
değildir. Örneğin:
int a;
++&a;

/* geçerli değil */

++ ve -- operatörleri nesne üretmezler. Yani ++a işleminde a bir artırılır, fakat ürün olarak a elde edilmez. a
artırılmış değeri elde edilir. Benzer biçimde sonrek durumunda aynı şey söz konusudur. Örneğin:
a++ = b; /* geçerli değil */
Dolayısıyla &++a ve &a++ ifadeleri de anlamsızdır. Ancak nesnelerin adresleri alınabilir.
Farklı Türden Adresin Bir Göstericiye Atanması
C'de bir göstericiye farklı türden bir adres atanamaz. Örneğin:
char s[] = "ankara";
int *pi;
pi = s;

/* geçersiz */

Anahtar Notlar: Yukarıdaki atama C'de geçersizdir. Fakat bilindiği gibi geçersiz bir progrtamı C derleyicileri bir mesaj veremek koşuluyla derleyebilir.
Yani bir derleyicinin yukarıdaki kodu derlemesi onun insafına kalmıştır.

Fakat bir göstericiye farklı türden bir adres tür dönüştürme operatörüyle atanabilir. Örneğin:
char s[] = "ankara";
int *pi;
pi = (int *)s;

/* geçerli */

Örneğin:
#include <stdio.h>
int main(void)
{
char s[] = "aaaa";
int *pi;
pi = (int *)s;
printf("%d\n", *pi);

/* buradaki sayı kaçtır? */

return 0;
}

Bir adresi başka türden bir göstericiye tür dönüştürme operatöryle atamak çoğuı zaman anlamsızdır. Örneğin
yukarıdaki kodda artık *pi ifadesi dört tane 'a' karakterinin oluşturduğu int değer olarak yorumlanır. Böyle bir şeyi
neden yapmak isteyebilriz? Bazı durumlarda böylesi işlemlere gereksinim duyulabilmektedir.
Adres Olmayan Bir Bilginin Bir Göstericiye Atanması
Bazen elimizde bir tamsayı değeri vardır. Bu değeri sayısal bileşen anlamında bir göstericiye yerleştirmek
161

isteyebiliririz. Örneğin:
int *pi;
int a = 0x1FC0;
pi = a;

/* geçersiz! */

Bu tür atamalar da tür dönüştürme operatörüyle yapılabilmektedir:
int *pi;
int a = 0x1FC0;
pi = (int *)a;

/* geçerli! */

Örneğin:
int *pi;
pi = 0x1FC0;
pi = (int *)0x1FC0;

/* geçersiz! */
/* geçerli */

Dizi İsimleriyle Göstericilerin Karşılaştırılması
Dizi isimleriyle göstericiler bazen kullanım bakımından yeni öğreneleri tereddütte bırakabilmektedir. Aralarındaki
benzerlikler ve farklılıklar şöyledir:
Açıklamalarda aşağıdaki iki bildirimi göz önünde bulundurunuz:
int a[10];
int *pi;
- Dizi isimleri de göstericiler de birer adres belirtir. Yani ikisini de kullandığımızda biz adres bilgisi kullanmış
oluruz. Fakat göstericiler bir nesne belirtir. Yani onun içerisine bir adres bilgisi atayabiliriz. Ancak dizi isimleri o
dizilerin başlangıç adreslerini belirtir fakat nesne belirtmez. Biz bir dizi ismine birşey atayamayız. Örneğin:
char s[10];
char *pc;
s = pc;
pc = s;

/* geçersiz! */
/* geçerli */

- Dizi isimleri dizilerin başlangıç adresi belirtir. Yani onların belirttiği adreste tahsis edilmiş bir alan vardır.
Halbuki göstericilerin içerisindeki adresler değiştirilebilir. Göstericiler bellekte başka yerleri gösterebilir hale
getirilebilir.
Gösterici Hataları
Bir gösterici bellekte potansiyel olarak her yeri gösterebilir. Fakat bir göstericiyi kullanarak * ya da []
operatörleriyle bellekte bizim için tahsis edilmemiş (yani bize ait olmayan) alanlara erişmek normal bir durum
değildir. Bu durum C'de tanımsız davranışa (undefined behavior) yol açmaktadır. elimiz bir gösterici olsun biz
parmağımızla başkasına ait bir araziyi gösterebiliriz. Bu yasak değildir. Fakat oraya erişemeyiz (yani giremeyiz).
Girersek başımıza ne geleceği belli değildir. Tabi biz kendi arazimizi göstererek oraya girebiliriz. İşte göstericiler
162

de tıpkı böyledir. Biz göstericilerle kendi tanımladığımız yani bizim için ayrılan nesnelere erişmeliyiz.
Peki bir yerin bizim için ayrıldığını nasıl anlarız? İşte tanımlama yoluyla oluşturduğumuz nesneler bize tahsis
edilmiştir. (Yani onların tapusu bizdedir.) Biz o alanlara erişebiliriz. Örneğin:
int a;
char s[100];
Burada &a'dan itibaren 4 byte, s'ten itibaren 100 byte bize ayrılmıştır. Biz bu alanları istediğimiz gibi kullanabiliriz.
Anahtar Notlar: Bir fonksiyona biz bir adres geçirelim. Fonksiyon onun tahsis edilmiş bir adres olup olmadığını anlayamaz. Bir adresin tahsis edilmiş
olup olmadığını anlamanın C'de resmi bir yolu yoktur.

Bizim için tahsis edilmemiş alanlara erişme işlemine "gösterici hatası" denilmektedir. Gösterici hataları maalesef
deneyimli programcılar tarafından bile yanlışlıkla yapılabilmektedir. Gösterici hatalarının tipik ortaya çıkış biçimi
şunlardır:
1) İlkdeğer Verilmemiş Göstericilerin Yol Açtığı Gösterici Hataları: Bir göstericinin içerisinde rastgele bir değer
varsa onu * ya da [] parantez operatörleriyle kullanamayız. Örneğin:
#include <stdio.h>
int main(void)
{
int *pi;
*pi = 100;

/* 100 rastgele bir yere atanıyor */

return 0;
}

Örneğin:
#include <stdio.h>
int main(void)
{
char *s;
gets(s);

/* Gösterici hatası! gets klavyeden girilen karakterleri nereye yerleştiriyor? */

return 0;
}

2) Dizi Taşmalarından Doğan Gösterici Hataları: Bir dizi için tam o kadar yer ayrılmıştır. Dizinin gerisi de ötesi de
bizim tahsis edilmemiştir. Oralara erişmek gösterici hatalarına yol açar. Örneğin:
int a[10];
int i;
...
for (i = 0; i <= 10; ++i)
a[i] = 0;

/* dikkat a[10] bizim için tahsis edilmemiş */

Örneğin:
char s[] = "ankara";
char d[] = "istanbul";
strcat(d, s);

/* dikkat d dizisi taşıyor! */

163

Örneğin:
char s[10];
gets(s);

Burada kullanıcı en fazla 9 karakter girmelidir. Yoksa dizi taşar.
3) Ömrü Biten Nesnelerin Yol Açtığı Gösterici Hataları: Bir fonksiyon yerel bir nesnenin ya da dizinin adresi ile
geri dönmemelidir. Çünkü fonksiyon bitince o fonksiyonun yerel değişkenleri boşaltılır. Dolayısıyla fonksiyonun
bize verdiği adres artık tahsis edilmiş bir alanın adresi olmaz. Örneğin:
#include <stdio.h>
char *getname(void)
{
char name[128];
printf("Adi Soyadi:");
gets(name);
return name;
}
int main(void)
{
char *s;
s = getname();
printf("%s\n", s);
return 0;
}

Burada getname fonksiyonu geri döndüğünde artık name isimli dizi yok edilecektir. Dolayısıyla main'de s
göstericisine atanan adres tahsis edilmemiş bir alanın adresi olacaktır. Yukarıdaki fonksiyonda name global
yapılırsa sorun kalmaz. Ya da fonksiyon şöyle düzenlenebilir:
#include <stdio.h>
void getname(char *s)
{
printf("Adi Soyadi:");
gets(s);
}
int main(void)
{
char s[128];
getname(s);
printf("%s\n", s);
return 0;
}

void Adresler ve void Göstericiler
C'de void türden bir değişken tanımlanamaz. Ancak gösterici tanımlanabilir. Örneğin:
164

void a;
void *pv;

/* geçersiz! */
/* geçerli */

void göstericiler türsüz göstericilerdir. void göstericiler * ya da [] operatörleriyle kullanılamazlar. Çünkü bu
operatörler eriştiği yerdeki nesnenin türünü bilmek zorundadır. void göstericiler ya da void adresler artırılamazlar
ve eksiltilemezler. Çünkü derleyici bu işlemlerde göstericinin sayısal bileşenini kaç artırıp kaç eksilteceğini
bilememektedir. Peki void göstericiler ne işe yarar?
void bir göstericiye herhangi türden bir adres doğrudan atanabilir. Tür dönüştürme operatörüne hiç gerek yoktur.
Örneğin:
void *pv;
char s[10];
int a[10];
pv = s;
pv = a;

/* geçerli */
/* geçerli */

Benzer biçimde void bir adres de herhangi bir türden göstericiye atanabilir. Örneğin:
void *pv;
int *pi;
char s[10];
pv = s;
...
pi = pv;

/* geçerli */
/* geçerli */

void göstericilere neden gereksinim duyulduğunu açıklayabilmek için memcpy fonksiyonu iyi bir örnek olabilir.
memcpy fonksiyonu bir adresten bir adrese koşulsuz n byte kopyalamaktadır. Bu fonksiyon strcpy fonksiyonunu
andırmakla birlikte ondan farklıdır. memcpy null karaktere bakmaz. Koşulsuz n byte kopyalar. Örneğin herhangi
bir türden diziye aynı türden başka bir diziye memcpy ile kopyalayabiliriz. C'de başı memxxx biçiminde başlayan
fonksiyonların prototipleri de <string.h> içerisindedir.
#include <stdio.h>
#include <string.h>
int main(void)
{
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int b[10];
int i;
memcpy(b, a, 10 * sizeof(int));
for (i = 0; i < 10; ++i)
printf("%d ", b[i]);
printf("\n");
return 0;
}

Biz memcpy fonksiyonuyla herhangi türden iki diziyi kopyalayabiliriz:
#include <stdio.h>
#include <string.h>
int main(void)
{
double a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

165

double b[10];
int i;
memcpy(b, a, 10 * sizeof(double));
for (i = 0; i < 10; ++i)
printf("%f ", b[i]);
printf("\n");
return 0;
}

İşte memcpy gibi bir fonksiyonun bizden her türlü adresi kabul edebilmesi için onun parametrelerinin void
gösterici olması gerekir. Gerçekten de memcpy fonksiyonunun prototipi şöyledir:
void *memcpy(void *dest, void *source, unsigned n);
Fonksiyon ikinci parametresiyle belirtilen adresten başlayarak birinci parametresiyle belirtilen adrese koşulsuz n
byte kopyalar. Birinci parametresiyle belirtilen adresin aynısına geri döner.
Peki biz memcpy gibi bir fonksiyonu nasıl yazabiliriz? void göstericiler artırılıp azaltılamadığına göre onların türü
belirli bir göstericiye atanması gerekir. Örneğin:
#include <stdio.h>
#include <string.h>
void *mymemcpy(void *dest, void *source, unsigned n)
{
char *pcdest = dest;
char *pcsource = source;
while (n-- > 0)
*pcdest++ = *pcsource++;
return dest;
}
int main(void)
{
double a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
double b[10];
int i;
mymemcpy(b, a, 10 * sizeof(double));
for (i = 0; i < 10; ++i)
printf("%f ", b[i]);
printf("\n");
return 0;
}

memcpy fonksiyonuyla yazı kopyalaması da yapabiliriz. Örneğin:
strcpy(d, s);
ile
memcpy(d, s, strlen(s) + 1);
166

işlevsel olarak eşdeğerdir. Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[30] = "ankara";
char d[30];
strcpy(d, s);
memcpy(d, s, strlen(s) + 1);
return 0;
}

memset isimli fonksiyon bir adresten başlayarak koşulsuz n byte'a belli bir değeri atar. Yani n tane byte'ı belli bir
değerle doldurur. Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
int a[10];
int i;
memset(a, 0, 10 * sizeof(int));
for (i = 0; i < 10; ++i)
printf("%d ", a[i]);
printf("\n");
return 0;
}

Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[200];
memset(s, 'a', 199);
s[199] = '\0';
printf("%s\n", s);
return 0;
}

memset fonksiyonunun prototipi şöyledir:
void *memset(void *dest, int val, unsigned n);
Fonksiyonun birinci parametresi doldurulacak yerin adresini, ikinci parametresi doldurulacak değeri ve üçüncü
parametresi kaç adet değerin doldurulacağını belirtir. memset fonksiyonunu şöyle yazabiliriz:
#include <stdio.h>
#include <string.h>
void *mymemset(void *dest, int val, unsigned n)

167

{
unsigned char *pcdest = dest;
while (n-- > 0)
*pcdest++ = ch;
return dest;
}
int main(void)
{
char s[200];
mymemset(s, 'a', 199);
s[199] = '\0';
printf("%s\n", s);
return 0;
}

memset fonksiyonunun strset isimli bir kardeşi vardır. strset char türden bir diziyi null karakter görene kadar belli
bir karakterle doldurur:
char *strset(char *dest, char ch);
Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = "ankara";
strset(s, 'x');
puts(s);
return 0;
}
Anahtar Notlar: C'de strxxx biçiminde str ile başlayan fonksiyonlar char * türünden göstericileri parametre olarak alır ve null karakter görene kadar
işlem yapar. Fakat memxxx biçiminde mem ile başlayan fonksiyonlar void * türünden parametre alır ve koşulsuz n byte için işlem yapar.
strcpy --- memcpy
strset --- memset
strchr --- memchr

strset fonksiyonu yerine memset kullanılabilir. Yani:
strset(s, ch);
ile,
memset(s, ch, strlen(s));
işlevsel olarak eşdeğerdir.
Yukarıda da belirtildiği gibi C'de void bir göstericiye her türden adres doğrudan atanabilir. Benzer biçimde void bir
adres de her türlü göstericiye atanabilir. Ancak void adresin herhangi bir göstericiye atanması bazılarınca
168

eleştirilmektedir. Çünkü bu sayede aslında yasak olan birşeyi yapabilir duruma gelmekteyiz (yani hülle yapılabilir):
char *pc;
int *pi;
pi = pc;

/* yasak */

Fakat:
char *pc;
int *pi;
void *pv;
pv = pc;
pi = pv;

/* geçerli */
/* geçerli */

İşte C++'ta eleştirilen bu durum düzeltilmiştir. Şöyle ki: C++'ta yine void göstericiye her türden adres doğrudan
atanabilir. Fakat void bir adres tür dönüştürmesi yoluyla başka türden bir göstericiye atanabilir. Böylece yukarıdaki
kod C'de geçerli olduğu halde C++'ta geçerli değildir. Bazı C programcıları böylesi kodların her iki dilde de geçerli
olmasını sağlamak için void adresleri atarken tür dönüştürmesi yaparlar. Örneğin:
pi = (int *)pv;

/* Hem C'de hem de C++'ta geçerli */

Özetle C'de void göstericiler bir adresin yalnızca sayısal bileşenini tutmak için ve tür dönüştürmesine programcıyı
zorlamamak için kullanılmaktadır. Eğer memcpy fonksiyonunun parametreleri char * türünden olsaydı. O zaman
onu biz şöyle kullanmak zorunda kalırdık:
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int b[10];
int i;
memcpy((char *)b, (char *)a, 10 * sizeof(int));

void göstericiler C'ye 80'li yılların ikinci yarısında katılmıştır.
Anahtar Notlar: Kursun bu noktasında koşul operatörü anlatılmıştır. Fakat notlarda "Diziler" konusundan sonraya eklenmiştir.

Göstericilerin Uzunlukları
Bir gösterici kaç byte uzunluktadır? Göstericilerin uzunlukları onların türleriyle ilgili değildir. Çünkü göstericilerin
türleri onların gösterdikleri yerdeki nesnenin uzunluğuyla ilişkilidir. Bir göstericinin uzunluğu o sistemin adres
alanına bağlıdır. Örneğin teorik olarak 32 bit işlemcilere 4GB RAM, 64 bit işlemcilere 16EB RAM takılabilir. Bu
durumda 32 bit sistemlerdeki göstericiler 4 byte, 64 bit sistemlerdeki göstericiler 8 byte yer kaplarlar. Biz
kursumuzda şekilleri genel olarak 32 bit mikroişlemcilere göre çiziyoruz. Yani örneğin sizeof(char *) ile,
sizeof(double *) aynı değerlerdedir.
String İfadeleri
C'de derleyici ne zaman iki tırnak içerisinde bir yazı görse önce o yazıyı char türden bir dizinin içerisine yerleştirir,
sonuna null karakteri ekler ve iki tırnak yerine o dizinin başlangıç adresini insert eder. Yani C'de iki tırnak ifadeleri
char türnden adres belirtmektedir. Böylece C'de iki tırnak ifdadeleri doğrudan char türdnen bir göstericiye
atanmalıdır. Örneğin:
#include <stdio.h>

169

int main(void)
{
char *str;
str = "ankara";
printf("%s\n", str);
return 0;
}

Eşdeğeri aşağıdaki gibi düşünülebilir:
#include <stdio.h>
static char compiler_generated_name[] = "ankara";
int main(void)
{
char *str;
str = compiler_generated_name;
printf("%s\n", str);
return 0;
}

Bu durumda örneğin biz char * parametreli bir fonksiyonu string ifadesiyle çağırabiliriz. Örneğin:
#include <stdio.h>
int main(void)
{
unsigned n;
n = strlen("ankara");
printf("%u\n", n);
puts("ankara");
return 0;
}

Örneğin char türden bir diziye sonradan (ilkdeğer vererek değil) bir yazı yerleştirecek olsak bunu karakter karakter
yerleştirmek pek uygun olmaz. Bunun en pratik ve doğru yolu strcpy fonksiyonunu kullanmaktadır:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[32];
strcpy(s, "ankara");
puts(s);
return 0;
}

char türden bir dizi ismine iki tırnak ifadesini atayamayız. Çünkü dizi isimleri nesne belirtmez. Göstericler nesne
belirtir. Örneğin:
char s[32];
170

char *ps;
s = "ankara";
ps = "ankara";

/* geçersiz! */
/* geçerli */

C'de ist,sna olarak char türden bir diziye iki tırnak ifadesi ile ilkdeğer verilirken kullanılan iki tırnak bir adres
belirtmemektedir. Bu iki tırnak içindeki karakterleri tek tek diziye yerleştir ve sonuna null karakter ekle anlamına
gelir. Yani:
char s[32] = "ankara";
bildiriminde bu iki tırnak ifadesi için derleyici bir adres insert etmeyecektir. Bu istisna durum aşağıdakiyle
eşdeğerdir:
char s[32] = {'a', 'n', 'k', 'a', 'r', 'a', '\0'};
Bunun dışındaki iki tırnak ifadelerinin hepsi birer string belirtir ve bunlar için derleyici birer adres insert eder.
Örneğin:
char *ps = "ankara";
Burada "ankara" bir adres belirtmektedir.
C'de iki tırnak ifadeleri ile oluşturulan string'ler güncellenmeye çalışılmamalıdır. String karakterlerinin
değiştirilmesi "tanımsız davranışa (undefined behavior)" yol açar. Örneğin:
#include <stdio.h>
int main(void)
{
char *str = "ankara";
char s[] = "ankara";
*str = 'x';
*s = 'x';

/* undefined behavior */
/* normal */

return 0;
}

Örneğin:
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = "ankara";
char *str = "ankara";
*strchr(s, 'k') = 'x';
puts(s);
*strchr(str, 'k') = 'x';
puts(s);

/* undefined behavior */

return 0;
}

171

String'ler statik ömürlü nesnelerdir. Yani hangi fonksiyonda oluşturulmuş olursa olsunlar programın başından
sonuna kadar bellekte kalırlar. Dolayısıyla bir fonksiyonun bir string'in başlangıç adresine geri dönmesi gösterici
hatası değildir. Örneğin:
#include <stdio.h>

int main(void)
{
char *str;
str = getstr();
printf("%s\n", str);
return 0;
}

Aşağıdaki örnekte iki tırnak istisna olan duruma ilişkindir. Dolayısıyla burada dizinin adresiyle geri dönülmektedir.
O da fonksiyon bittiğinde yok edilir.
#include <stdio.h>
char *getstr(void)
{
char s[] = "ankara";
return s;
}
int main(void)
{
char *str;
str = getstr();
/* dikkat! gösterici hatası */
printf("%s\n", str);
return 0;
}

Özdeş string'ler için aynı yerin mi kullanılacağı ya da farklı yerler mi ayrılacağı C'de belirsiz (unspecied) davranış
olarak ele alınmaktadır. Yani derleyici bu ikisinden birini yapabilir. Bu durum derleyicileri yazanların isteğine
bırakılmıştır. Örneğin:
#include <stdio.h>
int main(void)
{
char *s = "ankara";
char *k = "ankara";
printf(s == k ? "Evet\n" : "Hayir\n");
return 0;
}

Burada derleyici bir tane "ankara" yazısı yerleştirip s ve k'ya onu atayabilir. Ya da iki farklı "ankara" yazısı
yerleştirip s ve k'ya farklı adresler atayabilir. Bazı derleyiciler de derleyici ayarlarından programcı bunu
değiştirebilmektedir.
Boş bir string oluşturulabilir. Bu durumda derleyici diziye yalnızca null karakteri yerleştirir. Örneğin:
172

char *s = "";

/* geçerli */

String'ler tek bir satır üzerine yazılmak zorundadır. Örneğin:
s = "this is a
test";
Böyle bir yazım geçersizdir. Peki ya string bir satıra sığmıyorsa ne olacaktır? C'de yan yana iki string atomu (yani
aralarında boşluk karakterlerinden başka bir karakter olmayan) derleme aşamasında derleyici tarafından
birleştirilmektedir. Örneğin:
#include <stdio.h>
int main(void)
{
char *s;
s = "this is a"
" test";
printf("%s\n", s);
return 0;
}

Yukarıdaki yazım tamamen geçerlidir.
Anahtar Notlar: C'de tek bir tes bölü ve hemen arkasından ENTER ('\n') karakteri "aşağıdaki satırı bu starırla birleştir" anlamına gelir. Örneğin:
#include <stdio.h>
int main(void)
{
int count;
cou\
nt = 10;
printf("%d\n", count);
return 0;
}
Yukarıdaki örnekte cou ve aşağısındaki satır birleştirilmiş ve count = 10 haline gelmiştir. Bu işlemin mümkün olması için '\'den sonra hemen '\n' karakterinin gelmesi gerekir.
Bu özelliği biz string'ler için de kullanabiliriz. Örneğin:
#include <stdio.h>
int main(void)
{
char *s;
s = "ankara,\
izmir";
printf("%s\n", s);
return 0;
}

String ifadeleri içerisinde '\' karakterleri '\' anlamına gelmez. Bunlar yanındak, karakterlerle başka bir karakter
anlamına gelir. Dolayısıyla '\' karakterinin kendisi '\\' biçiminde ifade edilmelidir. Örneğin:
#include <stdio.h>

173

int main(void)
{
char *path = "c:\\windows\\temp";
printf("%s\n", path);
return 0;
}

Adreslerin Karşılaştırılması
C'de adresler altı karşılaştırma operatörüyle de karşılaştırılabilir. Örnğin:
int *p, *q;
if (p > q) {
...
}
Ancak karşılaştırılan adreslerin aynı türden olması ya da birinin void türden olması gerekir. Fakat C'de rastgeele iki
adresin karşılaştırılması "tanımsız davranış" olarak değerlendirilir. İki adresin karşılaştırılabilmesi için bunların
aynı dizinin ya da yapının elemanları olması gerekir. Örneğin:
#include <stdio.h>
void putsrev(char *s)
{
char *end = s;
while (*end != '\0')
++end;
--end;
while (end >= s) {
putchar(*end);
--end;
}
putchar('\n');
}
int main(void)
{
char *s = "ankara";
putsrev(s);
return 0;
}

Gösterici Dizileri (Array of Pointers)
Her elemanı bir gösterici olan dizilere gösterici dizileri denir. Gösterici dizileri T bir tür belirtmek üzere,
T * <isim>[uzunluk];
biçiminde bildirilir. Örneğin:
int *a[10];
Bu dizini her elemanı int türden bir göstericidir. Yani dizinin her elemanı int * türündendir. Örneğin:
174

#include <stdio.h>
int main(void)
{
int x = 10, y = 20, z = 30;
int *a[3];
int i;
a[0] = &x;
a[1] = &y;
a[2] = &z;
for (i = 0; i < 3; ++i)
printf("%d\n", *a[i]);
return 0;
}

C'de en fazla karşımıza çıkan char türden göstericileridir. Yazıların başlangıç adresleri char türden bir gösterici
dizisine yerleştirilirse dizi yazıları tutar hale gelir. Örneğin:
#include <stdio.h>
int main(void)
{
char *names[5];
int i;
names[0] = "ali";
names[1] = "veli";
names[2] = "selami";
names[3] = "ayse";
names[4] = "fatma";
for (i = 0; i < 5; ++i)
printf("%s\n", names[i]);
return 0;
}

175

Dizilere küme parantezleri içeriisnde ilkdeğer verebildiğimize göre aşağıdaki ilkdeğerleme de geçelidir:
#include <stdio.h>
int main(void)
{
char *names[5] = { "ali", "veli", "selami", "ayse", "fatma" };
int i;
for (i = 0; i < 5; ++i)
printf("%s\n", names[i]);
return 0;
}

Bu dizinin sonuna NULL adres (Null karakter değil) yerleştirirsek, NULL adres görene kadar işlem yapabiliriz:
#include <stdio.h>
int main(void)
{
char *names[] = { "ali", "veli", "selami", "siracettin", "ayse", "fatma", NULL };
int i;
for (i = 0; names[i] != NULL; ++i)
printf("%s\n", names[i]);
return 0;
}

Sınıf Çalışması: char türdne bir gösterici dizisinin içerisine birtakım isimlerin adresleri yerleştirimiştir. Gösterici
dizisinin sonunda NULL adres vardır. char türden geniş bir dizi açınız, bu isimleri aralarına ',' karakteri koyarak tek
bir dizide (tabi sonu null karakter ile bitmeli) birleştiriniz. Sonra da bu diziyi puts ile yazdırınız.
Çözüm:
#include <stdio.h>
#include <string.h>
int main(void)
{
char *names[] = { "ali", "veli", "selami", "siracettin", "ayse", "fatma", NULL };
char str[100];
int i;
str[0] = '\0';
for (i = 0; names[i] != NULL; ++i) {
if (i != 0)
strcat(str, ", ");

176

strcat(str, names[i]);
}
puts(str);
return 0;
}

sprintf Fonksiyonu
sprintf fonksiyonu kullanım bakımından tamamen printf gibidir. Ancak ekrana yazmak yerine yazılacakları char
türden bir dizinin içerisine yazar. Fonksiyonun birinci parametresi char türden dizinin adresidir. Fonksiyonun
prototipi şöyledir:
int sprintf(char *s, char *format, ...);
Fonksiyonun birinci parametresi dizinin başlangıç adresini alır. Diğer parametreleri printf ile aynıdır. Örneğin:
#include <stdio.h>
int main(void)
{
char s[100];
int a = 10;
double b = 12.345;
sprintf(s, "a = %d, b = %f\n", a, b);
puts(s);
return 0;
}

Sınıf Çalışması: Üç basamklı int türden bir sayıyı yazı biçiminde adresi aldığı char türdne bir dizinin içerisine
yerleştiren num_to_text isimli fonksiyonu yazınız.
char *num_to_text(int val, char *s);
Fonksiyon birinci parametresiyle belirtilen değeri yazıya dönüştürerek ikinci parametresi ile aldığı diziye yerleştirir.
Fonksiyon ikinci parametresiyle aldığı adresin aynısına geri döner.
char s[100];
num_to_text(983, s);
puts(s);
/* dokuz yüz seksen üç */
Çözüm:
#include <stdio.h>
#include <string.h>
char *num_to_text(unsigned long val, char *s);
int main(void)
{
char s[100];
unsigned long val;
for (;;) {
printf("Sayi:");
scanf("%lu", &val);

177

if (val == 123)
break;
num_to_text(val, s);
puts(s);
/* dokuz yüz seksen üç */
}
return 0;
}
char *num_to_text(unsigned long val, char *s)
{
char *ones[] = { "bir", "iki", "uc", "dort", "bes", "alti", "yedi", "sekiz", "dokuz" };
char *tens[] = { "on", "yirmi", "otuz", "kirk", "elli", "altmis", "yetmis", "seksen", "doksan" };
int one, ten, hundred;
*s = '\0';
hundred = val / 100;
ten = val % 100 / 10;
one = val % 10;
if (!val) {
strcat(s, "sifir");
return;
}
if (hundred) {
if (hundred != 1) {
strcat(s, ones[hundred - 1]);
strcat(s, " ");
}
strcat(s, "yuz");
}
if (ten) {
if (hundred)
strcat(s, " ");
strcat(s, tens[ten - 1]);
}
if (one) {
if (ten)
strcat(s, " ");
strcat(s, ones[one - 1]);
}
}

Soruyu genelleştirerek de çözebiliriz:
#include <stdio.h>
#include <string.h>
char *num_to_text(unsigned long val, char *s);
int main(void)
{
char s[100];
unsigned long val;
for (;;) {
printf("Sayi:");
scanf("%lu", &val);
if (val == 123)
break;
num_to_text(val, s);
puts(s);
/* dokuz yüz seksen üç */
}

178

return 0;
}
char *num_to_text(unsigned long val, char *s)
{
char *ones[] = { "bir", "iki", "uc", "dort", "bes", "alti", "yedi", "sekiz", "dokuz" };
char *tens[] = { "on", "yirmi", "otuz", "kirk", "elli", "altmis", "yetmis", "seksen", "doksan" };
char *others[] = { "bin", "milyon", "milyar", "trilyon", "katrilyon", "katrilyar" };
int one, ten, hundred;
int digits3[5], temp;
int i;
*s = '\0';
temp = val;
for (i = 0; val; ++i) {
digits3[i] = val % 1000;
val /= 1000;
}
val = temp;
if (!val) {
strcat(s, "sifir");
return;
}
while (--i >= 0) {
hundred = digits3[i] / 100;
ten = digits3[i] % 100 / 10;
one = digits3[i] % 10;
if (hundred) {
if (hundred != 1) {
strcat(s, ones[hundred - 1]);
strcat(s, " ");
}
strcat(s, "yuz");
}
if (ten) {
if (hundred)
strcat(s, " ");
strcat(s, tens[ten - 1]);
}
if (one) {
if (ten)
strcat(s, " ");
if (i != 1 || digits3[i] != 1)
strcat(s, ones[one - 1]);
}
if (i != 0) {
strcat(s, " ");
strcat(s, others[i - 1]);
strcat(s, " ");
}
}
}

exit Fonksiyonu
exit prototipi <stdlib.h> dosyasında olan standartd bir C fonksiyonudur. exit çağrıldığında program sonlanır. Yani
sanki main bitmiş gibi bit etki oluşur. Bu durumda biz bir programı sonlandırmak için illa da akışın main'e geri
dönmesini beklemek zorunda değiliz. Herhangi bir zaman herhangi bir fonksiyonda exit fonksiyonunu çağırırsak
program sonlanır. Fonksiyonun prototipi şöyledir:
179

#include <stdlib.h>
void exit(int code);
Fonksiyon parametre olarak programın exit kodunu alır. İşletim sistemlerinde her sonlanan programın bir exit kodu
vardır. Bu exit kodunun kaç olduğunun bir önemi yoktur. Bu kod işletim sistemine iletilir. İşletim sistemi de birisi
(genellikle üst proses) isterse bunu ona verir. Ancak geleneksel olarak başarılı sonlanmalar için sıfır değeri,
başarısz sonlanmalar için sıfır dışı değerler kullanılmaktadır. Hatta okunabilirliği artırmak için <stdlib.h>
içerisinde iki sembolik sabit bildirilmiştir:
#define EXIT_SUCCESS
#define EXIT_FAILURE

0
1

Her ne kadar C standartlarında EXIT_SUCCESS ve EXIT_FAILURE sembolik sabitlerinin değerleri 0 ve 1 olarak
kesin bir biçimde belirtilmemişse de derleyicilerin hemen hepsi EXIT_SUCCESS için 0 değerini,
EXIT_FAILURE için 1 değerini kullanmaktadır.
main fonksiyonu sonlandığında program sonlanmaktadır. O halde main fonksiyonun da return işlemi programın
sonlanmasına yol açar. İşte C standartlarına göre main bittiğinde main fonksiyonunun geri dönüş değeri alınarak
exit çağrılır. Yani program aslında her zaman exit ile sonlandırılır. O halde bir C programının şöyle çalıştırıldığı
düşünülmelidir:
exit(main());
Ayrıca C'de main fonksiyonuna özgü olmak üzere, main fonksiyonunda hiç return kullanılmazsa sanki return 0
kullanılmış gibi işlem görür.
Prosesin Adress Alanı Ve Bölümleri
İşletim sistemi çalıştıracağı progamı ikincil bellekten alarak fiziksel belleğe yükler. Bu program için bellekte belli
bir yer ayırmaktadır. Buna prosesin adres alanı (address space) denir. Proseisn adres alanı içerisinde şu bölümler
vardır:
Stack Bölümü: Yerel ve parametre değişlkenlerinin yaratıldığı ve yok edildiği alana stack denir. Stack'te nesneler
çok hızlı yaratılır ve yok edilir. Bloktan çıkıldığında o blok içerisinde tanımlanmış olan nesnelerin hepsi stack'ten
atılır.
Data Bölümü: İlkdeğer verilmiş global nesnelerin yaratıldığı bölümdür. Data bölümü programın başından sonuna
kadar kalır. Burada yaratım ve boşaltım yapılmaz. Program çalışırken artık bu bölümde tahsisat yapılamaz.
BSS Bölümü: İlkdeğer verilmemiş global nesnelerin yaratıldığı bölümdür. BSS bölümü programın başından
sonuna kadar kalır. Burada yaratım ve boşaltım yapılmaz. Program çalışırken artık bu bölümde tahsisat yapılamaz.
Heap Bölümü: Dinamik bellek fonksiyonlarıyla tahsisat yapılan bölümdür. Heap'te alan tahsisatı programın
çalışma zamanı sırasında yapılır ve yok edilir. Tahsisat yapılırken ve serbest bırakılırken nerelerin boş ve doldu
olduğu sorgulandığı için stack'teki tahsisata göre çok yavaştır. Ancak bu bölümde yapılan tahisatlar bloktan
çıkıldığında otomatik geri bırakılmaz. Yani yaşamaya devam eder.
Sistemlerde en küçük alan stack olma eğilimindedir. Bunu daha sonra data ve bss alanları sonra da heap alanı izler.
En büyük alan heap olma eğilimindedir.
Dinamik Bellek Yönetimi (Dynamic Memory Management)
180

Bilindiği gibi C'de dizi uzunlukları sabit ifadesi biçimde verilmek zorundadır. Fakat bazen bir dizinin hangi
uzunlukta açılacağı işin başında belli değildir. Ancak program çalışırken birtakım olaylar sonucunda dizinin
uzunluğu bilinmektedir. İşte bu tür durumlarda programın çalışma zamanı sırasında dizi açmaya gereksinim
duyulur. Programın çalışma zamanı sırasında bellek tahsis etme işlemine "dinamik bellek yönetimi" denilmektedir.
C'de dinamik bellek yönetimi ismine "dinamik bellek fonksiyonları" denilen bir grup standart C fonksiyonuyla
gerçekleştirilir. Bunlar malloc, calloc, realloc ve free fonksiyonlarıdır.
Dinamik bellek fonksyionları bellekte ismine "heap" denilen bir alanda tahsisatlarını yaparlar. Heap alanının
büyüklüğü sistemden sisteme değişebilmektedir. C standartlarında söylenmese de modern sistemlerde her
programın heap'i ayrıdır. Yani bir orgramdaki dinamik tahsisatların başka bir programa etkisi yoktur. Program
bitinci modern sistemlerde o programın kullandığı heap alanı da sisteme iade edilir.
malloc Fonksiyonu
malloc programın çalışma zamanı sırasında parametresiyle belirtilen sayıda byte kadar ardışıl alanı tahsis eder.
Tahsis ettiği alanın başlangıç adresiyle geri döner. Prototipi şöyledir:
#include <stdlib.h>
void *malloc(unsigned n);
malloc parametresiyle belirtilen miktarda byte kadar ardışıl alanı heap'te tahsis eder. Tahsis ettiği alanın başlangıç
adresine geri döner. Eğer heap doluysa malloc tahsisatı yapamaz. Bu durumda NULL adrese geri döner. malloc ile
tahsis edilen blokta çöp değerler vardır. Her ne kadar Windows gibi Linux gibi işletim sistemlerinde prosesin heap
alanı çok büyükse de yine de her bellek tahsisatının başarısının kontrol edilmesi iyi bir tekniktir.
malloc fonksiyonunun bize verdiği adres herhangi türden bir dizi olarak kulanılabilir. Örneğin biz malloc ile biz 32
byte bir alan tahsis etmiş olalım. Orayı 4 elemanlı double bir dizi gibi de, 8 elemanlı int bir dizi gibi de, 32
elemanlı char türden bir dizi gibi de kullanabiliriz. Ne de olsa tüm diziler bellekte ardışıl tutulmaktadır. Örneğin:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int n, i;
int *pi;
printf("Kac elemanli bir int dizi olusturmak istiyorsunuz?");
scanf("%d", &n);
pi = (int *)malloc(n * sizeof(int));
if (pi == NULL) {
printf("cannot allocate memory!\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < n; ++i) {
printf("%d. elemani giriniz:", i + 1);
scanf("%d", &pi[i]);
}
for (i = 0; i < n; ++i)
printf("%d ", pi[i]);
printf("\n");
return 0;

181

}

calloc Fonksiyonu
Aslında calloc fonksiyonu taban bir fonksiyon değildir. Pek çok kütüphanede calloc fonksiyonu malloc
fonksiyonunu çağıracak biçimde yazılmıştır. Prototipi şöyledir:
#include <stdlib.h>
void *calloc(unsigned count, unsigned size);
calloc iki parametresinin çarpımı kadar arşılı alan tahsis eder. Geleneksel olarak birinci parametre veri yapısının
eleman sayısı, ikinci parametre ise bir elemanın byte uzunluğu olarak girilir. Örneğin biz 20 elemanlı bir int dizi
tahsis edecek olsak birinci parametreye 20, ikinci parametresizeof(int) biçiminde girilir. calloc fonksiyonu malloc
fonksiyonundan farklı olarak tahsis ettiği alanı sıfırlar. Halbuki malloc Yine fonksiyon başarı durumunda tahsis
edilen alanın başlangıç adresine, başarısızlık durumunda NULL adrese geri döner. Örneğin:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int *pim;
int *pic;
int i;
if ((pim = (int *)malloc(10 * sizeof(int))) == NULL) {
printf("cannot allocate memory!\n");
exit(EXIT_FAILURE);
}
if ((pic = (int *)calloc(10, sizeof(int))) == NULL) {
printf("cannot allocate memory!\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < 10; ++i)
printf("%d ", pim[i]);
printf("\n");
for (i = 0; i < 10; ++i)
printf("%d ", pic[i]);
printf("\n");
return 0;
}

calloc fonksiyonunu malloc kullanarak biz de yazabiliriz:
void *mycalloc(unsigned count, unsigned size)
{
void *ptr;
if ((ptr = malloc(count * size)) == NULL)
return NULL;
return memset(ptr, 0, count * size);
}

realloc Fonksiyonu
182

realloc daha önce tahsis edilmiş bir alanı büyütmek ya da küçültmek için kullanılır. Fonksiyonun prototipi şöyledir:
#include <stdlib.h>
void *realloc(void *ptr, unsigned newsize);
Fonksiyonun birinci parametresi daha önce tahsis edilmiş alanın başlangıç adresini alır. İkinci parametre toplam
yeni uzunluğu belirtir. Fonksiyon tipik olarak şöyle çalışmaktadır: eğer blok büyütülüyorsa realloc önce tahsis
edilmiş alanın hemen altında istenilen kadar ilave yer var mı diye bakar. Eğer varsa orayı da tahsis eder. Böylece
blok yer değiştirmemiş olur. Eğer önceki alanın hemen altında toplam yeni uzunluğu karşılayacak kadar boş yer
yoksa realloc heap alanının başka bir yerinde toplam yeni uzunluk kadar yeni bir yer arar. Bulursa burayı tahsis
eder. Eski alandaki bilgileri burayqa kopyalar. Eski alanı free hale getirir ve yeni alanın başlangıç adresiyle geri
döner. Her ne kadar standartlarda realloc'un önce eski bloğun aşağısında yer arayıp aramayacağı belirtilmemişse de
tipik çalışma böyledir. Örneğin realloc aslında eski bloğun altında boş yer olsa bile yine de bloğu taşıyabilir. Tabi
realloc yine de başarısz olabilir. Yani ne eski yerin altında ne de herap'in başka bir yerinde toplam yeni uzunluğu
karşılayacak kadar yer olmayabilir. Bu durumda realloc NULL adrese geri döneri Ayrıca bloğun küçültülmesi
durumunda da blok yer değiştirebilir. Küçültme durumunda başarısızlık olmaz fakatg blok yer değiştirebilir.
O halde realloc fonksiyonunun geri dönüş değeri her zaman değerlendirilmelidir. Örneğin:
p = malloc(10);
...
realloc(p, 20);

/* hata! */

Burada realloc bloğun yerini değiştirebilir. Bu durumda p hala eski bloğu gösterir durumda olacaktır. Oysa şöyle
yapılmalıydı:
p = malloc(10);
...
p = realloc(p, 20);

/* doğru, fakat başarısızlık durumuna dikkat */

realloc başarız olduğunda eski bloğu free hale getirmemektedir. eğer programa devam edilecekse eski bloğun
kaybedilmemesi uygun olur:
p = malloc(10);
...
temp = realloc(p, 20);

/* doğru */

if (temp == NULL) {
...
}
else
p = temp;
...
realloc ile bloğun büyütüldüğü durumda bloğa ek yapılan alanda rastgele (çöp) değerler vardır. Yani burası da tıpkı
malloc fonksiyonunda olduğu gibi sıfırlanmaz.
realloc fonksiyonunun birinci parametresi NULL girilirse realloc malloc gibi davranır. Yani:
p = malloc(n);
ile,
183

p = realloc(NULL, n);
aynı işleve sahiptir. realloc kullanılması için daha önce kesinlikle bloğun dinamik bellek fonksiyonlarıyla tahsis
edilmiş olması gerekir. Normal bir diziyi biz realloc ile büyütüp küçültemeyiz. Örneğin:
#include <stdio.h>
#include <stdlib.h>
#define BLOCK_ELEM_SIZE

5

int main(void)
{
int *pi = NULL;
int val, count, i;
count = 0;
for (;;) {
printf("Sayi giriniz:");
scanf("%d", &val);
if (val == 0)
break;
if (count % BLOCK_ELEM_SIZE == 0) {
pi = (int *)realloc(pi, (count + BLOCK_ELEM_SIZE) * sizeof(int) );
if (pi == NULL) {
printf("cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
}
pi[count++] = val;
}
for (i = 0; i < count; ++i)
printf("%d ", pi[i]);
printf("\n");
return 0;
}

aynı işleve sahiptir. realloc kullanılması için daha önce kesinlikle bloğun dinamik bellek fonksiyonlarıyla tahsis
edilmiş olması gerekir. Normal bir diziyi biz realloc ile büyütüp küçültemeyiz.
Sınıf Çalışması: Bir döngü içerisinde sürekli isim isteyiniz. Girilen isimleri dinamik olarak büyütülen char türden
bir diziye aralarına ',' koyarak ekleyiniz. "exit" yazıldığında döngüden çıkınız ve üm yazıyı tek bir puts ile
yazdırınız.
Çözüm:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
char *names;
char name[64];
int count;
count = 1;
names = (char *)malloc(1);

184

if (names == NULL) {
printf("cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
*names = '\0';
for (;;) {
printf("Isim giriniz:");
gets(name);
if (!strcmp(name, "exit"))
break;
if (count != 1)
strcat(names, ", ");
count += strlen(name) + 2;
names = (char *)realloc(names, count);
if (names == NULL) {
printf("cannot allocate memory!\n");
exit(EXIT_FAILURE);
}
strcat(names, name);
}
puts(names);
return 0;
}

Önce malloc kullanmadan realloc fonksiyonunu malloc gibi kullanmak isteyebiliriz. Ancak bu durumda ilk
tahsisattan önce names dizisini başında null karakter bulunması gerekir. Şöyle çözüm söz konusu olabilir:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
char *names = NULL;
char name[64];
int count, len;
count = 1;
for (;;) {
printf("Isim giriniz:");
gets(name);
if (!strcmp(name, "exit"))
break;
if (count != 1)
strcat(names, ", ");
len = strlen(name) + 2;
names = (char *)realloc(names, count + len);
if (names == NULL) {
printf("cannot allocate memory!\n");
exit(EXIT_FAILURE);
}
if (count == 1)
*names = '\0';
count += len;
strcat(names, name);
}
puts(names);
return 0;
}

185

free Fonksiyonu
free fonksiyonu daha önce malloc, calloc ya da realloc fonksiyonlarıyla tahsis edilmiş alanı serbest bırakmak için
kullanılır. Yani free'den sonra artık o alan sani hiç tahsis edilmemiş gibi olur. Fonksiynunun prototipi şöyledir:
#include <stdlib.h>
void free(void *ptr)
Fonksiyon daha önce tahsis edilmiş olan bloğun başlangıç adresini alır ve o bloğun tamamını serbest bırakır.
Bloğun bir kısmının serbest bırakılması söz konusu değildir.
Modern sistemlerin hepsinde çalışan programların (proseslerin) heap alanları birbirlerinden farklıdır. Yani bir
programdaki dinamik tahsisatlar diğer programın heap alanını azaltmazlar. Ancak yine de C standartlarında
proseslerin heap alanlarının farklı olduğu belirtilmemiştir. Yani bazı küçük kapasiteli sistemlerde programdan
çıkılsa bile heap tahsisatları kalıyor olabilir. Fakat mevcut sistemlerde bir program sonlandığında onun bütün
tahsisatları otomatik free hale getirilmektedir.
Örneğin:
if ((ptr = malloc(100)) == NULL) {
printf("cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
...
free(ptr);
Heap Organizasyonu Nasıl Yapılmaktadır?
Heap alanının hangi büyüklükte olacağı ve heap olarak belleğin neresinin kullanılacağı sistemden sisteme
değişebilmektedir. Ancak dinamik bellek fonksiyonları kendi aralarında hangi bölgelerin tahis edilmiş olduğunu
bir tahsisat tablosu yoluyla tutmaktadır. Pek çok sistemde tahsisat algoritması olarak "boş blok bağlı listeleri"
kullanılıyorsa da çok çeşitli tahsisat algoritmaları vardır. Burada bir fikir oluşsun diye bu fonksiyonların aaşağıdaki
gibi bir tahsisat tablosu oluşturduğunu düşünebiliriz:

Yapılar (Structures)
Elemanları bellekte ardışıl biçimde tutulan fakat farklı türlerden olabilen veri yapılarına "yapı (structure)"
denilmektedir. Dizi ile yapılar birbilerine çok benzerler. Her ikisinde de elemanları ardışıl olarak bellekte
tutulmaktadır. Fakat dizi elemanları aynı türden olduğu halde yapı elemanları farklı türlernden olabilmektedir.
186

Yapılarla çalışırken önce yapıların bir şablonu bildirilir. Buna "yapı bildirimi" denir. Yapıl bildirimi bellekte yer
kaplamaz. Yani tanımlama değildir. Yapı bildirimini gören derleyici yapı elemanlarının türlerini ve isimlerini
öğrenir. Daha sonra bu yapı türünden gerçek nesnler tanımlanır. Yapı bildiriminin genel biçimi şöyledir:
struct <isim> {
<eleman bildirimleri>
};
Örneğin:
struct DATE {
int day, month, year;
};
struct COMPLEX {
double real;
double imag;
};
struct SAMPE {
int a;
long b;
double c;
};
Yapı isimlerini bazı programcılar büyük harflerle bazıları küçük harflerle harflendirmektedir. Biz kurusumuzda
yapı isimlerini büyük harflerle harflendireceğiz. Yapı bildirimi ile derleyici yapı elemanlarının isimlerini ve
türlerini öğrenir.
Yapı bildirimleri yerel ya da global düzeyde yapılabilir. Eğer yapı bildirimi yerel düzeyde yapılmışsa o yapı ismi
ancak o blokta kullanılabilir. Global olarak yapılmışsa her yerde kullanılabilir. Yapı bildirimleri genellikle global
düzeyde yapılmaktadır. Çünkü çoğu kez yapıların farklı fonksiyonlarda kullanılması gerekmektedir.
Her yapı bildirimi aynı zamanda bir tür de belirtmektedir. Yani bir yapı bildirimi ile biz bir tür de oluşturmuş
oluruz. Yapı bildirimleriyle oluşturulan türler struct anahtar sözcüğü ve yapı ismiyle ifade edilir. Örneğin struct
DATE gibi, struct SAMPLE gibi.
Yapı bildirimi yapıldıktan sonra artık o yapı türünden nesneler tanımlanır. Örneğin:
struct DATE d;
struct SAMPLE s;
Burada d "struct DATE" türünden, s ise "struct SAMPLE" türündendir.
Yapılar bileşik nesnelerdir. Yani parçalardan oluşmaktadır. Örneğin:
struct SAMPLE {
int a;
long b;
double c;
};
187

struct SAMPLE s;

Burada s a, b, ve c parçalarından oluşan nesnein bütününü temsil eder.
Yapı nesneleri genellikle bütünsel olarak kullanılmaz. Onların parçaalarına erişilip parçaları kullanılır. Yapı
elemanlarına erişmek için nokta operatörü kullanılmaktadır.
Nokta operatörü iki operandlı araek bir operatördür. Nokta operatörünün sol tarafındaki operand yapı nesnesinin
bütünü, sağ taraftaki operand onun bir elemanı olmak zorundadır. Bu operatör sol taraftaki yapının sağ taraftaki
elemanına erişmekte kullanılır. Örneğin:
#include <stdio.h>
struct SAMPLE {
int a;
long b;
double c;
};
int main(void)
{
struct SAMPLE s;
s.a = 10;
s.b = 20;
s.c = 12.4;
printf("%d, %ld, %f\n", s.a, s.b, s.c);
return 0;
}

Burada s nesnesi struct SAMPLE türündendir. s.a ifadesi int türdendir. s.a ifadesi "s nesnesinin a parçası" anlamına
gelir. s.b ifadesi long türden, s.c ifadesi ise double türdendir.
C standartlarına göre yapı bildiriminde ilk yazılan eleman düşük adreste bulunacak biçimde eleman ardı
şıllığı oluşturulur. Yani örneğimizde s'in a parçası en düşük adrestedir. Bunu b parçası izler onu da c parçası izler.
Nokta operatörü öncelik tablosunun en yüksek düzeyinde soldan sağa grupta bulunur
188

() [].

Soldan-Sağa

+ - ++ -- ! sizeof & *

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

...

...

Örneğin &s.a gibi bir ifadede s.a'nın adresi alınmaktadır. Çünkü nokta operatörü & operatöründen daha yüksek
önceliklidir. Örneğin:
#include <stdio.h>
struct SAMPLE {
int a;
long b;
double c;
};
int main(void)
{
struct SAMPLE s;
printf("%p, %p, %p\n", &s.a, &s.b, &s.c);
return 0;
}
Anahtar Notlar: Anımsanacağı gibi Kernighan & Ritchie yazıam tarzında iki operandlı operatörlerle operandlar arasında birer boşluk karakteri
bırakılıyordu. Fakat nokta ve -> operatörleri iki operandlı olmasına karşın bunlarla operandlar arasında boşluk karakteri bırakılmamaktadır.

Bir yapı nesnesinin elemanlarına henüz değer atanmadıysa içerisinde ne vardır? İşte eğer yapı nesnesi yerelse onun
tüm elemanlarında çöp değerler, global ise sıfır değerleri bulunur.
Bir yapı nesnesine küme parantezleri içerisinde ilkdeğer verebiliriz. (Tıpkı dizilerd eolduğu gibi) Örneğin:
#include <stdio.h>
struct SAMPLE {
int a;
long b;
double c;
};
int main(void)
{
struct SAMPLE s = { 10, 20, 20.5 };
printf("%d, %ld, %f\n", s.a, s.b, s.c);
return 0;
}

Tıpkı dizilerde olduğu gibi yapının az sayıda elemanına ilkdeğer verebiliriz. Bu durumda geri kalan elemanlar
derleyici tarafından sıfırlanır. Fakat yapının fazla sayıda elemanına ilkdeğer vermeye çalışırsak derleme
aşamasında error oluşur.
Aynı türden iki yapı nesnesi birbirlerine atanabilir. Bu durumda yapının karşılıklı elemanları birbirlerine
atanmaktadır. Örneğin:
189

#include <stdio.h>
struct SAMPLE {
int a;
long b;
double c;
};
int main(void)
{
struct SAMPLE s = { 10, 20, 30.5 };
struct SAMPLE k;
k = s;
printf("%d, %ld, %f\n", s.a, s.b, s.c);
printf("%d, %ld, %f\n", k.a, k.b, k.c);
return 0;
}

Atama işleminde yapıların türlerinin aynı olması gerekir. Tür ise isme bağlıdır. İçi aynı olan farklı isimli yapıları
birbirlerine atayamayız.
Yapı Elemanı Olarak Diziler
Bir dizi bir yapının elemanı olabilir. Bu durumda yapının dizi elemnanına erişildiğinde bu ifade dizinin tamamını
temsil eder, ifade içerisinde kullanıldığında ise yapı içerisindeki dizinin başlangıç adresini belirtir. Örneğin:
#include <stdio.h>
struct PERSON {
char name[32];
int no;
};
int main(void)
{
struct PERSON per;
printf("Adi soyadi:");
gets(per.name);
printf("No:");
scanf("%d", &per.no);
printf("%s, %d\n", per.name, per.no);
return 0;
}

190

Böyle yapı nesnesine ilkdeğer de verebiliriz:
struct PERSON per = {"Kaan Aslan", 123};
Tabi buradaki iki tırnak ifadesi adres anlamına gelmez. Karakterlerin name dizisine kopyalanacağı anlamına gelir.
Nokta operatöryle [] operatörünün aynı grupta soldan sağa öncelikli olduğuna dikkat ediniz. Örneğin:
per.name[3]
ifadesi per.name dizisinin 3. indeksli elemanı anlamına gelir. Yani:
per -------> struct PERSON türündendir
per.name -------> char * türündendir
per.name[3] ------> char türündendir
Örneğin:
#include <stdio.h>
struct PERSON {
char name[32];
int no;
};
int main(void)
{
struct PERSON per = { "Kaan Aslan", 123 };
char ch;
ch = per.name[3];
putchar(ch);
return 0;
}

Yapı Elemanı Olarak Göstericilerin Kullanılması
Bir yapının elemanı bir gösterici olabilir. Örneğin:
struct PERSON {
char *name;
int no;
191

};
struct PERSON per;
Burada name elemanı bir göstericidir ve bu göstericinin tahsis edilmiş bir alanı gösteriyor olması gerekir. Örneğin:
#include <stdio.h>
struct PERSON {
char *name;
int no;
};
int main(void)
{
struct PERSON per;
per.name = "Kaan Aslan";
per.no = 123;
printf("%s, %d\n", per.name, per.no);
return 0;
}

Yapı Türünden Adresler ve Göstericiler
Bir yapı nesnesinin adresi alınabilir. Bu durumda elde edilen adresin sayısal bileşeni tüm yapı nesnesinin bellekteki
başlangıç adresi, tür bileşeni ise po yapı türündendir. Bir yapı nesnesinin adresi aynı türden bir yapı göstericisne
atanabilir. Örneğin:
struct SAMPLE {
int a;
long b;
double c;
};
struct SAMPLE s;
struct SAMPLE *ps;
ps = &s;

192

Bir yapı göstericisi ya da bir yapı türünden adres * operatörüyle kullanılırsa yapı nesnesinin tamamına erişilir. Yani
yukarıdaki örnekte *ps ile s aynıdır. Burada ps struct SAMPLE * türünden *ps ise struct SAMPLE türündedir.

Yapı Göstericisi Yoluyla Yapı elemanlarına Erişilmesi
p bir yapı türünden adres a da bu yapının bir elemanı olmak üzere bu adresin gösterdiği yerdeki yapı nesnesinin a
elemanına erişmek için (*p).a ifadesi kullanılır. *p.a ifadesi geçersizdir. Çünkü nokta operatörü * operatöründen
daha yüksek öncelikli olduğu için bu ifadede önce p.a yapılmaya çalışılır ki nokta operatörünün solundaki operand
geçersi olur. Çünkü nokta operatörünün solundaki operand yapı nesnesinin kendisi olmalıdır, adresi olmamalıdır.
Örneğin:
#include <stdio.h>
struct SAMPLE {
int a;
long b;
double c;
};
int main(void)
{
struct SAMPLE s;
struct SAMPLE *ps;
ps = &s;
(*ps).a = 10;
(*ps).b = 20;
(*ps).c = 30;
printf("%d, %ld, %f\n", (*ps).a, (*ps).b, (*ps).c);
return 0;
}

Ok (Arrow) Operatörü
Ok operatörü -> karaketerleriyle elde edilir. Ok operatörü iki operandlı araek bir operatördür. Ok operatörünün
193

solundaki operand bir yapı türünden adres, sağındaki operand o yapının bir elemanı olmak zorundadır. On
operatörü sol taraftaki operandla belirtilen adresteki yapı nesnesinin sağ taraftaki operandla belirtilen elemanına
erişmekte kullanılır. Yani:
p->a
ile
(*p).a
tamamen eşdeğerdir.
Nokta operatörüyle ok operatörünün her ikisi de yapı elemanlarına erişmekte kullanılır. Nokta operatörü nesnenin
kendisiyle ok operatörü adresiyle erişim sağlar. Ok operatörü öncelik tablosunun en üst düzeyinde soldan sağa
grupta bulunur:
( ) [ ] . ->

Soldan-Sağa

+ - ++ -- ! sizeof & *

Sağdan-Sola

* /%

Soldan-Sağa

+ -

Soldan-Sağa

...

...

Örneğin:
#include <stdio.h>
struct SAMPLE {
int a;
long b;
double c;
};
int main(void)
{
struct SAMPLE s;
struct SAMPLE *ps;
ps = &s;
ps->a = 10;
ps->b = 20;
ps->c = 30;
printf("%d, %ld, %f\n", ps->a, ps->b, ps->c);
return 0;
}

Örneğin:
#include <stdio.h>
struct POINT {
int x, y;
};
int main(void)

194

{
struct POINT pt;
struct POINT *ppt;
ppt = &pt;
ppt->x = 10;
ppt->y = 20;
printf("(%d, %d)\n", ppt->x, ppt->y);
return 0;
}

s bir yapı türünden nesne a da bu yapının bir elemanı olmak üzere &s->a ifadesi geçersizdir. Çünkü & operatörü ->
operatöründen daha düşük önceliklidir. Ancak (&s)->a ifadesi geçerlidir ve s.a ile eşdeğerdir.
p bir yapı türünden adres ve a da bu yapının bir elelmanı olmak üzere &p->a ifadesi geçerlidir ve bu ifade p
göstericisinin gösterdiği yerdeki nesnenin a parçasının adresi anlamına gelir.
Örneğin:
#include <stdio.h>
struct PERSON {
char name[32];
int no;
};
int main(void)
{
struct PERSON per = { "Ali Serce", 234 };
struct PERSON *pper;
pper = &per;
printf("%s, %d\n", pper->name, pper->no);
printf("%c\n", pper->name[2]);
return 0;
}

Yapıların Fonksiyonlara Parametre Yoluyla Aktarılması
Yapıların fonksiyonlara aktarılmasında iki teknik kullanılır. Bunlardan birincisi nesnenin kopyalama yoluyla
aktarılması tekniği, diğeri ise adres yoluyla aktarma tekniğidir. Nesnenin kendisinin aktarılması genel olarak kötü
bir tekniktir. Adrtes yoluyla aktarma iyi bir tekniktir. Gerçekten de C'de yapı nesneleri hemen her zaman
fonksiyonlara adres yoluyla aktarılır.
2) Yapı Nesnelerinin Fonksiyonlara Kopyalama Yoluyla Aktarılması: Bu yöntemde fonksiyonun parametre
değişkeni bir yapı türünden yapı nesnesidir. Fonksiyon da aynı yapı türünden bir nesneyle çağrılır. Aynı türden iki
yapı nesnesi atanabildiğine göre bu çağırma geçerlidir. Ancak burada aktarım kopyalama yoluyla yapılmaktadır.
Örneğin:
#include <stdio.h>
struct PERSON {
char name[32];
int no;
};

195

void foo(struct PERSON per)
{
printf("%s, %d\n", per.name, per.no);
}
int main(void)
{
struct PERSON x = { "Ali Serce", 234 };
foo(x);
return 0;
}

Bu yöntem genel olarak kötü bir tekniktir. Çünkü büyük bir yapının bu yöntemde tüm elemanlarını tek tek aktarım
sırasında fonksiyona kopyalanır. Üstelik bu yöntemde fonksiyon içerisinde artık biz orijinal nesneye erişemeyiz.
Tabi eğer yapı çok küçükse bu teknik kötü bir teknik olmaz. Bu durumda kullanılabilir.
2) Yapı Nesnelerinin Fonksiyonlara Adres Yoluyla Aktarılması: Bu yöntemde fonksiyonun parametre
değişkeni yapı türünden gösterici olur. Fonksiyon da aynı türden bir yapı nesnesinin adresiyle çağrılır. Bu
kullanılması gereken doğru tekniktir. Örneğin:
#include <stdio.h>
struct PERSON {
char name[32];
int no;
};
void foo(struct PERSON *per)
{
printf("%s, %d\n", per->name, per->no);
}
int main(void)
{
struct PERSON x = { "Ali Serce", 234 };
foo(&x);
return 0;
}

Örneğin:
#include <stdio.h>
struct DATE {
int day;
int month;
int year;
};
void get_date(struct DATE *date)
{
printf("Gun:");
scanf("%d", &date->day);
printf("Ay:");
scanf("%d", &date->month);
printf("Yil:");
scanf("%d", &date->year);

196

}
void disp_date(struct DATE *date)
{
printf("%02d/%02d/%04d\n", date->day, date->month, date->year);
}
int main(void)
{
struct DATE date;
get_date(&date);
disp_date(&date);
return 0;
}

Örneğin:
#include <stdio.h>
struct COMPLEX {
double real, imag;
};
void get_comp(struct COMPLEX *comp)
{
printf("Gercek Kisim:");
scanf("%lf", &comp->real);
printf("Sanal Kisim:");
scanf("%lf", &comp->imag);
}
void disp_comp(struct COMPLEX *comp)
{
printf("%.0f+%.0fi\n", comp->real, comp->imag);
}
int main(void)
{
struct COMPLEX z;
get_comp(&z);
disp_comp(&z);
return 0;
}

Yapılara Neden Gereksinim Duyulmaktadır?
1) Yapılar olgular için mantıksal bir kap oluşturmaktadır. Yani tarih gibi, sanal sayılar gibi, şahıs bilgileri gibi
birbirleriyle ilgili çok sayıda nesne bir yapıyla ifade edilirse daha kolay bir temsil yeteneği el edilir. Gerçekten de
mantıksal bakımdan birbirleriyle bağlantılı nesnelerin yapılarla temsil edilmesi okunabilirliği ve anlaşılabilirliği
artırmaktadır.
2) Bir fonksiyona çok sayıda parametre aktarılacaksa onların tek tek aktarılmaları hem yazılımsal olarak zordur.
Hem anlaşılır olmaktan çıkar hem de yavaştır. Bunun yerine çok sayıda parametre bir yapında toplanım tek bir
parametre biçiminde fonksiyona geçirilebilir.
3) Bir fonksiyonun tek bir geri dönüş değeri vardır. Eğer fonksiyon dış dünyaya çok sayıda değer iletecekse bu
yapılarla sağlanabilir. Örneğin iletilecek değerler bir yapıyla ifade edilir. Fonksiyona yapı nesnesinin adresi
197

geçirilir. Fonksiyon da bu nesnenin içini doldurur.
Fonksiyonların Geri Dönüş Değerlerinin Yapı Olması Durumu
Bir fonksiyonun geri dönüş değeri bir yapı türünden olabilir. Bu durumda return ifadesi de aynı türden bir yapı
nesnesi olmalıdır. Aslında bu yöntem de C'de çoğu kez (yani yapı büyükse) iyi teknik kabul edilmez. Çünkü
burada return işlemi sırasında geçici nesneye bir kopyalama yapılmakta ve geri dönüş değerinin atanması sırasında
da aynı sorun oluşmaktadır. Örneğin:
#include <stdio.h>
struct COMPLEX {
double real, imag;
};
void disp_comp(struct COMPLEX *comp)
{
printf("%.0f+%.0fi\n", comp->real, comp->imag);
}
struct COMPLEX add_comp(struct COMPLEX *z1, struct COMPLEX *z2)
{
struct COMPLEX result;
result.real = z1->real + z2->real;
result.imag = z1->imag + z2->imag;
return result;
}
int main(void)
{
struct COMPLEX z1 = { 3, 2 };
struct COMPLEX z2 = { 1, 4 };
struct COMPLEX result;
result = add_comp(&z1, &z2);
disp_comp(&result);
return 0;
}

Genellikle programcılar çoklu bilgiyi böyle almaktansa bir nesne verip fonksiyonun onun içerisine yerleştirme
yapmasını tercih ederler. Örneğin:
#include <stdio.h>
struct COMPLEX {
double real, imag;
};
void disp_comp(struct COMPLEX *comp)
{
printf("%.0f+%.0fi\n", comp->real, comp->imag);
}
void add_comp(struct COMPLEX *z1, struct COMPLEX *z2, struct COMPLEX *result)
{
result->real = z1->real + z2->real;
result->imag = z1->imag + z2->imag;
}

198

int main(void)
{
struct COMPLEX z1 = { 3, 2 };
struct COMPLEX z2 = { 1, 4 };
struct COMPLEX result;
add_comp(&z1, &z2, &result);
disp_comp(&result);
return 0;
}

Yapılarda Hizalama (Alignment Kavramı)
Modern 32 işlemcilerde bellek bağlantısı bir hamlede 4 byte bilgiyi çekeck biçimde yapımıştır. Benzer biçimde 64
bit işlemcilerde de bellek bağlantısı bir hamlede 8 byte bilgiyi çekecek biçimde yapılmıştır. Böylece örneğin 32 bit
işlemciler aslında 32 adres yoluna değil 30 adres yoluna sahiptir. Tabi makina komutları yine aynı biçimde byte
ardeslemeli çalışmaktadır. Aşağıda 32 bit bir işlemcinin bellek erişimi resmedilmiştir:

Bu sistemlerde eğer 4 byte'lık bir bilgi (örneğin int türden bir bilgi) 4'ün katlarında değilse makina komutları göreli
olarak daha yavaş çalışmaktadır. Çünkü bu 4 byte'ı işlemci iki bus erişimiyle elde eder:

Tabi bir byte bir bilgiye kaçın katlarında olursa olsun tek bus hareketiyle erişilebilmektedir. Peki 2 byte'lık bilgiler?
Bunların da 2'nin katlarında olması gerekir. Örneğin 2'nin katlarında olmayan 2 byte'lık (örneğin short türden bir
nesne) bir nesne aşağıdaki gibi gösterilebilir:

İşte derleyiciler işlemcilerin böyle çalıştıklarını bildiği için makina komutları daha hızlı çalışsın diye 4 byte'lık
199

nesneleri 4'ün katlarına, 8 byte'lık nesneleri 8'in katlarına, 2 byte'lık nesneleri 2'nin katlarına, 1 byte'lık nesneleri
1'in katlarına yerleştirmektedir. Derleyiciler bunlara yerel değişkenler için ve global değişkenler için dikkaet
ederler. Yapı elemanları bellekte ardışıl olacağından ve ilk yazılan elemanın düşük adreste olması gerekeceğinden
bu hizalama (alignement) yapılar için nasıl gerçekleştirilecektir? İşte derleyiciler yapı elemanlarının arasına
boşluklar koyarak o elemanların belli adres katlarında olmasını sağlayabilmektedir. Örneğin:
struct SAMPLE {
char a;
int b;
char c;
int d;
};
struct SAMPLE s;
32 bit bir işlemcide bu yap nesnesinin bellkete 10 byte yer kaplayacağı düşünülebilir. Ancak derleyiciler a ile b
arasına ve c ile d arasına 3'er byte boşluk bırakarak int olan kısımların 4'ün katlarına gelmesini sağlayabilmektedir.
Böylece bu yapı nesnesinin sizeof değerinin 16 çıkması programcıyı şaşırtmamalıdır. Örneğin:
#include <stdio.h>
struct SAMPLE {
char a;
int b;
char c;
int d;
};
int main(void)
{
struct SAMPLE s;
printf("%u\n", sizeof(s));

/* 16 */

return 0;
}

Peki yukarıdaki yapıyı aşağıdaki gibi düzenleseydik ne olurdu?
#include <stdio.h>
struct SAMPLE {
char a;
char b;
int c;
int d;
};
int main(void)
{
struct SAMPLE s;
printf("%u\n", sizeof(s));

/* 12 */

return 0;
}

Hizalama pek çok derleyicide derleyici seçeneklerinden yönetilebilmektedir. Örneğin Microsoft C derleyicilerinde
hizalama Proje ayarlarında C-C++/Code Generation/Struct Member Alignment ile değiştirilebilmektedir. Eğer
hizalama "1 byte hizalama moduna çekilirse derleyici yapı elemanlarını 1'in katlarına yerleştirmeye çalışır.
200

Dolayısıyla elemanlar arasında hiç boşluk bırakmaz.
C standartlarına hizalama kavramı bir kurala bağlanmamıştır. Standartlarda yalnızca derleyicinin yapı elemanları
arasında boşluk bırakabileceği belirtilmiştir.
Peki derleyicinin yapı elemanları arasında boşluk bırakabilmesi erişimde bir soruna yol açar mı? Yanıt hayır.
Çünkü derleyici nerelere boşluk bıraktığını bildiği için ona göre erişimi yapmaktadır. Örneğin aşağıdaki yapı için
derleyici 4 byte hizalama kullanmış olsun:
struct SAMPLE {
char a;
int b;
char c;
int d;
};

Şimdi p göstericisinin bu yapıyı gösterdiğini düşünelim. Artık derleyici p->b ifadesiyle p adresinden 1 byte
sonraya değil 4 byte sonraya erişir. Çünkü araya boşluk bıraktığını zaten kendisi bilmektedir. Yani yukarıdaki
yapıyı biz şöyle düşünebiliriz:
struct SAMPLE {
char a;
char temp1, temp2, temp3;
int b;
char c;
char temp4, temp5, temp6;
int d;
};

Yapılar İçin Dinamik Tahsisat Yapılması
Mademki yapı elemanları bellekte ardışıl bir biçimde tutulmaktadır. O halde yapı nesneleri için de heap'te dinamik
tahsisatlar yapılabilir. Dinamik tahsisat yaparken hizalama olasılığını göz önüne almak gerekir. Bu nedenle yapının
byte uzunluğunun sizeof operatörü ile elde edilmesi uygun olur. sizeof operatörü derleyicinin o anda uyguladığı
hizalamayı da hesaba katmaktadır. Örneğin:
#include <stdio.h>
#include <stdlib.h>
struct PERSON {
char name[32];
int no;
};
int main(void)
{
struct PERSON *per;
per = (struct PERSON *)malloc(sizeof(struct PERSON));
if (per == NULL) {
printf("cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
printf("Adi soyadi:");
gets(per->name);
printf("No:");
scanf("%d", &per->no);
printf("%s, %d\n", per->name, per->no);

201

free(per);
return 0;
}

Yapı Dizileri
Her elemanı bir yapı nesnesi olan dizilere yapı dizileri (array of structures) denilmektedir. Yapı dizileri de normal
dizilerde olduğu gibi bildirilir. Örneğin:
struct PERSON persons[3];

Örneğin:
#include <stdio.h>
#include <string.h>
struct PERSON {
char name[32];
int no;
};
int main(void)
{
struct PERSON persons[3];
int i;
strcpy(persons[0].name, "Kaan Aslan");
persons[0].no = 123;

202

strcpy(persons[1].name, "Ali Serce");
persons[1].no = 234;
strcpy(persons[2].name, "Necati Ergin");
persons[2].no = 678;
for (i = 0; i < 3; ++i)
printf("%s, %d\n", persons[i].name, persons[i].no);
return 0;
}

Anımsanacağı gibi dizi isimleri tüm diziyi temsil etmektedir. Ancak bunlar işleme sokulduğunda derleyici
tarafından dizinin başlangıç adresine dönüştürülürler. Yani biz dizi isimlerini kullandığımızda aslında o dizilerin
başlangıç adreslerini kullanıyor oluruz. Dizi isimleri kullanıldığında nesne belirtmezler.
Biz bir yapı dizisinin ismini aynı yapı türünden bir yapı göstericisine atayabiliriz. Örneğin:
#include <stdio.h>
#include <string.h>
struct PERSON {
char name[32];
int no;
};
int main(void)
{
struct PERSON persons[3], *per;
int i;
strcpy(persons[0].name, "Kaan Aslan");
persons[0].no = 123;
strcpy(persons[1].name, "Ali Serce");
persons[1].no = 234;
strcpy(persons[2].name, "Necati Ergin");
persons[2].no = 678;
per = persons;
for (i = 0; i < 3; ++i) {
printf("%s, %d\n", per->name, per->no);
++per;
}
return 0;
}

Bir yapı göstericini bir artırdığımızda göstericinin içerisindeki adres yapı uzunluğu kadar artmaktadır.
Yapı dizilerine de küme parantezleri ile ilkdeğer verilebilir. Bu durumda eleman olan her yapı nesnesi için de ayrı
bir küme parantezi kullanılır. Örneğin:
struct PERSON persons[3] = {
{ "Kaan Aslan", 123 }, { "Ali Serce", 345 }, { "Necati Ergin", 654 }
};

Aslında bu tür durumlarda ,çteki küme parantezleri zorunlu değildir. Örneğin yukarıdaki ilk değer verme şöyle
yapılabilirdi:
203

struct PERSON persons[3] = {
"Kaan Aslan", 123 , "Ali Serce", 345, "Necati Ergin", 654
};

Fakat bu biçimde ilkdeğer verme hem okunabilirliği azaltmakta hem de aradaki bir değer unutulduğunda diğer tüm
değerlerin yanlış elemanlara atanması gibi bir soruna yol açabilmektedir. Örneğin:
struct POINT {
int x;
int y;
};
struct POINT points[5] = {
{ 1, 2 }, { 4, 7 }, { 6, 8 }, { 7, 9 }, { 3, 4 }
};

Burada 2 değerinin yazılmadığını düşünelim:
struct POINT points[5] = {
{ 1 }, { 4, 7 }, { 6, 8 }, { 7, 9 }, { 3, 4 }
};

Artık dizinin ilk elemanının y değeri sıfır olacaktır. Ancak:
struct POINT points[5] = {
1, 4, 7 , 6, 8, 7, 9, 3, 4
};

Burada tamamen bir kaydırma oluşmaktadır.
Örneğin:
#include <stdio.h>
struct POINT {
int x;
int y;
};
int main(void)
{
struct POINT points[5] = {
{ 1, 2 }, { 4, 7 }, { 6, 8 }, { 7, 9 }, { 3, 4 }
};
int i;
for (i = 0; i < sizeof(points) / sizeof(*points); ++i)
printf("(%d, %d)\n", points[i].x, points[i].y);
return 0;
}

Bir yapı dizisini de fonksiyona parametre yoluyla aktarabiliriz. Bunun için yine onun başlangıç adresini ve
uzunluğunu fonksiyona geçiririz. Örneğin:
#include <stdio.h>
#include <string.h>
struct PERSON {
char name[32];
int no;
};

204

void sort_persons_byname(struct PERSON *per, int size);
void sort_persons_byno(struct PERSON *per, int size);
void disp_persons(struct PERSON *per, int size);
int main(void)
{
struct PERSON persons[] = {
{ "Selami Hakyemez", 123 }, { "Ahmet Hamdi Tanpinar", 523 }, { "Hulisi Sen", 323 },
{ "Siracettin Bilyap", 654 }, { "Ali Ipek", 234 }
};
sort_persons_byname(persons, 5);
disp_persons(persons, 5);
printf("-----------\n");
sort_persons_byno(persons, 5);
disp_persons(persons, 5);
return 0;
}
void sort_persons_byname(struct PERSON *per, int size)
{
int i, k;
struct PERSON temp;
for (i = 0; i < size - 1; ++i)
for (k = 0; k < size - 1 - i; ++k)
if (strcmp(per[k].name, per[k + 1].name) > 0) {
temp = per[k];
per[k] = per[k + 1];
per[k + 1] = temp;
}
}
void sort_persons_byno(struct PERSON *per, int size)
{
int i, k;
struct PERSON temp;
for (i = 0; i < size - 1; ++i)
for (k = 0; k < size - 1 - i; ++k)
if (per[k].no > per[k + 1].no) {
temp = per[k];
per[k] = per[k + 1];
per[k + 1] = temp;
}
}
void disp_persons(struct PERSON *per, int size)
{
int i;
for (i = 0; i < size; ++i)
printf("%s, %d\n", per[i].name, per[i].no);
}

Yapı Bildirimiyle Nesne Tanımlamasının Birlikte Yapılması
Bir yapı bildirilirken bildirim ';' ile kapataılmayıp bir değişken listesi de yazılırsa aynı zamanda o yapı türünden
nesneler de tanımlanmış olur. Örneğin:
struct POINT {
int x, y;
205

} pt1, pt2;
Bu bildirimin aşağıdakinden hiçbir farkı yoktur.
struct POINT {
int x, y;
};
struct POINT pt1, pt2;
Örneğin:
struct PERSON {
char name[32];
int no;
} per = {"Kaan Aslan", 123}, *pper, persons[] = { {"Ali Serce", 123}, {"Ahmet
Altintarti", 345} };
Burada "per" struct PERSON türünden bir nesnedir, "pper" struct PERSON türünden bir göstericidir. persons ise
struct PERSON türünden bir dizidir. Bu biçimde bildirilmiş değişkenler yapı global olarak bildirildiyse global,
yerel olarak bildirildiyse yerel biçimdedir.
C standartlarına göre eğer yapı bildirimi ile aynı zamanda o yapı türünden n esne tanımlanıyorsa bu durumda
yapıya isim verilmeyebilir. Örneğin:
struct {
char name[32];
int no;
} x, y;
Ancak eğer yapı türündne değişken tanımlanmıyorsa yapıya isim verilmek zorudadır. Örneğin:
struct {
/* geçersin */
char name[32];
int no;
};
İsimsiz yapıların hepsi farklı bir tür kabul edilir. Yani örneğin:
struct {
char name[32];
int no;
} x;
struct {
char name[32];
int no;
} y;
Burada x ve y derleyici tarafından aynı türden kabul edilmemektedir. Bu nedenle biz örneğin bunları birbirlerine
atayamayız.
İç İçe Yapı Bildirimleri
206

Bir yapının elemanları başka yapı türünden olabilir. Bu tür durumlara "iç içe yapı bildirimleri" denilmektedir.
Örneğin:
struct DATE {
int day, month, year;
};
struct PERSON {
char name[32];
struct DATE bdate;
int no;
};

Örneğin:
#include <stdio.h>
struct DATE {
int day, month, year;
};
struct PERSON {
char name[32];
struct DATE bdate;
int no;
};
int main(void)
{
struct PERSON per = { "Sacit Bayram", { 12, 10, 1970 }, 2000 };
printf("%s, %d/%d/%d, %d\n", per.name, per.bdate.day, per.bdate.month, per.bdate.year, per.no);
return 0;
}

İç içe yapılarda ilkdeğer verilirken iç yapı ayrıca küme parantezine alınabilir ya da alınmayabilir. Ancak
okunabilirlik bakımından iç yapıya ilişkin değerlerin küme parantezleri içerisine alınması tavsiye edilir.
İç içe yapıların alternatif bildirim biçimi de vardır. Bu biçimde iç yapı dış yapının fiziksel olarak içerisinde
bildirilir. Örneğin:
struct PERSON {
char name[32];
struct DATE {
int day, month, year;
} bdate;
int no;
};

207

Burada dış yapı bildirimi içerisinde hem iç yapı bildirilmiş hem de o yapı türünden değişken bildirimi yapılmıştır.
Bu biçimdeki bildirimde içeride bildirilen yapı (örneğimizde struct DATE) ayrıca dış yapıdan bağımsız olarak da
kullanılabilir. Örneğin:
struct PERSON per;
struct DATE date;
/* geçerli */
Yani bu iki iç içe yapı bildirim biçimi semantik olarak tamamen eşdeğerdir. Genel olarak birinci biçimin daha
okunabilir olduğu söylenebilir.
typedef Bildirimleri
typedef anahtar sözcüğü bir tür isminin tam olarak yerini tutabilen alternatif isimler oluşturmak için kullanılır.
typedef standartlarda bildirimdeki bir yer belirleyici (storage class specifier) biçiminde tanımlanmıştır. Bir
bildirime typedef anahtar sözcüğü eklenirse bildirimdeki değişken ismi o değişkenin türünü belirten tür ismi haline
gelir. Örneğin:
int I;
Burada I bir değişken ismidir ve int türdendir. Şimdi bildirime typedef ekleyelim:
typedef int I;
Burada I artık int türünü temsil eder. Örneğin:
int a, b, c;
ile,
I a, b, c;
tamamen eşdeğerdir. Örneğin:
char *STR;
Burada STR char * türünden bir değişkendir. Şimdi bildirimin başına typedef yerleştirelimr:
typedef char *STR;
Artık STR char * türünü temsil etmektedir. Yani:
char *s;
ile
STR s;
aynı anlamdadır.
Örneğin:
#include <stdio.h>

208

typedef int I;
typedef char *STR;
int main(void)
{
I a;
STR s = "Ankara";
a = 10;
printf("%d\n", a);
printf("%s\n", s);
return 0;
}

Örneğin:
int A, B, C;
Burada A, B ve C int türden değişken isimleridir. Bildirimin başına typedef getirelim:
typedef int A, B, C;
Burada artık, A, B ve C int türünü temsil eden tür ismidir. Örneğin:
int I, *PI;
Burada I int türünden, PI da int * türündendir. Bildirimin başına typedef getirelimr:
typedef int I, *PI;
Burada artık I int türünü, PI da int * türünü temsil eder. Örneğin:
struct PERSON {
char name[32];
int no;
};
struct PERSON PER;
Burada PER struct PERSON türündendir. Şimdi bildirimin başına typedef getirelim:
typedef struct PERSON PER;
Artık PER struct PERSON türünü belirten bir tür ismi haline gelmiştir. Yani örneğin:
struct PERSON per;
ile,
PER per;
aynı anlamdadır. Örneğin:
#include <stdio.h>

209

struct PERSON {
char name[32];
int no;
};
typedef struct PERSON PER;
int main(void)
{
PER per = { "Ali Serce", 123 };
printf("%s, %d\n", per.name, per.no);
return 0;
}

Örneğin aynı işlem şöyle de yapılabilirdi:
typedef struct PERSON {
char name[32];
int no;
} PER;
PER per = {"Ali Serce", 123};
Örneğin:
struct {
char name[32];
int no;
} PER;
Burada PER bildirilen yapı türünden bir nesnedir. Başına typedef getirelim:
typedef struct {
char name[32];
int no;
} PER;
Burada PER bu yapıyı temsil eder. Örneğin:
PER x;
PER y;
x ve y aynı türdendir.
Örneğin:
int ARY[3];
Burada ARY int[3] türündedir. Şimdi başına typedef getirelim:
typedef int ARY[3];
Burada artık ARY 3 elemanlı bir int dizi türü ismidir. Yani örneğin:
210

int a[3];
ile,
ARY a;
aynı anlamdadır. Örneğin:
#include <stdio.h>
typedef int ARY[3];
int main(void)
{
ARY a = { 1, 2, 3 };
int i;
for (i = 0; i < 3; ++i)
printf("%d\n", a[i]);
return 0;
}

Örneğin:
void FOO(int a);
Burada FOO geri dönüş değeri void parametresi int olan bir fonksiyon prototipidir. Başına typedef getirelim:
typedef void FOO(int a);
Artık Foo geri dönüş değeri void parametresi int olan bir fonksiyon türünü temsil eder. Yani:
FOO x, y;
ile,
void x(int a);
void y(int a);
aynı anlmadadır.
typedef anahtar sözcüğünün bildirimde başa gelmesi zounlu değildir. Fakat değişken isminin solunda bulunmak
zorudadır. Örneğin:
int typedef I;
typedef int I;
int I typedef;

/* geçerli */
/* geçerli */
/* geçersiz */

typedef bildirimleri yerel ya da global düzeyde yapılabilir. Eğer yerel düzeyde yapılırsa o typedef ismi yalnızca o
blokta kullanılabilir. Eğer global düzeyde yapılırsa her yerde kullanılabilir. typedef bidirimleri genellikle globak
düzeyde yapılmaktadır. Hatta çoğu kez programcılar typedef bildirimlerini başlık dosyalarının içerisine yerleştirir.
Bazı typedef bildirimleri ile yaratılmak istenen etki #define önişlemci komutuyla ya yaratılabilmektedir. Örneğin:
#define I int
211

I a, b, c;
Fakat pek çok tür #defile ile oluşturulamaz. Örneğin:
typedef int ARY[3];
Bunun karşılığını #define ile oluşturamayız. Ya da örneğin:
#define I int *
I a, b;
Burada yalnızca a gösterici olur. Halbuki:
typedef int *I;
I a, b;
Burada hem a hem de b göstericidir. Karmaşık türler #define ile zaten oluşturulamaz. Ayrıca #defibe önişlemci
aşamasına ilişkindir. Halbuki typedef derleme modülü tarafından değerlendirilir.
typedef Bildirimlerine Neden Gereksinim Duyulmaktadır?
1) typedef karmaşık türlerin daha kolay yazılmasını sağlar. Örneğin:
char *PARY[5];
PARY names = {"ali", "veli,", "selami", "ayse", "fatma"};
2) typedef okunabilirliği artırmak için de kullanılabilmektedir. Yani bir türe onun kullanım amacına uygun bir isim
verirsek kodu inceleyen kişiler onu daha iyi anlamlandırabilirler. Örneğin:
typedef int BOOL;
BOOL foo()
{
...
}
Burada biz foo'nun başarı ya da başarısızlık biçiminde bir geri dönüş değerine sahip olduğunu anlıyoruz.
3) typedef taşınabilirliği artımak için kullanılabilir. Örneğin bir kütüphane oluşturan ekip bazı türlerin duruma göre
sistemden sisteme değişebileceğini gördüğünden bunlara typedef ismi atayabilir.
/* lib.h */
typedef int HANDLE;
HANDLE foo(void);
212

Burada HANDLE int türdendir. Programcı fonksiyonu şöyle kullanır:
HANDLE h;
h = foo();
Burada kütüphaneyi yazanlar başka bir sistem için HANDLE değerini long olarak typedef edebilirler. Biz de int
yerine HANDLE kullandığımızda boşuna kodumuzu değiştirmek zorunda kalmayız. Yani değişiklikten kodumuz
etkilenmemiş olur. Gerçekten de C/C++'ta yazılmış framework'ler ve kütüphanelerde typedef ile oluşturulmuş tür
isimlerine çık sık rastlanır.
C'de Standart Olarak Bildirilen Bazı typedef İsimleri
C'de de bazı başlık dosyalarında bildirilmiş olan çeşitli typedef isimleri vardır. Bunlar taşınabilirlik sağlamak
amacıyla oluşturulmuştur. Tabi bunları kullanmak için ilgili dosyasının include edilmesi gerekir. C'nin tüm standart
typede isimleri <stddef.h> isimli bir dosyada bildirilmiştir. Bu standart typedef isimlerinin hepsinin sonu xxx_t ile
biter. Fakat bazı typedef isimleri ayrıca başka başlık dosyalarında da bildirilmiş durumdadır. Bunların bazıları
aşağıda açıklanmaktadır:
size_t türü: Standartlara göre size_t işaretsiz bir tamsayı türü olarak typedef edilmek zorundadır. size_t tipik
olarak ilgili sistemdeki bellek büyüklüğünü ifade edecek biçimde derleyicileri yazanlar tarafından uygun bir türe
typedef edilir. Bazı sistemlerde size_t unsigned int olarak bazı sistemlerde de unsigned long int olarak karşımıza
çıkabilmektedir. size_t C'de bazı fonksiyonların prototilerinde kullanılmıştır. Örneğin malloc fonksiyonunun
standartlarda belirtilen prototipi şöyledir:
void *malloc(size_t size);
Yani malloc fonksiyonunun parametresi o sistemde derleyiciyi yazanlar size_t türünü nasıl typedef etmişlerse o
türdendir. Örneğin strlen fonksiyonunun da orijinal prototipi şöyledir:
size_t strlen(const char *str);
C programcıları da kendi programlarında genellikle dizi uzunluklarını size_t ile fade ederler. size_t türü <stddef.h>
dosyasıının yanı sıra <stdio.h>, <stdlib.h> gibi temel başlık dosyalarında typedef edilmiştir.
ptrdiff_t Türü: C'de iki adres toplanamaz. Ancak aynı türden iki adres çıkartılabilir. İşlem sonucu bir tamsayı
türündendir. Öyle ki, önce adreslerin sayısal bileşenleri çıkartılır, sonuç adresin türünün uzunluğuna bölünür. Yani
C'de aynı türden iki adresi çıkarttığımızda sonuç sanki aradaki eleman sayısını vermektedir. Örneğin:
int a[10];
Burada &a[5] - &a[0] ifadesi bize 5'i verir. Aslında a dizisi hangi türden olursa olsun bu işlem 5 değerini verecektir.
Aynı türden iki adresi çıkarttığımızda sonuç hangi türdendir? İşte standartlar sonucun ptrdiff_t türünden olacağını
söyler. ptrdiff_t işaretli bir tamsayı türü olarak typedef edilmelidir. Pek çok derleyicide ptrfdiff_t int ya da long
türdendir.
C'de standart olan birkaç tür daha ileride ele alınacaktır.
C'de Bildirim İşleminin Genel Biçimi
Daha önce biz bildirimin genel biçimini şöyle görmüştük:
<tür> <değişken listesi>;
213

Aslında bildirimin genel biçimi şöyledir:
[yer belirleyici anahtar sözcükler] [tür niteleyici anahtar sözcükler] [tür belirten sözcükler]
<değişken listesi>;

Görüldüğü gibi bildirimde türün yanı sıra yer belirleyiciler (storage class specifers) ve tür niteleyiciler (type
qualifiers) de kullanılmaktadır. Örneğin:

Genel olarak bildirimde yer belirleyicileri, tür niteleyicileri ve tür belirten sözcükler yer değiştirebilir. Örneğin
aşağıdaki iki bildirim eşdeğerdir:
static const int a = 10;
const int static a = 10;
Fakat genellikle programcılar önce yer belirleyici, sonra tür niteleyici en sonra da tür belirten anahtar sözcükleri
yzamaktadır.
C'de yer belirleyici (storage class Specifiers) olarak aşağıdaki 5 anahtar sözcük kullanılabilir:
auto
static
register
extern
typedef
Aslında typedef anahtar sözcüğünün yer belirleyici işlevi yoktur. Tasarımcılar typedef'i başka bir yere
yerleştiremeyince buraya yerleştirmişlerdir. Bildirimde en fazla 1 tane yer belirleyici anahtar sözcük
bulundurulabilir. C'de ayrıca iki de tür niteleyici (type qualifier) anahtar sözcük vardır:
const
volatile
C90'da eğer bildirimde tür belirten sözcük kullanılmamışsa fakat yer belirleyici ya da tür niteleyici anahtar
sözcüklerden en az biri kullanılmışsa bu durumda default olarak tür belirten sözcük int kabul edilmektedir. Yani
örneğin:
const a = 10;
bildirimi geçerlidir. Burada a'nın türü int'tir. Ancak bildirimde yalnızca değişken ismi bulundurulamaz. Örneğin:
a, b = 20;

/* geçersiz */

Böyle bir bildirim geçersizdir. Halbuki C99 ve C11'de bildirimde mutlaka tür belirten sözcük bulundurulmak
zorundadır.
214

Yer Belirleyici Anahtar Sözcüklerin İşlevleri
auto Belirleyicisi: auto aslında işlevi olmayan bir anahtar sözcük durumundadır. auto belirleyicisi yerel
değişkenlerle ya da parametre değişkenleriyle kullanılabilir. Global değişkenlerle kullanılamaz. auto değişkenin
ilgili blok bittiğinde bellekten atılacağını (yani stack'te yer ayrılacağını) vurgulamaktadır.
extern Belirleyicisi: Aslında biz tek bir .c dosyasını derlemek zorunda değiliz. Bir proje çok uzun olabilir ve
programcı bunu çeşitli dosyalara yaymak isteyebilir. Bu durumda .c dosyaları bağımsız olarak derlenir. Oluşan
object modüller birlikte link edilerek çaıştırılabilen dosya (executable) oluşturulur. Örneğin projemiz a1.c a2.c a3.c
biçiminde üç kaynak dosyadan oluşuyor olsun:

Görüldüğü gibi linker aslında birden fazla object modülü çalıştırılabilen dosyaya dönüştürebilmektedir. C
standartlarında projeyi oluşturan kaynak dosyalara "translation unit" denilmektedir. Programcılar ise genellikle bıu
dosyalara "modül" demektedir.
Peki bir programı neden birden fazla kaynak dosyaya bölerek yazmak isteriz? Birinci neden karmaşıklığı
azaltmaktır. Büyük bir projenin birden fazla dosyaya bölünmesi yönetlebilirliği artırır. Örneğin farklı kişiler garklı
dosyalar üzerinde çalışabilirler. Sonra bunları birleştirebilirler. İkinci neden derleme zamanının azaltılmasıdır.
Şöyle ki, örneğin 100000 satırlık bir projeyi tek bir kaynak dosya olarak organizae etmiş olalım. Proje içerisindeki
bir satırı bile değiştirsek tüm projeyi yeniden derlememiz gerekir. Halbuki bunu 10000 satırlık 10 dosyaya ayırsak
yalnızca değişikliğin yapıldığı modülü derlememiz yeterli olur. Tabi hep berber her defasında bir link işlemi yine
yapılmak zorundadır. Tabi link işlemi derleme işlemine göre daha kısa bir işlemdir.
B irden fazla modülle çalışma nasıl yapılmaktadır? Derleyicilerin komut satırlı biçimlerinde önce her modülü
derleyip sonra birlikte link işlemi yapılabilir. gcc derleyicisinde -c seçeneği Microsoft'un cl derleyicisinde /c
seçeneği yalnızca derleme yapar link etme işlemini yapmaz. Daha sonra yalnızca derlenmiş bu modüller link
edilebilir. gcc programına object modülleri verirsek zaten o link işlemini yapmaktadır. Microsoft'un linker
programı link.exe isimli programdır. Örneğin:
gcc -c a1.c
gcc -c a2.c
gcc -c a3.c
Buradan a1.o, a2.o ve a3.o dosyaları elde edilecektir. Sonra bunlar aşağıdaki gibi link edilebilirler:
gcc -o app a1.o a2.o a3.o
Bunun yerine aynı işlem şöyle de yapılabilirdi:
gcc -o app a1.c a2.c a3.c
Biz gcc'ye birden fazla .c dosyası verirsek gcc onları önce bağımsız olarak derler sonra object modülleri link
215

ederek çalıştırılabilir (executable) dosyayı oluşturur.
IDE'lerde projeye birden fazla kaynak dosya eklenirse bunlar otomatik olarak derlenir ve object modüller link
edilerek çalıştırılabilir dosya elde edilir.
Birden fazla dosya ile çalışırken bir dosyadaki global değişkenin diğer dosyalardan da erişilebilmesi gerekir.
Ancak her dosya bağımsız olarak derlendiği için diğer dosyada global olarak tanımlanmış değişkenleri derleyici
tanımaz. Yani derleyici bir dosya derlenirken hangi dosyaların projenin parçalarını oluşturduğunu bilmemektedir.
Projeyi oluşturan her kaynak dosya bağımısız olarak derlenir. İşte başka bir müdlde global olarak tanımlanmış olan
bir değişken kullanılacaksa onun için extern bildiriminin yapılması gerekir. Örneğin:
extern int g_x;
Global değişkenin yalnızca bir modülde global olarak tanımlanması fakat onun kullanıldığı tüm modüllerde extern
olarak bildirilmesi gerekir. Global tanımlamanın hangi modülde yapıldığının bir önemi yoktur.
extern bir tanımlama değil bildirim işlemidir. extern belirleyicisini gören derleyici değişkenin başka bir modülde
tanımlandığını anlar.. Ona göre kod üretir. Object modül içerisine linker için şöyle bir mesaj yazar: "Sayın linker
bu değişken başka bir modülde tanımlanmış. Ben durumu idare ettim. Fakat sen proje link edilirken bu değişkenin
hangi modülde tanımlandığını bul, bunu onla ilişkilendir. Bu değişken o değişkendir." Linker da link işlemine
sokulan tüm modüllere bakarak bu birleştirmeyi yapar.
Burada dikkat edilmesi gerek durum global değişkenin yalnızca tek bir modülde global tanımlamasının yapılması
gerekliliğidir. eğer global değişken birden fazla modülde global tanımlanırsa her modül sorunsuz derlenir fakat link
aşamasında aynı isimli birden fazla global tanımlama yapılmış olması nedeniyle error oluşur. Benzer biçimde
global değişken her modülde extern bildirilirse yine her modül başarılı olarak derlenir ancak link aşamasında
global tanımlamaya rastlanmadığından error oluşur.
Bir değişkenin başka modüllerden kullanılabilirliğine o değişkenin bağlama durumu (linkage) denilmektedir.
Değişkenin bağlama durumu üç biçimde olabilir:
1) Dışsal Bağlama Durumu (External Linkage): Burada değişken başka modüllerden kullanılabilir. Global
değişkenler default olarak dışsal bağlamaya sahiptir. Global değişkenleri extern ile bildirirsek de dışsal bağlama
oluşur. Fakat extern bir tanımlama değildir. Global değişkenin tek bir tanımlamasını olması gerektiği için tek bir
modülde global tanımlama yapılmalı diğer modüllerde extern bildirilmelidir.
2) İçsel Bağlama Durumu (Internal Linkage): İçsel bağlamaya sahiğ değişkenler yalnızca bir modülün her
yerinde kullanılabilirler. Ancak farklı modüllerden kullanılamazlar. Bir global değişken static anahtar sözcüğü ile
bildirilirse onun bağlaması içsel bağlama olur. Artık diğer modüllerden o kullanılamaz.
Özetle C'de bir global değişken default olarak dışsal bağlamaya sahiptir. Ancak onu static anahtar sözcüğüyle
bildirirsek içsel bağlamaya sahip olur.
3) Bağlamasız Durum (No Linkage): C'de yerel değişkenlerin ve parametre değişkenlerinin bağlaması yoktur.
Bir global değişken C'de aynı kaynak dosyada hem global olarak tanımlanmış olabilir hem de extern olarak
bildirilmiş olabilir. Bu durum hata oluşturmaz. Değişkenin bağlama durumu dışsal bağlamadır. Bu durumda
değişken için yer ayrılır. Yani extern bildiriminin bir etkisi olmaz. Örneğin:
int g_a;

/* global tanımlama */

extern int g_a;

/* Ggobal bildirim */
216

Buradaki etki aşağıdakiyle eşdeğerdir:
int g_a;
Bir global değişken extern belirleyicisi kullanılarak bildirilmiş olsun ve ilkdeğer de verilmiş olsun. Örneğin:
extern int g_a = 10;
C standartlarına göre artık bu bildirim aynı zamanda bir tanımlamadır. Yani değişken için yer ayrılır. Başka bir
deyişle yukarıdaki bildirim aşağıdaki ile eşdeğerdir:
int g_a = 10;
extern bildirimi yerel bir blokta yapılabilir. Tabi bu durumda o değişken yerel bir değişken olmaz. Başka
modüldeki global bir değişken anlamındadır. Fakat bu isim yalnızca o blokta kullanılabilir. Örneğin:
void foo(void)
{
extern int a;
...
}
void bar(void)
{
a = 10;
}

/* geçersiz! */

Burada yerel bloktaki extern belirleyicisi ile bildirilmiş değişken aslında yerel bir değişken değildir. Dışsal
bağlamaya sahip muhtemelen başka modülde tanımlanmış bir global değişkendir. Ama biz bu ismi yalnızca foo
bloğunda kullanabiliriz.
C standartlarına göre farklı modüllerde aynı global değişkenin ilkdeğer verilmeden tanımlanması yapılabilir. Buna
standartlarda "tentative declaration" denilmektedir. Bu durumda her ne kadar global değişkenin her modül için
tanımlaması object modüle yazılsa da linker bunların tek bir kopyasını çalıştırılabilen dosyaya yazmaktadır.
Dolayısıyla aşağıdaki kod geçerlidir:

Ancak ilkdeğer verme durumunda bu geçerlilik kaybolur. Aşağıdaki derlemelerde link aşamasında error oluşur:

217

Peki bir modülde tanımlanmış bir fonksiyonu diğer modüllerden çağırabilir miyiz? Fonksiyonlar teknik olarak
global değişkenler gibidir. Fonksiyonların da default bağlama biçimleri dışsal bağlamadır. Yani onlar başka bir
modülden kullanılabilirler. Ancak kullanmadan önce bir fonksiyonun tanımlamasının ya da prototip bildirimin
derleyici tarafından görülmesi gerekir. Bu nednele biz bir modülde tanımladığımız fonksiyonu diğer modülden
kullanmadan önce fonksiyon prototipini bulundurmalıyız. eğer prototip bulundurmadan foo gibi bir fonksiyonu
çağırırsak derleyici onun aşağıdaki gibi bir prototipe sahip olduğunu varsayar:
int foo();
Örneğin:
/* a1.c */
#include <stdio.h>
extern int g_x;
void foo(void);
int main(void)
{
g_x = 10;
foo();
printf("%d\n", g_x);
return 0;
}

/* a2.c */
#include <stdio.h>
int g_x;
void foo()
{
g_x = 100;
}

Prototiplerde extern belirleyicisinin kullanılmasına gerek yoktur. Fakat kullanılsa da sorun oluşmaz.
Çok modüllü derlemelerde önerilen durum. Proje için ortak bir başlık dosyası hazırlamak ve tüm modeüllerden
bunu include etmektir. Bu başlık dosyasında yer kaplayan hiçbir tanımlama bulunmamalıdır. Yalnızca #'li
önişlemci bidirimleri, extern bildirimler, fonksiyon prototipleri, yapı bildirimleri vs. bulunmalıdır. Global
değişkenlerin ayrıca bir dosyada global tanımlaması yapılmalıdır. Örneğin:
/* project.h */
#ifndef PROJECT_H_
#define PROJECT_H_
void foo(void);
void bar(void);
extern int g_a;
extern int g_b;
#endif

218

/* a1.c */
#include <stdio.h>
#include "project.h"
int g_a;
int g_b;
int main(void)
{
foo();
bar();
printf("%d, %d\n", g_a, g_b);
return 0;
}
/* a2.c */
#include <stdio.h>
#include "project.h"
void foo()
{
g_a = 10;
}
/* a3.c */
#include <stdio.h>
#include "project.h"
void bar()
{
g_b = 20;
}

static Belirleyicisi: static belirleyicisi yer değişkenlerle ya da global değişkenlerle kullanılabilir. Fakat parametre
değişkenleriyle kullanılamaz. Static yerel ve static global değişkenler tamamen farklı anlamlara gelirler.
static belirleyicisi yerel değişkenlerle kullanılırsa bu durum o değişkenin ömrünün static ömürlü olduğunu gösterir.
Yani blok bittiğinde değişken yok edilmez. Program çalışmaya başladığında bellekte yer kaplar, program
sonlanana kadar bellekte kalır. Örneğin:
#include <stdio.h>
void foo(void)
{
static int count = 1;
printf("%d\n", count);
++count;
}
int main(void)
{
foo();
foo();
foo();

219

return 0;
}

static yerel dğeişkene ilkdeğer verilmemişse içerisinde sıfır bulunur. Verilen ilkdeğer derleme aşasında
değerlendirilir. Program yüklendiğinde static yerel değişken o değerle başlar. Artık bloğa her girişte bu ilkdeğer
tekrar atanmaz.
Peki static yerel değişkenin global değişkenden ne farkı vardır? Bunların ömürleri aynı olmasına karşın faaliyet
alanları farklıdır. static yerel değişkenler blok faaliyet alanı kuralına uyarlar. Global değişkenler ise dosya faaliyet
alanına sahiptir.
Bir fonksiyonun static yerel bir nesnenin ya da dizinin adresiyle geri dönmesinde bir sakınca yoktur. Çünkü
programdan çıkılsa bile o nesne yaşamaya devam etmektedir. Örneğin:
#include <stdio.h>
char *getname(void)
{
static char name[64];
printf("Adi soyadi:");
gets(name);
return name;
}
int main(void)
{
char *nm;
nm = getname();
puts(nm);
return 0;
}

static anahtar sözcüğü global değişkenlerle kullanılırsa bu durumda global değişkenin bağlama durumu "içsel
bağlama (internal linkage)" olur. Yani böyle deişkenler diğer modüllerden hiçbir biçimde kullanılamazlar. Başka
bir modülde aynı isimli global nesne olsa bile bu durum soruna yol açmaz.
Bir global değişken aynı modülde hem static hem de extern olarak bildirilebilir mi? Tabi bu durum saçmadır.
Böyle bir şeyden kaçınmak gerekir. Ancak standartlara göre bir global değişken önce static ile sonra extern ile
bildirilirse nesnenin içsel bağlamaya sahip olduğu kabul edilir. Fakat önce extern sonra static ile bildirilirse bu
durum tanımsız davranışa yol açar.
register Belirleyicisi: register belirleyicisi global değişkenlerle kullanılamaz. Yerel ya da parametre değişkenleri
ile kullanılabilir. Aslında uzunca bir süredir bu belirleyicinin ciddi bir işlevi kalmamıştır. Çünkü derleyicilerin kod
optimizasyonları son derece gelişmiş durumdadır. Dolayısıyla bu belirleyicinin sağlayacağı fayda tartışmalıdır.
CPU içerisinde ismine "yazmaç (register)" denilen küçük bellek bölgeleri vardır. CPU ile RAM bağlantılıdır. CPU
aritmetik ya da mantıksal ya da karşılaştırma işlemlerini yapmak için operandları yazmaçlardan alır. Dolayısıyla
örneğin:
c = a + b;
gibi bir işlem aşağıdaki gibi makine komutlarıyla yapılmaktadır:
220

mov
mov
add
mov

reg1, a
reg2, b
reg1, reg2
c, reg1

işte register anahtar sözcüğü söz konusu değişkenin RAM yerine CPU içerisindeki yazmaçlarda tutulmasını
istemek için kullanılmaktadır. Böylece bu değişkenler işleme sokulurken boşuna yeniden yazmaçlara alınmak
zorunda kalınmaz. Şüphesiz çok yoğun işlem gören (örneğin döngü değişkenleri gibi) nesnelerin yazmaçlarda
tutulması anlamlı olur.
register belirleyicisi bir emir değildir. Rica niteliğindedir. Yani biz bir nesneyi aşağıdaki gibi tanımlamış olalım:
register int x;
Derleyici bunu yazmaçlarda tutmak zorunda değildir. İsterse bunu normal nesnelerde olduğu gibi yine RAM'de
tutabilir. Bunun için de programcıya herhangi bir bildirimde (uyarı gibi) bulunmaz. Zaten modern derleyiciler
gerekli gördükleri nesneleri gerektiği kadar yazmaçlarda tutacak biçimde kod optimizasyonu uygulamaktadır. Bu
belirleyiciyi kullanmak yerine derleyicinin optimizasyon mekanizmasına güvenmek daha uygun gözükmektedir.
CPU'lardaki yazmaç miktarları CPU'dan CPU'ya değişebilmektedir. Genel olarak RISC tabanlı mimarilere sahip
olan işlemcilerde CISC tabanlı mimarilere sahip olan işlemcilere göre daha fazla yazmaç bulunma eğilimindedir.
Bir nesnenin programcının isteği ile yazmaçta tutulması eldeki yazmaç sayısını azaltabilir. Bunu farkeden derleyici
bu belirleyiciyi hiç dikkate almayabilir.
Tür Niteleyici Anahtar Sözcükler
C'de tür niteleyici iki anahtar sözcük vardır: const ve volatile. Bunların her ikisi de bildirimde kullanılabilir.
const Belirleyicisi
const bir nesne ilkdeğer verilirerek bildirilir. Artık bundan sonra bu nesneye değer atanamaz. Eğer const bir
nesneye değer atanmak istenirse derleme aşamsında "error" oluşur. Örneğin:
const int x = 10;
printf("%d\n", x);
x = 20;

/* geçerli */
/* geçersiz! */

const bir nesnenin ilkdeğer verilmeden tanımlanması C++'ta geçersizdir. C'de geçerli olsa da anlamsızdır. (İlkdeğer
verilmediğine göre ve bundan sonra değer de atanamayacağından böyle bir tanımlamanın bir anlamı olamaz.)
221

const anahtar sözcüğü dekleratör ilişkin değildir. Türe ilişkin kabul edilir. Yani:
int const x = 10, y = 20;
Burada hem x hem de y const durumdadır.
Peki const belirleyicisinin ne faydası vardır? const temel olarak okunabilirliği ve anlaşılırlığı kuvvetlendirmek için
kullanılır. Örneğin:
const int personel_sayisi = 150;
gibi bir tanımlamada koda bakan kişi program içerisinde personel sayısının değişmeyeceğini anlayabilir. const
belirleyicisi kodu yazanın yanlışlıkla bir nesneye atama yapmasını da engelleyebilmektedir. Bu durumda derleme
aşamasında hatayla karşılaşan programcı hatasını anlayabilir. const belirleyicisi bazı durumlarda derleyicilere bazı
optimizasyonları yapmaya olanak sağlayabilir.
const belirleyicisi ile #define sembolik sabitleri benzer amaçlarla kullanılabilmektedir. Örneğin:
#define personel_sayisi 150
const int personel_sayisi = 120;
Fakat sembolik sabitler gerçekten bir sabittir. Halbuki const nesneler gerçekten birer nesnedir. Örneğin biz const
nesnelerin adreslerini alabiliriz. Fakat sembolik sabitlerin adreslerini alamayız.
Bir dizinin tamamı const olabilir. Bu durumda biz dizinin hiçbir elemanını değiştiremeyiz Örneğin:
const int a[5] = {10, 20, 30, 40, 50};
a[3] = 100;

/* geçersiz! */

const bir dizinin tüm elemanları const bir nesne gibidir.
Bir yapı nesnesi de const olabilir. Bu durumda yapının hiçbir elemanını değiştiremeyiz. Örneğin:
struct COMPLEX {
double real, imag;
};
const struct COMPLEX z = {3, 2};
z.real = 5;
z.imag = 7;

/* geçersiz! */
/* geçersiz! */

Yapı bildiriminde belli elemanlar const yapılabilir. Bu durumda yapı nesnesinin tamamaı const olmasa bile bu
elemanları daha sonra değiştiremeyiz. Örneğin:
struct SAMPLE {
int a;
const int b;
222

};
struct SAMPLE s = {10, 20};
s.a = 30;
s.b = 40;

/* geçerli */
/* geçerli değil! */

Genellikle programcılar yapı elemanlarını const yapmazlar. Çünkü bu durum karmaşıklığa yol açmaktadır.
const belirleyicisi en çok göstericilerle kullanılır. Böyle göstericilere const göstericiler denilmektedir.
const Göstericiler
Bir gösterici bildiriminde iki nesne söz konusu olur: Göstericinin kendisi ve onun gösterdiği yer. Bunların
gangisinin const olacağına göre const göstericiler üçe ayrılmaktadır:
1) Kendisi değil gösterdiği yer const olan const göstericiler
2) Gösterdeiği yer değil kendisi const olan const göstericiler
3) Hem kendisi hem de gösterdiği yer const olan const göstericiler
En çok kullanılan ve okunabilirlik bakımından en faydalı olan const göstericiler kendisi değil gösteridği yer const
olan const göstericilerdir. Bir const göstericinin hangi gruba girdiği const anahtar sözcüğünün yerine bakılarak
karar verilir. Eüer const anahtar sözcüğü * atomunun solundaysa bu gösterdiği yer const olan const göstericidir.
Örneğin:
const int *pi;

/* int const *pi ile aynı */

Burada pi'nin kendisi const değildir. *pi yani pi'nin gösterdiği yer const durumdadır.
Eğer const anahtar sözcüğü * atomunun sağına getirilirse bu durumda göstericinin kendisi const olur. Örneğin:
int * const pi = ptr;
Burada const pi'yi nitelemektedir. Yani burada pi const durumdadır. *pi const değildir. Nihayaet const anahtar
sözcüğü iki yerde de bulunabilir:
const int * const pi = ptr;
Burada hem pi hem de *pi const durumdadır.
Kendisi Değil Gösterdiği Yer const Olan const Göstericiler
Bu tür göstericilerin bildirimlerinde const anahtar sözcüğü * atomunun soluna getirilir. Örneğin:
const int *pi;
Tabi aşağıdaki bildirim de eşdeğerdir:
int const *pi;
Burada göstericinin kendisi const değildir. Yani onun içerisine istedğimiz bir adresi istediğimiz zaman atayabiliriz.
Ancak onun gösterdiği yere atama yapamayız. Örneğin:
223

int a = 10, b = 20;
const int *pi;
pi = &a;
*pi = 30;

/* geçerli, pi const değil */
/* Geçersiz göstericinin gösterdiği yer const */

pi = &b;
*pi = 40;

/* geçerli pi const değil */
/* Geçersiz göstericinin gösterdiği yer const */

Bu tür const göstericilerde tam olarak göstericinin gösterdiği yer const değil o gösterici ile erişilen her yer const
biçimdedir. Örneğin:
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
const int *pi;
pi = a;

/* geçerli */

pi[3] = 20;

/* geçersiz*/

pi[1000] = 30;

/* Dizi taşması var ama derleme aşamasında yiner error oluşur */

pi += 500;
*pi = 40;

/* geçerli */
/* geçersiz! */

Gösteridiği yer const olan const göstericiler en çok karşımıza fonksiyon parametresi olarak çıkarlar. Örneğin:
void foo(const int *pi)
{
/* ... */
}

Burada foo bizden int türden bir adres alır. Parametre const bir gösterici olduğuna göre foo aldığı adresteki nesneyi
değiştirmez. Onu kullanabilir ama değiştirmez. Böylece fonksiyona bakan kişi fonksiyonun adresini verdiği
nesneyi değiştirip değiştirmeyeceini anlar. Gösterici parametrelerdeki const'luk çok önemlidir. Örneğin strlen
fonksiyonunun orijinal prototipinde parametre const bir göstericidir:
size_t strlen(const char *str);
Bu prototipiten biz şunu anlarız: Biz strlen fonksiyonuna char türden bir dizinin başlangıç adresini vereceğiz.
Fonksiyon bu adresteki yazıyı değiştirmeyecek. Yalnızca onu okuyacak.
Göstericilerde const'luk çok kararlı bir biçimde kullanılmalıdır. Böylece bir fonksiyonun parametresinin const
olmayan bir gösterici olduğunu gördüğümüzde artık biz onun verdiğimiz adresteki bilgiyi değiştireceğini anlarız.
(Çünkü değiştirmeyecek olsaydı zaten onu yazan göstericiyi const yapardı.). Çeşitli örnekler verelim:
- strcpy fonksiyonun orijinal prototipinde birinci parametre const olmayan bir gösterici, ikinci parametre const bir
göstericidir:
char *strcpy(char *dest, const char *source);
Bu prototipe baktığımızda bizim fonksiyona iki char türden adres göndereceğimiz anlaşılır. Fonksiyon birinci
argümanla gönderdiğimiz adresteki bilgiyi değiştirecektir. Ancak ikinci argümanla gönderdiğimzi adresteki bilgiyi
değiştirmeyecektir.
- strchr fonksiyonun parametresi const bir göstericidir:
224

char *strchr(const char *s, int c);
- strcat fonksiyonunun birinci parametresi const olmayan bir gösterici ikinci parametresi const bir göstericidir:
char *strcat(char *dest, const char *source);
- Bir diziyi sıraya dizen sort isimli bir fonksiyon yazacak olsak onun parametresi const gösterici olamaz:
void sort(int *pi, size_t size);
- puts fonksiyonun parametresi const bir gösterici, gets fonksiyonun parametresi const olmayan bir göstericidir:
void puts(const char *str);
char *gets(char *str);
Yapı nesnelerinin adresini alan fonksiyonların gösterici parametreleri const ise fonksiyonlar bizden aldıkları yapı
neesnesinin elemanlarını kullanırlar fakat değiştirmezler. Fakat bu fonksiyonların gösterici parametreleri const
olmayan bir göstericiyse bu durumda fonksiyon yapı nesnesinin içini doldurmaktadır. Yani eğer fonksiyonun yapı
gösterici parametresi const ise nesnenin içini biz doldururuz o kullanır. eğer const olmayan bir gösteric ise o
doldurur biz kullanırız. Çeşitli örnekler verelim:
- Örneğin sistemin zamanını alan GetSystemTime isimli bir fonksiyon olsun. Bu fonksiyon bizden TIME isimli bir
yapı nesnesinin adresini alsın onun içerisine sistem zamanını yerleştirsin. Bu durumda fonksiyonun gösterici
parametresi const olmayan bir gösterici olmalıdır:
struct TIME {
int hour, minute, second;
};
void GetSystemTime(struct TIME *t);
...
struct TIME t;
GetSystemTime(&t);
- Sistem zamanını bizim belirdiğimiz zaman olacak biçimde değiştiren SetSystemTime fonksiyonunun yapı
gösterici parametresi const gösterici olmalıdır:
void SetSystemTime(const TIME *t);
- Veritabanından birisini ismiyle arayıp bulursa bulduğu kişinin bilgilerini PERSON isimli bir yapı nesnesine
yerleştren fonksiyonun parametrelerinin const'luk durumu şöyledir:
BOOL FindPerson(const char *name, struct PERSON *per);
- Seri portun setting değerlerini alıp bize veren fonksiyonun yapı gösterici parametresi const olmayan bir gösterici
olmalıdır:
void GetSerialPortSettings(struct SERIAL *serial);
- Bunun tam tersi işlemini yapan fonksiyonun parametresi const gösterici olmalıdır:
void SetSerialPortSettings(const struct SERIAL *serial);
225

Fonksiyonların gösterici parametrelerindeki const'luğa çok önem verilmelidir. Maalesef acemi C programcıları
bunlara önem vermezler ve acemilikleri hemen anlaşılır.
Fonksiyonun gösterici olmayan parametrelerinin const'luğunun hiçbir önemi yoktur. Bunların const yapılması da
amaç bakımından faydasız ve saçmadır. Örneğin:
void foo(const int x);
Burada bildirim geçersiz değildir. Ancak böyle const bildirimin kimseye hiçbir faydası yoktur. Şöyle ki:
Fonksiyonun parametre değişkenini değiştirip değiştirmeyeceği bizi ilgilendirmez. Önemli olan bizden aldığı
nesnelerin değerlerini değiştirip değiştirmeyeceğidir. Bu nedenle parametrelerdeki const'luk yalnızca göstericiler
söz konusu olduğunda anlamlı olur.
const Nesnelerin Adresleri ve const Adres Dönüştürmeleri
const bir nensenin adresini bir göstericiye atayıp o nesneyi derleyiciyi kandırarak değiştebilir miyiz? Örneğin:
const int a = 10;
int *pi;
pi = &a;
*pi = 20;

/* geçersiz */

İşte bu durumu engellemek için C'ye şöyle bir kural eklanmeiştir: "const bir nesnenin adresi ancak gösterdiği yer
const olan const bir göstericiye atanabilir." O halde yukarıdaki örnekte zaten biz a'nın adresini pi'ye atayamayız.
Peki pi'yi const yapalım:
const int a = 10;
const int *pi;
pi = &a;
*pi = 20;

/* geçerli */
/* geçersiz */

Bir fonksiyonun adresini aldığı nesneyi değiştirmediği halde onun parametresinin const gösterici yapılmamasının
önemli bir dezavantajı vardır. Biz artık o fonksiyonu const bir nesnenin adresiyle çağıramayız. Örneğin bir int dizi
içerisindeki sayıları ekrana yazdıran disp isimli fonksiyonun normal olarak gösterici parametresinin const olması
gerekir. Fakat programcının kötü teknik uygulayarak bunu const yapmadığını düşünelim:
void disp(int *pi, size_t size);
Biz artık bu fonksiyonu const bir adresle çağıramayız:
const int a[] = {1, 2, 3};
disp(a, 3);

/* geçersiz */

const nesnelerinin adresleri const adreslerdir. const bir adres ancak gösterdiği yer const olan göstericilere atanabilir.
Tabi const olmayan bir adresin const bir göstericiye atanmasının hiçbir sakınscası yoktur. Örneğin biz coonst
olmayan x nesnesinin adresini const bir göstericiye atayabiliriz. Çünkü zatane x'in değiştirilmemesi konusunda bir
çekince yoktur. const anahtar sözcüğü türe ilişkin olduğu için başka bir deyişle T bir tür belirtmek üzere const T *
türünden T * türüne otomatik dönüştürme yoktur. Fakat T * türünden const T * türüne otomatik dönüştürme vardır.
226

Bazen const bir adresin const'luğunu kaldırmak gerekebilir. Bu durumda const T * türünden T * türüne tür
dönüştürme operatörü ile dönüştürme yapabiliriz. Yani const T * türünden T * türüne otomatik dönüştürme yoktur
fakat tür dönüştürme operatörü ile dönüştürme yapılabilir.
C'de (ve tabi C++'ta) const bir nesnenin adresini tür dönüştürme operatörüyle const olmayan bir göstericiye atayıp
orayı değiştirmeye çalışırsak bu durum tanımsız davranışa (undefined behavior) yol açar. (Gerçekten de statik
ömürlü const nesnelerin Windows ve Linux'ta güncellenmeye çalışılması programın çökmesine yol açmaktadır.)
Örneğin:
#include <stdio.h>
int main(void)
{
const int a = 20;
int b = 30;
int *pi;
const int *pci;
pi = &a;
pi = (int *)&a;
*pi = 40;

/* geçersiz */
/* geçerli */
/* geçerli ama tanımsız davranışa yol açar */

pci = &b;
pi = pci;
pi = (int *)pci;
*pi = 50;

/* geçerli */
/* geçersiz */
/* geçerli */
/* normal yani tanımsız davranış değil */

return 0;
}

Örneğin:
#include <stdio.h>
const int g_a = 10;
int main(void)
{
int *pi;
pi = (int *)&g_a;
*pi = 20;
printf("%d\n", g_a);

/* geçerli */
/* tanımsız davranış, Windows'ta ve Linux'ta program çöker */

return 0;
}

Gösterdiği Yer Değil Kendisi const Olan const Göstericiler
Daha önce de belirtildiği gibi böyle const göstericiler seyrek kullanılmaktadır. Bunların bildirimlerinde const
anahtar sözcüğü * atomunun sağına getirilir. Örneğib:
char s[50];
char d[50];
char * const pc = s;
*pc = 'x';
pc = d;

/* geçerli */
/* geçersiz */
227

Hem Gösterdiği Yer Hem de Kendisi const Olan const Göstericiler
Bunlar hepten seyrek kullanılırlar. Burada const beelirleyicisi hem * atomunun soluna hem de sağına getirilir.
Örneğin:
char s[50];
char d[50];
const char * const pc = s;
pc = d;
*pc = 'x';

/* geçerli değil */
/* geçerli değil */

Derleyicilerin Kod Optimizasyonları ve volatile Belirleyicisi
Kodun çalışmasında hiçbir değişikliğin olmaması koşuluyla derleyiciler programcının yazdığı kodu yeniden
düzenleyebilirler. Bundan amaç kodun daha hızlı çalışması (speed optimization) ya da daha az yer kaplamasıdır
(size optimization). Derleyicinin kodun daha hızlı çalışması ya da daha az yer kaplaması için kodu yeniden
düzenlemesine kod optimizasyonu denilmektedir.
Pek çok kod optimizasyon teması vardır. Örneğin "ortak alt ifadelerin elimine edilmesi (common subexpression
elimination)" denilen teknikte derleyici ortak alt ifadeleri yeniden yapmamak için bir yerde (muhtemelen bir
yazmaçta) toplar. Örneğin:
x = a + b + c;
y = a + b + d;
z = a + b + e;
deyimlerinde derleyici her defasında a + b işlemini yapmamak için bunun toplamını bir yazmaçta saklayabilir ve
her defasında onu kullanabilir:
reg = a + b;
x = reg + c;
y = reg + d;
z = reg + e;
Derleyici kullanılmayan nenseleri sanki tanımlanmamış gibi elemine edebilir. Döngü içerisindeki gereksiz ifadeleri
döngünü dışına çıkartabilir vs.
Derleyiciler nesneleri ikide bir yeniden yazmaçlara çekmemek için belli büre yazmaçlarda tutabilirler. Örneğin:
x = g_a + 10;
y = g_a + 20;
z = g_a + 30;
Burada derleyici her defasında a'yı yeniden RAM'den yazmaca çekmeyebilir. Onu bir kez çekip sonraki erişimlerde
o yazmacı kullanabilir. Fakat bzen özellikle çok thread'li uygulamalarda ya da kesme (interrupt) uygulamalarında
bu istenmeyebilir. Şöyle ki:

228

Okla gösterilen noktada başka bir kaynak tarafından g_a değiştirildiğinde derleyicinin ürettiği kod bu değişikliği
anlayamaz. Halbuki bazı durumlarda programcı bu değişikliğin kod tarafından anlaşılmasını isteyebilir. İşte
volatile belirleyicisi buna sağlamak için kullanılmaktadır:
volatile int g_a;
volatile bir nesne kullanıldığında derleyici her zaman onu yeniden belleğe başvurarak alır. Yani onu optimizasyon
amaçlı yazmaçlarda bekletmez. Örneğin aşağıdaki bir döngü söz konusu olsun:

Başka bir akışın (örneğin bir thread'in) bu g_falg nesnesini 0 yaparak döngüyü sonlandırabilme olanağı olduğunu
düşünelim. eğer derleyici g_flag nesnesini bir kez yazmaca çekip hep onu yazmaçtan kullanırsa diğer thread g_flag
nesnesini sıfıra çekse bile döngüden çıkılmaz. Bunu engellemek için g_flag volatile yapılmalıdır:
volatile int g_flag;
Nesnenin volatile olduğunu gören derleyici artık o neesnenin değerini her zaman belleğe başvurarak elde eder.
volatile bir gösterici söz konusu olabilir. Aslında tıpkı const'luk durumunda olduğu gibi volatile belirleyicisinde de
gösterici üç biçimde olabilir:
1) Kendisi değil gösteridği yer volatile olan volatile göstericiler
2) Gösterdiği yer değil kendisi volatile olan volatile göstericiler
3) Hem kendisi hem de gösterdiği yer volatile olan volatile göstericiler
Yine en çok kullanılan volatile göstericiler "kendisi değil gösterdiği yer volatile olan volatile göstericilerdir". Yine
229

volatile anahtar sözcüğünün getirildiği yere göre bunlar değişebilmektedir:
volatile int *pi;
int * volatile pi;
volatile int * volatile pi;
Gösteridği yer volatile olan bir göstgericinin anlamı nedir?
volatile int *pi;
Burada *pi ya da pi[n] gibi ifadelerle erişen nesneler geçici süre yazmaçlarda bekletilmezler. Bunlar her defasında
yeniden belleğe başvurularak oradan alınırlar. volatile bir nesnenin adresi ancak gösterdiği yer volatile olan bir
göstericiye atanabilir. Örneğin:
volatile int a;
int *pi;
volatile int *piv;
pi = &a;
piv = &a;

/* geçerli değil */
/* geçerli */

volatile olma durumu const olma durumuyla aynı mantığa sahiptir. Yani T bir tür belirtmek üzere volatile T *
türünden T * türüne otomatik dönüştürme yoktur ancak T * türünden volatile T * türüne doğurdan dönüştürme
vardır. Örneğin:
int a;
volatile int *piv;
piv = &a;

/* geçerli */

Tabi tür dönüştürme operatörüyle volatile'lığı atarak volatile T * türünden T * türüne dönüştürme yapılabilir.
const ve volatile belirleyicilerine kısaca İngilizce "cv qualifiers" denilmektedir. const ve volatile birlikte
kullanılabilir. Örneğin:
const volatile int g_a = 10;
enum Türleri ve Sabitleri
enum türleri C'de bir grup sembolik sabiti kolay bir biçimde oluşturmak için kullanılmaktadır. enum bildiriminin
genel biçimi şöyledir:
enum [isim] {<enum sabit listesi>};
enum sabit listesi ',' atomuyla ayrılan isimlerden oluşur. Örneğin:
enum COLORS {Red, Green, Blue, Yellow};
enum DAYS {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};
İlk enum sabitinin değeri sıfırdır. Sonraki her sabit öncekinden bir fazladır. Örneğin:
230

Enum sabitlerine İnglizce "enumerator" da denilmektedir. Enum sabitleri nesne belirtmezler. Derleyici enum
sabitleri kullanıldığında onlar yerine koda gerçekten o sabitin değerini yerleştirir. Yani enum sabitleri #define
oluşturulmuş sembolik sabitlere benzetilebilir. Ancak #define önişlemciye ilişkindir. Halbuki enum türleri ve
sabitleri derleme aşamasına ilişkindir.
Enum bildirimi global ya da yerel düzeyde yapılabilir. Bu durumda enum sabitlerinin de faaliyet alanı global ya da
yerel olmaktadır. Örneğin:
#include <stdio.h>
enum {Red, Green, Blue};
int main(void)
{
int color, city;
enum {Adana, Ankara, Eskisehir};
color = Green;
printf("%d\n", color);

/* geçerli */

city = Ankara;
printf("%d\n", city);

/* geçerli */

return 0;
}
void Foo()
{
int color, city;
color = Green;
printf("%d\n", color);

/* geçerli */

city = Ankara;
printf("%d\n", city);

/* geçersiz */

}

Bir enum sabitine '=' atomu ile bir değer verilebilir. Bu durumda sonrakiler onu izler. Aynı değere sahip birden
fazla enum sabiti bulunabilir. Örneğin:
enum COLORS {Red = 10, Green, Blue = -5, Yellow, Magenta = 9, Purple};

Burada Red = 10, Green = 11, Blue = -5, Yellow = -4, Magenta = 9, Purple = 10 değerlerini almaktadır.
C'de enum türleri int türü gibi değerlendirilir. Bu durumda enum sabitleri de sanki int türden sabitlermiş gibi ele
alınacaklardır. enum türleri işlem öncesinde yine büyük türe dönüştürülürler. Yani tamamen birer tamsayı türü gibi
değerlendirilirler.
enum türünden nesneler bildirilebilir. Örneğin:
231

enum COLORS color;
color = Red;
color = 10;

/* geçerli */
/* geçerli */

enum türünden nesneler sanki int türündenmiş gibi değerlendirilirler. Böylece bir enum türünden nesneye diğer
sayısal türleri doğrudan atayabiliriz. Farklı enum türünden değeri de birbirlerine doğrudan atayabiliriz.
Anahtar Notlar: C++'ta, C# ve Java'da enum türleri farklı birer tür belirtmektedir. Yani bir tamsayı türü enum türüne doğrudan atanamaz.
enum türlerine aynı türden enum sabitleri atanabilir. Fakat C'de enum türleri sanki int türü gibi değerlendirilmektedir.

Enum'lar yukarıda da belirtildiği gibi aynı türden bir dizi sembolik sabiti kolay bir biçimde ifade etmek için
kullanılmaktadır.
C'de Dosya İşlemleri
İşletim sistemi tarafından organize edilen ikincil belleklerde tanımlanmış bölgelere dosya (file) denilmektedir.
Dosyaların isimleri vardır. Özellikleri vardır. Dosyaların erişim hakları vardır. Pek çok sistemde her dosyaya
herkes erişemez.
Modern sistemlerde dosyalar dizinlerin (directories) içerisinde bulunur. Aynı dizin içerisinde aynı isimli birden
fazla dosya bulunamaz. Fakat farklı dizinlerde aynı isimli dosyalar bulunabilmektedir: Dosya isimlerinin Windows
sistemlerinde büyük harf-küçük harf duyarlılığı yoktur. Fakat Unix/Linux sistemlerinde vardır. Yani örneğin
"test.txt" dosyası ile "Test.txt" dosyası Windows'ta aynı isimli isimli dosyalardır. Fakat UNIX/Linux sistemlerinde
bunlar farklı isimli dosyalardır.
Bir dosyanın yerini belirten yazısal ifadelere yol ifadeleri (path) denilmektedir. Yol ifadeleri mutlak (absolute) ve
göreli (relative) olmak üzere ikiye ayrılır. Yol ifadesinin ilk karakteri Windows'ta '\', UNIX/Linux'ta '/' ise böyle
yol ifadelerine mutlak (absolute) yol ifadeleri denilmektedir. Mutlak yol ifadeleri kök dizinden itibaren yer belirtir.
Örneğin:
"/a/b/c.txt"
"a/b/c.txt"
"a.txt"

/* mutlak */
/* göreli */
/* göreli */

Windows'ta dizinler sürücüler (drives) içerisindedir. Her sürücünün ayrı bir kökü (root) vardır. Halbuki
UNIX/Linux sistemlerinde toplamda tek bir kök vardır. Bu sistemlerde sürücü kavramı yoktur. Başka bir aygıt bu
sistemlere takıldığında onun kökü bir dizinin altında gözükür. Bu işleme "mount işlemi" denilmektedir.
Windows'ta sürücü bir harf ve ':' karakterindne oluşur. Örneğin C:, D:, E: gibi...
İşletim sistemlerinde çalışmakta olan programlara "process" ya da "task" denilmektedir. Her prosesin bir çalışma
dizini (current working directory) vardır. İşte göreli yol ifadeleri prosesin çalışma dizininden itibaren yer belirtir.
Örneğin prosesimizin çalışma dizini "/temp" olsun:
"/a/b/c.txt" biçimindeki yol ifadesi mutlaktır. Ve her zaman kökten itibaren yer beliritir. Fakat "a/b/c.txt"
biçimindeki yol ifadesi görelidir. Bu durumda bu yol ifadesi "/temp/a/b/c.txt" biçiminde ele alınır. Örneğin "a.txt"
yol ifadesi görelidir ve prosesin çalışma dizininde aranır.
Pekiyi prosesin çalışma dizini neresidir? Prosesin çalışma dizini program çalışırken değiştirilebilir. Fakat program
çalışmaya başladığında default olarak çalıştırılabilen dosyanın bulunduğu yerdedir. Visual Studio idesinden
çalıştırılan programların çalışma dizini proje dizinidir.
Windows sistemlerinde mutlak yol ifadelerinde sürücü belirtilmemişse prosesin çalışma dizini hangi sürücüye
232

ilişkinse o mutlak yol ifadesinin o sürücüye ilişkin olduğu anlaşılır. Örneğin prosesin çalışma dizini "E:\Study"
olsun. Biz de "\A\B\C.txt" biçiminde bir yol ifadesi belirtelim. Bu yol ifadesi E'nin kökünden itibaren yer
belirtecektir. Tabi mutla k yol ifadeleri sürücü içeriyorsa her zaman o sürücü dikkate alınır.
C'de Dosya İşlemleri
C'de dosya işlemleri prototipleri <stdio.h> içerisinde bulunan standart C fonksiyonlarıyla yapılmaktadır. Bütün
dosya fonksiyonlarının isimleri f harfi başlar. Dosya işlemleri aslında işletim sisteminin sunduğu sistem
fonksiyonlarıyla yapılmaktadır. Standart C fonksiyonları bu işletim sisteminin sistem fonksiyonlarını çağırarak
işlemini yapar.
C'de tipik olarak dosya işlemleri 3 aşamda yürütülür:
1) Önce dosya açılır
2) Sonra dosyadan okuma yazma yapılır
3) En sononda dosya kapatılır
Dosyanın kapatılması zorunlu değildir. Çünkü program bittiğinde exit işlemi sırasında zaten tüm açık dosyalar
kapatılmaktadır. Tabi biz dosyayı çeşitli sebeplerden dolayı program bitmeden erken kapatmak isteyebiliriz.
Dosyanın Açılması
Dosyayı açmak için fopen fonksiyonu kullanılır. Fonksiyonun prototipi şöyledir:
FILE *fopen(const char *path, const char *format);
Fonksiyonun birinci parametresi açılacak dosyanın yol ifadesini belirtir. İkinci parametre açış modunu belirtir.
Açış modu aşağıdakilerden biri biçiminde olabilir:
Açış Modu
"r"
"r+"
"w"
"w+"
"a"
"a+"

Anlamı
Olan dosyayı açmak için kullanılır. Eğer dosya yoksa fonksiyon başarısız olur. Böyle
açılmış dosyalardan yalnızca okuma yapabiliriz.
Olan dosyayı açmak için kullanılır. Eğer dosya yoksa fonksiyon başarısız olur. Böyle
açılmış dosyalardan hem okuma hem de yazma yapabiliriz (+ okuma yazma anlamına
gelir.)
Dosya yoksa yaratılır ve açılır. Dosya varsa sıfırlanır ve açılır. Yalnızca yazma yapılabilir.
Dosya yoksa yaratılır ve açılır. Dosya varsa sıfırlanır ve açılır. Hem okuma hem de yazma
yapılabilir.
Dosya yoksa yaratılır ve açılır. Dosya varsa olan dosya açılır. Dosyadan okuma yapamayız.
Fakat her yazılan sona ekleme anlamına gelir. (Yani dosyanın ortasına yazma diye bir
durum yoktur. Her yazma işlemi ekleme anlamına gelir.)
Dosya yoksa yaratılır ve açılır. Dosya varsa olan dosya açılır. Dosyadan okuma yapabiliriz.
Fakat her yazılan sona ekleme anlamına gelir. (Yani dosyanın ortasına yazma diye bir
durum yoktur. Her yazma işlemi ekleme anlamına gelir.)

fopen fonksiyonu başarı durumunda FILE isimli bir yapı türünden adrese geri döner. fopen açılan dosyanın
bilgilerini stdio içerisinde bildirilmiş ve FILE ismiyle typedef edilmiş bir yapı nesnesinin içerisine
yerleştirmektedir ve o o yapı nesnesinin adresine geri dönmektedir. Programcı FILE yapısının elemanlarını bilmek
zoruda değildir. Ancak FILE isminin bir yapı belirttiğini bilmelidir. Fonksiyon başarısız olabilir. Bu durumda
fopen NULL adrese geri döner. Mutlaka başarı kontrolü yapılmalıdır. FILE türünden adrese biz "dosya bilgi
gösterici" diyeceğiz. İngilizce genellikle bu adrese "file stream" denilmektedir.
233

Örneğin:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
if ((f = fopen("test.dat", "w")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
return 0;
}

Dosyanın Kapatılması
Dosyayı kapatmak için fclose fonksiyonu kullanılır. Fonksiyonun prototipi şöyledir:
int fclose(FILE *f);
Fonksiyon parametre olarak fopen fonksiyonundan alınan FILE yapı adresini (yani dosya bilgi göstericisini)
almaktadır. Fonksiyon başarı durumunda sıfır değerine başarıszlık durumunda -1 değerine geri döner. Dosyanın
kapatılmasının başarısının kontrol edilmesine gerek yoktur. Zaten dosya başarılı bir biçimde açılmışsa kesinlikle
başarılı kapatılır.
Örneğin:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
if ((f = fopen("test.dat", "w")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}

Dosya Göstericisi (File Pointer) Kavramı
Dosya byte'lardan oluşan bir topluluktur. Dosyanın içerisinde ne oolursa olsun dosya işletim sistemi için bir byte
yığınıdır. Dosyanın her bir byte'ına ilk byte sıfır olmak üzere bir numara verilmiştir. Bu numaraya ilgili byte'ın
offset'i denir. Örneğin aşağıdaki çizimde her bir X bir byte'ı gösteriyor olsun. Tüm bu byte'ların bir offset2i vardır.

Dosya göstericisi bellekte bir adres belirten daha önce gördüğümüz gibi bir gösterici değildir. Buradaki isim
234

tamamen kavramsal olarak verilmiştir. Dosya göstericisi bir offset belirtir. Bir imleç görevindedir. Tüm okuma ve
yazma işlemleri dosya göstericisinin gösterdiği yerden itibaren yapılır.
Örneğin dosya göstericisi 2'inci offset'i gösteriyor olsun:

Şimdi biz dosyadan 2 byte okuyacak olalım. İşte okuma işlemi dosya göstericisinin gösterdiği yerden itibaren
yapılır. Yani 2'inci ve 3'üncü offset'teki byte'lar okunur. Benzer biçimde yazma işlemi de her zaman dosya
göstericisinin gösterdiği yerden itibaren yapılır. Okuma ve yazma işlemleri dosya göstericisini okunan ya da
yazılan byte miktarı kadar ilerletir. Örneğin dosyaya YY ile temsil edilen iki byte'ı yazmış olalım:

Dosya ilk kez açıldığında dosya göstericisi sıfırıncı offset'i gösteriyor durumdadır.
EOF Durumu
Dosyanın sonında özel hiçbir karakter ya da byte yoktur. Dosya göstericisinin dosyanın son byte'ından sonraki
byte'ı göstermesi durumuna EOF durumu denilmektedir. Örneğin:

Dosya gösterisici EOF durumundaysa artık o dosyada olan bir byte'ı göstermiyordur. Bu nedenle EOF durumundan
okuma yapılamaz. Dosya göstericisi EOF durumundaysa okuma fonksiyonları başarısız olur. Ancak EOF
durumunda yazma yapılabilir. Bu durum dosyaya ekleme yapma anlamına gelir.
Pekiyi bir dosyayı açıp byte byte okuduğumuzu düşünelim. Ne olur? Biz sırasıyla byte'ları okuruz. Dosya
göstericisi en sonında EOF durumuna gelir. Artık okuma yapamayız.
fgetc Fonksiyonu
fgetc dosyadan bir byte okuyan standart C fonksiyonudur. Prototipi şöyledir:
int fgetc(FILE *f);
Fonksiyon parametre olarak fopen fonksiyonundan elde edilen dosya bilgi göstericisini alır. Dosya göstericisinin
gösterdiği yerdeki byte'ı okur. Okuduğu byte ile geri döner. Geri dönüş değeri int rüdendir. Okuma başarılıysa int
bilginin yüksek anlamlı byte'larında sıfır bulunur. En düşük anlamlı byte'ında okunan değer bulunur. fgetc IO
235

hatası nedeniyle ya da EOF nedeniyle okumayı yapamazsa EOF denilen bir değere geri döner: EOF değeri <stdio.h>
içerisinde -1 olarak define edilmiştir:
#define EOF

-1

Pekiyi fgetc okuduğu byte'a geri döndüğüne göre neden geri dönüş değeri char değil de int türdendir. Eğer fgetc'in
geri dönüş değeri char olsaydı bu durumda dosyadan FF numaralı byte'ı okuduğunda FF = -1 olduğundan fgetc'in
başarısız mı olduğu yoksa gerçekten FF numaralı byte'ı mı okuduğu anlaşılamazdı. Halbuki fonksiyonun geri
dönüş değeri int olduğu için bu sorun oluşmamaktadır. Yani:
00 00 00 FF ---> FF numaralı byte okunmuş
FF FF FF FF --> başarısız olunmuş
Örneğin bir dosyayı sonuna kadar okuyup yazdıran örnek program şöyle yazılabilir:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
int ch;
if ((f = fopen("Sample.c", "r")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
while ((ch = fgetc(f)) != EOF)
putchar(ch);
fclose(f);
return 0;
}

feof ve ferror Fonksiyonları
Bir dosya fonksiyonu (örneğin fgetc gibi) başarısız olduğunda bunun nedeni dosya sonuna gelinmiş olması olabilir
ya da daha ciddi (genellikle biz artık şey yapamayız) IO hatası olabilir. fgetc fonksiyonu her iki durumda da EOF
değeriyle geri dönmektedir. Dosya sonuna gelmiş olmak gayet normal bir durumdur. Halbuki bir disk hatası ciddi
bir soruna işaret eder. İşte bizim fgetc gibi bir fonksiyonun neden EOF'a geri döndüğünü tespit edebilmemeiz
gerekir. Bunun için feof ve ferror fonksiyonlarından faydalanılır:
int feof(FILE *f);
int ferror(FILE *f);
feof fonksiyonu dosya göstericisinin EOF durumundaolup olmadığını tespit eder. Eğer dosya göstericisi EOF
durumundaysa fonksiyon sıfır dışı herhangi bir değere, EOF durumunda değilse 0 değerine geri döner. Ancak bu
fonksiyon son okuma işlemi başarısız olduğunda kullanılmalıdır. Şöyle ki: Biz dosyadaki son byte'ı fgetc ile
okuduğumuzda dosya göstericisi EOF'a çekildiği halde feof sıfıra geri döner. Bundan sonra bir daha fgetc
uygularsak fgetc başarısz olur. Arık feof sıfır dışı değere geri döner.
ferror ise son okuma ya da yazma işleminde IO hatası oluşup oluşmadığını belirlemek için kullanılmaktadır. Eğer
son dosya işlemi IO hatası nedeniyle balarısız olmuşsa ferror sıfır dışı bir değere, değilse sıfır değerine geri döner.
Özellikle son işlemin başarısı iyi bir teknik bakımından kontrol edilmelidir. Örneğin:
236

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
int ch;
if ((f = fopen("Sample.c", "r")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
while ((ch = fgetc(f)) != EOF)
putchar(ch);
if (ferror(f)) {
printf("cannot read file!..\n");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}

Örneğin aşağıdaki gibi dosya sonuna kadar okuma işlemi hatalıdır:
while (!feof(f)) {
ch = fgetc(f);
putchar(ch);
}

Çünkü burada son byte okunduktan sonra henüz feof sıfır dışı değer vermez. Dolayısıyla program fazladan bir byte
okunmuş gibi davranır. Ayrıca burada IO hatası için bir tespit yapılmamıştır. Doğru teknik şöyledir:
while ((ch = fgetc(f)) != EOF)
putchar(ch);
if (ferror(f)) {
printf("cannot read file!..\n");
exit(EXIT_FAILURE);
}

fputc Fonksiyonu
fputc dosyaya dosya göstericisinin gösterdiği yere bir byte yazan en temel yazma fonksiyonudur. Prototipi şöyledir:
int fputc(int ch, FILE *f);
Fonksiyon birinci parametresiyle belirtilen int değerin en düşün anlamlı byte'ını yazar. Baaşarı durumunda yazdığı
değer, başarısızlık durumunda EOF değerine geri döner.
Örneğin:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{

237

FILE *f;
char s[] = "this is a test, yes this is a test!";
int i;
if ((f = fopen("test.txt", "w")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
for (i = 0; s[i] != '\0'; ++i)
if (fputc(s[i], f) == EOF) {
printf("cannot write file!..\n");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}

Dosya kopyalayan örnek bir program şöyle yazılabilir:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *fs, *fd;
int ch;
if ((fs = fopen("sample.c", "r")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
if ((fd = fopen("xxx.c", "w")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
while ((ch = fgetc(fs)) != EOF)
if (fputc(ch, fd) == EOF) {
printf("cannot write file!..\n");
exit(EXIT_FAILURE);
}
if (ferror(fs)) {
printf("cannot read file!..\n");
exit(EXIT_FAILURE);
}
printf("success...\n");
fclose(fs);
fclose(fd);
return 0;
}

fread ve fwrite Fonksiyonları
fread ve fwrite fonksiyonları getc ve fputc fonksiyonlarının n byte okuyan ve n byte yazan genel biçimleridir. fread
dosya göstericisinin gösterdiği yerden itibaren n byte'ı okuyarak bellekte verilen adresten itibaren bir diziye
yerleştirir. fwrite ise tam tersini yapmaktadır. Yani bellekte verilen bir adresten başlayarak n byte'ı dosya
238

göstericisinin gösterdiği yerden itibaren dosyaya yazar. Fonksiyonların prototipleri şöyledir:
size_t fread(void *ptr, size_t size, size_t count, FILE *f);
size_t fwrite(const void *ptr, size_t size, size_t count, FILE *f);
fread fonksiyonun birinci parametresi bellekteki tarnsfer adresidir. Fonksiyon ikinci ve üçüncü parametrelerin
çarpımı kadar byte okur (yani size * count kadar). Son parametre okuma işleminin yapılacağı dosyayı
belirtmektedir. Genellikle ikinci parametre okunacak dizinin bir elemanının byte uzunluğu olarak, ikinci parametre
ise okunacak eleman uzunluğu olarak girilir. Örneğin dosyada int bilgiler olsun ve biz 10 int değeri okumak
isteyelim:
int a[10];
fread(a, sizeof(int), 10, f);
fread fonksiyonu başarı durumunda okuyabildiği parça sayısına geri döner. Başarıszlık durumunda sıfır değerine
geri dönmektedir. fread fonksiyonu ile dosyada olandan daha fazla byte okunmak istenebilir. Bu durumda fread
okuyabildiği kadar byte'ı okur ve okuyabildiği parça sayısına geri döner. Örneğin dosya göstericisinin gösterdiği
yerden itibaren dosyada 20 byte kalmış olsun. Biz de aşağıdaki gibi bir okuma yapmış olalım:
fread(a, sizeof(int), 10, f);
Biz buarad 40 byte okuma talep etmiş olabiliriz. Ancak fread kalan 20 byte'ın hepsini okur ve 5 değerine geri öner.
Yani fread toplam okunan byte sayısının ikinci parametrede belirtilen değere bölümüne geri dönmektedir.
fwrite fonksiyonu da tamamen aynı biçimde çalışır. Tek fark fwrite dosyadan belleğe okuma değil bellekten
dosyaya yazma yapmaktadır. fwrite da başarı durumunda yazılan parça sayısına başarısızlık durumunda sıfır
değerine geri döner.
Örneğin 10 elemanlı bir int dizi dosyaya tek hamlede fwrite fonksiyonuyla şöyle yazdırılabilir:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
if ((f = fopen("Sample.dat", "wb")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
if (fwrite(a, sizeof(int), 10, f) != 10) {
printf("cannot write file!..\n");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}

Şimdi de yazdığımız sayıları tek hamlede fread ile okuyalım:
#include <stdio.h>

239

#include <stdlib.h>
int main(void)
{
FILE *f;
int a[10];
int i;
if ((f = fopen("Sample.dat", "rb")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
if (fread(a, sizeof(int), 10, f) != 10) {
printf("cannot read file!..\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < 10; ++i)
printf("%d ", a[i]);
printf("\n");
fclose(f);
return 0;
}

Şimdi de bir dosyadan belli bir miktar okuyup diğerine yazarak dosya kopyalaması yapmaya çalışalım:
#include <stdio.h>
#include <stdlib.h>
#define BUF_SIZE

512

int main(void)
{
FILE *fs, *fd;
char buf[BUF_SIZE];
size_t n;
if ((fs = fopen("sample.c", "rb")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
if ((fd = fopen("xxx.c", "wb")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
while ((n = fread(buf, 1, BUF_SIZE, fs)) > 0)
if (fwrite(buf, 1, n, fd) != n) {
printf("cannot write file!..\n");
exit(EXIT_FAILURE);
}
if (ferror(fs)) {
printf("cannot read file!..\n");
exit(EXIT_FAILURE);
}
printf("success...\n");
fclose(fs);
fclose(fd);

240

return 0;
}

Yapıların Dosyalara Yazılması ve Okunması
Yapı elemanları bellekte ardışıl bir biçimde tutulduğuna göre, biz bir yapıyı tek hamlede fwrite fonksiyonuyla
yazıp, fread fonksiyonuyla okuyabiliriz. Örneğin struct PERSON türünden per isimli bir yapı nesnesi olsun:
fwrite(&per, sizeof(struct PERSON), 1, f);
Klavyeden girilen değerlerden oluşan yapı nesneleri fwrite fonksiyonuyla dosyaya yazdırılmaktadır:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct tagPERSON {
char name[32];
int no;
} PERSON;
int main(void)
{
FILE *f;
PERSON per;
if ((f = fopen("person.dat", "wb")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
for (;;) {
printf("Adi soyadi:");
gets(per.name);
if (!strcmp(per.name, "exit"))
break;
printf("No:");
scanf("%d", &per.no);
getchar();
/* tamponu boşaltmak için, şimdilik takılmayın */
if (fwrite(&per, sizeof(per), 1, f) != 1) {
printf("cannot write file!..\n");
exit(EXIT_FAILURE);
}
}
fclose(f);
return 0;
}

Aynı dosyadan kayıtları okuyan program da şöyle yazılabilir:
#include <stdio.h>
#include <stdlib.h>
typedef struct tagPERSON {
char name[32];
int no;
} PERSON;
int main(void)

241

{
FILE *f;
PERSON per;
if ((f = fopen("person.dat", "rb")) == NULL) {
printf("cannot open file!..\n");
exit(EXIT_FAILURE);
}
while (fread(&per, sizeof(per), 1, f) > 0)
printf("%s, %d\n", per.name, per.no);
if (ferror(f)) {
printf("cannot read file!..\n");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}

fprintf ve fscanf fonksiyonları
fprintf fonksiyonu printf gibi çalışan fakat dosyaya yazdırma amaçlı kullanılan standart C fonksiyonudur.
İlk parametresi dışında diğer parametreleri printf fonksiyonu ile aynıdır. fprintf fonksiyonunun prototipi aşağıdaki
gibidir.
int fprintf(FILE *f, const char *format, ...);
Fonksiyonun birinci paramtresi yazılacak dosyayı belirtmektedir. Fonksiyonun ikinci parametresi formatlanması
istenen yazıdır. printf fonksiyonu ile aynıdır. fprintf fonksiyonu aşağıdaki gibi kullanılabilir:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
char file_name[] = "test.txt";
int i;
if ((f = fopen(file_name, "w")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
for (i = 0; i < 10; ++i)
fprintf(f, "sayı=%d\n", i + 1);
fclose(f);
return 0;
}

Burada fprintf fonksiyonu ile formatlı bir şekilde dosyaya yazma yapılmıştır. Yukarıda yazma yapılan dosyanın
içeriği okunarak ekrana aşağıdaki gibi bir programla yazdırılabilir:
#include <stdio.h>
#include <stdlib.h>

242

int main(void)
{
FILE *f;
char file_name[] = "test.txt";
int i, ch;
if ((f = fopen(file_name, "r")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
while ((ch = fgetc(f)) != EOF)
putchar(ch);
if (ferror(f)) {
printf("can not read file...!");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}

fprintf fonksiyonu ile dosyaya formatlı bir bilgi yazılmaktadır. Aşağıdaki programlar fprintf ve fwrite
fonksiyonlarının farkını göstermektedir:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
char file_name[] = "test.txt";
int val, ch;
if ((f = fopen(file_name, "w")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
val = 1234;
fprintf(f, "%d\n", val);
fclose(f);
if ((f = fopen(file_name, "r")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
while ((ch = fgetc(f)) != EOF)
putchar(ch);
fclose(f);
return 0;
}
#include <stdio.h>
#include <stdlib.h>

243

int main(void)
{
FILE *f;
char file_name[] = "test.txt";
int val, ch;
if ((f = fopen(file_name, "w")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
val = 1234;
fwrite(&val, sizeof(int), 1, f);
fclose(f);
if ((f = fopen(file_name, "r")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
while ((ch = fgetc(f)) != EOF)
putchar(ch);
fclose(f);
return 0;
}

Anahtar Notlar: Bilindiği fwrite ve fread fonksiyonları dosyaya ikili olarak bilgi yazıp okumaktadırlar:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
char file_name[] = "test.txt";
int val, i;
if ((f = fopen(file_name, "wb")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
for (i = 0; i < 4; ++i)
fwrite(&i, sizeof(int), 1, f);
fclose(f);
if ((f = fopen(file_name, "rb")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
while (fread(&val, sizeof(int), 1, f) > 0)
printf("%d\n", val);
fclose(f);

244

return 0;
}

fscanf fonksiyonu scanf fonksiyonu gibi ancak dosyadan okuma yapma amaçlı kullanılmaktadır. fscanf fonksiyonu
dosyadan formatlı olarak okuma yapar. Fonksiyonun prototipi aşağıdaki gibidir:
int fscanf(FILE *f, const char *format, ...);
Fonksiyonun birinci parametresi okuma yapılacak dosyayı belirtmektedir. Diğer parametreleri scanf fonksiyonu ile
aynıdır.
fscanf fonksiyonu ile dosyadan okuma işlemi aşağıdaki gibi yapılabilir.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
char file_name[] = "test.txt";
int a, b;
if ((f = fopen(file_name, "r")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
fscanf(f, "%d %d", &a,

&b);

printf("a=%d\nb=%d\n", a, b);
fclose(f);
return 0;
}

fscanf fonksiyonun geri dönüş değeri dosyadan okunarak bellekteki alanlara yazılan değer sayısıdır. Hiç bir yazma
yapılmadıysa fonksiyon 0(sıfır) değerine geri döner. Eğer ilk alana atama yapılmadan dosyanın sonuna gelinmişse,
ya da bir hata oluşmuşsa fonsiyon EOF değerine geri döner. Aşağıdaki program her bir satırında 4 adet sayı olan
bir dosyadan okuma yapmaktadır ve her bir dörtlü grubun toplamını bulmaktadır:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
char file_name[] = "test.txt";
int a, b, c, d;
if ((f = fopen(file_name, "r")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
while (fscanf(f, "%d %d %d %d", &a, &b, &c, &d) != EOF)
printf("%d\n", a + b + c + d);
if (ferror(f)) {

245

printf("can not read file....!\n");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}

fscanf fonksiyonu ile her okunan bilgi dönüştürülerek bir bellek alanına aktarılmak zorunda değildir. Böyle
okumalarda % ile format karakteri arasına * konularak okunan değerin devre dışı bırakılması (ama okunması)
sağlanabilir. Örneğin:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
char file_name[] = "test.txt";
int a, b;
if ((f = fopen(file_name, "r")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
fscanf(f, "%d%*s%d", &a, &b);
if (ferror(f)) {
printf("can not read file....!\n");
exit(EXIT_FAILURE);
}
printf("a=%d\n", a);
printf("b=%d\n", b);
fclose(f);
return 0;
}

Burada dosya içerisinde örneğin
10 ------ 20
gibi bir bilgiden yalnızca 10 ve 20 sayıları okunmaktadır.
Sınıf Çalışması: Formatı aşağıdaki gibi olan bir dosya içerisinde dosya formatının geçerliliğini kontrol etmeden
yaş ortalamasını bulan program
Dosya formatı:
isim mert yas 18
isim oguz yas 40
isim serkan yas 35
isim mustafa yas 42
#include <stdio.h>

246

#include <stdlib.h>
int main(void)
{
FILE *f;
char file_name[] = "test.txt";
int age, sum = 0, count = 0;
if ((f = fopen(file_name, "r")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
while (fscanf(f, "%*s%*s%*s%d", &age) != EOF) {
sum += age;
count++;
}
if (ferror(f)) {
printf("can not read file....!\n");
exit(EXIT_FAILURE);
}
printf("Yas Ortalamasi:%lf\n", (double) sum / count);
fclose(f);
return 0;
}

Sınıf Çalışması: Formatı aşağıdaki gibi olan bir dosya içerisinde dosya formatının geçerliliğini kontrol etmeden
değerlerin ortalamasını bulan programı yazınız.
Firma1 30 40 56
Firma2 10 20 35
Firma3 10 20 33
#include <stdio.h>
#include <stdlib.h>
#define MAX_LEN

32

typedef struct tagCOMPANYINFO {
char name[MAX_LEN];
int val1, val2, val3;
} COMPANYINFO;
int main(void)
{
FILE *f;
char file_name[] = "test.txt";
int i;
COMPANYINFO companies[3];
if ((f = fopen(file_name, "r")) == NULL) {
printf("can not open file...%s\n", file_name);
exit(EXIT_FAILURE);
}
for (i = 0; i < 3; ++i) {

247

fscanf(f,
"%s
&companies[i].val3);
}

%d

%d

%d",

companies[i].name,

&companies[i].val1,

&companies[i].val2,

if (ferror(f)) {
printf("can not read file....!\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < 3; ++i) {
double avg = (companies[i].val1 + companies[i].val2 + companies[i].val3) / 3.;
printf("%s ---> %lf\n", companies[i].name, avg);
}
fclose(f);
return 0;
}

Aşağıdaki program rasgele ad, soyad ve not belirleyerek grades.txt isimli dosyaya formatlı bir şekilde yazma
yapmaktadır.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void exit_sys(const char *msg);
int main(void)
{
FILE *f;
char file_name[] = "grades.txt";
int i;
int number_of_students;
char *names[8] = {"oguz", "mert", "durukan", "boran", "mustafa", "serkan", "onur", "latif"};
char *snames[8] = { "aksoy", "kaya", "vural", "altan", "karpuz", "sert", "mulaim", "naif" };
if ((f = fopen(file_name, "w")) == NULL)
exit_sys("can not open file\n");
srand((unsigned)time(NULL));
number_of_students = rand() % 20 + 30;
for (i = 0; i < number_of_students; ++i)
fprintf(f, "%s %s %d\n", names[rand() % 8], snames[rand() % 8], rand() % 101);
fclose(f);
return 0;
}
void exit_sys(const char *msg)
{
printf(msg);
exit(EXIT_FAILURE);
}

Sınıf Çalışması: Yukarıda oluşturulan grades.txt dosyasını kullanarak belirli bir geçme değeri belirleyip, geçenleri
pass.txt kalanları fail.txt isimli dosyaya formatlı olarak yazdıran programı yazınız.
#include <stdio.h>
#include <stdlib.h>

248

#include <time.h>
#define PASS_GRADE 50
void exit_sys(const char *msg);
int main(void)
{
FILE *fgrades, *fpass, *ffail;
char grades_file_name[] = "grades.txt";
char pass_file_name[] = "pass.txt";
char fail_file_name[] = "fail.txt";
char name[20], sname[20];
int grade;
if ((fgrades = fopen(grades_file_name, "r")) == NULL)
exit_sys("can not open file\n");
if ((fpass = fopen(pass_file_name, "w")) == NULL)
exit_sys("can not open file\n");
if ((ffail = fopen(fail_file_name, "w")) == NULL)
exit_sys("can not open file\n");
while (fscanf(fgrades, "%s%s%d", name, sname, &grade) != EOF)
if (grade < PASS_GRADE)
fprintf(ffail, "%s %s %d\n", name, sname, grade);
else
fprintf(fpass, "%s %s %d\n", name, sname, grade);
if (ferror(fgrades))
exit_sys("can not read file\n");
fclose(fgrades);
fclose(fpass);
fclose(ffail);
return 0;
}
void exit_sys(const char *msg)
{
printf(msg);
exit(EXIT_FAILURE);
}

Metin ve İkili Dosyalar
C de bir dosya metin (text) ya da ikili (binary) modda açılabilmektedir. Açılış modunda hiç belirtme yapılmassa
default olarak dosya text modda açılır. Programcı isterse açılış mod yazısının sonuna "t" ekleyerek de açılışı text
modda yaptırabilir. Örneğin:
if (f = fopen("test.txt", "w") == NULL)
/*...*/
ya da örneğin
if (f = fopen("test.txt", "wt") == NULL)
/*...*/
Bir dosyayı binary modda açmak için mod yazısının "b" getirilmelidir. Örneğin:
249

if (f = fopen("test.txt", "wb") == NULL)
/*...*/
Text ve binary modda açılan dosyalar için Windows ve Unix/Linux sistemlerinde farklılıklar bulunmaktadır. Bir
dosya text modda açılmışsa ve çalışılan sistem windows ise yazma yapan herhangi bir fonksiyon Line feed (LF)
('\n') karakterini yazdığında aslında dosyaya Carriage Return (CR)('\r') ve LF karakterlerinin ikisi birden yazılır.
Benzer şekilde dosyadan okuma yapan fonksiyonlar çalışılan sistem windows ise ve dosya text modda açılmışsa
CRLF karakterlerini yanyana gördüğünde yalnızca LF olarak okuma yaparlar. Aşağıdaki program bir text modda
açılmış bir dosyaya beş adet LF karakteri yazmaktadır:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
int i;
if ((f = fopen("test.txt", "w")) == NULL) {
printf("can not open file");
exit(EXIT_FAILURE);
}
for (i = 0; i < 5; ++i)
fputc('\n', f);
fclose(f);
return 0;
}

Bu program Windows sistemlerinde çalıştırıldığında yazma yapılan dosya 10 byte olacaktır. Çünkü her LF yazması
aslında CR ve LF karakterlerinin ikisinin birden yazılması demektir. Unix/Linux sistemlerinde text dosya ve binary
dosya arasında hiç bir fark yoktur. Yani yukarıdaki program Unix/Linux sistemlerinde çalıştırıldığında 5 byte
olacaktır. Çünkü beş adet LF karakteri dosyaya yazılmıştır.
Aşağıdaki program az önce üretilmiş olan dosya içerisindeki karakterleri okumaktadır:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
int i;
int ch;
if ((f = fopen("test.txt", "rb")) == NULL) {
printf("can not open file");
exit(EXIT_FAILURE);
}
while ((ch = fgetc(f)) != EOF)
printf("%d\n", ch);
fclose(f);
return 0;

250

}

Bu program çalıştırıldığında binary modda olduğundan CRLF çiftlerini okuyacaktır.
Metin dosyaları için Windows sistemlerinde diğer sistemlere bir fark daha vardır. Windows sistemlerinde text
modunda okuma yapılırken 26 numaralı Ctrl+Z karakteri sonlandırıcı karakter olarak kabul edilir. Örneğin
aşağıdaki program bir exe dosyanın tüm karakterini text modda okumaktadır:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
int i;
int ch;
long count = 0;
if ((f = fopen("Sample.exe", "r")) == NULL) {
printf("can not open file");
exit(EXIT_FAILURE);
}
while ((ch = fgetc(f)) != EOF)
count++;
printf("Count=%ld\n", count);
fclose(f);
return 0;
}

Bu program windows sistemlerinde çalıştırıldığında dosya içerisinde ctrlz karakteri görüldüğünde okuma
sonlanacaktır. Ancak aynı program Unix/Linux sistemlerinde çalıştırıldığında herhangi sonlanma olmayacaktır.
Dosya Göstericisinin Konumlandırılması ve fseek Fonksiyonu
Anımsanacağı gibi dosya açıldığında dosya göstericisi 0'ıncı offset'tedir. Okuma yazma işlemleriyle dosya
göstericisi otomatik ilerletilmektedir. Ancak biz isteresek dosya göstericisini fseek fonkisyonuyla istediğimiz
offset'e konumlandırabiliriz. fseek fonksiyonunun prototipi şöyledir:
#include <stdio.h>
int fseek(FILE *stream, long offset, int whence);
Fonksiyonun birinci parametres, konumlandırılacak dosyaya ilişkin dosya bilgi göstericisini alır. İ;kinci parametre
dosya opffset'ini belirtmektedir. Üçüncü parametre konumlandırma orijinini belirtir. Üçüncü parametre üç
değerden birisi olabilir: 0, 1 veya 2. Bu değerler aynı zamanda aşağıdaki gibi define da edilmiştir:
#define SEEK_SET
#define SEEK_CUR
#define SEEK_END

0
1
2

Eğer üçüncü paramere sıfır girilirse ikinci parametre dosyanın başından itibaren offset belirtir. Yani ikinci
parametre >= 0 olmak zorundadır. Örneğin:
251

fseek(f, 100, SEEK_SET);
Burada dosya göstericisi 100'üncü offset'e konumlandırılmıştır. Eğer üçüncü parametre 1 girilirse konumlandırma
dosya göstericisinin gösterdiği yerden itibaren yapılır. Tabi bu durumda ikinci parametre sıfır, pozitif ya da negatif
olabilir. Örneğin:
fseek(f, 1, SEEK_CUR);
Bu işlemle dosya göstericisi neredeyse onun 1 ilerisine konumlandırılır. Örneğin:
fseek(f, -10, SEEK_CUR);
Burada dosya göstericisi 10 geriye konumlandırılmaktadır. Eğer son parametre 2 girilirse bu durumda
konumlandırma EOF'dan itibaren yapılır. Tabi bu durumda ikinci parametre <= 0 girilmek zorundadır. Örneğin:
fseek(f, 0, SEEK_END);
Bu durumda dosua göstericisi EOF'a konumlandırılır. Yani artık yazma yapmak istediğimizde dosyaya ekleme
yapmış oluruz. Fonksiyon konumlandırma başarılıysa 0 değerine, başarısızsa EOF (-1) değerine geri döner.
Örneğin:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
if ((f = fopen("Test.txt", "r+")) == NULL) {
printf("can not open file");
exit(EXIT_FAILURE);
}
fseek(f, 0, SEEK_END);
fprintf(f, "Yes, this is a test");
fclose(f);
return 0;
}

Burada dosya göstericisi dosyanın sonuna çekilip yazma yapılmıştır. Örneğin:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
char s[10];
if ((f = fopen("Test.txt", "r+")) == NULL) {
printf("can not open file");
exit(EXIT_FAILURE);
}

252

fseek(f, 10, SEEK_SET);
fgets(s, 5, f);
puts(s);
fclose(f);
return 0;
}

Burada dosya göstericisi dosyanın 10'uncu offset'ine çekilip okuma yapılmıştır.
C'de okumadan yazmaya yazmadan okumaya geçişte mutlaka fseek ya da fflush işlemi yapılmalıdır.
stdin, stdout ve stderr Dosyaları
Bir C programında stdin, stdout ve stderr FILE * türünden dosya bilgi göstericisi belirtmektedir. Bu isimler
<stdio.h> dosyasında bildirilmiştir. (Dolayısıyla bu isimler anahtar sözcük değildir. Bunları kullanabilmemiz için
<stdio.h> dosyasını include etmeliyiz.
stdin dosyasına "standard input" dosyası, stdout dosyasına "standart output" dosyası, stderr dosyasına ise "standard
error dosyası" denilmektedir.
C standartlarında "klavye" ve "ekran" lafı edilmemiştir. Standartlara göre stdout ekrana ya da istenirse başka
aygıtlara yönlendirilebilir. Örneğin printf stdout nereye yönlendirilmişse oraya yazar. stdout eğer yazıcıya
yönlendirilmişse printf de yazıcıya yazdıracaktır. Bugün kullandığımız masaüstü ve dizüstü bilgisayarlarda stdout
default olarak ekrana yönlendirilmiş durumdadır. Fakat biz onu değiştirebiliriz. Örneğin standartlara göre getchar,
gets fonksiyonlar stdin dosyasından okuma yapar. stdin de bilgisayarlarımızda default olarak klavyeye
yönlendirilmiş durumdadır. Fakat biz onu başka aygıtlara yönlendirebiliriz. Örneğin:
printf(.....);
çağrısının aslında,
fprintf(stdout, ....);
çağrısından hiçbir farkı yoktur. Örneğin:
#include <stdio.h>
int main(void)
{
fprintf(stdout, "This is a test\n");
return 0;
}

Benzer biçimde örneğin getchar aslında fgetc(stdin) ile aynı işlemi yapar.
stderr dosyası hata mesajlarının yazdırırlacağı dosyayı temsil eder. Default durumda stderr dosyası da ekrana
yönlendirilmiştir. Ancak biz onu dosyaya ya da başka aygıta yönlendirebiliriz. Programın hata msajlarının stdout
yerine fprintf fonksiyonuyla stderr dosyasına yazdırılması iyi bir tekniktir. Örneğin:
if ((p = malloc(size)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
253

exit(EXIT_FAILURE);
}
Windows'ta ve UNIX/Linux sistemerinde stdout dosyasını yönlendirmek için komut satırında > işareti kullanılır.
Örneğin:
sample > x.txt
Benzer biçimde stderr dosyası 2> sembolüyle yönlendirilir. Örneğin:
sample 2> y.txt
Burada stdout dosyasına yazılanlar yine ekrana çıkar fakat stderr dosyasına yazılanlar y.txt dosyasına yazılır. İki
yönlendirme beraber de kullanılabilir:
sample > x.txt 2> y.txt
stdin dosyasını yönlendirmek için < sembolü kullanılmaktadır. Örneğin:
sample < x.txt
Buarada artık stdin dosyasından okuma yapıldığında sanki x.txt dosyasındakiler klavyeden girilmiş gibi işlem
gerçekleşir.
Bit Operatörleri (Bitwise Operators)
Bit operatörleri sayıların karşılıklı bitleri üzerinde işlem yapan operatörlerdir. Bit operatörleri şunlardır:
~
<<
>>
&
|
^

Bit Not (Bitwise Not)
Sola Öteleme (left shift)
Sağa Öteleme (right shift)
Bit And (Bitwise And)
Bit Or (Bitwise Or)
Bit Exor (Bit Exclusive Or)

Bit And ve Bit Or Operatörleri
Tek ampsersand Bit And, Tek çubuk Bit Or operatörü anlamına gelir. (Anımsanacağı gibi bunlardan iki tane yan
yana getirilirse mantıksal And ve Mantıksal Or operatörleri anlaşılır.) Bu operatörler sayının karşılıklı bitlerini And
ve Or işlemine sokarlar. Örneğin:
#include <stdio.h>
int main(void)
{
unsigned char a = 0x5F;
unsigned char b = 0xC4;
unsigned c;
c = a & b;
printf("%02X\n", c);

/* 0x44 */

c = a | b;

254

printf("%02X\n", c);

/* 0xDF */

return 0;
}

Soru: Bir sayının n'inci bitinin durumunu belirleyiniz.
Yanıt: Sayı tüm bitleri sıfır n'inci 1 olan bir sayıyla Bit And işlemine sokulur. Sonuç sıfırsa n'inci sıfır, sonuç
sıfırdan farklıysa n'inci bir 1'dir.
Soru: Sayının diğer bitlerine dokunmadan n'inci bitini 0 yapınız.
Yanıt: O sayıyı bütün bitleri 1 olan n'inci biti 0 olan bir sayıyla Bit And işlemine sokarız.
Soru: Sayının diğer bitlerine dokunmadan n'inci bitini 1 yapınız.
Yanıt: O sayıyı bütün bitleri 0 olan n'inci biti 1 olan bir sayıyla Bit Or işlemine sokarız.

Örneğin:
#include <stdio.h>
int main(void)
{
unsigned char a = 0x7F;
a &= 0xDF;
printf("%02X\n", a);

/* 0x5F */

return 0;
}

Bit Exor Operatörü
Eğer bitler aynıysa 0 değerini veren bitler farklıysa 1 değerini veren işleme EXOR (exclusive Or) işlemi
denilmektedir. EXOR işleminin doğruluk tablosu şöyledir:
a
0
0
1
1

b
0
1
0
1

a^b
0
1
1
0

Örneğin:
#include <stdio.h>
int main(void)
{
unsigned char a = 0x9A;
unsigned char b = 0x7C;
unsigned char c;

255

c = a ^ b;
printf("%02X\n", c);

/* 0xE6 */

return 0;
}

Exor geri dönüşümlü bir operatördür. Bu nedenle şifreleme işlemlerinde çok kullanılır. Yani a ^ b = c ise, c ^ b = a
ve c ^ a = b'dir. Böylece bir dosyanın byte'ları birtakım değerlerle Exor çekilerek bozulmuşsa yine aynı değerlerle
exor çekilerek düzeltilebilir. (Yani değeri bozan anahtarla açan anahtar aynı olabilmektedi.) Örneğin Exor ile
şifreleme için şöyle bir örnek verilebilir:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
char passwd[128];
unsigned seed;
int i;
int ch;
printf("Enter password:");
gets(passwd);
seed = 0;
for (i = 0; passwd[i] != '\0'; ++i)
seed = seed * 31 + passwd[i];
if ((f = fopen("test.txt", "r+")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
srand(seed);
while ((ch = fgetc(f)) != EOF) {
ch ^= rand() % 256;
fseek(f, -1, SEEK_CUR);
fputc(ch, f);
fseek(f, 0, SEEK_CUR);
}
fclose(f);
return 0;
}

Exor işleminde 0 etkisiz elemandır. 1 ise tersleme işlemi yapar.
Soru: Bir sayının diğer bitlerine dokunmadan n'inci bitini onun tersiyle yer değiştiriniz.
Yanıt: Sayı tüm bitleri 0 olan n'inci biti 1 olan bir sayıyla Exor çekilir.
Bit Not Operatörü
C'de ~ sembolü tek operandlı önek bir bit operatörüdür. Sayının 0 olan bitlerini 1, 1 olan bitlerini sıfır yapar.
Örneğin :
#include <stdio.h>

256

int main(void)
{
unsigned a = 0, b;
b = ~a;
printf("%u\n", b);

/* 4294967295 */

return 0;
}

&, |, ^ ve ~ Operatörlerinin Öncelik Tablosundaki Yerleşimi
Bit operatörlerinden ~ operatörü tek operandlı olduğu için öncelik tablosunun ikinci düzeyinde sağdan-sola grupta
bulunur. & ve | operatörleri mantıksal operatörlerden daha önceliklidir.
( ) [ ] -> .

Soldan Sağa

+ - ++ -- ! (tür), sizeof * & ~

Sağdan Sola

* /%

Soldan Sağa

+ -

Soldan Sağa

< > <= >=

Soldan Sağa

== !=

Soldan Sağa

&

Soldan Sağa

^

Soldan Sağa

|

Soldan Sağa

&&

Soldan Sağa

||

Soldan Sağa

?:

Sağdan Sola

= += -= *= /= %= |= &= ^=

Sağdan Sola

,

Soldan Sağa

& ve | operatörleri karşılaştırma operatörlerinden daha düşük önceliklidir. Maalesef programcılar aşağıdaki gibi
hataları sık yapmaktadır:
if (a & 0x80 != 0)
...
}

{

Burada sayının en yüksek anlamlı bitinin 1 olup olmadığında bakılmak istenmiştir. Ancak != operatörü &
operatöründen daha öncelikli olduğu için kullanım hatalıdır. İşlemin şöyle yapılması gerekirdi:
if ((a & 0x80) != 0)
...
}

{

Bazı derleyiciler bu tür durumlarda uyarı ile programcının dikkatini çekmektedir.
Sola ve Sağa Öteleme Operatörleri
257

C'de << operatörüne sola öteleme (left shift), >> operatörüne ise sağa öteleme (right shift) operatörü denilmektedir.
Bu operatörler iki operandlı araek operatörlerdir.
Öteleme operatörlerinin sol tarafındaki operand'lar ötelenecek değeri, sağ tarafındaki operand'lar öteleme miktarını
belirtir. Sola ötelemede her bir bir sola kaydırlır. En soldaki bit kaybedilir, en sağdan sıfırla besleme yapılır.
Örneğin:

Sayıyı 1 kez sola ötelemek onu ikiyle çarpmak anlamına gelir. Örneğin:
a = 0x02;
b = a << 1;

/* 0000 0010 */
/* 0000 0100 */

Örneğin:
#include <stdio.h>
int main(void)
{
unsigned int a = 2, b;
b = a << 1;
printf("%d\n", b);
return 0;
}

İşaretli syaılarda sola öteleme işlemi sırasında taşma olabilir. Eğer sola ötelemede taşma olursa tanımsız davranış
(undefined behavior) oluşur. Örneğin:
int a = -2147483647, b;
b = a << 1;
/* Bu sayının iki katı int sınırlarının dışında! Tanımsız davranış! */

Örneğin:
int a = -1, b;
b = a << 1;

/* sorun yok b = -2 */

Sağa ötelemede ise sayının bütün bitleri bir sağa kaydırılır. en sağdaki bit kaybedilir. En soldan sıfır ile besleme
yapılır. Sayıyı bir kez sağa ötelemek 2'ye tam bölmek anlamına gelir.

Örneğin:
#include <stdio.h>

258

int main(void)
{
unsigned int a = 100, b;
b = a >> 2;
printf("%d\n", b);

/* 25 */

return 0;
}

Eğer sayı işaretliyse ve negatifse en soldan besleme 0 ile yapılırsa sayı pğozitif hale gelir. Sayının negatifliğinin
korunması için en soldan 1 ile beslenmesi gerekir. İşte standartlara göre işaretli negatif sayıların sağa
ötelenmesinde en soldan 0'la mı besleme yapılacağı yoksa 1 ile mi besleme yapılacağı (başka bir deyişle işaret
bitinin korunup korunmayacağı) derleyicileri yazanların isteğine bırakılmıştır. Bu nedenle işaretli sayıların sağa
ötelenmesine dikkat edilmelidir. Örneğin Microsoft derleyhicileri ve gcc derleyicileri işaret bitini korumaktadır:
#include <stdio.h>
int main(void)
{
int a = -2, b;
b = a >> 2;
printf("%d\n", b);

/* -1 */

return 0;
}

Biz sola ya da sağa istediğimiz kadar öteleme yapabiliriz. Kuralları özetlemek gerekirse:
- İşaretsiz sayıların sola ve sağa ötelenmesinde tanımsız davranış ya da derleyiciye bağlı davarnış gözükmez. Sola
ötelemede taşma olsa bile yüksek alnmlı bit atılır.
- İşaretli sayıların sola ötelenmesinde taşma olursa tanımsız davranış oluşur.
- İşaretli negatif sayıların sağa ötelenmesinde işaret bitinin korunup korunmayacağı derleyicileri yazanların isteğine
bırakılmıştır.
Soru: Sayının n'inci, 1'leyiniz . Fakat n'in değerini bilmiyoruz. (Örneğin n klavyeden giriliyor.)
Yanıt: Mademki n değeri bilinmiyor işlem şöyle yapılabilir (a ilgili sayı olsun, n de bit numarasını göstersin):
b = a | 1 << n;
Soru: Sayının n'inci, 0 layınız. Fakat n'in değerini bilmiyoruz. (Örneğin n klavyeden giriliyor.)
Yanıt: İşlem şöyle yapılabilir:
b = a & ~(1 << n )
Soru: Klavyeden bir n değeri isteyiniz. Öyle bir sayı oluşturunuz ki, son n biti 1 olsun diğer bitleri 0 olsun.
Örneğin n = 4 için şöyle bir sayı oluşturulmalıdır:
0000 1111
n = 2 için şöyle bir sayı oluşturulmalıdır:
259

0000 0011
Yanıt: İşlem şöyle yapılabilir:
a = ~(~0U << n);
Soru: Klavyeden bir n değeri isteyiniz. Öyle bir sayı oluşturunuz ki ilk n biti 1 olsun diğer bitleri 0 olsun. Örneğin
n = 4 için şöyle bir sayı oluşturulmalıdır:
1111 0000
Yanıt:
a = ~(~0U >> n)
Soru: İşaretsiz bir sayı var. 1 olan bitlerinin kaç tane olduğunu bulunuz.
Yanıt: Eğer döngüsüz yapılacaksa bir look-up table oluşturulur. 1 byte'lık sayılar için bu mümkün olsa da 2
byte'lık ve daha uzun sayılar için sorunludur. Örneğin:
#include <stdio.h>
int main(void)
{
unsigned n, count;
printf("Sayi giriniz:");
scanf("%d", &n);
count = 0;
do {
if (n & 1)
++count;
n >>= 1;
} while (n);
printf("%d\n", count);
return 0;
}

Öteleme operatörleri öncelik tablosunda artimetik operatörlerle karşılaştırma operatörleri arasında bulunur. Öncelik
tablonun son şekli şöyledir:
( ) [ ] -> .

Soldan Sağa

+ - ++ -- ! (tür), sizeof * & ~

Sağdan Sola

* /%

Soldan Sağa

+ -

Soldan Sağa

<<

>>

Soldan Sağa

< > <= >=

Soldan Sağa

== !=

Soldan-Sağa

&

Soldan Sağa

^

Soldan Sağa
260

|

Soldan Sağa

&&

Soldan Sağa

||

Soldan Sağa

?:

Sağdan Sola

= += -= *= /= %= |= &= ^=

Sağdan Sola

,

Soldan Sağa

Programların Komut Satırı Argümanları
Bir programı komut satırından çalıştırırken programdan isminden sonra girilen yazılara komut satırı argümanları
(command line arguments) denilmektedir. Standartlara göre C'de main fonksiyonunun geri dönüş değeri int olmak
zorundadır. main fonksiyonunun parametresi ya void olmak zorundadır ya da main iki parametreye sahip olabilir.
Parametrelerden biri int türden diğeri char ** türündendir. Bu parametre char *[] biçiminde de ifade edilemektedir.
Yani main fonksiyonu aşağıdaki iki biçimden biri olarak tanımlanmak zorundadır:
int main(void)
{
...
}

int main(int argc, char *argv[])
{
...
}
İkinci biçimdeki parametre değişken isimleri istenildiği gibi alınabilir. Ancak argc (argument counter) ve argv
(argument variable list) isimleri gelenekseldir.
main fonksiyonuna bu argümanları işletim sistemi ve derleyicilerin giriş kodları geçirmektedir. Birinci parametre
komut satırına girilen boşlukla ayrılmış yazıların sayısını belirtir (programın ismi de dahil). Örneğin:
ls -l -i
Burada argc 3 olarak geçirilir. Yalnızca programın ismini yazarak programı çalıştırmak isteseydik argc değeri 1
olurdu. argv ise komut satırı argümanlarına ilişkin yazıların başlangıç adreslerinin bulunduğu diziyi belirtir. Yani
argv'nin her elemanı sırasıyla programın isminden başlayarak bir argümanı bize verir. Dizinin sonunda NULL
adresin bulunacağı garanti edilmektedir. Örneğin:

261

Örneğin:
#include <stdio.h>
int main(int argc, char *argv[])
{
int i;
for (i = 0; i < argc; ++i)
printf("%s\n", argv[i]);
return 0;
}

Aynı döngü şöyle de kurulabilirdi:
#include <stdio.h>
int main(int argc, char *argv[])
{
int i;
for (i = 0; argv[i] != NULL; ++i)
printf("%s\n", argv[i]);
return 0;
}

Visual Studio IDE'sinde komut satırı argümanları proje ayarlarında "Debugging / Command Arguments"
kısmından girilebilir.
Örneğin type (ya da cat) işlemini yapan bir program şöyle yazılabilir:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
FILE *f;
int ch;
if (argc == 1) {
printf("usage: <mytype> <path>\n");
exit(EXIT_FAILURE);
}
if (argc > 2) {
fprintf(stderr, "too many arguments!..\n");
exit(EXIT_FAILURE);
}
if ((f = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "cannot open file: %s\n", argv[1]);
exit(EXIT_FAILURE);

262

}
while ((ch = fgetc(f)) != EOF)
putchar(ch);
if (ferror(f)) {
fprintf(stderr, "IO error!\n");
exit(EXIT_FAILURE);
}
return 0;
}

Programın başında komut satırı argümanlarının kontrol edilmesiyle sık karşılaşılmaktadır. Yukarıda da gördüğünüz
gibi önce program uygun komut satırı argümanlarıyla çalıştırılmış mı diye bakılmıştır.
Komut satırı argümanlarının birer yazı biçiminde bize verildiğine dikkat ediniz. Örneğin biz n tane sayının
toplamını yazdıran add isimli bir program yazmak isteyelim:
./add 10 20 30 40
Önce bu tazıları sayıya dönüştürmemiz gerekir. Bunun için ise atoi, atol ya da atof fonksiyonları kullanılmaktadır.
atoi, atol ve atof Fonksiyonları
Prototipi <stdlib.h> dosyasında bulunan bu standart C fonksiyonları bizden sayı belirten bir yazıyı parametre
olarak alır ve onu gerçekten sayı olarak bize verir:
int atoi(const char *str);
long atol(const char *str);
double atof(const char *str);
Örneğin:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char s[] = "123.45";
double d;
d = atof(s);
printf("%f\n", d);
return 0;
}

Bu fonksiyonlar yazının başındaki boşluk karakterlerini (white space) atarlar. İlk uygun olmayan karakter
gördüklerinde işlemini sonlandırırlar. Hiçbir uygun karaktger bulunamazsa bu fonksiyonlar 0 ile geri dönmektedir.
atoi fonksiyonu şöyle yazılabilir.
#include <stdio.h>
#include <ctype.h>
int myatoi(const char *str)
{
int val = 0;
int sign = 1;

263

while (isspace(*str))
++str;
if (*str == '-') {
sign = -1;
++str;
}
while (isdigit(*str)) {
val = val * 10 + *str - '0';
++str;
}
return val * sign;
}
int main(void)
{
char s[] = " -1205";
int i;
i = myatoi(s);
printf("%d\n", i);

/* 12 */

return 0;
}

Şimdi yukarıda belirtilen add programını yazalım:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
double total = 0;
int i;
for (i = 1; i < argc; ++i)
total += atof(argv[i]);
printf("%f\n", total);
return 0;
}

itoa ve ltoa Fonksiyonları
itoa fonksiyonu atoi fonksiyonun, ltoa fonksiyonu da atol fonksiyonun ters işlemini yapan fonksiyonlardır. Ancak
bu fonksiyonlar standart C fonksiyonları değildir. Dolayısıyla bazı C derleyicilerinde bulunmayabilirler. Örneğin
bu fonksiyonlar Microsoft ve Borland derleyicilerinde varken, gcc derleyicilerinde bulunmamaktadır. Bunun
yerine standart sprintf sonlsiyonu kullanılabilir.
sprintf Fonksiyonu
sprintf fonksiyonu printf fonksiyonunun char türden bir diziye yazan versiyonudur. Nasıl fprintf fonksiyonu
printf'in dosyaya yazan versiyonuysa sprintf de diziye yazan versiyonudur. Örneğin:
#include <stdio.h>
int main(void)
{

264

char s[100];
int a = 10, b = 20;
sprintf(s, "a = %d, b = %d", a, b);
puts(s);
return 0;
}

sprintf fonksiyonun birinci parametresi char türden bir adrestir. Diğer parametreleri printf ile aynıdır. Genel olarak
bir sayıyı yazıya dönüştürmek için de sprintf kullanılabilir. Örneğin:
#include <stdio.h>
int main(void)
{
char s[100];
double d = 12.345;
sprintf(s, "%f", d);
puts(s);
return 0;
}

sscanf Fonksiyonu
Bu fonksiyon scanf'in char türden diziden okuyan versiyonudur. Yani fscanf nasıl dosyadan okuyorsa, sscanf de
diziden girilenleri sanki klavyeden (stdin dosyasından) girilmiş gibi ele alır. Örneğin:
#include <stdio.h>
int main(void)
{
char s[100] = "
int a, b;

123 456

";

sscanf(s, "%d%d", &a, &b);
printf("a = %d, b = %d\n", a, b);
return 0;
}

sscanf fonksiyonunun birinci parametresi char türden dizinin adresini alır. Diğer parametreleri scanf fonksiyonunda
olduğu gibidir. Dolayısıyla bu fonksiyon da yazıyı sayıya dönüştüren atoi, atol ve atof fonksiyonlarının daha genel
bir biçim olarak kullanılabilir.
Gösteriyi Gösteren Göstericiler (Pointers to Pointer)
Göstericiler de birer nesne olduğuna ve bellekte yer kapladığına göre onların da adresleri alınabilir. Bir göstericinin
adresi alınırsa nasıl bir göstericiye yerleştirilmelidir. İşte T türünden bir göstericinin adresi T* türünden bir
göstericiye yerleştirilebilir. Böyle göstericiler iki tane * atomu ile bildirilirler. Örneğin:
int **ppi;
Burada ppi bir gösterixiyi gösteren göstericidir. Yani gösterici türünden göstericidir. Biz ppi'yi * operatörüyle
kullanırsa (*ppi'yi kapatıp sola bakın) elde ettiğimiz nesne int * türündendir. Yani bir göstericidir. Yani:
ppi, int ** türündendir.
265

*ppi, int * türündendir.
**ppi, int türdendir.

Örneğin:
#include <stdio.h>
int main(void)
{
int a = 10;
int *pi;
int **ppi;
pi = &a;
ppi = &pi;
printf("%d\n", **ppi);
return 0;
}

Anımsanacağı gibi bir dizinin ismini bir ifadede kullandığımızda aslında o dizinin adresini kullanmış oluruz. Başka
bir deyişle bir dizinin ismi o dizinin ilk elemanın adresi gibidir. O halde bir gösterici dizisinin ismi de o gösterici
dizisinin ilk elemanın adresi gibi olacağına göre iki yıldızlı bir göstericiye atanabilir. Örneğin:
char *s[10];
Burada s ifadesi char ** türündendir. Yani char türden bir göstericiyi gösteren göstericiye atanabilir:
char **ppc;
ppc = s;
Örneğin biz bir gösterici dizini bir fonksiyona geçirmek istesek fonksiyonun parametre değişkeni göstericiyi
gösteren gösterici olmalıdır. Örneğin:
#include <stdio.h>
void disp_names(char **ppnames);
int main(void)
{
char *names[] = { "ali", "veli", "selami", "ayse", "fatma", NULL };
disp_names(names);
return 0;
}

266

void disp_names(char **ppnames)
{
int i;
for (i = 0; ppnames[i] != NULL; ++i)
printf("%s\n", ppnames[i]);
}

Fonksiyonun göstericiyi gösteren gösterici parametresi yine dizi formunda belirtilebilir. Yani örneğin:
void disp_names(char **ppnames)
{
...
}
ile,
void disp_names(char *ppnames[])
{
...
}
aynı anlamdadır. Ya da örneğin:
int main(int argc, char *argv[])
{
...
}
ile,
int main(int argc, char **argv)
{
...
}
aynı anlamdadır.
Bazen fonksiyona bir gösterici bir göstericinin adresi gönderilir. Fonksiyon da o göstericinin içerisine birşeyler
yazabilir. Örneğin:
#include <stdio.h>
#include <stdlib.h>
void mallocstr(char **ptr, size_t size)
{
*ptr = (char *)malloc(size);
if (*ptr == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
}
int main(void)
{

267

char *str;
mallocstr(&str, 32);
gets(str);
puts(str);
return 0;
}

Bir göstericiyi gösteren göstericiyi 1 artırdığımızda içindeki adresin sayısal değeri kaç artar? Yanıt bir gösterici
kadar artar. Örneğin argv char ** türünden olsun. ++argv yaptığımızda argv'nin içerisindeki adres bir gösterici
(yani 32 bit sistemlerde 4 byte, 64 bit sistemlerde 8 byte) artacaktır. Örneğin:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
while (*argv != NULL)
puts(*argv++);
return 0;
}

Bilindiği gibi C'de void * türünden bir göstericiye biz her türden adresi atayabiliriz. Ancak void ** türünden
göstericiye her adresi atayamayız. Yalnızca void * türünden göstericinin adresini atayabiliriz. Örneğin:
int a;
int *pi;
void *pv;
void **ppv;
pi = &a;
pv = pi;
ppv = &pv;
ppv = &pi;

/* geçerli */
/* geçerli */
/* geçerli */
/* geçersiz! */

int * türünün void * türüne atanması normal ve geçerlidir. Ancak bu int ** türünün void ** türüne atanabileceği
anlamına gelmez. void ** türüne biz yalnızca void ** türünden bir adresi atayabiliriz. Biz aslında int ** türünü de
istersek void * türünden bir göstericiye atayabiliriz. Örneğin:
int a;
int *pi;
int **ppi;
void *pv;
int **ppi2;
pi = &a;
ppi = &pi;
pv = ppi;
ppi2 = (int **) pv;

/* geçerli */
/* geçerli */
/* geçerli */
/* tür dönüştürmesi zorunluı değildir */

Gösterici dizileri için dinamik tahsisatlar yapabiliriz. Örneğin önce 5 elemanlı char türden bir gösterici dizisini
dinamik olarak tahsis edelim. Sonra da dizinin her elemanının 32 byte'lık char türden dinamik tahsis edilmiş bir
diziyi göstermesini sağlayalım:
268

char **ppc;
int i;
if ((ppc = (char **)malloc(5 * sizeof(char *))) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < 5; ++i)
if ((ppc[i] = (char *)malloc(32)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
...
for (i = 0; i < 5; +i)
free(ppc[i]);
free(ppc);
Soru: Yukarıdaki tahsisat sistemini tek malloc ile oluşturunuz. Böylece tek free ile sistem serbest bırakılsın.
Yanıt: Sistem için gereken tüm bellek 5 * sizeof(char *) + 5 * 32 byte kadardır. Önce bu tahsis edilir. Sonra da
gösterici dizisinin elemanlarının kendi alanlarını göstermesi sağlanır:
char **ppc;
char *pc;
int i;
if ((ppc = (char **)malloc(5 * (sizeof(char *) + 32))) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
pc = (char *)(ppc + 5);
for (i = 0; i < 5; ++i) {
ppc[i] = pc;
pc += 32;
}
...
free(ppc);

269

Tabi böyle bir sistemde 32 byte'lık diziler daha sonra realloc ile büyütülü küçültülemezler.
C'de aslında göstericiyi gösteren göstericiyi gösteren göstericiler ve daha çok kademeli göstericiler de bildirilebilir.
Ancak üç yıldızlı göstericilerin bile pek bir kullanım alanı yoktur. Biz bir göstericiyi gösteren göstericinin adresini
üç yıldızlı bir göstericiye yerleştirebiliriz. Örneğin:
int a = 10;
int *pi;
int **ppi;
int ***pppi;
int ****ppppi;
pi = &a;
ppi = &pi;
pppi = &ppi;
ppppi = &pppi;
Çok Boyutlu Diziler
Çok boyutlu dizler bazı olayları temsil ederken okunabilirliği artırmak için kullanılabilmektedir. Örneğin bir
satranç tahtasını temsil etmek için iki boyutlu bir dizi kullanabiliriz. Bir matematiksel bir matrisi temsil etmek için
yine iki boyutlu bir diziden faydalanabiliriz. Dizilerin boyut sayıları fazla olabilse de pratikte en çok kullanılan çok
boyutlu diziler iki boyutlu dizilerdir. İki boyutlu dizilere matris de denilmektedir.
C'de çok boyutlu diziler aslında bellekte tek boyutlu diziymiş gibi tutulmaktadır. Zaten bellek çok boyutlu değildir.
Tek boyutludur. Çok boyutlu diziler aslında "dizi dizileri" gibi düşünülmelidir. Örneğin 4x3'lik bir matris aslında
her elemanı 3 elemanlık dizi olan 4'lik dizi gibidir. C'de çok boyutlu diziler birden fazla köşeli parantezle
bildirilirler. Örneğin:

270

Bildirimdeki ilk köşeli parantez dizi dizisinin uzunluğunu, ikinci köşeli parantez eleman olan dizilerin uzunluğunu
belirtir. Örneğin:

Çok boyutlu bir diziye birden fazla küme paranteziyle ilkdeğer verilebilir. Örneğin:
int a[4][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
Örneğin:
#include <stdio.h>
int main(void)
{
int a[4][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }, { 10, 11, 12 } };
int i, k;
for (i = 0; i < 4; ++i) {
for (k = 0; k < 3; ++k)
printf("%d ", a[i][k]);
printf("\n");
}
return 0;
}

Aslında iç küme parantezleri ayrıca kullanılmak zorunda değildir. Örneğin:
int a[4][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

Fakat bir elemanın yazılması unutulduğunda diğer elemanlar birer kayabilir. Bu nedenle iç küme parantezlerinin
belirtilmesi tavsiye edilir.
Biz matriste erişim için yalnızca ilk köşeli parantezi kullanırsak (örneğin a[2] gibi) bu ifade bir nesne belirtmez.
Dizi dizisinin o indise ilişkin dizisinin başlangıç adresini belirtir. Örneğin:

271

Örneğin:
#include <stdio.h>
int main(void)
{
int a[4][3];
int *pi;
pi = a[2];
pi[0] = 10;
pi[1] = 20;
pi[2] = 30;

/* geçerli */
/* a[2][0] = 10 */
/* a[2][1] = 20 */
/* a[2][1] = 30 */

printf("%d, %d, %d\n", a[2][0], a[2][1], a[2][2]);
return 0;
}

Bir matrisin yani dizisinin ismi yine o dizi dizisinin başlangıç adresini belirtir. Bir dizi dizisinin başlangıç adresi
dizi göstericisine atanabilir. Gösterdiği yer bir dizi olan göstericiye dizi göstericisi (pointer to array) denir. Dizi
göstericileri şöyle bildirilir:
<tür> (*<gösterici_ismi>)[<sütun uzunluğu>];
Örneğin:
int (*pa)[4];
Burada pa'nın gösterdiği yerde (yani *pa) int[4] türünden bir nesne başka bir dyişle 4 elemanlı bir dizi vardır. *pa
bir nesne değildir, sanki bir dizinin ismi gibidir. İşte int[N][M] türünden bir matrisin ismi böyle bir göstericiye
atanabilir. Örneğin:

272

Aşağıdaki gibi bir matris bildirimi yapılmış olsun:
int a[4][3];
Burada a'yı ve a[i]'yi atayacağımız göstericiler nasıl olmalıdır?

Aşağıdaki gibi bir dizi göstericisi bildirilmiş olsun:
int (*pa)[3];
Burada pa'yı bir artırdığımızda pa'nın içerisindeki adres 3 * sizoef(int) kadar artar.
Bir matirisin ismini atayacağımız dizi göstericisinin sütun uzunluğuyla matrisin sütun uzunluğu aynı olmak
zorundadır. Örneğin:

İkiden fazla boyut söz konusu oılduğunda aynı prensip söz konusudur. Örneğin:
int a[3][4][5];
Burada a "dizi dizisi dizisidir". a adresini atayacağımız dizi göstericisi de iki köşeli parantez içermelidir:
int (*pa)[4][5];
pa = a;
273

Yani birinci boyut dışındaki bütün boyutların uzunlukları belirtilmek zorundadır. Burada *pa nesne değildir.
pa[i][k]'da nesne değildir. Ancak pa[i][k][j] bir nesnedir. Pekiyi a[i]'yi atayacağımız gösterici nasıl olmalıdır? Yanit:
int (*pa)[5];
biçiminde olmalıdır. Çünkü a[i] bir matrisin adresi gibidir. O da yukarıdaki gibi bir göstericiye atanabilir.
Pekiyi bir matrisi fonksiyona parametre olarak nasıl geçirebiliriz:
#include <stdio.h>
void disp(int(*pa)[3], int size)
{
int i, k;
for (i = 0; i < size; ++i) {
for (k = 0; k < 3; ++k)
printf("%d ", pa[i][k]);
printf("\n");
}
}
int main(void)
{
int a[4][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }, { 10, 11, 12 } };
disp(a, 4);
return 0;
}

Göstericiyi Gösteren Göstericiler ve Matrisler
Matrisel bir sistem oluşturabilmek için iki seçenek söz konusu olabilir:
1) Önce göstericiyi gösteren gösterici için sonra da onun elemanı olan göstericiler için tahsisat yapmak. Örneğin:
int **ppi;
int i;
ppi = (int **)malloc(4 * sizeof(int *));
for (i = 0; i < 4; ++i)
ppi[i] = (int *) malloc(3 * sizeof(int));

2) Doğrudan çok boyutlu bir dizi kullanmak.
274

int ppi[4][3];

Şüphesiz ikinci biçim bellekte daha az yer kaplamaktadır. Ancak birinci biçimde matrisin her satırı aynı uzunlukta
olmak zorunda değildir.
Bir matris için dinamik tahisat yapılabilir. Örneğin:
int(*pa)[3];
pa = (int(*)[3])malloc(4 * 3 * sizeof(int));

Tabii typedef bildirimi ile türler daha sade gösterilebilir. Örneğin:
typedef int(*PA3)[3];
PA3 pa;
pa = (PA3)malloc(4 * 3 * sizeof(int));

Makrolar
#define önişlemci komutunun parametrik kullanımına makro denilmektedir. Makro yazılırken #define komutunda
STR1 yazısı parantez içerir. Parantez içerisindekiler makro parametrelerini belirtir. Makro parametreliyse biz onu
kullanırken sanki bir fonksiyon gibi argüman gireriz. Örneğin:

Burada square(10) ifadesini önişlemci 10 * 10 biçiminde açmaktadır. a makro parametresidir.
#include <stdio.h>
#define square(a)

a * a

int main(void)
{
int result;
result = square(10);

275

printf("%d\n", result);
return 0;
}

Örneğin:
#include <stdio.h>
#define square(a)

a * a

int main(void)
{
int result;
int x = 10;
result = square(x);
/* result = x * x */
printf("%d\n", result);
return 0;
}

Bir makro fonksiyon gibi işlev görmelidir. Kodu inceleyen kişi onun bir fonksiyon mu yoksa makro mu olduğunu
anlamak zorunda kalmamalıdır. Oysa yukarıdaki square tam olarak bir fonksiyon gibi kullanılamaz. Örneğin:

Burada önişlemci 5 - 2 ifadesini a kabul edip bunu 5 - 2 * 5 - 2 biçiminde açar. Buradaki problemi ortadan
kaldırmak için makro parametreleri paranteze alınmalı ve makro en dıştan ayrıca paranteze alınmalıdır. Örneğin:
#define square(a)

((a) * (a))

Şimdi artık square tam olarak b ir fonksiyon etkisi yaratır. En dıştan paranteze alınmasının nedeni yüksek öncelikli
opetaörlerden tüm ifadenin etkilenmesini sağlamaktır. Örneğin:
#include <stdio.h>
#define max(a, b)

((a) > (b) ? (a) : (b))

int main(void)
{
int a = 3, b = 4, c;
c = max(a, b);
/* c = ((a) > (b) ? (a) : (b)) */
printf("%d\n", c);
return 0;
}

Örneğin:
#include <stdio.h>
#define beep() putchar('\7');
int main(void)
{

276

beep();
beep();
return 0;
}

Makro daha karmaşık olabilir. Bu durumda birden fazla satıra yazmak okunabiliği artırır. Anımsanacağı gibi \
karakterini hemen ENTER (LF) izlerse derleyici onun aşağısındaki satırı aynı satır gibi kabul eder. Örneğin:
#include <stdio.h>
#include <stdlib.h>
#define check(a)

if ((a) == 0) {
\
fprintf(stderr, "Error\n");
exit(EXIT_FAILURE);
\
}

\

int main(void)
{
int a = 0;
check(a);
return 0;
}

Ancak çok satırlı ve deyim içeren makrolar yazılırken dikkat edilmelidir. Yukarıdaki check(a); işlemi aslında
önişlemci tarafından şöyle açılır:
if ((a) == 0) {
fprintf(stderr, "Error\n");
exit(EXIT_FAILURE);
};

Buradaki son noktalı virgül check çağrısının sonundaki noltalı virgüldür. Gerçi bu noktalı virgül derleme modülü
tarafından boş deyim kabul edileceğinden çoğu kez soruna yol açmaz. Fakat aşağıdaki gibi bir kullanımda soruna
yol açacaktır:

Bu nedenle çok satırlı makroların sanki do-while deyimiymiş gibi yazılması gerekmektedir. Örneğin:

277

Artık if içerisinde çağrılan makro şöyle açılacaktır:

Böylece check fonksiyonun sonundaki noktalı virgül do-while'ın noktaı virgülü olur, boş deyim olmaz.
Bazı makroları çağırırken ++ ve -- operatörlerinin argümanlarda kullanılmaması gerekir. Örneğin:
#define square(a)

((a) * (a))

Biz böyle bir makroyu aşağıdaki gibi çağırmış olalım:
int x = 3, y;
y = square(++x);
Burada square bir fonksiyon olsaydı hiçbir sorun ortaya çıkmazdı. Ancak makro olarak yazıldığında aynı ifadede
birden fazla ++x gözüküyor olur. Böyle bir kod derleyici için tanımsız davranışa yol açacaktır.
Makro mu Fonksiyon mu?
Bir fonksiyonun çağrılması sırasında küçük bir maliyet söz konusudur. Bu maliyeti oluşturan etkenler şunlardır:
- Fonksiyon çağrılırken kullanılan CALLve RET makina komutları
- Fonksiyona girişte ve çıkışta gereken bazı makina komutları (örneğin stack frame düzüenlemesi için gereken
komutlar).
- Parametrelerin aktarımı için gereken makina komutları
Yukarıdaki makina komutları ortalama 10 civarındadır. Oysa bazen birer satırlık fonksiyonlar yazmak isteyebiliriz.
Örneğin:
double square(double a)
{
return a * a;
}
İşte bir iki satırlık küçük fonksiyonların fonksiyon olarak yazılması onların çağrılması sırasında göreli (çoğu zaman
bunun hiçbir önemi yoktur) zaman kaybına yol açabilmektedir. Bu tür fonksiyonların fonksiyon olarak değil de
makro olarak organize edilmesi uygun olur. Büyük kodların makro olarak tanımlanması kodu ciddi biçimde
büyütebilmektedir. O halde çok küçük fonksiyonlar makro olarak diğerleri normal fonksiyon olarak yazılabilirler.
278

Şüphesiz makrolar başlık dosyalarına yerleştirilmelidir. Onları çağıracak kişi onların fonksiyon mu makro mu
olduğunu bilmek zorunda değildir. Örneğin getchar fonksiyonu bazı derleyicilerde makro olarak yazılmıştır.
#define getchar() fgetc(stdin)
Diğer Önişlemci Komutları
Biz şimdiye kadar #include ve #define komutlarını gördük. Bu bölümde diğer önemli bazı önişlemci komutları
görülecektir.
#if, #else, #elif ve #endif Komutu
#if önişlemci komutunun yanında tamsayı türlerine ilişkin bir sabit ifadesi bulunmak zorundadır. Örneğin:
#if MAX > 10
....
#else
...
#endif
Önişlemci #if komutunun yanındaki ifadenin sayısal değerini hesaplar. Bu değer sıfır dışı bir değerse #else'e kadar
kısım derleme modülüne verilir, sıfır ise #else ile #endif arasındaki kısım derleme modülüne verilir.
#include <stdio.h>
#include <stdlib.h>
#define SIZE 10000
int main(void)
{
#if SIZE < 1000
int a[SIZE];
#else
int *a;
if ((a = (int *)malloc(SIZE * sizeof(int))) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
#endif
...
return 0;
}

Burada SIZE değeri 1000'den küçükse dizi normal olarak büyükse dinamik olarak tahsis edilmiştir. Komutta #else
kısmı olmak zorunda değildir.
#if komutu bir önişlemci komutu olduğuna göre işleme sokulması derleme modülünden önce yapılır. #elif komutu
#else #if etkisi yaratır ancak bu durumda tek bir #endif yetmektedir. Örneğin:
#define SYSTEM 2
#if SYSTEM == 1
/* ... */
#elif SYSTEM == 2
/* ... */
#elif SYSTEM == 3
/* ... */

279

#endif

#ifdef, #else, #endif Komutu
#ifdef komutunu bir değişken ismi izlemek zorundadır. Bu değişken ismi bir sembolik sabit ya da makro ismidir.
Önişlemci böyle bir sembolik sabitin ya da makronun daha önce #define komutu ile define edilip edilmediğine
bakar. (Ancak onun kaç olarak define edildiğine bakmaz). Eğer o sembolik sabit ya da makro daha yukarıda define
edilmişse önişlemci #else'e kadar olan kısmı derleme modülüne verir, define edilmemişse #else ile #endif
arasındaki kısmı derleme modülüne verir. Örneğin:
#include <stdio.h>
#define TEST
int main(void)
{
#ifdef TEST
printf("TEST define edilmis!\n");
#else
printf("TEST define edilmemis!\n");
#endif
return 0;
}

C derleyicileri bir sembolik sabiti derleme sırasında define edebilme olanacağını vermiştir. Örneğin gcc ve cl
derleyicilerinde -D seçeneği ile bu yapılabilmektedir:
gcc -o sample -D TEST sample.c
Visual Studio IDE'sinde aynı etki proje seçeneklerinde "C-C++/Preprocessor/Preprocessor Definitions" menüsüyle
yapılabilmektedir.
#ifdef çeşitli platformlar için farklı kodların derleme dahil edilmesi amacıyla çok sık kullanılır. Örneğin:
#ifdef UNIX
....
#else
...
#endif

Komutta #else kısmı olmak zorunda değildir.
#ifndef, #else, #endif Komutu
Bu komut #ifdef komutunun tam tersi işlem görmektedir. Yani yanındaki sembolik sabit ya da makro define
edilmemişse #else'e kadar olan kısım #define edilmişse #else ile #endif arasındaki kısım derleme modülüne verilir.
#ifndef include korumalarında (include guards) çok sık kullanılmaktadır. Aynı başlık dosyasının ikinci include
edilmesi pek çok derleme hatasının oluşmasına yol açabilir. (Örneğin aynı yapının iki kez bildirilmesi, aynu
enum'un ikinci kez bildirilmesi, aynı typedef bildiriminin ikinci kez yapılması geçersizdir.) Bazen kontrolümüz
dışında aynı dosyanın birden fazla kez include edilme durumu oluşabilmektedir. Örneğin a.h dosyası ve b.h
dosyaları kendi içerisinde x.h dosyasnı include etmiş olsun. Biz de bir uygulamada mecburen a.h ve b.h dosyalarını
include edersek x.h dosyası iki kez include edilmiş olur. Büyük projelerde bu olasılık çok fazladır. include
koruması şöyle oluşturulur:
/* x.h dosyası */
280

#ifndef X_H_
#define X_H_
...
...
...
#endif
Burada önişlemci x.h dosyasını ilk kez açtığında X_H_ sembolik sabiti henüz define edilmediği için #endif'e kadar
kısmı yani bütün dosya içeriğini derleme modülüne verir. İkinci kez aynı dosyayı açtığında artık X_H_ sembolik
sabiti define edilmiş olacağı için artık dosya içeriğini derleme modülüne vermez. Bu örnekteki X_H_ makro ismi
dosya isminden hareketle uydurulmuş herhangi bir isimdir. Tüm include dosyaları böyle bir koruma ile
oluşturulmalıdır (çünkü onların her zaman dolaylı olarak birden fazla kez include edilmesi mümkün
olabilmektedir.)
#error Komutu
#error komutu önişlemci tarafından derlem işlemini fatal error ile sonlandırır. Komutun yanında bir yazı bulunur.
Bu yazı ekrana hata mesajı olarak yazdırılır (Yazının iki tırnak içerisinde olması gerekmez.) Örneğin:
#include <stdio.h>
#ifndef LINUX
#error this program only compiles in Linux
#endif
int main(void)
{
return 0;
}

#pragma Komutu
#pragma komutu standart bir önişlemci komutudur. #pragma anahtar sözcüğünü başka bir komut sözcüğü izler. Bu
komut sözcüğü standart değildir. Yani #pragma komutu standarttır ancak onun yanındaki komut sözcüğü
derleyiciden derleyiciye değişebilmektedir. Her derleyicinin pragma komutları diğerinden farklı olabilir. Prgama
komutları belli bir derleyiciye özgü işlemlerin yaptırılması için kullanılır. Örneğin:
#include <stdio.h>
#pragma pack(1)
struct SAMPLE {
char a;
int b;
char c;
int d;
};
#pragma pack()
int main(void)
{
struct SAMPLE s;

281

printf("%u\n", sizeof(s));
return 0;
}

Burada pack pragma komutu her derleycide olmak zorunda değildir. Microsoft derleyicilerinde ve gcc
derleyicilerinde bu komut hizalama sağlamak için kullanılabilir.
Derleyicilerin pragma komutlarının listesi onların referans dokümanlarından öğrenilebilir.
## (Token Pasting) Önişlemci Operatörü
Bu önişlemci komutu iki yazıyı birleştirmek için kullanılır. Örneğin:
#define Name(x, y)

x##y

struct Name(CSD, Sample) {
...
};
Önişlemci bu yapı bildirimini şöyle açar:
struct CSDSample {
...
};
Örneğin:
#include <stdio.h>
#define Name(x) CSD##x
int main(void)
{
int Name(x), Name(y);
CSDx = 10;
CSDy = 20;
printf("%d, %d\n", CSDx, CSDy);
return 0;
}

C'nin Önceden Tanımlanmış Sembolik Sabitleri ve Makroları
C önişlemcisi bazı sembolik sabit ve makro isimlerini hiç define edilmediği halde define edilmiş gibi kabul
etmektedir. Bunlara önceden tanımlanmış (predefined) sembolik sabitler ve makrolar denir. Bunların hepsinin
başında ve sonun iki alt tire vardır.
__FILE__: Önişlemci bu sembolik sabiti gördüğünde bunun yerine iki tırnak içerisinde bunun bulunduğu kaynak
dosyanın ismini yerleştirir. Örneğin:
#include <stdio.h>
#include <stdlib.h>
int foo(void)
{

282

return 0;
}
int main(void)
{
if (!foo()) {
fprintf(stderr, "Error in file: %s\n", __FILE__);
exit(EXIT_FAILURE);
}
return 0;
}

__LINE__: Önişlemci bu sembolik sabiti gördüğünde bu sembolik sabit hangi satıra yerleştirilmişse onun satır
numarasını yazar (iki tırnak içerisinde değil). Örneğin:
#include <stdio.h>
#include <stdlib.h>
int foo(void)
{
return 0;
}
int main(void)
{
if (!foo()) {
fprintf(stderr, "Error in file: %s\n in line %d\n", __FILE__, __LINE__);
exit(EXIT_FAILURE);
}
return 0;
}

__DATE__ ve __TIME__: Önişlemci bu makrolar yerine iki tırnak içerisinde derleme işleminin yapıldığı tarihi ve
zamanı yerleştirir.
__STDC__: Bu makro eğer standart C derleyicisinde çalışılıyorsa define edilmiş kabul edilir, değilse define
edilmemiş kabul edilir. Örneğin:
#ifndef __STDC__
error this program cannot compile with non standard C compiler
#endif
Yukarıdaki önceden tanımlanmış sembolik sabitlerin dışında derleyicilerin kendilerine özgü önceden tanımlanmış
başka sembolik sabitleri ve makroları da vardır. Örneğin _WIN32 ve _WIN64 sembolik sabitleri Microsoft C
derleyicilerine özgüdür:
#ifndef _WIN64
#error this program can only compile in Windows 64 platform
#endif

283

284


