Ana sayfa > Programlama > C++ Programlama > Sınıf

Sınıf

► Detaylı anlatım

Nesneye yönelik programlama (NYP) çalışma sistemi sınıflar içinde yer alan iki temel kavram üzerinde şekillenir:

1. Değişkenler (veriler): NYP ile geliştirilen uygulamalarda ihtiyaç duyulan farklı türden değişkenler sınıf içinde tanımlanır.

2. Değişkenlere işlem yapan fonksiyonlar (metodlar): NYP ile geliştirilen uygulamalarda sınıf içinde tanımlanan değişkenlere işlem yapmak üzere fonksiyonlar içinde kodlar tanımlanır.

NYP ile geliştirilen uygulamalarda program içinde, veriler ile verilere işlem yapacak olan fonksiyonlar (metodlar) sınıf (class) adı verilen yapıların içinde tanımlanır. Sınıf tanımlandıktan sonra bu sınıf türünden bir değişken (nesne) oluşturularak, bu nesne yoluyla sınıf içinde yer alan tüm değişken ve fonksiyonlara erişim sağlanır.

Sınıf (Class) bildirimi

Bir nesne oluşturmadan önce, class anahtar kelimesini kullanarak nesnenin tüm özellik (değişkenler) ve davranışlarını (fonksiyonlar) gösteren genel yapısını tanımlamamız gerekir.

Sınıflar class anahtar kelimesi ile oluşturulur. Bir sınıf oluşturulduğunda, sınıf içindeki değişkenlere yine sınıf içindeki fonksiyonların işlem yapmasını sağlayan yeni bir veri türü tanımlanmış olur.

Sınıf adı verilen bu yeni veri türü oluşturulduktan sonra, bu sınıfa ait nesne bildirimi yapılır. Bu işlem, int bir veri türünden değişken tanımlamaya benzer.

Bir sınıf bildiriminin genel yapısı aşağıda gösterilmektedir:

class sınıf-adı {
   // private veri ve fonksiyonlar
   private:   
      veri-türü değişken_adı;
      .
	  .
      veri-türü değişken_adı;
   
      veri-türü fonksiyon_adı (veri-türü);
      .
	  .
      veri-türü fonksiyon_adı (veri-türü);
      
   // protected veri ve fonksiyonlar
   protected:
      veri-türü değişken_adı;
      .
      .
      veri-türü değişken_adı;
   
      veri-türü fonksiyon_adı (veri-türü);
      . 
      .
      veri-türü fonksiyon_adı (veri-türü);

   // public veri ve fonksiyonlar
   public:
      veri-türü değişken_adı;
      .
      .
      veri-türü değişken_adı;
   
      veri-türü fonksiyon_adı (veri-türü);
      . 
      .
      veri-türü fonksiyon_adı (veri-türü);	 

} nesne/nesne-listesi; // İsteğe bağlı olarak tanımlanır.

Bir sınıf içinde bildirimi yapılan tüm fonksiyon ve veriler, ön tanımlı olarak, private özelliği taşır ve sadece sınıfın diğer üyeleri tarafından erişilebilir.

Bir sınıf içinde yer alan protected fonksiyon ve verilere ise; bu sınıftan türetilen alt sınıflar public olarak türetildiğinde, alt sınıfların içindeki fonksiyonlar direk erişim sağlayabilir.

Bir sınıf içinde yer alan public fonksiyon ve verilere ise, programın içinde yer alan kodların tamamı tarafından erişim sağlanabilir.

Sınıf içindeki üye fonksiyonların kod bloğu sınıf içinde veya sınıf dışında ayrıca yapılabilir.

private, public ve protected erişim tanımlayıcılarından birisi kullanıldığında, başka bir erişim tanımlayıcısı ile karşılaşana veya sınıf bildiriminin sonu gelene kadar, erişim tanımlayıcının geçerliliği devam eder.

Erişim tanımlayıcılarını istediğimiz sayıda ve farklı sıralamalarla kullanabiliriz.

Aşağıdaki kod satırları sinif isimli bir sınıf tanımlar:


class sinif {
  // Sadece sınıf fonksiyonlarının erişebileceği private değişkenler
  private:  
    int priid;
  // Sadece sınıf fonksiyonları ile türetilmiş sınıf fonksiyonlarının erişebileceği private değişkenler
  protected:  
    int proid;	
  // Sınıf fonksiyonları, türetilmiş sınıf fonksiyonları ve sınıf nesneleri erşim sağlayabilir.
  public: 
    int pubid;
	void deger_ata(int pid1, int pid2, int pid3);
    void deger_goster();
};

Yukarıdaki sınıf tanımlamasında, priid değişkeni private olduğundan, bu sınıf elemanına sınıf üyesi olmayan herhangi bir fonksiyon tarafından erişilemez. Bu özellik nesneye yönelik programlama dilinin kapsülleme özelliğinin bir sonucudur.

public olarak tanımlanan deger_ata() ve deger_goster() fonksiyonları sinif sınıfında yer aldıklarından üye fonksiyonlardır. Aynı zamanda, priid, proid, pubid değişkenleri de sinif sınıfında yer aldıklarından üye değişkenlerdir.

Bir sınıf içinde bildirimi yapılan fonksiyonlara üye fonksiyon adı verilir. Üye fonksiyonlar içinde tanımlandıkları sınıftaki private, public ve protected olmak üzere tüm elemanlara erişim sağlayabilirler.

Bir sınıf içinde bildirimi yapılan değişkenlere üye değişken adı verilir.

Bir sınıf içindeki private fonksiyon ve değişkenlere, sadece sınıf içindeki fonksiyonlar yoluyla, protected değişkenlere, sınıf içindeki fonksiyonlar ile bu sınıftan public olarak türetilen alt sınıfların fonksiyonları yoluyla, public değişkenlere ise, sınıf içindeki fonksiyonlar, bu sınıftan türetilen alt sınıfların fonksiyonları ve programın herhangi bir yerinde tanımlanan sınıf nesneleri yoluyla erişim sağlanabilir.

Eğer bir değişken veya fonksiyon için herhangi bir erişim türü tanımı yapılmamışsa, ön tanımlı olarak, private kabul edilir.

Bir sınıf içindeki değişken ve fonksiyonlara, program içinde bildirimi yapılan sınıf türünden nesneler yoluyla erişmek için, bu değişken ve fonksiyonları public: ifadesinden sonra tanımlamamız gerekir. Bu durumda, programımızın sınıf dışındaki fonksiyonları tanımlanan sınıftan oluşturulan nesneye public fonksiyonlar yoluyla erişim sağlar. Tüm değişkenleri private ve bu verilere dışarıdan erişimi public tanımlı sınıf fonksiyonlarıyla yapmak veri güvenliği açısından en tercih edilen yöntem olarak kabul görür.

Nesne (Object) bildirimi

Nesne bildirimi 2 farklı yöntemle yapılabilir:

1. Nesne bildirimi sınıf bildirimi ile birlikte yapılır.

2. Sınıf bildirimi yapıldıktan sonra, sınıf adını kullanarak nesne bildirimi yapılır.

1. Sınıf bildirimi ile birlikte nesne bildirimi


class sinif {
  // Sadece sınıf fonksiyonlarının erişebileceği private değişkenler
  private:  
    int priid;
  // Sadece sınıf fonksiyonları ile türetilmiş sınıf fonksiyonlarının erişebileceği private değişkenler
  protected:  
    int proid;	
  // Sınıf fonksiyonları, türetilmiş sınıf fonksiyonları ve sınıf nesneleri erşim sağlayabilir.
  public: 
    int pubid;
	void deger_ata(int pid1, int pid2, int pid3);
    void deger_goster();
} nes;

Yukarıda, sinif adlı bir sınıfı oluşturulurken aynı zamanda sinif türünden nes adlı bir nesne tanımlanır.

2. Sınıf bildirimi yapıldıktan sonra nesne bildirimi

Bir sınıf tanımlayarak, yeni bir veri tipi oluşturduktan sonra, bu veri tipinden değişkenler oluşturmak için nesne bildirimi yapılır. Nesne bildirimi yapmak için sınıf adı ile birlikte oluşturulacak nesne adı kullanılır:

sınıf-adı nesne-adı

Aşağıdaki kod satırı sinif sınıfından nes adlı bir nesne oluşturur:


sinif nes;

Tanımlaması yaptığımız sınıf içindeki fonksiyonların sadece bildirimini yaptık. Bu fonksiyonların içinde yer alacak kodları yazabilmek için aşağıdaki genel yapıyı kullanmamız gerekir:

geri-dönüş-değeri sınıf-adı::fonksiyon-adı(parametre1, parametre2, ...)
{
  işlem satırı;
  .
  .  
}

Fonksiyon kodlarını tanımlayan ana yapı içinde yer alan :: işlemcisi bu fonksiyonun sol tarafta yer alan sınıfa ait olduğunu gösterir.

Şimdi, yukarıda tanımlamasını yaptığımız sınıf içinde yer alan fonksiyonların ana yapılarını da içeren programı oluşturmaya çalışalım:


#include <iostream>

using namespace std;

class sinif {
  private:
    // Bu değişkene sadece sinif içindeki fonksiyonlar erişim sağlayabilir.
    int priid;

  protected:
    // Bu değişkene sinif içindeki fonksiyonlar ile sinifana sınıfından türetilmiş sınıf fonksiyonları erişim sağlayabilir.
    int proid;

  public:
    // Bu değişkene sinif içindeki fonksiyonlar ve sinif sınıfından türetilmiş sınıf fonksiyonları ile
    // sinifana türünden ve türetilmiş sınıf türünden oluşturulmuş nesneler doğrudan erişim sağlayabilir.
    int pubid;
    void deger_ata(int pid1, int pid2, int pid3)
    {
      priid = pid1; proid = pid2; pubid = pid3;
      cout << "sinif değişkenlerine değer atama: " << priid << " " << proid << " " << pubid << endl;
    }
    void deger_goster()
    {
      cout << "sinif değişken değerleri: " << priid << " " << proid << " " << pubid << endl;
    }
};

int main(void)
{
  sinif nes;

  cout << "nes değişkeninin sinif elemanlarına erişimi:" << endl;
  cout << "--------------------------------------------" << endl;
  nes.deger_ata(7, 21, 135);
  nes.deger_goster();

  // nes.priid = 954; // Derleme hatası verir (Nesne sınıf içindeki private değişkene doğrudan erişim sağlayamaz).
  // nes.proid = 954; // Derleme hatası verir (Nesne sınıf içindeki protected değişkene doğrudan erişim sağlayamaz).
  nes.pubid = 954;    // Nesne sınıf içindeki public değişkene doğrudan erişim sağlar.

  nes.deger_goster();

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

nes değişkeninin sinif elemanlarına erişimi:
--------------------------------------------
sinif değişkenlerine değer atama: 7 21 135
sinif değişken değerleri: 7 21 135
sinif değişken değerleri: 7 21 954

Program, sinif adlı bir sınıf oluşturur. Sınıf içinde de private, protected ve public olmak üzere üç adet değişken ve bu değişkenlere değer atayan ve ekranda gösteren iki adet fonksiyon tanımlar.

Program çalışmaya başladığında, sinif cinsinden nes adlı bir nesne tanımlar. Nesne yoluyla, sınıf fonksiyonlarını çağırarak, önce deger_ata() fonksiyonu ile sınıf içindeki değişkenlere birer değer atar, sonra deger_goster() fonksiyonu ile değişken değerlerini ekrana yazar. Nesne yoluyla sınıf içindeki pubid adlı public değişkene 954 değeri atar. Sınıf içinde yer alan private ve protected değişkenlere doğrudan nesne yoluyla erişim sağlamaya çalışırsa, program derleme hatası verir. Sonra, deger_goster() fonksiyonu ile değişken değerlerini tekrar ekrana yazar.

Bir sınıftan oluşturulmuş nesneler ayrı bir sınıf kopyası üzerinde işlem yaptığından, farklı nesnelere ait değişken değerlerinin birbiri ile ilgisi yoktur.

Bir sınıf içinde yer alan üye fonksiyonların, aynı sınıf içinde yer alan diğer fonksiyon ve değişkenlere erişim için nokta (.) işlemcisini kullanmasına gerek yoktur.

Bir sınıftan oluşturulan nesne yoluyla sınıf içinde yer alan private ve protected değişken ve fonksiyonlara direk erişim sağlanmaz, bu erişim aynı sınıf içinde yer alan üye fonksiyonlar yoluyla sağlanır.

Constructor ve destructor kavramı

C++'da nesnelerin bildirimi yapılırken, nesnenin tanımlandığı sınıfta yer alan değişkenlere bir ilk değer verme işlemi gerçekleştirmek için constructor fonksiyonları kullanılır.

Aynı şekilde nesneler yok edilirken de, belirli işlemleri gerçekleştirmek için destructor fonksiyonları kullanılır.

constructor ve destructor fonksiyonları içinde tanımlandığı sınıfın bir elemanı olup, sınıf ile aynı adı taşır. destructor fonksiyonları başına ~ işareti alır.

Bir sınıfın constructor fonksiyonu, bir nesne oluşturulduğunda, destructor fonksiyonu ise, nesne yok edildiğinde, otomatik olarak çağrılır.

C++'da constructor ve destructor fonksiyonları herhangi bir değer geri vermediğinden, fonksiyon bildiriminde dönüş değeri tanımlaması yapılmadığına dikkat ediniz.

Şimdi, constructor ve destructor fonksiyonlarının kullanımını bir örnek üzerinde incelemeye çalışalım:


#include <iostream>

using namespace std;

class sinif {
  private:
    // Bu değişkene sadece sinif içindeki fonksiyonlar erişim sağlayabilir.
    int priid;

  protected:
    // Bu değişkene sinif içindeki fonksiyonlar ile sinif sınıfından türetilmiş sınıf fonksiyonları erişim sağlayabilir.
    int proid;

  public:
    // Bu değişkene sinif içindeki fonksiyonlar ve sinif sınıfından türetilmiş sınıf fonksiyonları ile
    // sinif türünden ve türetilmiş sınıf türünden oluşturulmuş nesneler doğrudan erişim sağlayabilir.
    int pubid;
    // Constructor fonksiyon bildirimi
    sinif(int pid1, int pid2, int pid3);
    // Destructor fonksiyon bildirimi
    ~sinif();
    void deger_ata(int pid1, int pid2, int pid3);
    void deger_goster();
};

// Sınıf fonksiyonlarının kod blok tanımlamaları
sinif::sinif(int pid1, int pid2, int pid3)
{
  cout << "constructor fonksiyonu ile sınıf değişkenlerine değer atama" << endl;
  priid = pid1; proid = pid2; pubid = pid3;
}

sinif::~sinif()
{
  cout << "Nesne yok edildi!" << endl;
}

void sinif::deger_ata(int pid1, int pid2, int pid3)
{
  cout << "Üye fonksiyon ile sınıf değişkenlerine değer atama" << endl;
  priid = pid1; proid = pid2; pubid = pid3;
}

void sinif::deger_goster()
{
  cout << "sınıf değişken değerleri: " << priid << " " << proid << " " << pubid << endl;
}

int main(void)
{
  // Nesne oluştururken sınıf değişkenlerine değer atama
  sinif nes(9, 25, 174);
  nes.deger_goster();

  // Üye fonksiyon ile sınıf değişkenlerine değer atama
  nes.deger_ata(7, 21, 135);
  nes.deger_goster();

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

constructor fonksiyonu ile sınıf değişkenlerine değer atama 
sınıf değişken değerleri: 9 25 174
Üye fonksiyon ile sınıf değişkenlerine değer atama 
sınıf değişken değerleri: 7 21 135
Nesne yok edildi!

Program, sinif adlı bir sınıf oluşturur. Sınıf içinde de private, protected ve public olmak üzere üç adet değişken ve bu değişkenlere nesne oluştururken değer atayan bir constructor fonksiyonu, bir destructor fonksiyonu, nesne ile değişkenlere değer atayan deger_ata() adlı bir fonksiyon ve değişkenleri ekrana yazan deger_goster() adlı bir fonksiyon tanımlar.

Program çalışmaya başladığında, sinif cinsinden nes adlı bir nesne bildirimi yaparken sınıf içindeki değişkenlere constructor fonksiyonu yoluyla birer değer atar. Nesne yoluyla, deger_goster() fonksiyonu ile değişken değerlerini ekrana yazar. Yine, nesne yoluyla deger_ata() fonksiyonu ile sınıf içindeki değişkenlere birer değer atar, sonra deger_goster() fonksiyonu ile değişken değerlerini yeniden ekrana yazar.

Burada destructor fonksiyonu içeriği sadece yaptığı işlemi göstermek için oluşturulmuştur.

Tek parametre değeri alan constructor fonksiyonları

Bir constructor fonksiyonu ile sadece tek bir ilk değer verme işlemi gerçekleştireceksek, bu işlemi aşağıdaki işlem satırı ile de yapabiliriz.

sınıf-adı nesne-adı = ilk-değer;

Aşağıdaki program 2 farklı yöntem kullanarak personel sınıfı içindeki int değişkene nesne oluşturma anında bir ilk değer atar:


#include <iostream>

using namespace std;

class sinif {
  private:
    int priid;
  public:
    sinif(int pid);
    ~sinif();
    void deger_ata(int pid);
    void deger_goster();
};

sinif::sinif(int pid)
{
  cout << "constructor fonksiyonu ile sınıf değişkenine değer atama" << endl;
  priid = pid;
}

sinif::~sinif()
{
  cout << "Nesne yok edildi!" << endl;
}

void sinif::deger_ata(int pid)
{
  cout << "Üye fonksiyon ile sınıf değişkenine değer atama" << endl;
  priid = pid;
}

void sinif::deger_goster()
{
  cout << "sınıf değişken değeri: " << priid << endl;
}

int main(void)
{
  // Nesne oluştururken sınıf değişkenlerine değer atama
  sinif nes1(25);
  // Sadece tek bir değer verme işlemi için nesne bildirimi
  sinif nes2 = 36; // Otomatik olarak sinif nes2(36) şekline çevrilir.

  // Üye fonksiyon ile sınıf değişkenlerini ekrana yazma
  nes1.deger_goster();
  nes2.deger_goster();

  // Üye fonksiyon ile sınıf değişkenlerine değer atama
  nes1.deger_ata(121);
  nes2.deger_ata(246);

  // Üye fonksiyon ile sınıf değişkenlerini ekrana yazma
  nes1.deger_goster();
  nes2.deger_goster();

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

constructor fonksiyonu ile sınıf değişkenine değer atama
constructor fonksiyonu ile sınıf değişkenine değer atama
sınıf değişken değeri: 25
sınıf değişken değeri: 36
Üye fonksiyon ile sınıf değişkenine değer atama
Üye fonksiyon ile sınıf değişkenine değer atama
sınıf değişken değeri: 121
sınıf değişken değeri: 246
Nesne yok edildi!
Nesne yok edildi!

Program, sinif adlı bir sınıf oluşturur. Sınıf içinde de private bir int değişken ve bu değişkene nesne oluştururken değer atayan bir constructor fonksiyonu, bir destructor fonksiyonu, nesne ile değişkene değer atayan deger_ata() adlı bir fonksiyon ve değişken değerini ekrana yazan deger_goster() adlı bir fonksiyon tanımlar.

Program çalışmaya başladığında, sinif cinsinden nes1 ve nes2 adlı iki nesne bildirimi yaparken sınıf içindeki değişkene constructor fonksiyonu yoluyla bir değer atar. Nesneler yoluyla, deger_goster() fonksiyonu ile değişken değerlerini ekrana yazar. Yine, nesne yoluyla deger_ata() fonksiyonu ile sınıf içindeki değişkene bir değer atar, sonra deger_goster() fonksiyonu ile değişken değerlerini yeniden ekrana yazar.

Explicit constructor fonksiyonlar

Bir sınıf içindeki constructor fonksiyonu sadece tek bir parametre aldığında, aşağıda gösterilen her iki nesne bildirimi de aynı işlemi yapmaktadır:

sınıf-adı nesne-adı(değer);

sınıf-adı nesne-adı = değer;

Nesne ile temsil edilen sınıf kopyasındaki değişkene değer atamak için atama işlemcisi kullanıldığında, bu satır otomatik olarak üstteki işlem satırındaki yapıya dönüştürülür. Bu otomatik dönüştürme işleminin yapılmasını istemediğimizde, explicit constructor fonksiyonlarını kullanabiliriz.

Şimdi, explicit constructor fonksiyonlarının kullanımını bir örnek üzerinde incelemeye çalışalım:


#include <iostream>

using namespace std;

class sinif {
  private:
    int priid;
  public:
    sinif(int pid);
    void deger_goster();
};

sinif::sinif(int pid)
{
  cout << "constructor fonksiyonu ile sınıf değişkenine değer atama" << endl;
  priid = pid;
}

void sinif::deger_goster()
{
  cout << "Sınıf değişken değeri: " << priid << endl;
}

int main(void)
{
  // Nesne oluştururken sınıf değişkenlerine değer atama
  sinif nes1(21);
  nes1.deger_goster();

  // Atama işlemcisi ile değer vererek nesne bildirimi
  // Aşağıdaki işlem satırları derleme hatası verir.
  // sinif nes2 = 36; // Otomatik olarak sinif nes2(36) şekline çevrilir.
  // nes2.deger_goster();

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

constructor fonksiyonu ile sınıf değişkenine değer atama
Sınıf değişken değeri: 21

Program, sinif adlı bir sınıf oluşturur. Sınıf içinde de private bir int değişken ve bu değişkene nesne oluştururken değer atayan bir constructor fonksiyonu ve değişken değerini ekrana yazan deger_goster() adlı bir fonksiyon tanımlar.

Program çalışmaya başladığında, sinif cinsinden nes1 adlı bir nesne bildirimi yaparken sınıf içindeki değişkene constructor fonksiyonu yoluyla bir değer atar. Nesne yoluyla, deger_goster() fonksiyonu ile değişken değerini ekrana yazar. Atama işlemcisi ile değer verilerek yapılan nes2 adlı nesne oluşturma işlemi ise, constructor fonksiyonu implicit olarak tanımlandığından, derleme hatası verir.

Constructor fonksiyonlarda ilk değer verme listesi

Bir sınıf içinde bildirimi yapılan değişkenlere, bu sınıftan oluşturulan nesne bildirimi esnasında, constructor fonksiyonlara geçirilen değerler yoluyla bir ilk değer verilebilir. Ancak, sınıf içinde const olarak bildirimi yapılan değişkenlere bir ilk değer vermek için ilk değer verme listesi içeren constructor fonksiyonlarını kullanabiliriz. İlk değer verme listesi içeren constructor fonksiyonlarının genel yapısı aşağıda gösterilmektedir:

constructor-adı(veri-türü1 değer1, veri-türü2 değer2, ... ) : değişken-adı1(değer1), değişken-adı2(değer2), ...
{ 
  // Kod
}

İlk değer verilecek olan değişkenler constructor fonksiyonunun adından sonra yer alır ve fonksiyon kodlarından : işareti ile ayrılır.

Şimdi, ilk değer verme listesi içeren explicit constructor fonksiyonlarının kullanımını bir örnek üzerinde incelemeye çalışalım:


#include <iostream>

using namespace std;

class sinif {
  private:
    const int priid1, priid2;
  public:
    sinif(int pid1, int pid2):priid1(pid1), priid2(pid2) { }
    void deger_goster();
};

void sinif::deger_goster()
{
  cout << "Sınıf değişken değerleri: " << priid1 << " " << priid2 << endl;
}

int main(void)
{
  sinif nes(21, 35);
  nes.deger_goster();

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

Sınıf değişken değerleri: 21 35

Program, sinif adlı bir sınıf oluşturur. Sınıf içinde, iki adet const private int değişken ve bu değişkenlere nesne oluştururken değer atayan ve bir ilk değer verme listesi içeren constructor fonksiyonu ve değişken değerlerini ekrana yazan deger_goster() adlı bir fonksiyon tanımlar.

Program çalışmaya başladığında, sinif cinsinden nes adlı bir nesne bildirimi yaparken sınıf içindeki değişkenlere, constructor fonksiyonu yoluyla değer atar. Nesne yoluyla, deger_goster() fonksiyonu ile değişken değerlerini ekrana yazar.

Constructor ve destructor fonksiyonlarının çalışma sırası

Bir sınıftan bir nesne oluşturulduğunda constructor fonksiyonu, yok edildiğinde ise destructor fonksiyonu çağrılır.

Ancak global ve lokal nesne bildirimlerinde bir farklılık meydana gelir. Nesne bildirimi global olarak yapıldığında, constructor fonksiyonları main() fonksiyonunun çalışmasından önce bildirim sırasına göre, destructor fonksiyonları ise main() fonksiyonunun çalışması sona erdikten sonra bildirim sırasının tersine olacak şekilde devreye girer.

Nesne bildirimi lokal olarak yapıldığında, bildirim yapılır yapılmaz constructor fonksiyonu çağrılır. Bildirimi ilk yapılan nesneden başlamak üzere constructor fonksiyonları devreye girer. Destructor fonksiyonları ise bildirimi en son yapılan nesneden başlamak üzere devreye girer.

Constructor fonksiyonları, önce global sonra yerel nesneler olmak üzere, bildirim sırasına göre çalışır. Destructor fonksiyonları, önce yerel sonra global nesneler olmak üzere, bildirim sırasının tersine çalışır.

Şimdi bu sistemin çalışmasını bir örnek üzerinde incelemeye çalışalım:


#include <iostream>

using namespace std;

class sinif {
  private:
    int priid;
  public:
    sinif (int pid);
    ~sinif();
} gnes1(7), gnes2(8); // global nesne bildirimleri

sinif::sinif(int pid)
{
  cout << "Nesne oluşturuluyor: " << pid << endl;
  priid = pid;
}

sinif::~sinif()
{
  cout << "Nesne yok ediliyor: " << priid << endl;
}

int main(void)
{
  sinif lnes01(21); // lokal nesne bildirimi

  sinif lnes02(35); // lokal nesne bildirimi

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

Nesne oluşturuluyor: 7
Nesne oluşturuluyor: 8
Nesne oluşturuluyor: 21
Nesne oluşturuluyor: 35
Nesne yok ediliyor: 35
Nesne yok ediliyor: 21
Nesne yok ediliyor: 8
Nesne yok ediliyor: 7

Program 2 adet global ve 2 adet lokal nesne bildirimi yapar. Nesnelerin oluşturulma ve yok edilme anındaki değişken değerlerini ekrana yazar.