Nesne Tabanlı Programlama

Nesne Tabanlı Programlama Sınıf İşlemleri

  • Sınıf kavramı, nesne tabanlı programlamanın temelini oluşturur.
  • Nesne tabanlı programlamanın ilk özelliği olan sarmalama (encapsulation) , veri ve bu veriyle ilgili işlemlerin tek bir birimde toplanması gerektiğini belirtir.
  • Gerçek hayata etrafımıza baktığımızda canlı cansız birçok nesneyle karşılaşırız.
  • Bu nesnelerin her birinin durumu ve davranış özellikleri vardır.

Sınıf İşlemleri

  • Nesne tabanlı programlama mantığını kullanırsak, Lola nesnesi, tüm köpek nesnelerini oluşturan sınıfın bir örneğidir.
  • Sınıf ise tüm köpek neslnelerini oluşturan sınıfın bir örneğidir.
  • Sınıf ise tüm köpek nesnelerini oluşturmak için kullanılan bir modeldir.
  • Buradan yola çıkarak sınıfı bir nesneyi oluşturmak için gereken model veya plan olarak tanımlayabiliriz

Köpek Sınıfı

Sınıf Tanımı

  • Sınıf, çözülmesi gereken problemin içeriğine göre yeni bir veri tipi ve bu veri tipi ile yapılacak işlemleri tanımlamamıza olanak sağlar.
  • Oluşturulan her nesnenin durum özellikleri veri üyesi (data member), davranış özellikleri üye fonksiyonlarla (member function) tanımlanır.

Kullanımı:

class sınıfAdı
          {
               public:// Her yerden erişilebilen üyeler
               private:// Sadece sınıf içinden erişilebilen üyeler
            };

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

  • public (genel): bu etiket altında tanımlanan üyelere programın her yerinden erişilebilir.
  • private (özel): bu etiket altında tanımlanan üyelere sadece sınıf içerisinden erişilebilir.

Sınıf tipinde tanımlanan değişkenlere nesne (object) adı verilir. Sınıf tanımı sırasında public ve private sınıf üyelerinin erişim etiketleri privare olarak varsayılır.

  1. #include <iostream>
  2. using namespace std;
  3. class Ornek1
  4. {
  5. public:
  6. int i; // veri üye
  7. void yaz() // fonksiyon üye
  8. {
  9. cout << “i=<< i << endl;
  10. }
  11. };
  12. int main()
  13. {
  14. Ornek1 x; // Ornek1 sınıfı tipinde x nesnesi tanımlanır
  15. x.i = 5; // nesnesinin i üyesine 5 atanır
  16. x.yaz(); // x nesnesinin yaz() fonksiyonu çağrılır
  17. return 0;
  18. }
  19. /*//////////////////////////////////////////////////////////////////////
  20.   Çıktı:
  21.   i=5
  22. //////////////////////////////////////////////////////////////////////*/

Sınıf Nesne veya Fonksiyon Üyelerine Erişmek

  • Yapılarda olduğu gibi bir nesnenin veri veya fonksiyon üyelereine erişmek için aşağıda görüldüğü gibi nokta (.) operatörünü kullanırız.

Kullanımı:

nesneAdı.üyeİsmi
 
x.i=5;
x.yaz();
  1. #include <iostream>
  2. using namespace std;
  3.  
  4. class Ornek2
  5. {
  6. public:
  7. int i; // Her yerden erişile bilen üyeler
  8. void yaz()
  9. {
  10. y = 5.2; // üye fonksiyonundan özel y üyesine erişelebilir
  11. z = 9;
  12. cout << “i=<< i << endl;
  13. cout << “y=<< y << endl;
  14. cout << “z=<< z << endl;
  15. }
  16.  
  17. private: // sadece sınıf içinde erişilebilen üyeler
  18. float y;
  19. int z;
  20. };
  21.  
  22. int main()
  23. {
  24. Ornek2 nsn; //Ornek2 Sınıfı tipinde nsn isimli nesne tanımı
  25. nsn.i = 5; // nsn nesnesin i üyesine 5 atanır;
  26. nsn.yaz(); // nsn nesnesinin yaz() fonksiyonunu çağırır
  27. return 0;
  28. }
  29.  
  30. /*//////////////////////////////////////////////////////////////////////
  31. int main()
  32.  {
  33.   Ornek2 nsn;
  34.   nsn.i = 5; // private olarak tanımlanmış y üyesine erişilemez
  35.   nsn.y = 5.2 ;//private olarak tanımlanmış z üyesine erişilemez
  36.   nsn.z = 9;
  37.   nsn.yaz();
  38.  return 0;
  39.   }
  40. /////////////////////////////////////////////////////////////////////*/

Yukarıdaki program incelendiğinde

  1. int main()
  2. {
  3. Ornek2 nsn;
  4. nsn.i = 5; // private olarak tanımlanmış y üyesine erişilemez
  5. nsn.y = 5.2 ; //private olarak tanımlanmış z üyesine erişilemez
  6. nsn.z = 9;
  7. nsn.yaz();
  8. return 0;
  9. }
  1. #include<iostream>
  2. using namespace std;
  3.  
  4. class S
  5. {
  6. public:
  7. int a;
  8. };
  9. int main()
  10. {
  11. S m, n; // S tipinde m ve n isminde iki nesne tanımlanır
  12. n.a = 8;
  13. cout << ” n nesnesinin a uyesi:<< n.a << end;
  14. m = n;
  15. cout << “m nesnesinin a uyesi:<< m.a << endl;
  16. S &ref = n; // n nesnesini gösteren referans değişkeni tanımlanır
  17. cout << ” ref referansinin a uyesi:<< ref.a << endl;
  18. ref.a = 7; //ref’in referans olduğu nesnenin a üyesi 7 atanır
  19. cout << “ref referansinin a uyesi:<< ref.a << endl;
  20.  
  21. S kere[3]; // S tipinde 3 nesneyi içeren bir dizi tanımlanır
  22. kere[2].a = 6; // kere dizisinin 2. indeksli nesnesinin a uyesine 6 atanır
  23. cout << “kere dizisinin 2. nesnesinin a uyesi:<< kere[2].a << endl;
  24. return 0;
  25. }
Sınıf Nesne veya Fonksiyon Üyelerine Erişmek

İkili Kapsam Çözme Operatörü

  • Sınıfın dışında tanımlanan fonksiyonun hangi sınıfın üye fonksiyonu olduğunu belirtmek amacıyla ikili kapsam çözme operatörü (::) ( binary scope resolution operator ) kullanılır.

Kullanımı:

  1. döndürülenVeriTipi SınıfAdı :: fonksiyonAdı(parametre listesi)
  2. {……..
  3. }
  1. #include<iostream>
  2. using namespace std;
  3.  
  4. class Sayi
  5. {
  6. int n;
  7. public:
  8. void sakla(int 0);
  9. int al();
  10. };
  11. void Sayi::sakla(int x) // Değiştirici fonksiyon tanımı
  12. {
  13. n = x;
  14. }
  15. int Sayi::al()
  16. {
  17. return n;
  18. }
  19. int main()
  20. {
  21. Sayi no;
  22. no.sakla();
  23. cout << “n=<< no.al() << endl;
  24. no.sakla(10);
  25. cout << “n=<< no.al() << endl;
  26. return 0;
  27. }
Değiştirici Fonksiyon
  • Bir sınıf üyesinin değerini değiştiren fonksiyonlara değiştirici fonksiyon (mutator function ) adı verilir.
  • Sınıf üyesini değiştirmeyen, sadece bu üyeleri döndüren fonksiyonlara erişimici fonksiyon (accessor function ) ismi verilir.
  1. #include >iostream>
  2. using namespace std;
  3. #define SINIF_MEVCUDU 2
  4. class Ogrenci
  5. {
  6.  
  7. int no,vize,final; //private üyeleri
  8. public: // erişimci fonksiyonlar
  9. int noAl(){return no;}
  10. int vizeAl(){return vize;}
  11. int finalAl(){return final;}
  12.  
  13. // Değiştirici Fonksiyonlar
  14. void noAta(int _no){no=_no;}
  15. void vizeAta(int _vize)){vize=_vize;}
  16. void finalAta(int _final){final=_final;}
  17. };
  18.  
  19. int main()
  20. {
  21. Ogrenci sinif [SINIF_MEVCUDU ]; // 50 Ögrencilik dizi tanımı
  22. int n,vize,final;
  23. float ortalama;
  24. for(int i=0; i<SINIF_MEVCUDU; i++)
  25. {
  26. cout<<endl<“Ogrenci numarasi,vize ve finali giriniz:;
  27. cin>>no>>vize>>final;
  28. Ogrenci ogenci; // ogrenci nesnesine deger aktarımı
  29. ogrenci.noAta(no);
  30. ogrenci.vizeAta(vize);
  31. ogrenci.finalAta(final);
  32. sinif[i]=ogrenci; // sinif dizisine eleman ekleme
  33. }
  34. for(int i=0; i<SINIF_MEVCUDU; i++)
  35. {
  36. ortalama=0.4*sinif[i].vizeAl()+0.6*sinif[i].finalAl();
  37. cout<<sinif[i].noAl()<<” numarali ogrencinin ortalamasi:<<ortalama<<endl;
  38. }
  39. return 0;
  40. }

Kimler Neler Demiş?

  Abone ol  
Bildir