Fonksiyonlar

Fonksiyonlar

Fonksiyon Tanımlama

Kullanımı:

VeriTipi fonksiyonAdı (değişken listesi)

{  ………….     

}

             // fonksiyon başlığı=> int main( ),
int main ()        // int=> veri tipi  main=> Fonksiyon adı
{           // fonksiyon gövdesi başlangıcı
    cout<< "Merhaba C++!";
return 0;,
}          // fonksiyon gövdesi bitişi
 

Daha önce bahsetmiş olduğumuz return  komutu fonksiyon kullanıldığında istenilen değeri çağrılan programa gönderme işlevini üstlenendir. 

#include<iostream>
using namespace std;
 
int faktoriyel (int x)  // "faktoriyel" adında fonksiyon tanımlanmış
{                       //"int x" adından integer bir" x" değişkeni alıyor
        ..............
      .........
    return f;   // "int faktoriyel" olarak tanımlandığı için çağrıldığı yere integer "f" değerini yollar
}
    main ()
   {
       .......
       ......
         cout<<sayi<<"!="<<faktoriyel(sayi)<<endl;  
        ....            // faktoriyel (sayi)  fonksiyon içine "sayi" değişkeni gönderilerek çağırılmış
   }

Aşıdaki programda Fonksiyon Başlığı yazan kısım fonksiyonun bir değişken gibi tanımlandığı kısımdır.(int x gibi)

int faktoriyel (int x)  
 

Fonksiyon Prototipi

  • Fonksiyonlar sekmesinde bahsettiğimiz fonksiyonun programda tanımlama işlemidir.
  • Kullandığımız her ismin (değişken, sabit, fonksiyon vs.) kullanmadan önce tanımlanması gerekmektedir.
  • Fonksiyonları önceden tanıtıp fonksiyon içeriğini istediğimiz yere, hatta başka bir dosyaya bile yazmamız fonksiyon prototipi ile mümkündür.
int fakt( int x);
 
// veya
 
int fakt (int); 

şeklinde tanımlanır. İlk tanımlamada değişkenin fonksiyonun içerisinde x olarak işlem yapacağını ikincisinde gönderilen programın kendi değişkenin kullanılacağı anlatılmıştır.

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. int fakt(int); //fonksiyon prototipi(tanımlanması)
  5.  
  6. int main()
  7. {
  8. int n,sonuc;
  9. cout<<“Bir sayi giriniz:;
  10. cin>>n;//girilen n kullanılarak 4 kez çağrılmıştır
  11. sonuc=(fakt(n)/4)*(6/fakt(n-1))+(fakt(n-2)/2)*(7/fakt(n-3));
  12. cout<<“Sonuc=<<sonuc<<endl;
  13. return 0;
  14. }
  15. int fakt(int x) //n değeri gönderilmiştir ve artık x olmuştur
  16. {
  17. int f=1;
  18. for(int i=1;i<=x;i++)
  19. f*=i;
  20. return f; // fonksiyon çağrıldığında f değeri gönderilmiştir
  21. }

Değişken Döndürmeyen Fonksiyonlar

Bir fonksiyon çağrılan fonksiyona  değer döndürmüyorsa veya değişken içermiyorsa bu durum void yazarak belirtilir. 

  • Void fonksiyonları değer döndürmeyeceğinden return komutu içermeyebilir.
  1. #include<iostream>
  2. using namespace std;
  3.  
  4. void fonk1(); // değişken döndürmeyen fonksiyon
  5.  
  6. int main()
  7. {
  8. int a=6;
  9. cout<<“a=<<a<<endl;
  10. fonk1(); // a değeri 7 olur fonk1 den çağırılmış çağrıldığından fonk fonksiyonunun içinde a yazdırılmış
  11.  
  12. system(“pause”);
  13. return 0;
  14. }
  15.  
  16. void fonk1()
  17. {
  18. int a=7;
  19. cout<<“a=<<a<<endl;
  20. }

Programda void mesaj (void) yazan kısımda “(void)” programın içinde bir değişken dönmediği anlamına gelir.

baştaki void kısmında ise programın çağrıldığı fonksiyona bir değişken göndermediği anlamına gelir.

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. void buyuk(float ,float) // fonksiyon prototipi
  5.  
  6. int main()
  7. {
  8. float x, y;
  9. cout << “Ikideger giriniz:;
  10. cin >> x >> y; // iki sayı girilir
  11. buyuk(x, y); // ikisayı fonksiyona yollanır
  12. return 0;
  13. }
  14. void buyuk(float a, float b)// iki sayının büyüğünü bulan fonksiyon
  15. {
  16. cout << “Sayilarin buyugu :;
  17. if (a>b) // iki sayı karşılaştırılır
  18. cout << a << endl;
  19. else
  20. cout << b << endl;
  21. }
  22. /*/////////////////////////////////////////////////////////////////////
  23.   main buyuk
  24.   x y a b
  25.  3.4 2.1 3.4 2.1
  26.  
  27. //////////////////////////////////////////////////////////////////////*/

Yukarıdaki programda alt fonksiyonda değişkenle işlem yapılmış fakat değişken çağrılan programa değer gönderilmemiştir. Aşağıda alan hesaplayan programda alan fonksiyonu parametre almamış ve parametre göndermiştir.

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. double alan(void); // fonsiyon prototipi(tanımlanması)
  5.  
  6. int main()
  7. {
  8. double sonuc;
  9. sonuc=alan(); // alan() fonksiyonu çağrılır döndürdüğü değer sonuc’a atanır
  10. cout<<“Alan=<<sonuc<<endl;
  11.  
  12. return 0;
  13. }
  14.  
  15. double alan (void) // en ve boyu okuyup digdörtgenin alanını hesaplar
  16. {
  17. double en,boy;
  18. cout<<“Digdortgenin en ve boyunu giriniz:;
  19. cin>>en>>boy;
  20. return en*boy; // en ile boy çarpılıp çağırıldığ fonksiyona döndürülür
  21. }

Parametreli Fonksiyonlar

  • Çağrılan fonksiyonla çağıran fonksiyon arasında veri alışverişi parametre kullanılarak yapılır.
  • Çağıran fonksiyonda yer alan parametreler gerçek parametre, çağrılan fonksiyonda yer alan parametrelere formal parametre ismi verilir.
  • Bu parametrelerin sayısının ve veri tipinin uyumlu olaması gerekir.
void fon (int, float);
int main()
{
       int x=5;
       float y=3.6;
   fon (x,v);  // gerçek parametre
}
void fon ( int a,float b)
{  // " ( int a,float b)" Formal parametre
.........
}
Referans Değişkeni
  • Referans değişkenleri bir değişkene farklı bir isim vermek için kullanılır.
  • Referans değişkenleri & (referans) operatörü ile tanımlanır.

Referans Değişkeni

deger değişkenin int 32 bitlik adresine 5 değeri kayıt edilmiştir.

&ref değişkenin direk adresi dir. & değişkenin adresine erişme operatörüdür. Bu adrese erişilmiş ve 5 değeri atanmıştır.

Referans değişkenlerini tanımladığımızda mutlaka ilk değer atamasını yapmamız gerektiğini, hangi değişkenin referansı olacağını belirtmemiz gerektiğini unutmayalım.

int &ref;  // Geçersiz tanımlama

Bir referans değişkeni tek bir değişkenin referansı olabilir ve bu ilk atama sırasında belirlenir. Daha sonra bu referans değişkeni farklı bir değişkenle ilişkilendirilmez.

int x=5,y=6;
 
int &ref=x;
 
ref=y; // geçersiz atama

Göstergeler kısmında bu kısım daha iyi anlaşılacaktır.

Fonksiyon Parametreleri
  • Değer Parametresi: Çağrılan fonksiyona gerçek parametre değerinin bir kopyası yollanır.Fonksiyonda formal parametre için bellekte bir yer açılır ve yollana değer bu yere kopyalanır. Fonksiyon bitiminde yeni açılan yer yok olur ve gerçek parametrenin değeri etkilenmez.
  • Referans Parametresi: Fonksiyona gerçek parametrenin referansı yollanır. Böylece fonksiyon başlığında yer alan formal parametre ve yollanan gerçek parametre parametreye yapılan herhangi bir değişiklik gerçek parametreye de yansır.

Fonksiyon ÇağırımıAşağıda bulunan programı inceleyelim

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. void supriz(int a, int & b); // fonsiyon prototipi(tanımlanması)
  5. {
  6. a=5;
  7. b=6;
  8. cout<<“a=<<a<<“b=<<b<<endl;
  9. }
  10.  
  11. int main()
  12. {
  13. int i=10;,j=20;
  14. supriz(i,j);
  15. cout<<“i=<<i<<“j=<<j<<endl;
  16.  
  17. return 0;
  18. }

Burada ana fonksiyonda (main) supriz(i,j) gönderilen i ve j değerleri supriz alt programında a ve &b değerlerine karşılık gelmiştir. Çıktıda görüleceği üzere i değeri a‘ya atanmış ve a‘nın değerini değiştirmiş 10 yapmıştır, &b‘ye atanan j değeri adrese atandığı için değeri değişmemiş &b adresinde bulunan değeri değiştirmemiş, ekrana o adresteki değeri 6 olarak yazdırmıştır.

Varsayılan Parametreler
  • Çağrılan fonksiyonda ki formal parametreler ile fonksiyon çağrılmasında yer alan gerçek parametrelerin sayı ve tip olarak uyuşması gerekir.
  • Çağıran fonksiyon, çağrıldığı fonksiyona gerçek parametre yollamayacaksa, varsayılan parametreler (default parameter) kullanılır.
    Gerçek parametre yollanmadığında daha önce tanımlanmış değeri alan parametreler varsayılan parametre denir.
  1. #include<iostream>
  2. using namespace std;
  3.  
  4. void fon (int x=1,int y=20) // Varsayılan değerlerle 2 formal parametre
  5. {
  6. cout<<x<<” “<<y<<endl;
  7. }
  8.  
  9. int main()
  10. {
  11. fon(5,10); // 2 gerçek parametre ile çağrılmış
  12. fon(5); // 1 gerçek parametre ile çağrılmış
  13. fon(); // gerçek parametresiz
  14.  
  15. return 0;
  16. }
  • Varsayılan parametreler parametre listesini sonunda yer almalıdır.
  void fon(int x=5, int y) // hata
  • Varsayılan parametreleri fonksiyon prototipinde veya fonksiyon başlığında belirtebiliriz, ancak ikisinde birden belirtmemiz gerekir.
void fon (int, int=5);  // fonksiyon prototipi
 
             …..
void fon ( int y, int x=5) // fonksiyon başlığı
 
             {……}
Fonksiyon Yükleme (Over Load)

Aynı isimde birden fazla fonksiyonu, farklı parametrelerle tanımlayabiliriz. Bu yönteme, Fonksiyon Yükleme ismi verilir.

Programda gönderilen değerler değerler iki fonksiyonda da aynı işlemi yapmaktadır.

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int topla(int, int);
  5. double topla(double, double);
  6.  
  7. int main()
  8. {
  9. cout <<1. topla fonksiyonu:<< topla(2,3)<< endl;
  10. cout <<2. topla fonksiyonu:<< topla(4.3, 5.6) << endl;
  11.  
  12. return 0;
  13. }
  14. int topla(int x, int y)
  15. {
  16. return x + y;
  17. }
  18. double topla(double x, double y)
  19. {
  20. return x + y;
  21. }
  22.  
  23. /*//////////////////////////////////////////////////////////////////////
  24.   Çıktı:
  25.   1.topla fonksiyonu:5
  26.   2.topla fonksiyonu:9.9
  27. ///////////////////////////////////////////////////////////////////////*
Satıriçi Fonksiyonlar

Satıriçi (inline) fonksiyonlar, fonksiyonun kullanıldığı yerlere doğrudan yapıştırılır, böylece fonksiyon çağırma işleminin yapılmasına gerek kalmaz.

inline VeriTipi fonksiyonAdı()
{
    // tanımlar
}
 
// örnek 
inline double alan()
{
   return a*a;
}
Recursive (Özyinelemeli) Fonksiyonlar
  • Bir fonksiyon doğrudan veya dolaylı olarak kendini çağırıyorsa recursive fonksiyon olarak adlandırılır.
  • Recursive fonksiyonlar bir kontrol deyimiyle iki duruma ayrılırlar.

                             Genel Durum (Recursive)

                             Temel Durum (Non- Recursive)

  • Tekrarlı (İterative) fonksiyonların hepsi recursive olarak çözülebilir

          Recursive fonksiyonların hafıza kullanımı daha yüksektir.

          Recursive kod yazımı daha kolaydır. Bazı algoritmalar yapıları gereği recursive yazıma daha uygundur

Sürekli kendini çağıran fonksiyonlar  sonsuz döngüye girer. 

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. int faktoriyel (int n)
  5. {
  6. if(n<=1)
  7. return 1;
  8. else
  9. return (n*faktoriyel(n-1));
  10. }
  11.  
  12. int main()
  13. {
  14. int n;
  15. cout<<“Bir sayi giriniz:;
  16. cin>>n;
  17. cout<<n<<!=<<faktoriyel(n)<<endl;
  18. return 0;
  19. }

Kimler Neler Demiş?

  Abone ol  
Bildir