Fonksiyonlar (Programlama)

C'de alt programlara fonksiyon denir Fonskiyon sözcüğü burada matematiksel anlamıyla değil diğer programlama dillerinde kullanılan, alt program, prosedür, subroutine sözcüklerinin karşılığı olarak kullanılmaktadır

Fonksiyonlar C dilinin temel yapı taşlarıdır Bir C programı en az bir C fonksiyonundan oluşur Bir C programının oluşturulmasında fonksiyon sayısında bir kısıtlama yoktur

Fonksiyonların onları çağıran fonksiyonlardan aldıkları girdileri ve yine onları çağıran fonksiyonlara gönderdikleri çıktıları vardır
Fonksiyonların girdilerine parametreler (parameters) ya da argumanlar (arguments) diyoruz
Fonksiyonların çıktılarına geri dönüş değeri (return value) diyoruz

Bir fonksiyon iki farklı yönden kullanılabilir :
fonksiyon, icrası* süresince belli amaçları gerçekleştirir (Belli işlemleri yapar)
- fonksiyon icrası sonunda bir değeri çıktı olarak kendisini çağıran fonksiyona gönderebilir

fonksiyonların geri dönüş değerleri (return values of the functions)

Bir fonksiyonun icrası sonunda onu çağıran fonksiyona dönüşünde gönderdiği değere, fonksiyonun geri dönüş değeri (return value) denmektedir Her fonksiyon bir geri dönüş değeri üretmek zorunda değildir

Bir fonksiyonun geri dönüş değeri varsa, fonksiyon çağırma ifadesi geri dönüş değerini üretir
Geri dönüş değeri bir değişkene atanabileceği gibi doğrudan aritmetik işlemlerde de kullanılabilir Örneğin* :

sonuc = hesapla();

Burada hesapla fonksiyonunun çağırılma ifadesiyle üretilen geri dönüş değeri, sonuc değişkenine atanmaktadır

Bir başka deyişle bir fonksiyon çağırma ifadesinin ürettiği değer, ilgili fonksiyonun ürettiği (eğer üretiyorsa) geri dönüş değeridir

Yukarıdaki örnekte önce hesapla() fonksiyonu çağırılacak daha sonra fonksiyonun icra edilmesiyle oluşan geri dönüş değeri sonuc değişkenine atanacaktır

Fonksiyonların geri dönüş değerleri nesne değildir yani sol taraf değeri (L value) değildir

Yani* C dilinde aşağıdaki gibi bir atama her zaman hata verecektir :

hesapla() = 5;************************************************ ************************* / hata** (L value required) /

fonksiyonların geri dönüş değerleri sağ taraf değeri (R value) dir Bu yüzden :

sonuc = hesapla1() + hesapla2() + x + 10;

gibi bir ifade geçerlidir çağırılmış olan hesapla1 ve hesapla2 fonksiyonları icra edilerek üretilen geri dönüş değerleri ile x değişkeni içindeki değer ve 10 sabiti toplanacaktır İfadeden elde edilen değer sonuç değişkenine atanacaktır

fonksiyonların geri dönüş değerleri farklı amaçlar için kullanılabilir;

i Bazı fonksiyonlar tek bir değer elde etmek amacıyla tasarlanmışlardır Elde ettikleri değeri de kendilerini çağıran fonksiyonlara geri dönüş değeri olarak iletirler* Örneğin :

y = pow(2, 3);

pow fonksiyonu standart bir C fonksiyonudur Birinci parametresiyle belirtilen sayının ikinci parametresiyle belirtilen kuvvetini hesaplayarak, hesapladığı sayıyı geri dönüş değeri olarak kendisini çağıran fonksiyona iletir Yukarıdaki örnekte 2 sayısının 3 kuvveti bu fonksiyon yardımıyla hesaplanarak bulunan değer y değişkenine atanmıştır

ii Bazı fonksiyonların geri dönüş değerleri fonksiyonun icrası sırasında yapılan işlemlerin başarısı hakkında bilgi verir Yani bu tür fonksiyonların geri dönüş değerleri test amacıyla kullanılmaktadır Geri dönüş değerleri yapılması istenen işlemin başarılı olup olmaması durumunu açıklar Örneğin :

p = malloc(200);

ifadesiyle bellekte 200* byte uzunluğunda bir blok tahsis etmek isteyen programcı bu işlemin başarılı bir biçimde yerine getirilip getirilmediğini de test etmek zorundadır Hemen arkasından p değişkeninin aldığı değeri kontrol edecek ve işlemin başarısı hakkında bir karara varacaktır Dolayısıyla malloc fonksiyonunun geri dönüş değeri, fonksiyonun yapması gereken işin başarılı bir şekilde sonuçlanıp sonuçlanmadığını göstermektedir

iii Bazı fonksiyonlar kendilerine gönderilen arguman(lar)ı belirli bir kritere göre test ederler Ürettikleri geri dönüş değerleri ise test sonucunu belirtir Örneğin:

if (isspace(ch)) {

}

burada isspace fonksiyonu parametre olarak aldığı karakterin (kendisine gönderilen argumanın) bir boşluk karakteri (white space) olup olmadığını test eder Eğer boşluk karakteriyse, isspace fonksiyonu 0 dışı bir değere geri dönecek, eğer boşluk karakteri değilse 0 değerine geri dönecektir Çağıran fonksiyonda da geri dönüş değerine göre farklı işlemler yapılabilecektir

iv) Bazı fonksiyonlar hem belli bir amacı gerçekleştirirler hem de buna ek olarak amaçlarını tamamlayan bir geri dönüş değeri üretirler Örneğin :

x =* printf(Merhaba Dünya
);

burada printf fonksiyonu ekrana Merhaba Dünya* yazısını yazmak için kullanılmıştır Ancak ekrana yazdığı karakter sayısını da geri dönüş değeri olarak vermektedir

iv) Bazan geri dönüş değerlerine ihtiyaç duyulmaz Örneğin yalnızca ekranı silme amacıyla tasarlanmış olan bir fonksiyonun geri dönüş değerine sahip olması gereksizdir

clrscr();

clrscr(); fonksiyonu yalnızca ekranı siler, böyle bir fonksiyonun geri dönüş değerine ihtiyacı yoktur

Fonksiyonların geri dönüş değerlerinin de türleri söz konusudur Fonksiyonların geri dönüş değerleri herhangi bir türden olabilir Geri dönüş değerlerinin türleri fonksiyonların tanımlanması sırasında belirtilir

fonksiyonların tanımlanması

Kendi yazdığımız fonksiyonlar için tanımlama (definition) terimini kullanıyoruz

C'de fonksiyon tanımlama işleminin genel biçimi şöyledir :

[Geri dönüş değerinin türü] <fonksiyon ismi> ([parametreler])
{


}

Yukarıdaki gösterimde açısal parantez içinde belirtilen ifadeler zorunlu olarak bulunması gerekenleri* köşeli parantez içinde belirtilen ifadeler ise bulunması zorunlu olmayan, isteğe bağlı (optional) ifadeleri göstermektedir Bu C diline ilişkin bir sentaks kuralı olmayıp, genel bir anlatım biçimidir

Tanımlanan fonksiyonlar en az bir blok içerirler Bu bloğa fonksiyonun ana bloğu denir Örneğin:

double fonk1()
{
******** Fonksiyonun ana bloğu


}

Ana blok içinde istenildiği kadar içiçe blok yaratılabilir
Yukarıdaki tanımlamadan fonk1 fonksiyonunun parametre almadığını ve geri dönüş değerinin de double türden olduğunu anlıyoruz

void anahtar sözcüğü

Bir fonksiyonun parametre değişkeni ya da geri dönüş değeri olmak zorunda değildir

Bir fonksiyonun parametre değişkeni olmadığı iki şekilde belirtilebilir:ß

i fonksiyon parantezlerinin içi boş bırakılır, yani buraya hiçbirşey yazılmaz
ii fonksiyon parantezleri içine void anahtar sözcüğü yazılır

fonk()******************************************** ****************** fonk(void)********************
{************************************************* ******************************* {


}************************************************* ******************************* }

yukarıdaki her iki tanımlama da aynı anlama gelmektedir

Geri dönüş değerine ihtiyaç duyulmadığı durumlarda da geri dönüş değerinin türü yerine void anahtar sözcüğü yerleştirilir Örneğin:

void sample(void)
{



}

Yukarıda tanımlanan sample fonksiyonu parametre almamakta ve bir geri dönüş değeri de üretmemektedir

Fonksiyon tanımlarken geri dönüş değeri yazılmayabilir Bu durum geri dönüş türünün olmadığı anlamına gelmez Eğer geri dönüş değeri yazılmazsa, C derleyicileri tanımlanan fonksiyonun int türden bir geri dönüş değerine sahip olduğunu varsayarlar Örneğin :

sample2()
{



}

tanımlanan sample2 fonksiyonunun parametresi yoktur ama int türden bir geri dönüş değeri vardır

C dilinde fonksiyon içinde fonksiyon tanımlanamaz!

Örneğin aşağıdaki durum error oluşturur, çünkü sample2 fonksiyonu sample1 fonksiyonunun içinde tanımlanmıştır:

double sample1()
{


int sample2()*************************************** / error /
{



}

}

tanımlamanın aşağıdaki şekilde yapılması gerekirdi :

double sample1()
{



}

int sample2()
{



}

fonksiyonların çağırılması (function calls)

C dilinde fonksiyon çağırma operatörü olarak () kullanılmaktadır Bir fonksiyon çağırıldığı zaman programın akışı fonksiyonu icra etmek üzere bellekte fonksiyonun kodunun bulunduğu bölgeye atlar, fonksiyonun icra edilme işlemi bittikten sonra da akış tekrar çağıran fonksiyonun kalınan yerinden devam eder

Fonksiyonlar ancak tanımlanmış fonskiyonların içerisinden çağırılabilirler Blokların dışından fonksiyon çağırılamaz

Çağıran fonksiyon ile çağırılan fonksiyonun her ikisi de aynı amaç kod içerisinde bulunmak zorunda değildir Çağıran fonksiyon ile çağırılan fonksiyon farklı amaç kodlar içerisinde de bulunabilir Çünkü derleme işlemi sırasında bir fonksiyonun çağırıldığını gören derleyici, amaç kod içerisine (yani obj içine) çağırılan fonksiyonun adını ve çağırılış biçimini yazmaktadır
Çağıran fonksiyon ile çağırılan fonksiyon arasında bağlantı kurma işlemi, bağlama aşamasında , bağlayıcı program (linker) tarafından yapılır
Bu nedenle tanımlanan bir fonksiyon içerisinde, var olmayan bir fonksiyon çağırılsa bile derleme aşamasında bir hata oluşmaz Hata bağlama aşamasında oluşur Çünkü bağlayıcı çağırılan fonksiyonu bulamayacaktır

Bütün C programları çalışmaya main fonksiyonundan başlar Programın başladığı nokta olma dışında main fonksiyonunun diğer fonksiyonlardan başka hiçbir farkı yoktur main fonksiyonun icrası bitince program da sonlanır Bir C programının çalışabilmesi için mutlaka bir main fonksiyonuna sahip olması gerekir Eğer main fonksiyonu yoksa hata bağlama (linking) aşamasında bağlayıcı program tarafından bildirilecektir

standart C fonksiyonları

Standard C fonksiyonları, C dilinin standarlaştırılmasından sonra, her derleyicide bulunması zorunlu hale getirilmiş fonksiyonlardır Yani derleyicileri yazanlar mutlaka standard C fonksiyonlarını kendi derleyicilerinde tanımlamak zorundadırlar Bu durum C dilinin taşınabilirliğini (portability) artıran ana faktörlerden biridir
Bir fonksiyonun derleyiciyi yazanlar tarafından tanımlanmış ve derleyici paketine eklenmiş olması, o fonksiyonun standart C fonksiyonu olduğu anlamına gelmez Derleyiciyi yazanlar programcının işini kolaylaştırmak için çok çeşitli fonksiyonları yazarak derleyici paketlerine eklerler Ama bu tür fonksiyonların kullanılması durumunda, oluşturulan kaynak kodun başka bir derleyicide derlenebilmesi yönünde bir garanti yoktur, yani artık kaynak kodun taşınabilirliği azalır
Örneğin printf fonksiyonu standart bir C fonksiyonudur Yani printf fonksiyonu her derleyici paketinde aynı isimle bulunmak zorundadır
Standart C fonksiyonları özel kütüphanelerin içerisinde bulunurlar Başlık dosyaları içinde, yani uzantısı h biçiminde olan dosyaların içinde standart C fonksiyonlarının prototipleri bulunmaktadır Fonksiyon prototipleri konusu ileride detaylı olarak incelenecektir
Kütüphaneler (libraries) derlenmiş dosyalardan oluşurDOS'da kütüphane dosyalarının uzantısı lib, UNIX'de ise a (archive) biçimindedir WINDOWS altında* uzantısı dll biçiminde olan dinamik kütüphaneler de bulunmaktadır
Derleyicileri yazanlar tarafından kaynak kodu yazılmış standart C fonksiyonları önce derlenerek obj haline getirilirler ve daha sonra aynı gruptaki diğer fonksiyonların obj halleriyle birlikte kütüphane dosyalarının içine yerleştirilirler Standart C fonksiyonları bağlama aşamasında , bağlayıcı (linker) tarafından çalışabilir (exe) kod içerisine yazılırlar Entegre çalışan derleyicilerde bağlayıcılar amaç kod içerisinde bulamadıkları fonksiyonları, yerleri önceden belirlenmiş kütüphaneler içinde ararlar Oysa komut satırlı uyarlamalarında (command line version) bağlayıcıların hangi kütüphanelere bakacağı komut satırında belirtilir
Standart* fonksiyonlarını kullanmak programların taşınabilirliğini artırdığı gibi proje geliştirme süresini de kısaltır Bu yüzden iyi bir C programcısının C dilinin standart fonksiyonlarını çok iyi tanıması ve bu fonksiyonları yetkin bir şekilde kullanabilmesi gerekmektedir

fonksiyonların geri dönüş değerlerinin oluşturulması

C dilinde fonksiyonların geri dönüş değerleri return anahtar sözcüğü ile oluşturulur return anahtar sözcüğünün bir başka işlevi de* içinde bulunduğu fonksiyonu sonlandırmasıdır Örnek:

#include <stdioh>

int sample(void)
{
int x = 10; int y = 20;

*********** return x y;
}

main()
{
int c;

*********** c = sample();
printf(c = %d
, c);
return 0;
}

Yukarıdaki örnekteki sample fonksiyonunda return anahtar sözcüğünün yanında yer alan x y ifadesi sample fonksiyonunu sonlandırmakta ve sample fonksiyonunun geri dönüş değerini oluşturmaktadır Fonksiyonun geri dönüş değeri, main fonksiyonu içinde c değişkenine atanmış ve daha sonra standart C fonksiyonu olan printf ile c fonksiyonunun değeri ekrana yazdırılmıştır fonksiyonun geri dönüş değerini başka bir değişkene atamadan aşağıdaki ifade ile de doğrudan ekrana yazdırabilirdik :

printf(%d
, sample());

aynı örnekte main fonksiyonu içinde de bir return ifadesinin yer aldığı görülmektedir main de bir fonksiyondur ve main fonksiyonunun da bir geri dönüş değeri olabilir main fonksiyonun geri dönüş değeri programın icrası bittikten sonra işletim sistemine bildirilmektedir main fonksiyonunun başına bir geri dönüş değer türü yazılmazsa derleyiciler main fonksiyonunun geri dönüş değerinin int türden olduğunu varsayarlar özellikle yeni derleyiciler, tanımlamalarıonda geri dönüş değerşleri olacağı belirtilen fonksiyonlarının bir return anahtar sözcüğüyle geri dönüş değeri üretmeme durumlarında bu durumu bir uyarı (warning) mesajı ile bildirirler Borland derleyicilerinde bu uyarı mesajı genellikle (warning : function should return a value) şeklindedir Bu uyarı mesajını kesmek için iki yol vardır

1yol : main fonksiyonu da yukarıdaki örnekte olduğu gibi* int türden bir geri dönüş değeri üretir Geleneksel olarak bu değer 0 ise programın problemsiz bir şekilde sonlandırıldığı anlamına gelir

2 yol : main fonksiyonunun başına void anahtar sözcüğü yazılarak bu fonksiyonuun bir geri dönüş değeri üretmeyeceği derleyiciye bildirilir Bu durumda derleyici de bir geri dönüş değeri beklemedeiği için bir uyarı mesajı da göndermez

return anahtar sözcüğünün kullanılması zorunlu değildir Bir fonksiyon içinde return anahtar sözcüğü kullanılmamışsa fonksiyonun icrası, fonksiyonun ana bloğunun sonuna gelindiğinde otomatik olarak biter Tabi bu tür bir fonksiyon herhangi bir şekilde bir geri dönüş değeri üretemeyecektir

return anahtar sözcüğünden sonra parantez kullanılabilir ama parantez kullanımı zorunlu değildir Okunabilirlik açısından özellikle uzun return ifadelerinde parantez kullanımı tavsiye edilmektedir

return (a b - c d);

return 5;********************* / return ifadesinin değişken içermesi bir zorunluluk değildir Bir fonksiyon ********************************* *********************** sabit bir değerle de geri dönebilir /

return sample();***********

bu örnekte return anahtar sözcüğünden sonra bir fonksiyon çaırma ifadesi yer almaktadır Bu durumda önce çağırlan fonksiyon icra edilir, ve geri dönüş değeri elde edilir, daha sonra elde edilen geri dönüş değeri tanımlanması yapılan fonksiyonun da geri dönüş değeri yapılmaktadır

Geri dönüş değeri olmayan fonksiyonlarda return anahtar* sözcüğü yanında bir ifade olmaksızın tek başına da kullanılabilir :

return;

Bu durumda içinde yer aldığı fonksiyonu bir geri dönüş değeri olmaksızın sonlandırır

C dilinde fonksiyonlar yalnızca bir geri dönüş değeri üretebilirler Bu da fonksiyonların kendilerini çağıran fonksiyonlara ancak bir tane değeri geri gönderebilmelerei anlamına gelmektedir Ancak, fonksiyonların birden fazla değeri ya da bilgiyi kendilerini çağıran fonksiyonlara iletmeleri gerekiyorsa, C dilinde bunu sağlayacak başka mekanizmalar vardır ve bu mekanızmalar ileride detaylı olarak incelenecektir

Fonksiyonların ürettiği geri dönüş değerlerinin kullanılması yönünde bir zorunluluk yoktur Örneğin fonk() fonksiyonu int türden bir değeri geri dönen bir fonksiyon olsun :

a = fonk();

yukarıdaki ifadese fonk fonksiyonunun geri dönüş değeri a değişkenine atanmaktadır Dolayısıyla biz bu fonksiyonu bir kez çağırmamıza karşın artık geri dönüş değerini a değişkeninede tuttuğumuz için, bu geri dönüş değerine fonksiyonu tekrar çağırmadan istediğimiz zaman ulaşabiliriz Ancak :

fonk();

şeklinde bir fonksiyon çağırma ifadesinde artık geri dönüş değeri bir değişkende saklanmamakatdır Bu duruma geri dönüş değerinin kuullanılmaması denir (discarded return value)
Örneğin standart bir C fonksiyonu olan printf fonksiyonun da bir geri dönüş değeri vardır (printf fonksiyonu ekrana bastırılan toplam karakter sayısına geri döner) ama bu geri dönüş değeri nadiren kullanılır

fonksiyon parametre değişkenlerinin tanımlanması

bir fonksiyonun parametreleri ya da parametre değişkenleri fonksiyonların kendilerini çağıran fonksiyonlardan aldıkları girdileri tutan değişkenleridir Bir fonksiyonun parametre sayısı ve bu parametrelerin türleri gibi bilgiler , fonksiyonların tanımlanması sıarsında derleyicilere bildirilirler
C dilinde fonksiyonların tanımlanmasında kullanılan 2 temel biçim vardır Bu biçimler birbirlerinden fonksiyon parametrelerinin derleyicilere tanıtılma şekli ile ayrılırlar* Bu biçimlerden birincisi eski biçim (new style) ikincisi ise yeni biçim (new style) olarak adlandırılır
Artık eski biçim hemen hemen hiç kullanılmamaktadır, ama C standartlarına göre halen geçerliliğini korumaktadır Kullanılması tavsiye edilen kesinlikle yeni biçimdir ancak eski kodların ya da kaynakların incelenmesi durumunda bunların alaşılabilmesi için eski biçimin de öğrenilmesi gerekmektedir

1 eski biçim (old style)

Bu biçimde fonksiyonun parametre değişkenlerinin yalnızca ismi fonksiyon parantezleri içinde yazılır (Eğer parametre değişkenleri birden fazla ise aralarına virgül koyulurDaha sonra alt satıra geçilerek bu değişkenlerin bildirimi yapılır Bu bildirimler daha önce öğrendiğimiz C dilinin* normal bildirim kuralları çerçeçvesi içinde yapılır Örnek :

double alan(x, y)
int x, y;
{**********
return x y;
}

Yukarıda tanımlanan alan fonksiyonunun iki parametre değişkeni vardır ve bu parametre değişkenlerinin isimleri x ve y'dir Her iki parametre değişkeni de int türdendir

int sample (a, b, c)
int a;
double b;
long c;
{



}

Bu örnekte ise sample fonksiyonu üç parametre almaktadır Parametre değişkenlerinin isimleri a, b ve c'dir İsmi a olan parametre değişkeni int türden, b olanı double türden ve ismi c olanı ise long türdendir

Eski biçimin dezavantajı gereksiz yere uzun oluşudur Çünkü fonksiyon parantezelerinin içinde parametre değişkenlerinin isimi yer almakta sonra tekrar bu isimler alt satırlarda yeniden kullanılarak bildirim yapılmaktadır

2 yeni biçim (new style)

Yeni biçim eski biçime göre daha kısa olmakla birlikte, yeni biçimin okunabilmesi eski biçime göre çok daha kolaydır
Yeni biçimde fonksiyon parametre değişkenlerinin bildirimi fonksiyon parantezelerinin içinde yalnızca bir kez yapılmaktadır Bu biçimde fonksiyonun parantezlerinin içine parametre değişkenin türü ve yanına da ismi yazılır Eğer birden fazla fonksiyon parametre değişkeni varsa bunlar virgüllerle ayrılır ancak her defasında tür bilgisi yeniden yazılır Örnek :

int sample (int x, int y)
{


}

int fonk(double x, int y)
{


}

Bu biçimde dikket edilmesi gereken önemli nokta, fonksiyon parametre değişkenleri aynı türden olsalar bile her defasında tür bilgisinin tekrar yazılması zorunluluğudur Örneğin :

int sample (double x, y)********************************** / error* /
{


}

bildirimi hatalıdır derleme aşamasında error ile neticelenir Doğru tanımlamanın aşağıdaki şekilde olması gerekmektedir :

int sample (double x, double y)
{


}

klavyeden karakter alan C fonskiyonları

Sistemlerin hemen hemen hepsinde klavyeden karakter alan 3 ayrı C fonksiyonu bulunur Bu fonksiyonların* biri tam olarak standarttır ama diğer ikisi sistemlerin hemen hemen hepsinde bulunmasına karşın tam olarak standart değildir

int getchar(void)

getchar standart bir C fonksiyonudur Geri dönüş değeri klavyeden alınan karakterin* ASCII tablosundaki sıra numarasını gösteren int türden bir sayıdır getchar fonskiyonu klavyeden karakter almak için enter tuşuna ihtiyaç duyar
aşağıda yazılan programda önce klavyeden bir karakter alınmış daha sonra alınan karakter ve karakterin sayısal karşılıkları ekrana yazdırılmıştır(getchar fonksiyonunun geri dönüş değeri klavyede basılan tuşa ilişkin karakterin ASCII tablosundaki sıra numarasıdır)

#include <stdioh>

main()
{
char ch;

*********** ch = getchar();
printf(
Karakter olarak ch = %c
ASCII numarası ch = %d
, ch, ch);
}

getchar derleyicilerin çoğunda stdioh dosyasında bir makro olarak tanımlanmıştır Makrolar konusunu daha ileride inceleyeceğiz

int* getch(void)

getchar fonksiyonu gibi bu fonksiyonda klavyede basılan tuşun ASCII karakter numarasıyla geri döner getchar fonksiyonundan iki farkı vardır
- basılan tuş ekranda görünmez
- enter tuşuna ihtiyaç duymaz Tuşa basar basmaz işlem görür

Yukarıda verilen programda getchar yerine getch yazarak programı çalıştırırsak farkı daha iyi görebiliriz

tam olarak standardize edilmemiştir Ama neredeyse bütün sistemlerde bulunur

getch fonksiyonu özellikle tuş bekleme ya da onaylama amacıyla kullanılmaktadır:


printf(devam için herhangi bir tuşa basınız
);
getch();

burada basılacak tuşun programcı açısından bir önemi olmadığı için fonksiyonun geri dönüş değeri kullanılmamıştır

int getche(void)

getche İngilizce get char echo sözcüklerinden gelmektedir
getche fonksiyonu da basılan tuşun ASCII numarasıyla geri döner ve enter tuşuna gereksinim duymaz Ama basılan tuşa ilişkin karakter ekranda görünür


getcharenter tuşuna ihtiyaç duyaralınan karakter ekranda görünürgetchenter tuşuna ihtiyaç duymazalınan karakter ekranda görünmezgetcheenter tuşuna ihtiyaç duymazalınan karakter ekranda görünür

*
ekrana karakter yazan C fonksiyonları

C dilinde ekrana karakter yazamakta iki fonksiyonun kullanıldığı görülür :

1 putchar fonksiyonu : int putchar(int ch)

putchar standart bir C fonksiyonudur Bütün sistemlerde bulunması zorunludur Parametresi olan karakteri ekranda imlecin bulunduğu yere yazar Örneğin


#include <stdioh>

main()
{

*********** char ch;

*********** ch = getchar();
putchar (ch);
return 0;
}

Burada putchar fonksiyonunun yaptığı işi printf fonksiyonuna da yaptırabilirdik ;

printf(%c, ch);

putchar(ch) ile tamamne aynı işleve sahiptir

putchar fonksiyonu ile '
' karakterini yazdırdığımızda printf fonksiyonunda olduğu gibi imleç sonraki satırın başına geçer putchar fonksiyonu ekrana yazılan karakterin ASCII karşılığı ile geri dönmektedir
putchar fonksiyonu derleyicilerin çoğunda stdioh dosyası içinde bir makro olarak tanımlanmıştır Makrolar konusunu ileriki derslerde detaylı öğreneceğiz

2 int putch

putch standart bir C fonksiyonu değildir Dolayısıyla sistemlerin hepsinde bulunmayabilir (ama yine de hepsinde bulunduğunu söyleyebiliriz) Bu fonksiyonun putchar fonksiyonundan tek farkı '
' karakterinin yazdırılması sırasında ortaya çıkar putch, '
karakterine karşılık yalnızca LF(line feed) (ASCII 10) karakterini yazmaktadır Bu durum imlecin** bulunduğu kolonu değiştirmeksizin aşağı satıra geçmesine yol açar

printf fonksiyonu

Değişkenlerin içerisindeki değerler aslında bellekte ikilik sistemde tutulmaktadır Bir değişkenin içerisindeki değerin ekrana, kaçlık sistemde ve ekrana nasıl yazdırılacağı programcının insiyatifindedir Değişkenlerin içerisindeki değerlerin ekrana yazdırılmasında printf fonksiyonu kullanılır printf standart bir C fonksiyonudur

printf fonksiyonunun kullanımı

printf aslında çok ayrıntılı özelliklere sahip bir fonksiyondur Burada yalnızca temel özellikleri görsel bir biçimde açıklanacaktır
printf iki tırnak içerisindeki karakterleri ekrana yazar Ancak iki tırnak içinde gördüğü % karakterlerini ekrana yazmaz
printf fonksiyonu % karakterlerini yanındaki karakter ile birlikte format karakteri olarak yorumlar
Format karakterleri iki tırnaktan sonra yazılan parametrelerle birebir eşleştirilir
Örnek :

int x, y;

x = 125;
y = 200;
printf(x = %d
y = %d
, x,* y);


<br clear="ALL">

printf fonksiyonunun yukarıdaki şekilde çağırılmasıyla x ve y değişkeni içindeki değerler ekrana onluk sistemde yazdırılacaktır
format karakterleri yerine eşlenen değişkenlerin içerisindeki değerler ekrana yazılır Format karakterleri sayıların ekrana nasıl yazılacağını belirtmekte kullanılır


format karakteri
Anlamı






%d
int türünü desimal sistemde yazar


%ld
long türünü desimal sistemde yazar


%x
unsigned int türünü hexadecimal sistemde yazar


%X
unsigned int türünü hexadecimal sistemde yazar(semboller büyük harfle)


%lx
unsigned long türünü hexadecimal sistemde yazar


%u
unsigned int türünü decimal sistemde yazar


%o
unsigned int türünü oktal sistemde yazar


%f
float ve double türlerini desimal sistemde yazar


%lf
double türünü desimal sistemde yazar


%e
gerçek sayıları üstel biçimde yazar


%c
char veya int türünü karakter görüntüsü olarak yazdırır


%s
string olarak yazdırır


%lf
long double türünü desimal sistemde yazdırır



yukarıdaki tabloda görüldüğü gibi double türü hem %f format karakteri hem de %lf format karakteri ile yazdırılabilmektedir Ama %lf (okunabiliriliği artırdığı için) daha çok tercih edilmektedir

Yukarıdaki tabloya göre unsigned int türünden bir sayıyı aşağıdaki şekillerde yazdırabiliriz :

unsigned int u;

printf(%u, u);************************ / u sayısını 10'luk sistemde yazar /
printf(%o, u);************************* / u sayısını 8'lik sistemde yazar* /
printf(%x, u);************************* / u sayısını 16'lık sistemde yazar /


short bir sayıyı yazarken d o u ya da x karakterlerinden önce h karakterini kullanıyoruz :

short int sh;

printf(%hd, sh);******************** / 10'luk sistemde yazar /

unsigned short int unsh;

printf(%hu, unsh);***************** / 10'luk sistemde yazar /
printf(%ho, unsh);***************** / 8'lik sistemde yazar /
printf(%hx, unsh);***************** / 16'lık sistemde yazar /

long bir sayıyı yazarken d o u ya da x karakterlerinden önce l karakterini kullanıyoruz :

long int lo;

printf(%ld, lo);********************************** / 10'luk sistemde yazar /

unsigned long int unlo;

printf(%lu, unlo);******************* / 10'luk sistemde yazar /
printf(%lo, unlo);******************* / 8'lik sistemde yazar /
printf(%lx, unlo);******************* / 16'lık sistemde yazar /

yukarıdaki bilgilerde unsigned bir tamsayıyı printf fonksiyonuyla 8'lik ya da 16'lık sistemde yazdırabileceğimizi gördük Peki signed bir tamsayıyı 8'lik ya da 16'lık sistemde yazdıramaz mıyız? Yazdırırsak ne olur?
sözkonusu signed tamsayı pozitif olduğu sürece bir sorun olmaz Sayının işaret biri 0 olduğu için sayının nicel büyüklüğünü etkilemez Yani doğru sayı ekrana yazar, ama sayı negatifse işaret biti 1 demektir, bu durumda ekrana yazılacak sayı işaret biti de nicel büyüklüğün bir parçası olarak değerlendirilerek yazılır Yani yazılan değer doğru olmayacaktır
% karakterinin yanında önceden belirlenmiş bir format karakteri yoksa , % karakterinin yanındaki karakter ekrana yazılır

%%* (%) karakterini yaz anlamına gelir

scanf fonksiyonu

scanf fonksiyonu klavyeden her türlü bilginin girişine olanak tanıyan standart bir C fonksiyonudur scanf fonksiyonu da printf fonksiyonu gibi aslında çok detaylı geniş kullanım özellikleri olan bir fonksiyondur Ancak biz bu noktada scanf fonksiyonunu yüzeysel bir şekilde tanıyacağız

scanf fonksiyonunun da birinci parametresi bir stringdir Ancak bu string klavyeden alınacak bilgilere ilişkin format karakterlerini içerir Bu format karakterleri önceden belirlenmiştir ve % karakterinin yanında yer alırlar scanf fonksiyonunun kullandığı format karakterlerinin printf fonksiyonunda kullanılanlar ile aynı olduğunu söyleyebiliriz Yalnızca gerçek sayılara ilişkin format karakterlerinde önemli bir farklılık vardır printf fonksiyonu %f formatı ile hem float hem de double türden verileri ekrana yazabilirken scanf fonksiyonu %f* format karakterini yalnızca float türden veriler için kullanır double tür için scanf fonksiyonunun kullandığı format karakterleri %lf şeklindedir scanf fonksiyonunun format kısmında format karakterlerinden başka bir şey olmamalıdır printf fonksiyonu çift tırnak içindeki format karakterleri dışındaki karakterleri ekrana yazıyordu, ancak scanf fonksiyonu* format karakterleri dışında string içine yazılan karakterleri ekrana basmaz, bu karakterler tamamen başka anlama gelecektir Bu nedenle fonksiyonun nasıl çalıştığını öğrenmeden bu bölgeye format karakterlerinden başka bir şey koymayınız Buraya konulacak bir boşluk bile farklı anlama gelmektedir

int x, y;

scanf("%d%d", &x, &y);

Yukarıdaki örnekte x ve y sayıları için desimal sistemde klavyeden giriş yapılmaktadır Giriş arasına istenildiği kadar boşluk karakteri konulabilir Yani ilk sayıyı girdikten sonra ikinci sayıyı SPACE, TAB ya da ENTER tuşuna bastıktan sonra girebilirsiniz Örneğin :

60



biçiminde bir giriş geçerli olabileceği gibi;

5
60

biçiminde bir giriş de geçerlidir scanf fonksiyonuna gönderilecek diğer argumanlar & operatörü ile kullanılmaktadır & bir gösterici operatörüdür ve ileriki derslerimizde ayrıntılı bir şekilde ele alınacaktır

scanf fonksiyonunun yalnızca giriş için kullanılır, ekrana yazmak için printf fonksiyonunu kullanmamız gerekir :

int number;

printf("bir sayi giriniz : ");
scanf("%d", &number);