Yapıcı ve Yıkıcı Fonksiyonlar

Yapıcı Fonksiyonlar

Yapıcı Fonksiyon

  • İng.constructor
  • Bir nesnenin tanımında bu  nesne üyelerine ilk değer ataması yapamak için kullanılan özel fonksiyondur.
  • Bir nesne tanımlandığında otomatik olarak çalışır.
  • Yapıcı fonksiyon yazarken dikkat edilmesi gerekenler
    • Yapıcı fonksiyonun ismi sınıf ismi ile ayn olmalıdır
    • Yapıcı fonksiyonların döndürme tipi yoktur.
    • Nesne tanımı yapıldığında otomatik olarak çağrıldıkları için yapıcı fonksiyonları özel olarak çağırmaya gerek yoktur.

Yapıcı fonksiyon kullanılmadığı durum

  1. #include <iostream>
  2. using namespace std;
  3. class Dikdortgen
  4. {
  5. int en, boy;
  6. public:
  7. void ata(int e,int b )
  8. {
  9. en = e; boy = b;
  10. }
  11. int alan()
  12. {
  13. return en*boy;
  14. }
  15. };
  16. int main()
  17. {
  18. Dikdortgen x; // x isimli bir dikdörtgen nesnesi
  19. x.ata(5, 10); // x’in enine5, boyuna 10 atanır
  20. cout << “Alan=<< x.alan() << endl;
  21. return 0;
  22. }
  23. /*//////////////////////////////////////////////////////////////////////
  24.   en 5
  25.   boy 10
  26.   ata()
  27.   alan()
  28.   x
  29. /////////////////////////////////////////////////////////////////////*/

Yapıcı fonksiyon kullanıldığı durum

  1. #include <iostream>
  2. using namespace std;
  3. class Dikdortgen
  4. {
  5. int en, boy;
  6. public:
  7. void ata(int e,int b )
  8. {
  9. en = e; boy = b;
  10. }
  11. int alan()
  12. {
  13. return en*boy;
  14. }
  15. };
  16. int main()
  17. {
  18. Dikdortgen x; // x isimli bir dikdörtgen nesnesi
  19. x.ata(5, 10); // x’in enine5, boyuna 10 atanır
  20. cout << “Alan=<< x.alan() << endl;
  21. return 0;
  22. }
  23. /*//////////////////////////////////////////////////////////////////////
  24.   en 5
  25.   boy 10
  26.   ata()
  27.   alan()
  28.   x
  29. //////////////////////////////////////////////////////////////////////*/
  • Yapıcı fonksiyon
    • Dikdortgen ( int e, int b ) { en=e; boy=b; }
  • Yapıcı Fonksiyon Çağırımı
    • Dikdortgen x(5,10); // Yapıcı fonksiyonun ismi (Dikdortgen ) sınıf ismi ile aynı
      Yapıcı fonksiyonun döndürme tipi tanımlanmamıştır.

!! Ayapıcı fonksiyonları public olarak tanımlamayı unutmamalı aksi halde otomatik olarak çağrılmaz.

  1. #include <iostream>
  2. using namespace std;
  3. class Nokta
  4. {
  5. int x, y;
  6. public:
  7. Nokta(int a = 0, int b = 0) //Yapıcı fonksiyon tanımı
  8. {
  9. x = a;
  10. y = b;
  11. }
  12. int xDegeri()
  13. {
  14. return x;
  15. }
  16. };
  17. int main()
  18. {
  19. Nokta bir(12, 6); // bir nesnesi yaratılır ve çağrılır
  20. Nokta iki(25); // iki nesnesi yaratılır ve yapıcı çağrılır
  21. Nokta uc; // üc nesnesi yaratılır ve yapıcı çağrılır
  22.  
  23. cout << “bir’in x kordinati:<< bir.xDegeri() << endl;
  24. cout << “iki’nin x kordinati:<< iki.xDegeri() << endl;
  25. cout << “uc’un x kordinati:<< uc.xDegeri() << endl;
  26. return 0;
  27. }
  28.  
  29. /*//////////////////////////////////////////////////////////////////////
  30.   Çıkıtı :
  31.   bir’in x kordinati: 12
  32.   iki’nin x kordinati:25
  33.   uc’un x kordinati:0
  34. /////////////////////////////////////////////////////////////////////*/

Nokta bir(12,6);
Nokta iki(25);
Nokta uc;

“bir” nesnesi için yapıcı fonksiyona 2 parametre, “iki” nesnesi için 1 parametre yollanır,“uc” nesnesi için ise  parametre gönderilmez. Bu durumda “iki” ve “uc” nesneleri için varsayılan değerler kullanılır ve bu nesneler aşağıdaki şekilde olur.

Varsayılan Yapıcı Fonksiyon

  • İng.Default constructor
  • Hiç parametresi olmayan yapıcı fonksiyonlarıdır.
 /* Varsayılan Yapıcı Fonksiyon */
              ogrenci();        
/* Varsayılan Yapıcı Fonksiyon Tanımı*/
             Ogrenci::Ogrenci()
                 {……..}
Üyelere İlk Atama
  • İng.Member initialization
  • Yapıcı fonksiyonlarda atama operatörünü ( = ) kullanmadan nesne üyelerine ilk değerlerini atamaya üyelere ilk atama adı verililir.
  1. #include <iostream>
  2. using namespace std;
  3. class Basit
  4. {
  5. int i;
  6. float f;
  7. public:
  8. Basit(int ,float);
  9. };
  10. Basit::Basit(int a, float b)
  11. {
  12. i = a;
  13. f = b;
  14. }
  15. int main()
  16. {
  17. Basit nsn(1, 2.5);
  18. return 0;
  19. }

ilk atama yöntemidir

Basit::Basit(int a,float b):i(a),f(b)
{ 
}
Yapıcı Fonksiyonu Yükleme

Yapıcı fonksiyonlar, farklı parametrelerle birden fazla tanımlanabilir.

Eleman () {};                                   // 1. yapıcı fonksiyon
Eleman ( int i, string s): n(i), isim(s){};     // 2. yapıcı fonksiyon
 
Eleman e1;                                      // 1. yapıcı çağrılır
Eleman e2(123,”Ali”);                          // 2. yapıcı çağrılır 
  • Eğer bir sınıfa hiçbir yapıcı fonksiyon tanımlanmamışsa, derleyici otomatik olarak içi boş bir varsayılan yapıcı fonksiyon tanımlar.
  • Eğer sınıfta başka bir yapıcı fonksiyon tanımı yapıldıysa, varsayılan fonksiyon otomatik olarak yaratılmaz.
class Eleman
   {
     int no;     // Eleman e; Doğru
     string isim;
    }
class Eleman
  {
     int no;
     string isim;    //Eleman e; Yanlış
      public:
     Eleman (int  _no, string _isim):no(_no),isim(_isim);
   }
class Eleman
  {
    int no;
    stringisim;
      public:        //Eleman e; Doğru
        Eleman() {}
    Eleman( int _no, string _isim):no(_no),isim(_isim);
   }
Yapıcı Fonksiyon Çağırma
  • Yapıcı fonksiyonlar nesne tanımı yapıldığı sırada otomatik olarak çağrılır.
  • Yapıcı fonksiyon istenildiğinde de çağrılabilir.
class Basit
  {
     int i;       // Basit nsn;  nsn i =>0   f=> 0 
     float f;
       public:
         Basit();   //nsn=Basit(7,4.3);    nsn i=> 7  f=> 4.3
         Basit::Basit(int a, float b):i(a),f(b) { }
   };
Basit::Basit( )       // nsn=Basit( ); nsn   i=>0  f=> 0
   {
     i=0;
      f=0.0
    }  

Kimler Neler Demiş?

  Abone ol  
Bildir