Ders1: Giriş
Dersin bu kısmında C programlama dilinin basit yapısı temel örneklerle anlatılmıştır. Gerekli olan bilgiler sade bir şekilde verilmiştir. Ayrıntılar ise bu dersin sahasının dışındadır. Eğer C dışında herhangi bir programlama dili biliyorsanız, bu kısımda anlatılan kısımları daha hızlı bir şekilde kavrayabilirsiniz. Eğer C dilini orta seviyede biliyorsanız bu kısmı atlayabailirsiniz.
C
C Programlama Dili genel amaçlı orta seviyeli ve yapısal bir programlama dilidir. 1972 yılında Dennis Ritchie tarafından Bell Telefon Labaraturvarında tasarlanmıştır. C, özellikle sistem programlamada sembolik makine dili(Assembler) ile tercih edilmektedir. İşletim sistemleri, derleyiciler ve debug programları gibi aşağı seviyeli sistem programlarının yazılımında yoğun olarak C programlama dili kullanılır.
Bu dil ilk olarak bir programlama dili olarak düşünülmemişti ve özel bir amacı vardı: UNIX işletim sistemini tasarlamak (UNIX işletim sisteminin 1000 satırlık bölümü C ile yazılmıştır). Günümüzde Nesneye Yönelik programlama dilleri (C++, Java gibi) ve script dilleri (JavaScript, JavaApplet, PHP gibi) gibi programlama dilleri tamamen C tabanlıdır. Kısacası Standart C dilini (ANSI C) ogrenmekle bu dillerin tamamına iyi bir hazırlık yapmış olursunuz. Derlerimizde tamamen ANSI C konu edilmiştir.
Neden C?
- C güçlü ve esnek bir dildir. C ile işletim sistemi yazabilir, kelime işlemciler oluşturabilir veya grafik çizebilirsiniz.
- C taşınabilir bir dildir. Yani herhangi bir C kodu hiçibir değişikliğe uğramadan, veya çok az bir değişimle, başka bir derleyicide derlenebilir. Örneğin, Windows işletim sistemlerinde yazılan bir C kodu, Linux, UNIX veya VAX gibi işletim sistemlerinde de derlenebilir.
- C yapısal bir dildir. C kodları fonksiyon olarak adlandıralan altprogramlardan oluşmuştur.
Kaynak Kodunun Derlenmesi
C kaynak kodları(programları) uzantısı .c olan dosyalarda saklanır ve derlenir. Bazı işletim sistemleri ile kullanılan C Derleyicileri ve bu derleyicilerde ilk.c dosyasının nasıl derlendiği Tablo 1.1 de verilmiştir.
Not: Eğer ismi geçen derleyicinin bir editörü varsa ilk.c bu editör de derlenebilir.
Tablo 1.1 : İşletim sistemleri, bazı derleyiciler ve derleme komutları
| Işletim Sistemi | Derleyici | Komut | Çalıştırma |
| MS-DOS / Windows | Microsoft C | cl ilk.c | ilk.exe |
| Borland Turbo C | tcc ilk.c | ilk.exe | |
| Borland C | bcc ilk.c | ilk.exe | |
| Zortec C | ztc ilk.c | ilk.exe | |
| UNIX | Tabanında var | cc ilk.c | run ilk |
| Linux | Tabanında var | c ilk.c | run ilk |
Borland TurboC-2.01 derleyicisini Buradan indirebilirsiniz.
İlk C Programı
Program 1.1 de verilen C programı derlendikten sonra, ekrana ‘Merhaba Dünya!’ yazacaktır. Satır başlarına yerleştirilen 1:, 2: 3: … rakamlarının yazılmasına gerek yoktur. Bu rakamlar sadece programdan daha sonra program ile ilgili açıklama yapılırken, ilgili satirda bulunan kodlar izah edilirken, kullanılacaktır.
Program 1.1 : Derlendikten sonra ekrana Merhaba Dünya! yazar
1: /* ilk.c programi */
2: #include <stdio.h>
3:
4: main()
5: {
6: printf("Merhaba Dünya!\n");
7: return 0;
8: }
ilk.c nin Borland Turbo C Derleyicisi ile derlenmesi ve çalıştırılması:
Editörde -> Ctrl+F9
MS-DOS komut satırında -> tcc ilk.c [RETURN]
ilk.exe [RETURN]
ilk.c nin çıktısı:
Merhaba Dünya!
ilk.c programı da verien 1. satırda /* ... */ ifadeleri görülmektedir. Bu ifadeler arasında yazılan herhangi bir metin, işlem vb. satırlar, derleyici tarafından işlenmez(görülmez). Yani /* */ ifadeleri açıklama operatörüdür. 2. satırda yazılı olan #include ifadesi, programda eklenecek olan başlık dosyanını işare eder. Bu örnekte verilen başlık dosyası (header file) stdio.h dir. Bu dosya standard giriş çıkış kütüphane dosyasıdır (STandarD-Input-Output). Bu tip dosyaların uzantısı .h dir. Bu dosyalar Başlık Dosyaları kısımlarında daha ayrıntılı olarak incelenecektir. 4. satırdaki main() ve 6. satırdaki printf() birer fonksiyondur. main() özel bir fonksiyondur ve programın yürütülmesine bu programdan başlanır. Dolayısıyla her C programında bir tane main() adlı fonksiyon olmalıdır. printf() ise standart kütüphane bulunan ekrana yazdırma fonksiyondur. stdio.h bu fonksiyon için kullanılmıştır. 7. satırdaki return 0 ifadesi programın sonlandığını göstermek için kullanılır. Çoğu zaman kullanılmasına gerek yoktur.
C Kodlarının Temel Özellikleri
Bir C programı aşağıda verilen özellikleri mutlaka taşımalıdır.
- Her C programı main() fonksiyonunu içermelidir.
- Satırın sonuna ; işareti konmalıdır.
- Her fonksiyonun başlangıcı ve bitişi sırasıyla { ve } sembolleri ile belirlenir.
- C dilinde yazılan kodlarda küçük-büyük harf ayrımı vardır (case sensitive). Örneğin A ile a derleyici tarafından farklı değerlendirilir.
- Açıklama operatörü /* */ sembolleridir.
- Değişken isimleri en fazla 32 karakterden oluşabilir. 32 karakterden uzun değişken isimlerinin ilk 32 karakteri değerlendirilir. Geriye kalan karakterler işleme tabi tutulmaz.
- Değişken adları ingiliz alfabesinde bulunan karakterler (A-Z) veya (a-z) ile yazılmalıdır.
- Değişken adları herhangi bir rakam ile başlayamaz. Ilk karakter bir harf olamalıdır.
- Aşağıda verilen kelimeler C deyimleridir ve değişken ismi olarak kullanılamaz.
auto enum short volatile break extern signed while case float sizeof char for static const goto struct continue if switch default int typedef do long union double register unsigned else return void
Kod Yazımı için Bazı Tavsiyeler
- Program açıklamaları ve döküman hazırlama program yazıldıkça yapın! Bu unutulmaması gereken çok önemli husustur.
- Değişken, sabit ve fonksiyon adları anlamlı kelimelerden seçilip yeterince uzun olmalıdır. Eğer bu isimler bir kaç kelimeden oluşacak ise, kelimeler alt çizgi ( _ ) ile ayrılmalıdır veya her kelime büyük harfle başlamalıdır. Örneğin:
int son_alinan_bit; void KesmeSayisi(); float OrtalamaDeger = 12.7786;
- Sabitlerin bütün harflerini büyük harfle yazın. Örneğin:
#define PI = 3.14; int STATUS 0x0379;
- Her alt yapıya girerken TAB tuşunu kullanın. Bu okunabilirliği arrtıracaktır. Örneğin:
for(i=0;i<10;i++) { for(j=0;j<i;j+=2) { do{ k = i+j; }while(k!=0); } } - Aritmetik operatörler ve atama operatörlerinden önce ve sonra boşluk karakteri kullanın. Bu, yazılan matematiksel ifadelerin daha iyi anlaşılmasını sağlayacaktır.Örneğin:
Hmax = pow(Vo,2) / (2*g); Tf = 2*Vo/g; Vy = Vo - g*t; y = Vo*t - (g*t*t)/2.0; z = ( a*cos(x) + b*sin(x) )*acos(y);
- Program bittikten sonra tekrar tekrar programınızı inceleyerek, programınızı daha iyi şekilde yazma yollarını arayın ve aynı fonksiyonları daha kısa algoritmalarla ve daha modüler şekilde elde etmeye çalışın. Programınızın anlaşılması için elinizden ne geliyorsa yapın. Bilginizi ve eserinizi başkalarına en iyi şekilde aktarın.
Ders2: Değişkenler ve Sabitler
Değişkenler bellekte bilginin saklandığı gözlere verilen sembolik adlardır. Her değişkenin tuttuğu değerin nasıl bir veri olduğunu gösteren bir tipi vardır. C dilinde temelde birkaç tane değişken tipi vardır. Bunlar Tablo 2.1 te listelenmiştir.
Tablo 2.1 : Değişken tipleri ve bellekte kapladıkları alanlar
| Değişken tipi | Açıklama | Bellekte işgal ettiği boyut (byte) |
| char | tek bir karakter için | 1 |
| int | tamsayı için | 2 yada 4 |
| float | tek duyarlı gerçel sayı için (6 basamak hassasiyet) | 2 yada 4 |
| double | çift duyarlı gerçel sayı için (12 basamak hassasiyet) | 4 yada 8 |
Fakat bazı özel niteleyiciler vardır ki bunlar yukarıdaki temel tiplerin önüne gelerek onların türevlerini oluşturur. Bunlar short, long, unsigned dır. Bu niteleyiciler sayesinde değişkenin bellekte kaplayacağı alan isteğe göre değiştirilebilir. Kısa (short), uzun (long), ve normal (int) tamsayı arasında yalnızca uzunluk farkı vardır. Eğer normal tamsayı 16 bit (2 byte) ise uzun tamsayı 32 bit uzunluğundadır. Kısa tamsayı 16 biti geçmeyecek uzunluktadır. Değişken tiplerinin bellekte kapladığı alan sizeof operatörü ile öğrenilebilir. Program 2.1 bu amaçla yazılmıştır.
Program 2.1 : Değişken tipleri ve türevlerinin bellekte kapladıkları alanlar
1: /* sizeof operatörünün kullanımı */
2: #include <stdio.h>
3:
4: main()
5: {
6: printf( "\nchar : %d byte", sizeof( char ));
7: printf( "\nint : %d byte", sizeof( int ));
8: printf( "\nshort : %d byte", sizeof( short ));
9: printf( "\nlong : %d byte", sizeof( long ));
10: printf( "\nunsigned char : %d byte", sizeof( unsigned char ));
11: printf( "\nunsigned int : %d byte", sizeof( unsigned int ));
12: printf( "\nunsigned short : %d byte", sizeof( unsigned short ));
13: printf( "\nunsigned long : %d byte", sizeof( unsigned long ));
14: printf( "\nfloat : %d byte", sizeof( float ));
15: printf( "\ndouble : %d byte", sizeof( double ));
16: printf( "\nlong double : %d byte", sizeof( long double ));
17:
18: return 0;
19: }
Değişkenler ve Sabitlerin Bildirimi
Değişkenler ve Sabitler programın başında bulunmalıdır. Bazı uygulamalarda değişkenin bir başlangıç değerinin olması istenir. Böyle durumlarda değişken bildirilirken başlangıç değeri verilebilir. Örneğin:
char isim='X', z;
int sayi=0, n=10;
float toplam=0.0, sonuc=22.14;
Sabit bildirimi, başlangıç değeri verilen değişken bildirimi gibi yapılır. Ancak; veri tipinin önüne const anahtar sözcüğü koyulmalıdır. Örneğin:
const float PI = 3.142857;
const double NOT= 12345.8596235489;
const int EOF= -1;
const char[] = "devam etmek için bir tuşa basın...";
gibi sabit bildirimleri geçerli olup bunların içerikleri program boyunca değiştirilemez. Yalnızca kullanılabilir. Genellikle, sabit olarak bildirilen değişken isimleri büyük harflerle, diğer değişken isimlerinin ise küçük harflerle yazılması(gösterilmesi) C programcıları tarafından geleneksel hale getirilmiştir.
Birçok C programında sabitler #define önişlemci komutu ile de tanımlandığını görebilirsiniz. Bu komutla sabit bildirimi, bir program parçasına ve makro fonksiyon tanımlaması yapılabilir. Bir program geliştirilirken simgesel sabitlerin kullanılması programın okunurluğunu arttır ve bazen gerekli de olabilir. Aşağıda verilen simgesel sabit bildirimleri geçerlidir. #define önişlemcisi ile makro fonksiyon tanımlama işlemi Fonksiyonlar bölümünde anlatılacaktır.
#define MAX 100 #define DATA 0x0378 #define YARICAP 14.22
Değişken Bildirim Yerleri ve Türleri
Yerel(local) Bildirim
Yerel değişkenler kullanıldığı fonksiyon içerisinde bildirilir. Yalnızca bildirildiği fonksiyon içerisinde tanınır ve kullanılabilir.
int topla(int a,int b) { /* yerel (local) değişken c nin bildirimi */ int c; c = a + b; return c; }Genel(general) Bildirim
Genel değişkenler bütün fonksiyonların dışında bildirilir. Bir değişken program boyunca sürekli olarak kullanılıyorsa genel olarak bildirilmelidir.
#include <stdio.h> void karesi(); /* ** m ve n global tip değişkendir. ** bu iki değişken tüm program boyunca kullanılmaktadır */ int m,n; main(){ m=7; karesi(); printf("%d nin karesi %d dir",m,n); } void karesi() { n = m*m; }
Tip Dönüşümleri
Bir formül içerisinde bir çok değişken veya sabit olabilir. Bu değişken ve sabitler birbirinden farklı tipte olursa, hesap sonucunun hangi tipte olacağı önemlidir. Bir bağıntıda ,çeriği dönüşüme uğrayan değişkenler eski içeriklerini korurlar. Dönüştürme işlemi için geçiçi bellek alanı kullanılır; dönüştürülen değer kullanıldıktan sonra o alan serbest bırakılır.
char kr; int tam; long int ltam; unsigned int utam; short int stam; float f; double d;
bildirimlerine göre:
bağıntı sonuç tipi ------- ---------- kr+5 int kr+5.0 double d+tam double f+d-2 double utam-tam unsigned ltam*tam long tam/2 int tam/2.0 double
bir değişkenin sabit değerin veya bağıntının önüne tür (cast) yazılarak sonucun hangi tip çıkması istendiği söylenebilir. Genel yazım biçimi:
(tür tipi) bağıntı;
örneğin x int, a ve b float tipinde iki değişken olsun:
int x=3;
float a,b;
...
a = x/2;
b = (float) x/2;
işleminin sonucunda a değişkenine 1.0, b değişkenine 1.5 değeri aktarılır. yani x/2 ile x/2.0 aynı anlamda değildir.
Ders3: Operatörler
Operatörler, değişkenler veya sabitler üzerinde matematiksel ve karşılaştırma işlemlerini yapan simgelerdir.
Aritmetik Operatörler
Değişken veya sabitler üzerinde temel aritmetik işlemleri gerçekleyen operatörlerdir. Bunlar Tablo 3.1 de listelenmiştir.
Tablo 3.1 : Aritmetik Operatörler
| Operator | Açıklama | Ornek | Anlami |
| + | toplama | x+y | x ve y nin toplamı |
| - | cikarma | x-y | x ve y nin farkı |
| * | carpma | x*y | x ve y nin çarpımı |
| / | bolme | x/y | x ve y nin oranı |
| % | artık bölme | x%y | x/y den kalan sayı |
Atama Operatörleri
Bu operatörler bir değişkene , bir sabit eşitlemek için kullanılır.
Birleşik atama: bazı ifadelerde işlem operatörü ile atama operatörü birlikte kullanılarak, ifadeler daha kısa yazılabilir. Eğer ifade
değişken = değişken [operatör] ifade;
şeklinde ise, daha kısa bir biçimde
değişken [operatör]= ifade;
olarak yazılabilir. Bunlar Tablo 3.2 te listelenmiştir.
Tablo 3.2 : Atama Operatörleri
| Operator | Açıklama | Ornek | Anlamı |
| = | atama | x=7; | x=7; |
| += | ekleyerek atama | x+=3; | x=x+3; |
| -= | eksilterek atama | x-=5; | x=x-5; |
| *= | çarparak atama | x*=4; | x=x*4; |
| /= | bölerek atama | x/=2; | x=x/2; |
| %= | bölüp, kalanını atama | x%=9; | x=x%9; |
| ++ | bir arrtırma | x++; veya ++x; | x=x+1; |
| -- | bir azaltma | x--; veya --x; | x=x-1; |
Karşılaştırma Operatörleri ve Mantıksal Operatörler
Sayısal değerleri veya karakterleri karşılaştırmak için kullanılır. Bunlar Tablo 3.3 de listelenmiştir.
Tablo 3.3 : Karşılaştırma Operatörleri ve Mantıksal Operatörler
| Operator | Açıklama | Ornek | Anlamı |
| > | büyüktür | x>y | x, y den büyük mü? |
| < | küçüktür | x<y | x, y den küçük mü? |
| == | eşittir | x==y | x, y ye eşit mi? |
| >= | büyük-eşittir | x>=y | x, y den büyük yada eşit mi? |
| <= | küçük-eşittir | x<=y | x, y den küçük yada eşit mi? |
| != | eşit değil | x!=y | x, y den farklı mı? |
| && | mantıksal VE | x>2 && x<y | x 2 den büyük VE y den küçük mü? |
| || | mantıksal VEYA | x>2 || x<y | x 2 den büyük VEYA y den küçük mü? |
Bit Düzeyinde Işlem Yapan Operatörler
Sayısal veya karakter değişkenlerin üzerinde bit düzeyinde mantıksal işlem yapan operatörlerdir. Bunlar Tablo 3.4 te listelenmiştir.
Tablo 3.4 : Bit düzeyinde işlem yapan operatörler
| Operator | Açıklama | Ornek | Sonucu |
| & | ve | 10 & 25 (00001010 & 00011001) | 8 (00001000) |
| | | veya | 10 | 25 (00001010 | 00011001) | 27 (00011011) |
| ^ | özel veya | 10 ^ 25 (00001010 ^ 00011001) | 19 (00010011) |
| ~ | değil | ~10 (00001010) | 245 (11110101) |
| >> | sağa kaydırma | 12 >> 3 (00001100 >> 3) | 1 (00000001) |
| << | sola kaydırma | 12 << 3 (00001100 << 3) | 96 (01100000) |
Program 3.1 : Aritmetik ve atama operatörlerinin kullanımı
1: /* Aritmetik ve atama operatörlerinin kullanımı */
2: #include <stdio.h>
3:
4: main()
5: {
6: int x, y; /* yerel değikenlerin bildirimi */
7:
8: x = 1; /* x in başlangıç değeri */
9: y = 3; /* y nin başlangıç değeri */
10:
11: printf(" x = %d ve y = %d,\n olarak veriliyor.", x, y, z);
12:
13: x = x + y;
14: printf("x <- x + y atamsının sonucunda x %d dir\n", x);
15:
16: x = 1; /* x e tekrar 1 değeri atanıyor */
17: x += y;
18: printf("x += y atamasının sonucunda x %d dir\n", x);
19:
20: return 0;
21: }
Ders4: Başlık Dosyaları
C dilinde bir program yazılırken, başlık dosyası (header file) olarak adlandırılan bir takım dosyalar #include önişlemcisi kullanılarak program içine koyulurlar. Çünkü kütüphanelerdeki birçok fonksiyon, başlık dosyaları içindeki bazı bildirimleri kullanırlar. Bu tür dosyaların uzantısı .h dir. Örneğin time.h gibi. ANSI C deki standart başlık dosyaları:
assert.h locale.h stddef.h
ctype.h math.h stdio.h
errno.h setjmp.h stdlib.h
float.h signal.h string.h
limits.h stdarg.h time.h
Bir çok C derleyicisinde yukarıdakilere ek olarak tanımlanmış başlık dosyaları da vardır. Bunlar derleyicinin yardım kısmından veya derleyicinin kullanım kılavuzundan öğrenilebilir.
Örnek Başlık DosyasıBaşlık dosyaları genellikle include dizininin içinde saklanır. Turbo C derleyicisine ait stdio.h başlık dosyasının içeriğini görmek için tıklayın. Başlık dosyaları kullanıcı tarafından da oluşturulabilir. Program 4.1 buna bir örnektir. Bu programda "benimki.h" başlık dosyası programın başına ilave edilmiştir.
/* benimki.h */
int topla(int x,int y){
return (x+y);
}
float ort(int x,int y){
return (x+y)/2.0;
}
"benimk.h" başlık dosyası iki tane fonksiyon içermektedir. Fonksiyon kavramı daha sonra ayrıntılı olarak incelenecektir.
Program 4.1 : Başlık dosyası örneği
1: #include <stdio.h>
2: #include "benimki.h"
3:
4: main()
5: {
6: int x,y,toplam;
7: float ortalama;
8: x = 10;
9: y = 20;
10: toplam = topla(x,y);
11: ortalama = ort(x,y);
12: printf("%d ve %d nin toplamı %d, ortalaması %f dir\n",x,y,toplam,ortalama);
13: }
Program 4.1 in çalışması için, benimki.h ve Program 4.1 aynı klasörün içinde olmalıdır. Aksi takdirde 2. satırdaki ifadede benimki.h dosyasının tam yolu yazılmalıdır.
Ders5: Temel G/Ç Fonksiyonları
Temel giriş/çıkış fonksiyonları kullanılırken stdio.h başlık dosyası programın başına eklenmelidir. Bu fonsiyonlardan en çok kullanılanlar aşağıda verillmiştir. Fakat bunların dışında olan bir kaç fonksiyon daha vardır.
printf() Fonksiyonu
Standart C kütüphanesinin bir parçası olan printf() fonksiyonu, değişkenlerin içeriğini veya bit mesajı ekrana bir düzenle(formatla) standart çıkışa(stdout) yazmak için belki de en çok kullanılan fonksiyondur. Daha önce yazılan örnek programlarda printf() fonksiyonu kullanılmıştı. Şimdi bu fonsiyonun nasıl kullanıldığı açıklanacaktır.
Basit olarak eğer ekrana Hata oluştu!.. şeklinde bir mesaj yazdırmak için, printf fonksiyonu çağırmak ve fonksiyon içinde, çift tırnaklar arasına, bu iletiyi yazmak yeterli olacaktır. Yani:
printf("Hata Oluştu!..");
Çoğu zaman ekrana, programda kullanılan bir değişkenin değeri yazdırılmak istenebilir. Örneğin ekranda bir alt satıra geçerek bir x değişkeninin sayısal değerini ekrana yazdırma işlemini gerçekleştirmek istediğinizi varsayalım. Bu durumda printf() fonksiyonun kullanımı şu şekilde olacaktır:
printf("\nx in değeri %d dir",x);
x=12 için bu işlemin sonucunda ekrana şu ileti çıkacaktır:
x in değeri 12 dir
Bu örnekte printf fonsiyonuna iki parametre aktarılmıştır. Birincisi ekranda gösterilecek ve çift tırnaklar arasına yazılan ifadeler, ikincisi ise ekranda sayısal değeri gösterilmek istenen değişken(x). Ayrıca bir alt satıra geçme işlemi \n ile gerçekleştirilmiştir. Daha genel bir ifade ile printf fonksiyonu iki kısımdan oluşur. Şöyle ki:
printf("karakter dizisi formatı",değişkenler);
Burada, birinci parametre karakter dizisi formatı, değişkenler kısmı ise ikinci parametredir. karakter dizisi formatı üç kısımdan oluşmaktadır:
- Düz metin(literal string): yazdırılmak istenen ileti.
- Konrol karakterleri(escape squence): değişkenlerin ve sabitlerin nasıl yazılacağını belirtmek ve imlecin alt satıra geçirilmesi gibi bazı basit işlemlerin gerçekleştirilmesi için kullanılır. Bu karakterler Tablo 5.1 de listelenmiştir.
- Tip belirleyici(conversion specifier): % işaretinden oluşur(%d gibi). Ekrana yazdırılmak istenen değişkenin tipi, % işaretinden sonra belirtilir (Bkz. Tablo 5.2 ). Yani % işaretinin hemen ardına yazılan bir veya bir kaç karakter, ilgili değişken ve sabitin nasıl yazılacağını düzenleme bilgisidir.
Tablo 5.1 : Kontrol karakterleri
| Karakter | Anlamı |
| \a | Ses üretir(alert) |
| \b | imleci bir sola kaydır(backspace) |
| \f | Sayfa atla. Bir sonraki sayfanın başına geç(formfeed) |
| \n | Bir alt satıra geç(newline) |
| \r | Satır başı yap(carriage return) |
| \t | Yatay TAB(Horizontal TAB) |
| \v | Dikey TAB(vertical TAB) |
| \" | Çift tırnak karakterini ekrana yaz |
| \' | Tek tırnak karakterini ekrana yaz |
| \\ | \ karakterini ekrana yaz |
| %% | % karakterini ekrana yaz |
Tablo 5.2 : Tip karakterleri
| Tip Karakteri | Anlamı | Tip |
| %c | tek bir karakter | char |
| %d | işaretli ondalık tamsayı | int, short |
| %ld | uzun işaretli ondalık tamsayı | long |
| %u | işaretsiz ondalık tamsayı | unsigned int, unsigned short |
| %f | Gerçel sayı | float, double |
| %s | karakter dizisi (string) | char |
| %lu | işaretsiz uzun tamsayı | unsigned long |
Tip karakterlerini kullanarak, not=12, pi=3.14 ve kr='A' değişkenleri printf() fonksiyonu ile ekrana yazdırılmak istensin. Bunun için:
...
int not=12;
float pi=3.14;
char kr='A';
...
printf("Not=%d , pi=%f ve kr=%c dir",not,pi,kr);
...
printf() fonksiyonu ile yazdırabilecek ifadeler için bir sınır yoktur. parametreler herhangi bir C deyimi olabilir. Örneğin x ve nin toplamı söyle yazılabilir:
z = x + y;
printf("%d",z);
Bu ifade şu şekilde de yazılabilir:
z = x + y;
printf("%d",x+y);
printf fonksiyonu kullanımı Program 5.1 te verilmiştir.
Program 5.1 : printf() fonksiyonunun kullanımı
1: /* sayısal değerleri ekrana yazdırmak için printf fonksiyonunun kullanımı */
2: #include <stdio.h>
3:
4: /* global değişken tanımlamaları */
5: int a = 2, b = 10, c = 50;
6: float f = 1.05, g = 25.5, h = -0.1 ,yuzde;
7:
8: main()
9: {
10: printf("\nTAB kullanılmadan yazılan tamsayılar : %d %d %d", a, b, c);
11: printf("\nTAB kullanılarak yazılan tamsayılar : \t%d \t%d \t%d", a, b, c);
12:
13: printf("\nÜç reel sayının tek satırda yazılması : %f\t%f\t%f", f, g, h);
14: printf("\nÜç reel sayının üç satırda yazılması: \n \n\t%f\n\t%f\n\t%f", f, g, h);
15:
16: yuzde = (25/220)*100.0;
17: printf("\n220 ün %%25 i %f dir", yuzde);
18: printf("\n%f/%f işleminin sonucu = %f\n", g, f, g / f);
19:
20: printf("\n program sonunda beep sesi çıkar...\a");
21:
22: return 0;
23: }
TAB kullanılmadan yazılan tamsayılar : 2 10 50
TAB kullanılarak yazılan tamsayılar : 2 10 50
Üç reel sayının tek satırda yazılması : 1.050000 25.500000 -0.100000
Üç reel sayının üç satırda yazılması:
1.050000
25.500000
-0.100000
220 nin %25 i 11.363636 dir
25.500000/1.050000 işleminin sonucu = 24.285715
program sonunda beep sesi çıkar...
Program 5.1 , printf() fonksiyonu ile değişkenlerin ekrana nasıl yazıldığını ve kontrol karakterlerinin kullanımını göstermektedir. 5. ve 6. satırda değişkenler global olarak bildirilmiştir. 10. ve 11. satırlarda üç tamsayının ekrana sırasıyla yanyana TABlı(\t) TABsız olarak yazdırılmıştır. 13. ve 14. satırlarda ise üç reel sayının yan yana ve alt alta kullanımı gösterilmiştir. 17. satırda yüzde değişkenine atanan değerin nasıl yazılacağı görülmektedir. 18. satırda g/f oranının başka bir değişkene aktarılmadan da yazdırılabileceğine dair bir örnektir. Program sonlanmadan önce beep sesinin duyulmasını 20. satırdaki \a kontrol karakteri sağlamıştır.
Bazen bir reel sayı ekrana sadece üç basmak hassasiyetle yazdırılmak istenebilir. Bunun için %f tip karakterinden önce hassasiyet(virgülden öce ve sonra) yazılır. Şöyle ki:
float x = 12.123548;
printf("%f in üç basamak hassasiyetli hali %5.3f dür.",x,x);
12.123548 in üç basamak hassasiyetli hali 12.124 dür.
puts() Fonksiyonu
#include <stdio.h> puts( katar );
katar olarak belirtilen karakter topluluğunu ekrana yazdıktan sonra, imleci alt satıra geçirir. Örneğin:
puts("puts() fonksiyonunun gösterimi!");
şekinde kullanılırsa çıkış şöyle olacaktır.
puts() fonksiyonunun gösterimi!
puts() fonksiyonu Tablo 2.7 de verilen kontrol karakterleri ile kullanılabilir.
puts("Bu birinci satır...\nBu ikinci satır...");
Bu birinci satır...
Bu ikinci satır...
scanf() Fonksiyonu
Birçok programda ekrana verilerin yazılmasının yanı sıra klavyeden veri okunması gerekebilir. scanf() fonksiyonu bu amaçla kullanılan fonksiyondur. printf() gibi scanf() fonksiyonuda Tablo 5.1 ve Tablo 5.2 de verilen karakterleri kullanır. Örneğin klavyeden bir x tamsayısı
scanf("&d",&x);
satırını yazmak yeterli olacaktır. burada & işareti adres operatörü olarak adlandırılır ve Pointerler kısmında ayrıntılı olarak açıklanacaktır. Klavyeden iki farklı sayı okunmak istendiğinde scanf() fonksiyonu şöyle kullanılır:
scanf("%d %f",&x,&y);
veriler
16 1.568
yada
16 1.568
veya
16 1.568
şekilinde okunabilir. Program 5.2 te scanf() fonksiyonunun kullanımı gösterilmiştir.
Program 5.2 : scanf() fonksiyonun kullanımı
1: /* scanf() fonksiyonu ile int, char ve float tipindeki verilerin okunması */
2: #include <stdio.h>
3:
4: main()
5: {
6: int x;
8: float y;
9: char kr;
10:
11: printf("Bir tamsayı girin :");
12: scanf("%d",&x);
13: printf("Bir karakter girin :");
14: scanf("%c",&kr);
15: printf("Bir reel sayı girin :");
16: scanf("%f",&y);
17:
18: printf("tamsayı :%d\nkarakter :%c\nreel sayı :%f olarak girdin.");
19:
20: return 0;
21: }
gets() Fonksiyonu
Klavyeden bir karakter topluluğu, katar, okumak için kullanılır. Okuma işlemi yeni satır karakteriyle karşılaşılıncaya kadar sürer. puts()-gets() arsındaki ilişki, printf()- scanf() arasındaki gibidir. puts() ile ekrana bir katar yazdırılırken, gets() ile okunur. Örneğin:
...
char ktr[10];
puts("Bir şeyler yazın:");
gets(ktr);
...
Yukarıdaki program parçası, klavyeden girilen karakterlerin, gets() fonksiyonu ile ktr katarına aktarmak için kullanılır. ktr[10] şeklindeki kullanım girilen katarın içerisinden ilk 10 karakteri değerlendir manasındadır. Bu kullanım daha sonra açıklanacaktır.
getchar() Fonksiyonu
Standart girişten bir karakter okur. Programı istenen bir yerde durdurup, bir karakter girinceye kadar bekletir.Örneğin:
...
for(i=0;i<10;i++)
{
getchar();
printf("%d\n",i);
}
...
Yukarıdaki program parçası 0-9 arası sayıları sırasıyla ekranda göstermek için kullanılır. Fakat her rakamı yazdırılmadan önce klavyeden herhangi bir karakter girip ENTER tuşuna basılması beklenir. Bu bekleme getchar() fonksiyonu ile gerçekleştirilir.
Ders6: Fonksiyonlar (Altrogram)
C Programlama Dili fonksiyon olarak adlandırılan alt programların birleştirilmesi kavramına dayanır. Bir C programı bir yada daha çok fonksiyonun bir araya gelmesi ile oluşur. C Dilini öğrenmek için ilk önce fonksiyon oluşturmayı ve onların diğerleri ile birlikte kullanılmasını öğrenmek gerekir.Her fonksiyonun bir adı ve fonksiyona gelen değerleri gösteren argumanları(bağımsız değişkenleri) vardır. C dilinde hazırlanan bir fonksiyonun genel yapısı şöyledir:
FonksiyonTipi FonksiyonAdı(arguman listesi)
argumanların tip bildirimleri
{
Yerel değişkenlerin bildirimi
...
fonksiyon içindeki deyimler veya diğer fonksiyonlar
...
}
Örnek fonksiyon : iki tamsayıyı toplayıp sonucu sonuc adlı değişkene aktarır.
/* Bu fonksiyon iki tamsayıyı toplar ve sonucu sonuc değişkenine aktarır */
int tamsayi_topla( int x, int y )
{
int sonuc;
sonuc = x + y;
return sonuc;
}
Yukarıdaki program parçası şu şekilde de yazılabilir:
/* Bu fonksiyon iki tamsayıyı toplar */
int tamsayi_topla( int x, int y )
{
return (x+y);
}
Her iki program parçasında da return (geri dönüş) deyimi kullanılmaktadır. Bu deyim C programlama dilinin anahtar sözcüklerinden biridir ve fonksiyon içerisinde sonucu, kendisini çağıran yere göndemek için kullanılır. Yani tamsay_topla() fonksiyonu herhangi bir programın içerisinde kullanıldığında, fonksiyonun üreteceği sonuç return deyiminden sonra belirtilen değişken veya işlem olacaktır. Örneğin:
...
int toplam;
toplam = tamsayi_topla(1,2);
printf("Toplam = %d dir",toplam);
...
şeklinde kullanılırsa, toplam değişkenine 1+2=3 değeri atanır. Fonksiyon kullanımı Program 6.1 nın üzerinde açıklanmıştır.
Program 6.1 : tamsayi_topla(); fonksiyonunu ile basit bir fonksiyon uygulaması
1: /* iki sayıyı topla ve sonucu ekranda göster */
2: #include <stdio.h>
3:
4: int tamsayi_topla( int x,int y ); /* fonksiyon prototipi */
5:
6: int main()
7: {
8: int toplam;
9: /*
10: fonksiyon çağırılıp, 5 ve 12 değerleri parametre olarak aktarılıyor.
11: tamsayi_topla(5,12) = 5 + 12 değeri toplam değişkenine atanması.
12: */
13: toplam = tamsayi_topla(5,12);
14:
15: printf("5 ve 12 nin toplamı %d dir.\n", toplam);
16
17: return 0;
18: }
19:
20: /* fonksiyon tanımlanması */
21: /* Bu fonksiyon iki tamsayıyı toplar ve sonucu sonuc değişkenine aktarır */
21: int tamsayi_topla( int x, int y )
22: {
23: int sonuc;
24: sonuc = x + y;
25: return sonuc;
26: }
Program 6.1 , basit bir fonksiyonun C programlama dilinde nasıl oluşturulduğunu ve kullanıldığını gösterir. 4. satırda kullanılacak olan fonksiyonun prototipi bildirilmektedir. Geleneksel olarak bütün fonksiyon kodları main() fonksiyonundan sonra bildirilir. (Gerçekte buna gerek yoktur. Fonksiyon bildirimleri main()den önce de tanımlanabilir.) Eğer geleneksel tercih yapılırsa, fonksiyonun adı main()den önce bildirilmelidir. Bu bildirime fonksiyon protipi(fonksiyon örneği) denir. 13. satırda toplam adlı tamsayı değişkenine tamsayi_topla() fonksiyonunun dönüş değeri, x + y değeri, atanır.
Ana programdan, main() fonksiyonundan, isteğe göre birden çok fonksiyon çağırmak mümkündür. Bir fonksiyonun çağırılması demek, o fonksiyonun geri dönüş değerinin ana programda kullanılması demektir. Birden çok fonksiyonun main() tarafından nasıl çağrıldığını temsil eden blok diyagram Şekil 6.1 de gösterilmiştir.
Şekil 6.1 : Ana programdan fonksiyonların çağırılması. Fonksiyonu çağırmak için, fonksiyonun adını yazmak yeterlidir.
Bir fonksiyonun her zaman geri dönüş değerinin olması gerekmez. Böyle fonksiyonların tipi void olarak belirtilmelidir. Bu tip fonksiyonlar başka bir yerde kullanılırken, herhangi bir değişkene atanması söz konusu değildir, çünkü geri dönüş değeri yoktur. Fakat void fonksiyonlara parametre aktarımı yapmak mümkündür. Örneğin Program 6.1 da kullanılan tamsayi_topla(): fonksiyonu void olarak şöyle bilidirilir:
/* x,y,z global değişken olmalıdır !... */
void tamsayi_topla( int x,int y,int z )
{
z = x + y;
}
Bu fonksiyon başka bir fonksiyonun içinde kullanılacaksa sadece isminin yazılması yeterli olacaktır. Mesela main() fonksiyonunda kullanmak istenirse:
main()
{
...
tamsayi_topla(5,12,z);
printf("5 ile 12 nin toplamı %d dir",z);
...
}
şeklinde olacaktır. Program 6.2 'de, ne parametresi ne de geri dönüş değerine sahip tipi void olan mesaj_yaz() fonksiyonu ile, ekrana basit bir mesajın, fonksiyon kullanarak, çıkarılması gösterilmiştir.
Program 6.2 : mesaj_yaz() fonksiyonunu ile ekrana mesaj verme
1: /* void mesaj_yaz() ile ekrana mesaj yazar */
2: #include <stdio.h>
3:
4: void mesaj_yaz(void); /* fonksiyon prototipi */
5:
6: main()
7: {
8: mesaj_yaz(); /* fonksiyonun çağırılması */
9: }
10: /* fonksiyonun bildirimi */
11: void mesaj_yaz(void)
12: {
13: puts("Merhaba...");
14: }
Program 6.2 'de 4. satırda void mesaj_yaz() fonksiyonunun prototipi bildirilmiştir. 8. satırda bu fonksiyonun sadece adı yazılmıştır. Derleyici bu satıra gelince hemen 11. satıra gidip puts() fonksiyonunu işleme koyar ve sonucu çağrıldığı yere, 8. satıra, gönderir.
Bir fonksiyon istenilen yerde istenildiği kadar kullanılabilir. Program 6.3 de topla() fonksiyonu, ortalama() fonksiyonunun içinden çağırılmıştır.
Program 6.3 : İki sayının toplamı ve ortalamasını fonksiyonlar kullanarak hesaplanması
1: /* iki sayının toplamını ve ortalamasını hesaplar */
2: #include <stdio.h>
3:
4: int topla( int x,int y );
5: float ortalama( int x, ,int y );
6:
7: int x,y; /* x ve y global olarak bildiriliyor */
8:
9: main()
10: {
11: puts("Toplamı ve ortalaması hesaplanacak iki sayı girin:");
12: scanf("%d %d",&x,&y);
13: printf( "\nToplamları : %d", topla(x,y) );
14: printf( "\nOrtalaması : %f", ortalama(x,y) );
15: }
16:
17: /* iki sayının ortalamasını hesaplar */
18: float ortalama(x,y)
19: {
20: float ort;
21: ort = topla(x,y)/2.0; /* topla(x,y) = x+y değeri çağırılıyor */
22: return ort;
23: }
24:
25: /* iki sayının toplamını hesaplar */
26: int topla(x,y)
27: {
28: return x+y;
29: }
Program 6.3 de, klavyeden girilen iki sayı 12. satırda okunmuştur. 13. ve 14. satırlarda fonksiyonlar sırasıyla çağırılmış ve sonuçları ekrana yazdırılmıştır. 21. satırda topla fonksiyounu, bir kez daha kullanılmıştır.
Başlık dosyalarında da bolca olan makro fonksiyon tanımlaması #define önişlemci komutu kullanılarak yapılır. Örneğin aşağıdaki makro fonksiyonlar geçerlidir.
#define kare(x) (x)*(x)
#define delta(a,b,c) (b)*(b)-4*(a)(c)
#define yaz() puts("Devam etmek için bir tuşa basın...")
#define PI 4*atan(1.0)
Bu şekilde tanımlanan fonksiyonların kullanımı, diğerleri gibidir. Yalnızca programın başında tanımlanır.
Hazırlayan Ömer Zafer ÖZGÖÇER
