FONKSİYONLAR VE DEĞİŞKENLER
BASITFONK.C
================================================================ #include <stdio.h>
void baslikat(); /* Fonksiyon prototipi */
int main()
{
printf("Fonksiyona gidiyorum. bakın ne yazacak: \n");
baslikat(); /* Fonksiyonu çağır */
printf("Fonksiyon bitti, geri döndüm! \n");
}
void baslikat()
{
printf("Merhaba dünya! :) \n");
}
================================================================
Burada ilk fonksiyon kullanan programımızı görüyorsunuz: İlk garip şey, fonksiyon prototipidir. Bu “ileride şöyle bir fonksiyon olacak” diye olacak fonksiyonu derleyiciye tanıtmamızdır.
Sonra ana program başlar, ve ekrana bir satır yazı yazar. sonra baslikat() komutunu görünce kaldığı yeri hatırlayarak alttaki fonksiyona atlar, fonksiyondaki komutu “merhaba dunya” ekrana yazar ve fonksiyon bittiği için geri döner, ana programa devam edip son printf’i de yazar ve program biter. Yani bu programın çıktısı şuna benzer:
Fonksiyona gidiyorum. bakın ne yazacak:
Merhaba dünya! :)
Fonksiyon bitti, geri döndüm!
Daha kapsamlı bir örnek görelim:
KARETOPL.C:
================================================================
#include <stdio.h>
int toplam; /* Global değişken */
/* Fonksiyon prototipleri: Yaratacağımız 3 fonksiyonu derleyiciye tanıtalım */
void baslik();
void kare(int rakam);
void bitis();
int main()
{
int index;
baslik(); /* Baslik isimli fonksiyonu çağırır */
for (index = 1;index <= 7;index++)
kare(index); /* Bu, kare fonksiyonunu çağırır. */
bitis(); /* Bu da, bitis isimli fonksiyonu çağırır */
}
void baslik() /* Bu baslik fonksiyonunun tanımıdır */
{
toplam = 0; /* "Toplam" isimli değişkene 0 değeri atanır. */
printf("Bu, kare programının başlığıdır\n\n");
}
void kare(int rakam) /* Bu, kare fonksiyonunun başlangıcıdır */
{
int karesi; /* Yerel değişken tanımlanıyor */
karesi = rakam * rakam ; /* Karesini oluşturuyor. */
toplam += karesi; /* Bulunan değer, toplama ekleniyor */
printf("%d nin karesi %d dir.\n",rakam,karesi);
}
void bitis() /* Bitiş fonksiyonu tanımlanıyor. */
{
printf("\nKarelerin toplamı: %d dir..\n",toplam);
}
================================================================
KARETOPL.C isimli programa bir bakin. Bu program, fonksiyonlu ilk programımız. göreceğiniz gibi C de fonksiyon tanımlamak o kadar kolaydır ki, programların fonksiyonlara parçalanması neredeyse istemeden olur.
Aslında, biz fonksiyonları kullanıp duruyorduk, örneğin kullandığımız printf komutu, bir fonksiyondur. Printf fonksiyonu, derleyici ile gelen fonksiyon kütüphanesinin bir parçasıdır.
Bu programın çalışan kısmına bir bakın. baslik() isimli bir satir ile başlıyor. İste C de, herhangi bir fonksiyon, bu şekilde çağrılır: ismi, parantez, ve şayet varsa bu fonksiyona gönderilmesi istenen değerler
yazılır. Programın çalışması bu satıra gelince, başlık isimli fonksiyona atlanır, ve buradaki işlemler yapılır Bitince, program geri döner, ve ana programda kaldığı yerden isleme devam eder, ve “for” döngüsüne gelir. Burada, yedi kere “kare” isimli bir fonksiyonu çağırır, daha sonra “bitis” fonksiyonunu çağırır ve program sona erer.
FONKSIYONUN TANIMLANMASI
main’den sonra ayni main’in özelliklerini taşıyan bir program göreceksiniz.
Sadece bunun ismi “baslik()” olarak tanımlanmıştır. Bu başlığın ilk satırında “toplam” değişkeninin değeri sıfıra atanır, ve bir başlık satırı yazılır. Dikkat ederseniz, “toplam” değişkenini, fonksiyonların dışında, programın başında tanımlamıştık. Bu şekilde tanımlanan bir değişken, o programdaki herhangi bir fonksiyondan çağrılabilir. Bu tip değişkenlere “global” denir.
Bu iki satırı main() in içine de koymamız mümkündür. Bu örnekteki amaç, sadece fonksiyonların kullanımını göstermektedir.
Void: Void ne demektir? Void, ingilizcede “boşluk” anlamına gelir. C dilinde ise fonksiyon tanımına yazılınca “bu fonksiyon geriye bir değer döndürmeyecek” demektir. Geriye değer döndürecek fonksiyonları yakında göreceğiz.
FONKSIYONA DEĞER GEÇİRMEK
Ana programda, “for” döngüsünde, “index++” deyimini görüyorsunuz. İlk olarak geçen konuda öğrendiğimiz birer birer arttırma metoduna alışmaya bakın, çünkü C programlarında çok karşılaşacaksınız.
“kare” isimli fonksiyonu çağırırken, bir yenilik kattık. Yani, parantez içindeki “index” deyimini. Bu da derleyiciye, o fonksiyona gidince, “index” in o andaki değerini de beraberimizde götürmek istediğimizi
belirtir. (Ya da, bilgisayarcı diliyle “kare fonksiyonuna bir parametre geçiriyoruz” diyebiliriz.)
“Kare” isimli fonksiyonun başlığına baktığımızda ise, parantezler içinde bir başka değişken ismi görüyoruz: “rakam.” Ana programdan “kare(index)” dediğimizde gelen index’in değerine, bu fonksiyon
içinde ‘rakam’ diyeceğimizi belirtiyoruz. Buna rakam demek yerine istediğimiz herhangi bir ismi verebilirdik – C nin değişken isim kurallarına uyması şartı ile. Fonksiyon, ona ne tip bir değer geçirileceğini bilmesi içinde, hemen alt satırda, “int rakam” diyerek, gelecek bu değerin bir integer olacağını belirtiyoruz.
Küme işaretinden sonra, “int karesi” deyimi ile, sadece bu fonksiyonun içinde tanımlı olan bir değişken daha tanımlandığını görüyoruz Bundan sonra, “karesi” değişkenine ‘rakam’ in karesini atıyoruz, ve “toplam” değişkenine de “karesi” değişkeninin değerini ekliyoruz.
FONKSİYON PROTOTİPİ?
Burada “Fonksiyon Prototipi” kavramını görüyoruz. Fonksiyon Prototipleri, derleyiciye “ileride şöyle bir fonksiyon tanımlayacağım, fonksiyonun döndüreceği değer şu tip olacak, ve şu adet ve şu tipte parametre ile çalışacak” demektir. Parametre, bir fonksiyona geçirilen değere/değerlere denir. Prototipin gerçek bir fonksiyon tanımından yegane farkı, sonunda noktalı virgülü olması , ve hemen ardından fonksiyonun { } işaretlerinin olmayışıdır.
Prototipin genel tanımı şöyledir:
geri_dönecek_veri_tipi fonksiyonun_ismi ( birinci_parametresi, ikinci_parametresi, …… ) ;
Burada “geri_dönecek_veri_tipi”, int, char, float vs. gibi bir veri tipidir. Yani fonksiyon bitince onu çağıran programa ne tip bir veri geri döndüreceğidir. Birazdan göreceğiz bunun detaylarını.
Bazı derleyiciler prototiplemeyi zorunlu kılar. Bu tip bir derleyiciniz varsa, programda kullanacağınız ve kendi yazdığınız tüm fonksiyonlar için programın başında birer prototip yazmanız mecburidir.
Bazıları ise, fonksiyonlarınızın tanımı çağrılmalarından önce ise, prototip gerektirmez. Bu tip derleyicilerde (mesela gcc), programı yazarken fonksiyon tanımını önce yapar, ve daha sonra fonksiyonu kullanırsanız, prototip yazmanız gerekmeyecektir.
BİR FONKSİYONA DEĞER ATAMA HAKKINDA EK BİLGİ
Aslında “index” in değerini fonksiyona geçirdiğimizde, anlattığımdan biraz daha fazla şey oldu.
Gerçekte, “index” in değerini geçirmedik bu fonksiyona, o değerin bir kopyasını geçirdik. Bu sayede, “index” in asıl değeri, fonksiyon tarafından kazara zarar göremez. “rakam” isimli değişkenimizi fonksiyon içinde istediğimiz gibi değiştirebilirdik, fakat ana programa geri döndüğümüzde, “index” in değeri yine ayni kalırdı.
Böylece, değişkenin değerinin zarar görmesini önlemiş oluyoruz, fakat ayni zamanda, ana programa bir değer döndürmemize de mani oluyoruz! Pointers kısımına gelince, çağıran fonksiyona değeri döndürmek için, iyi tanımlı bir metot göreceğiz O zamana kadar ana programa değer döndürmenin yegane
yolu, global değişkenler kullanmaktır. Global değişkenlerden biraz bahsetmiştik, bu konu içerisinde, daha da bahsedeceğiz.
Programa devam ederek, bitis() isimli bir fonksiyonun çağrılışına geliyoruz. Bu çağırma da, hiçbir yerel değişkeni olmayan fonksiyonu çağırır. “toplam” değişkeninin değerini yazdıktan sonra ana kesime dönen
program, yapacak başka bir şey olmadığını görünce durur.
BİR BAŞKA ÖRNEK:
=====================================================================
#include <stdio.h>
int mult ( int x, int y ); /* Fonksiyon Prototipi */
int main()
{
int x;
int y;
printf( "Çarpılmasını istediğiniz iki rakamı giriniz: " );
scanf( "%d", &x );
scanf( "%d", &y );
printf( "Girdiğiniz iki rakamın çarpımı %d dır. \n", mult( x, y ) );
}
int mult (int x, int y) { return x * y; }
=====================================================================
Bu örnekte de, kullanıcıdan scanf fonksiyonu sayesinde iki rakam öğreniyoruz. Yani programın çalışması scanflere gelince duruyor, ve program kullanıcıdan iki tane rakam girmesini bekliyor. Kullanıcı rakamları birer birer giriyor, enter tuşuna basınca scanf, yazılan değeri yanındaki değişkene atıyor.
Scanflerden sonra program mult ismindeki fonksiyonu çağırıp, ona bu iki rakamı geçiriyoruz, ve o fonksiyon da bize bunları çarpıp sonucunu döndürüyor.
UFAK BİR YALANI İTİRAF ETME ZAMANI
Biraz önce size bir fonksiyondan bir değer döndürmek için yegane yolun global değişkenler ile olabileceğini söylemiştim Fakat bir başka metot daha var. Lütfen KARELER.C isimli programa bakin…
KARELER.C:
=====================================================================
#include <stdio.h>
int main() /* Ana program burada. */
{
int x,y;
for(x = 0;x <= 7;x++) {
y = squ(x); /* x*x i hesaplayalım.. */
printf("%d nin karesi %d dir...\n",x,y);
}
for (x = 0;x <= 7;++x)
printf("%d nin karesi %d dir...\n",x,squ(x));
}
squ(in) /* Bir rakamın karesini bulan fonksiyon */
int in;
{
int kare;
kare = in * in;
return(kare); /* Yeni bulduğumuz değer döndürülüyor.. */
}
=====================================================================
Bu program, tek bir değer döndürmenin kolay olduğunu gösteriyor. Fakat, birden fazla değer döndürmek için, başka metotlara gerek olduğunu hatırlamanızda fayda var.
Ana programda, iki tane tamsayi değişkeni tanımlıyoruz, ve 8 kere islenen bir “for” döngüsü başlatıyoruz döngüdeki ilk satir, “y = squ(x);”, yeni ve tuhaf görünüşlü bir satir. Önceki programlarda gördüğümüz gibi, squ(x) kısmı, squ isimli fonksiyonu, x parametresi ile çağırmaktadır. Fonksiyona
baktığımızda, bu gecen değişkenin orada ‘in’ isminde olduğunu, ve kare ismindeki yerel değişkene, geçirdiğimiz değerin karesinin atandığını görüyoruz Daha sonra, yeni “return” komutunu görüyoruz Parantezler içindeki bu değer, fonksiyonun kendisine atanır, ve ana programa bu değer
dondurulur. Yani, “squ(x)” fonksiyonu, x in karesine atanır, ve bu değer, ana programa atanır. örneğin, x in değeri 4 ise, y nin değeri, “y=squ(x)” satırından sonra 16 olacaktır..
Bir başka düşünme sekli de, “squ(x)” sözcüğünü, “x” in karesi değerinde bir değişken olarak düşünmektir. Bu yeni değişken de, değişkenlerin kullanıldığı herhangi bir yerde kullanılabilir. Başka bir değişken olarak
görmeye bir örnek olarak bu programda ikinci bir döngü vardır. Burada,
y değişkenine atamak yerine, printf’in içinde, bu fonksiyonu çağırıyoruz
Bir fonksiyondan dönecek değişkenin tipi, derleyiciye bildirilmelidir.
Fakat, bizim yaptığımız gibi şayet belirtmezsek, derleyici dönecek değerin tam sayı (integer) olacağını kabul edecektir. Başka tiplerin tanımlanmasını ise, bundan sonraki programda göreceğiz.
KAYAR NOKTA FONKSIYONLARI
KAYARKAR.C:
================================================================
#include <stdio.h>
float z; /* Bu bir global değişkendir */
float sqr(float); /* sqr isimli fonksiyonun prototipi */
float glsqr(void); /* glsqr isimli fonksiyonun prototipi */
int main()
{
int index;
float x,y;
for (index = 0;index <= 7;index++){
x = index; /* int'i float yapalım */
y = sqr(x); /* x'in karesini alalım.. */
printf("%d in karesi %10.4f dir.\n",index,y);
}
for (index = 0; index <= 7;index++) {
z = index;
y = glsqr();
printf("%d in karesi %10.4f dir.\n",index,y);
}
}
float sqr(deger) /* float'in karesini al, float dondur. */
float deger;
{
float karesi;
karesi = deger * deger;
return(karesi);
}
float glsqr() /* float'in karesini al, float dondur. */
{
return(z*z);
}
================================================================
KAYARKAR.C isimli programa bir bakin. İlk önce daha sonra kullanacağımız bir global değişken tanımlamak ile başlıyor. Programın “main” kısımında,bir tamsayi değişkeni tanımlanıyor. Bunun altında, iki tanı tamsayi değişkeni tanımı vardır.
Simdi programın ortasında yer alan “sqr” fonksiyonuna bir bakin. Burada
fonksiyonun isminin başında bir “float” sözcüğü göreceksiniz. Bu
derleyiciye herhangi bir yerden bu fonksiyon çağrılınca, dönecek değerin
float olacağını bildiriyor. Simdi bu fonksiyon, ana programdaki çağırma ile
uyumludur. Bunun altında, “float deger” satirini görüyorsunuz. Bu da, bu
fonksiyona, çağıran tarafından geçirilecek değerin, bir “float” yani kayar
nokta olacağını bildirir.
Bundan sonraki fonksiyon “glsqr” da, bir kayar nokta döndürüyor, fakat o,
input için global bir değişkeni (z değişkenini) kullanıyor. Ayrıca, yeni
bir değişken tanımlamadan, karesini almayı “return” komutunun içinde
yapıyor.
DEGISKENLERIN ALANI
ALAN.C:
================================================================
#include <stdio.h>
int say; /* Bu bir global değişkendir. */
int main()
{
register int index; /* Bu değişken sadece "main" içinde kullanılabilir */
baslik_1();
baslik_2();
baslik_3();
/* bu programın ana "for" döngüsü */
for (index = 8;index > 0;index--)
{
int birsey; /* Bu değişken sadece bu küme işaretleri arasında tanımlı */
for (birsey = 0;birsey <= 6;birsey++)
printf("%d ",birsey);
printf(" index simdi: %d oldu.\n",index);
}
}
int sayac; /* Bu değişken bu noktadan sonra kullanılabilir. */
baslik_1()
{
int index; /* Bu değişken sadece baslik_1 içinde tanımlı */
index = 23;
printf("Baslik_1 deki değeri %d\n",index);
}
baslik_2()
{
int say; /* Bu değişken sadece baslik_2 içinde geçerli */
/* ayni isimli global değişkenin yerini alır.. */
say = 53;
printf("Baslik_2 deki değeri %d\n",say);
sayac = 77;
}
baslik_3()
{
printf("Baslik_3 deki değeri ise %d\n",sayac);
}
İlk tanımlanan değişken “say”, bütün fonksiyonlardan önce tanımlandığı
için, herhangi biri tarafından çağrılabilir, ve daima erişilebilir. Daha
sonra, “sayac” isimli bir değişken tanımlıyoruz. Bu da global bir
değişkendir, fakat ana programdan sonra tanımlandığı için, ana program
tarafından kullanılamaz. Global bir değişken, fonksiyonların dışında
tanımlanan değişkenlere denir. Bu tip değişkenlere dışsal değişkenler adi
da verilebilir.
Ana programa geri dönerek, “index” isimli değişkenin tanımına bakalım. Su
an için “register” sözcüğünü göz önüne almayın. Bu değişken “otomatik” bir
değişkendir, yani o fonksiyon çağrıldığında oluşur, ve fonksiyondan
çıkınca kaybolur. Ana program başka fonksiyonları çağırdığında bile daima
çalışır olduğundan, burada pek manası yoktur. Tanımlanan diğer bir değişken
de, “birsey” değişkenidir. Bu değişken, sadece “for” döngüsünün içinde
tanımlıdır, ve başka bir yerden erişilemez. Herhangi bir küme
döngüsünün başına, değişken tanımlamaları konulabilir. Kümeden çıkınca, bu
değişken tanımsız olacaktır.
OTOMATİK DEĞİŞKENLER HAKKINDA…
Baslik_1’e bir bakin. “index” isimli bir değişken kullanıyor. Bu değişkenin
ana programdaki “index” ile arasında, ikisinin de otomatik değişken olması
dışında hiçbir bağ yoktur. Program, bu fonksiyonu islemezken, bu değişken
yoktur bile. Baslik_1 çağrıldığında, bu değişken yaratılır, ve baslik_1
bitince de bu değişken silinir. Fakat bu, ana programdaki ayni isimli
değişkenin değerini hiç etkilemez, çünkü ayrı nesnelerdir.
Yani otomatik değişkenler, gerektiğinde yaratılırlar, ve isleri bitince de
silinirler. hatırlamanız gereken bir nokta da, bir fonksiyon birden fazla
kere çağrıldığında, otomatik değişkenlerin eski değerleri saklanmaz, yeni
baştan değer atanmaları gerekir.
STATİK DEĞİŞKENLER ?
Bir başka değişken tipi ise, statik değişkenlerdir. değişkeni tanımlarken
başına “static” sözcüğünü koyarak, o değişken yada değişkenler, fonksiyonun
tekrar tekrar çağrılmasında, eski değerlerini tutarlar.
Ayni sözcüğü bir global değişkenin önüne koyarak, o değişkenin sadece o
dosya içindeki fonksiyonlara tanımlı olmasını sağlayabiliriz. Bundan da
anlayacağınız gibi, birkaç parçadan oluşan dosyalar arasında global
değişkenlerin tanımlanması mümkündür. Bunu 14. konuda daha iyi göreceğiz.
AYNI ISMI TEKRAR KULLANMAK
baslik_2 ye bir bakin. Burada “say” isimli değişkenin tekrar tanımlandığını
ve 53 değerini aldığını görüyoruz. Global olarak tanımlanmasına karşın,
ayni isimde bir otomatik değişken tanımlamak mümkündür. Bu değişken tümüyle
yeni bir değişkendir, ve global olarak,
programın başında tanımlanan “say” ile arasında hiçbir bağlantı yoktur. Bu
sayede kafanızda “acaba global isimlerle karisirmi” sorusu olmadan
fonksiyon yazabilirsiniz.
REGISTER DEĞİŞKENLERİ NEDİR
sözümü tutarak, register değişkenine donelim. Bir bilgisayar bilgiyi
hafızada yada registerlerde tutabilir. Register sahasına erişim, hafızaya
erişimden çok daha hızlıdır, fakat programcının kullanabileceği az sayıda
register vardır. Bazı değişkenlerin program tarafından çok kullanılacağını
düşünüyorsanız, o değişkeni “register” olarak tanımlayabilirsiniz.
Bilgisayar ve derleyici tipinize göre, bir yada birkaç değişkeni bu
şekilde tanımlayabilirsiniz. çoğu derleyicilerin hiç register değişkenleri
yoktur, ve “register” sözcüğünü göz önüne almadan derleme yaparlar.
Register değişkenleri, sadece tamsayi ve karakter tipi değişkenler ile
kullanılabilir. seçtiğiniz derleyiciye göre, unsigned, long yada short
tiplerinde register olabilir.
DEĞİŞKENLERİ NEREDE TANIMLAYALIM
Bir fonksiyona parametre olarak geçirilmiş değişkenler varsa, bunların
tanımı, fonksiyon isminden sonra, ve açık küme işaretinden önce
yapılmalıdır. Fonksiyonda kullanılan diğer değişkenler ise, fonksiyonun
başında, hemen açık küme işaretinden sonra tanımlanır.
STANDART FONKSİYON KÜTÜPHANESİ
Her derleyici, içinde birçok fonksiyon olan bir kütüphane ile birlikte
gelir. Bunlar genellikle giriş/çıkış işlemleri, karakter ve katar (string) işleme,
ve matematiksel fonksiyonları içerir. Bunların çoğunu sonraki konularda
göreceğiz.
Bunun dışında, çoğu derleyicinin, standart olmayan, ve kullandığınız
bilgisayarın özelliklerini kullanan, ilave fonksiyonları vardır. örneğin,
IBM-PC ve uyumlular için, BIOS servislerini kullanan fonksiyonlar
sayesinde, isletim sistemine komutlar vermeyi, yada ekrana direk yazmayı
sağlayan fonksiyonlar olabilir.
BİRKAÇ ÖRNEK DAHA:
ASAL.C
================================================================
#include<stdio.h>
int asal_kontrol(int rakam);
int main(){
int n1,n2,i,flag;
printf(“İki rakam giriniz: “);
scanf(“%d %d”,&n1, &n2);
printf(“%d ve %d arasındaki asal sayılar şunlardır: “, n1, n2);
for(i=n1;i<=n2;++i)
{
flag=asal_kontrol(i);
if(flag==0)
printf(“%d “,i);
}
return 0;
}
int asal_kontrol(int rakam) /* asal sayı kontrol fonksiyonu */
{
int j,flag=0;
for(j=2;j<=rakam/2;++j){ // 2 den o rakamın yarısına kadar olan her sayıyla bölmeye çalışalım.
if(rakam%j==0){ // tam bölündüyse asal sayı olamaz
flag=1;
break;
}
}
return flag;
}
================================================================
RECURSION NEDIR ?
RECURS.C:
================================================================
#include <stdio.h>
int main()
{
int index;
index = 8;
geri_say(index);
}
geri_say(rakam)
int rakam;
{
rakam--;
printf("rakam degeri %d dir.\n",rakam);
if (rakam > 0)
geri_say(rakam);
printf("Simdi rakam %d oldu..\n",rakam);
}
================================================================
Recursion, ilk karşılaşıldığında çok korkutucu görünen bir kavramdır.
Fakat RECURS.C isimli programa bakarsanız, recursion’un bütün zorluğunu
yenebiliriz. Aslında fazla basit ve dolayısı ile aptal olan bu program,
bize recursion’un kullanımını göstermesi bakımından çok yararlıdır.
Recursion, kendini çağıran bir fonksiyondan başka birşey değildir Yani,
bitmek için bir kontrol mekanizmasına ihtiyacı olan bir döngüdür
karşınızdaki programda “index” değişkeni 8 e atanır, ve “geri_say”
fonksiyonunun parametresi olarak kullanılır Bu fonksiyon da, bu değişkenin
değerini teker teker azaltır, ve bize bu değeri gösterir Sonra tekrar
kendisini çağırır, değeri bir kez daha azalır, tekrar, tekrar.. Sonunda
deger sıfıra ulaşır, ve döngü artık kendini çağırmaz Bunun yerine, daha
önceki çağırmada kaldığı yere geri döner, tekrar geri döner, en sonunda ana
programa geri döner, ve program sona erer.
NE OLDU ?
Fonksiyon kendisini çağırdığında, bütün değişkenlerini,ve çağırılan fonksiyonun islemesi bittiğinde dönmesi gereken yeri hafızaya sakladı.
Bir dahaki sefere kendinin tekrar çağırdığında, yine ayni şeyi yaptı, ta ki
kendisini tekrar çağırması bitene kadar. Daha sonra tekrar bu bilgileri,
ayni koyma sırası ile geri okudu.
hatırlamanız gereken nokta, recursion’un bir noktada bitmesi gerektiğidir,
şayet sonsuz bir döngüye girerseniz, bilgisayarın hafızası bitecek ve bir
hata mesajı çıkacaktır.
FACTORIAL.C:
================================================================
#include <stdio.h>
unsigned long factorial(unsigned long);
int main()
{
int num;
printf("Faktoriyeli alınacak rakamı yazın. \n");
scanf("%d",&num);
printf("%d nin faktoriyeli: %ld dir.\n", num, factorial((unsigned long) num));
}
unsigned long factorial(unsigned long i)
{
if (i==0) return 1;
return (i * factorial(i-1));
}
================================================================
Burada ise faktoriyel fonksiyonunu görebiliriz. Önce, matematikte faktoriyel neydi?
-
0! = 1 yani, sıfırın faktoriyeli birdir.
-
n > 0 ise, n! = nx(n-1)! Diğer rakamlar için ise, o rakama kadar olan tüm tamsayıların birbiri ile çarpılmasıdır.
Yani,
6! = 6×5! = 6x5x4! = 6x5x4x3! = 6x5x4x3x2! = 6x5x4x3x2x1! = 6x5x4x3x2x1x1 = 720
gibi.. Fonksiyonda göreceğiniz üzere, şayet gelen değer sıfır ise, geriye bir döndürüyoruz. Değilse, tekrar kendimizi çağırıp parametredeki değeri 1 eksiltiyoruz.
ODEVLER
1. Daha önce yazdığımız Santigrad’dan Fahrenheit’a karşılık tablosundaki derece hesaplamasını bir fonksiyona geçiriniz.
2. Ekrana isminizi 10 kere yazan bir program yazınız. Yazma isini yapmak için bir fonksiyon çağırınız. Daha sonra bu fonksiyonu main() in başına alarak, derleyicinin bunu kabul edip etmediğini kontrol ediniz.