C Programlama da Sınıflar ve Nesneler

C Programlama da Sınıflar ve Nesneler

 

Sınıf (Class) Kavramı : Nesne tabanlı programlamada gereken nesneleri sınıflar yardımıyla oluşturmaktır. Sınıfları, nesneleri oluşturmak için önceden oluşturulmuş bir kalıp veya ilk örnek olarak da düşünülebilir. Örneğin, kağıt üzerine detayları çizilmiş bir ev planını kullanarak aynı evden pek çok örnek ev oluşturulabilir. İşte burada kağıt üzerindeki bu plan sınıftır. Bu plana bakılarak yapılan ev ise sınıftan oluşturulan nesne örneğidir.

 

Sınıf kavramı, nesne-tabanlı programlamanın temelini oluşturur. Nesnelerin her birinin durumu ve davranış özellikleri vardır. Bir Nesne, durum ve davranış özelliklerini içinde barındırır.

 

Oluşturulan her nesnenin durum özelliklerine veri üyesi (data member), davranış özelliklerine üye fonksiyonları (member function) denir.

 

Örneğin, bir bisikleti yazılım nesnesi olarak tanımlarsak bisiklet sınıfında hız, vites, jant büyüklüğü gibi veri üyeleri tanımlanabilir. Ayrıca vites değiştirmek, fren yapmak ve hızı artırmak için üye fonksiyonları tanımlamak gereklidir. 

 

Sınıf tanımında yer alan üyelere erişimi, farklı erişim etiketleri kullanarak sınırlandırılabilir:

 

public:  Bu etiket altında tanımlanan üyelere programın her yerinden erişilebilir.

private: Bu etiket altında tanımlanan üyelere sadece sınıf içerisinden erişilebilir.

 

Nesne (Object) Kavramı : Sınıf tipinde tanımlanan değişkenlere nesne (object) adı verilir. Sınıf tanımında public veya private belirtilmezse, tanımlanan sınıf üyelerinin erişim etiketleri private olarak varsayılır.

 

Sınıf Tanımlama Örnek: 

#include <iostream>
using namespace std;
class sinifOrnek
{
    public:
      int x;        //Veri Üyesi (data member)
      void yaz()    //Fonksiyon Üye (member function)
      {
           cout<<"x="<<x<<endl;
      }
};
int main()
{
   sinifOrnek y;  //sinifOrnek sınıfı tipinde y nesnesi tanımlanıyor.
   y.x = 3;      //y nesnesinin x üyesine 3 atanıyor.  
   y.yaz();     //y nesnesinin yaz() fonsiyonu çağrılıyor 
   return 0;
}

 

Aynı yapılarda olduğu gibi bir nesnenin veri veya fonksiyon üyelerine erişmek için nokta (.) operatörünü kullanırız. nesneAdı.üyeİsmi

   y.x = 3;      
   y.yaz();    

 

Örnek 1:

#include <stdio.h>
#include <conio.h>
#include <cstdlib>
#include <iostream>

using namespace std;
class Ornek
{
      public:
             int i; //Her noktadan erişilebilen üye
             void yaz()
             {
                  t = 6.1; //Üye fonksiyondan özel t üyesine erişilebilir.
                  z = 8;
                  cout<<"i= "<<i<<endl;
                  cout<<"t= "<<t<<endl;
                  cout<<"z= "<<z<<endl;                
             }
      private:  //Sadece sınıf içinden erişilebilen üyeler
              float t;
              int z;
};
int main()
{
    Ornek nesne;  //Ornek sınıfı tipinde nesne isimli nesne tanımı
    nesne.i = 6;  //nesne isimli nesnenin i üyesine 6 atanıyor.
    nesne.yaz(); //nesne isimli nesnenin yaz() fonksiyonu çağrılır. 
getch();
}

 

 

Örnek 2:

#include <stdio.h>
#include <conio.h>
#include <cstdlib>
#include <iostream>

using namespace std;
class Ornek
{
      public:
             int i; //Her noktadan erişilebilen üye
             void yaz()
             {
                  t = 6.1; //Üye fonksiyondan özel t üyesine erişilebilir.
                  z = 8;
                  cout<<"i= "<<i<<endl;
                  cout<<"t= "<<t<<endl;
                  cout<<"z= "<<z<<endl;                
             }
      private:  //Sadece sınıf içinden erişilebilen üyeler
              float t;
              int z;
};
int main()
{
    Ornek nesne;  //Ornek sınıfı tipinde nesne isimli nesne tanımı
    nesne.i = 6;  //nesne isimli nesnenin i üyesine 6 atanıyor.
    nesne.yaz(); //nesne isimli nesnenin yaz() fonksiyonu çağrılır. 
getch();
}

 

 

int main()
{
   ornek3 nesne;
   nesne.i =5;
   nesne.t =6.1;
   nesne.z =8;
   nesne.yaz()
}

Örnek 2'de public olarak etiketlenmiş a üyesine main fonksiyonundan erişim sağlanabilirken, private olarak etiketlenmiş b ve c üyelerine erişim sağlanamayacaktır.
 

Nesne Tanımlama Örnek: 

#include <stdio.h>
#include <conio.h>
#include <cstdlib>
#include <iostream>

using namespace std;

class NesneOrnek
{
      public:
            int n;
};
int main()
{
    NesneOrnek x,y; //NesneOrnek tipinde x ve y isimlerinde nesneleri tanımlıyoruz.
    y.n=6; //y nesnesinin n üyesine 6 atanır.
    cout<<" y nesnesinin n uyesi: "<<y.n<<endl;
    x=y; //" x nesnesini y nesnesine kopyalıyoruz
    cout<<" x nesnesinin n uyesi: "<<x.n<<endl;
    NesneOrnek &ref=y; //y nesnesini gösteren referans değişkeni ref tanımlıyoruz.
    cout<<" ref referansinin n uyesi: "<<ref.n<<endl;
    ref.n =5; //ref'in referans olduğu nesnenin n üyesine  ataması yapıyoruz.
    cout<<" ref referansinin n uyesi: "<<ref.n<<endl;
    NesneOrnek ndizi[3]; //NesneOrnek tipinde 3 nesneyi içeren bir dizi tanımlıyoruz.
    ndizi[2].n=4; //ndizinin 2.indeksli nesnesinin n üyesine 4 ataması yapıyoruz.
    cout<<" ndizi dizisinin 2.nesnesinin n uyesi: "<<ndizi[2].n<<endl;
getch();    
}

 

Örnek 3: 
Bir  Su Otamatımız olsun ve programımızda SuOtomatı adında bir sınıf tanımlayalım.

Durum özellikleri veri üyeleri (data members) :

• ŞişeSu Fiyatı
• Otomatta Kalan Su Sayısı

Davranış özellikleri üye fonksiyonları (member functions):

• ilkVerilenSu(): fiyat ve Su Şişesi sayısına parametre olarak gelen değerleri atayacak. Varsayılan değeri 1 lira, sayı değeri ise 100 olarak alınacak.
• suVerme(): Kullanıcıya ücreti gösterecek. Kullanıcı yeterli ücreti girdiyse ve otomatta su mevcut ise kullanıcıya bir şişe su verecek ve kullanıcının para üstünü hesaplayacak.
• goster(): Su fiyatını ve otomatta kalan şişe sayısını verecek.

#include <stdio.h>
#include <conio.h>
#include <cstdlib>
#include <iostream>
using namespace std;

class SuOtomati
{
      float fiyat;
      int sayi;
      public:
             void ilkVerilenSu (float f=1, int s=100);
             void suVerme();
             void goster(); 
};

void SuOtomati::ilkVerilenSu( float f, int s)
{
     fiyat=f;
     sayi=s;
}

void SuOtomati::suVerme()
{
     float odeme,fark;
     cout<<"Bir Sise Su Fiyati: "<<fiyat<<" lira."<<endl;
     cout<<"Odemeniz: ";
     cin>>odeme;
     if((odeme>=fiyat)&&(sayi>0))
     {
       cout<<"Su Veriliyor."<<endl;
       sayi--;
       fark=odeme-fiyat;
       if(fark>0)
       {
                 cout<<"Para Ustunuz: ";
                 if(fark<1.0)
                    cout<<fark<<" lira"<<endl;
                 else 
                    cout<<fark*100<<" kurus"<<endl;                 
       }
}
else
    cout<<"Otomatta Su Mevcut Degil";
}

void SuOtomati::goster()
{
     cout<<"Son Durum:"<<endl; 
     cout<<"Bir Sise Su Fiyati: "<<fiyat<<endl;
     cout<<"Otomatta Kalan Su Sayisi: "<<sayi<<endl; 
}
int main()
{
    SuOtomati univ;
    univ.ilkVerilenSu();
    univ.suVerme();
    univ.goster();
    getch();
}

 

 

 

Son örneğimizde diğer örneklerden farklı olarak ikili kapsam çözme operatörü (::) binary scope resolution operator kullandık.
 

void SuOtomati::ilkVerilenSu( float f, int s)

 

Bu operatörün amacı sınıfın dışında tanımlanan fonksiyonun hangi sınıfın üye fonksiyonu olduğunu belirtmek içindir.