C++Programlama
C++ Programlama Yazılım 

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

Ali ÇAKIR 2 yorum , , , , ,

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.         Dikdortgen(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(5,10);  // x isimli bir dikdörtgen nesnesi
  19.              cout << “Alan= ” << x.alan() << endl;
  20.    return 0;
  21.          }
  22. /*//////////////////////////////////////////////////////////////////////
  23.                                  Alan=50
  24. //////////////////////////////////////////////////////////////////////*/
  • 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.

!! Yapı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
    }
4.3 3 votes
Article Rating

Bunları da sevebilirsiniz

C++Programlama

Kontrol Yapıları

Ali ÇAKIR 0
İnternet of Things

Esp8266 Wifi Led Kontrol

Ali ÇAKIR 0
Cprogramlama

İki Boyutlu Diziler

Ali ÇAKIR 0
Abone ol
Bildir
2 Yorum
Beğenilenler
En Yeniler Eskiler
Satır İçi Geri Bildirimler
Tüm yorumlar
Evren Darik
20/08/2020 12:33

ilk iki konsol aynı, ikisinde de yapıcı fonksiyon satırı yok. Ekleme unutulmuş olabilir

0
Yazar
Ali ÇAKIR
07/10/2020 22:13
Yanıtla  Evren Darik

Teşekkürler. Düzenleme sağlanmıştır.

0
2
0
Düşüncelerinizi paylaşınx