Nesne Tabanlı Programlama
Ali ÇAKIR
0 yorum
C ++ Programlama Değiştirici Fonksiyon, C++ Nesne Tabanlı Programlama, C++ Programlama Dersleri, C++ Programlama İkili Kapsam Çözme Operatörü, C++ Programlama Sınıf Nesne veya Fonksiyon Üyelerine Erişmek, C++ Programlama Sınıflar
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.
- 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
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.
#include <iostream> using namespace std; class Ornek1 { public: int i; // veri üye void yaz() // fonksiyon üye { cout << “i= ” << i << endl; } }; int main() { Ornek1 x; // Ornek1 sınıfı tipinde x nesnesi tanımlanır x.i = 5; // nesnesinin i üyesine 5 atanır x.yaz(); // x nesnesinin yaz() fonksiyonu çağrılır return 0; } /*////////////////////////////////////////////////////////////////////// Çıktı: i=5 //////////////////////////////////////////////////////////////////////*/
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();
#include <iostream> using namespace std; class Ornek2 { public: int i; // Her yerden erişile bilen üyeler void yaz() { y = 5.2; // üye fonksiyonundan özel y üyesine erişelebilir z = 9; cout << “i=” << i << endl; cout << “y=” << y << endl; cout << “z= ” << z << endl; } private: // sadece sınıf içinde erişilebilen üyeler float y; int z; }; int main() { Ornek2 nsn; //Ornek2 Sınıfı tipinde nsn isimli nesne tanımı nsn.i = 5; // nsn nesnesin i üyesine 5 atanır; nsn.yaz(); // nsn nesnesinin yaz() fonksiyonunu çağırır return 0; } /*////////////////////////////////////////////////////////////////////// int main() { Ornek2 nsn; nsn.i = 5; // private olarak tanımlanmış y üyesine erişilemez nsn.y = 5.2 ;//private olarak tanımlanmış z üyesine erişilemez nsn.z = 9; nsn.yaz(); return 0; } /////////////////////////////////////////////////////////////////////*/
Yukarıdaki program incelendiğinde
int main() { Ornek2 nsn; nsn.i = 5; // private olarak tanımlanmış y üyesine erişilemez nsn.y = 5.2 ; //private olarak tanımlanmış z üyesine erişilemez nsn.z = 9; nsn.yaz(); return 0; }
#include<iostream> using namespace std; class S { public: int a; }; int main() { S m, n; // S tipinde m ve n isminde iki nesne tanımlanır n.a = 8; cout << ” n nesnesinin a uyesi:” << n.a << end; m = n; cout << “m nesnesinin a uyesi: ” << m.a << endl; S &ref = n; // n nesnesini gösteren referans değişkeni tanımlanır cout << ” ref referansinin a uyesi: ” << ref.a << endl; ref.a = 7; //ref’in referans olduğu nesnenin a üyesi 7 atanır cout << “ref referansinin a uyesi: ” << ref.a << endl; S kere[3]; // S tipinde 3 nesneyi içeren bir dizi tanımlanır kere[2].a = 6; // kere dizisinin 2. indeksli nesnesinin a uyesine 6 atanır cout << “kere dizisinin 2. nesnesinin a uyesi: ” << kere[2].a << endl; return 0; }

İ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ı:
döndürülenVeriTipi SınıfAdı :: fonksiyonAdı(parametre listesi) {…….. }
#include<iostream> using namespace std; class Sayi { int n; public: void sakla(int 0); int al(); }; void Sayi::sakla(int x) // Değiştirici fonksiyon tanımı { n = x; } int Sayi::al() { return n; } int main() { Sayi no; no.sakla(); cout << “n= ” << no.al() << endl; no.sakla(10); cout << “n= ” << no.al() << endl; return 0; }
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.
#include >iostream> using namespace std; #define SINIF_MEVCUDU 2 class Ogrenci { int no,vize,final; //private üyeleri public: // erişimci fonksiyonlar int noAl(){return no;} int vizeAl(){return vize;} int finalAl(){return final;} // Değiştirici Fonksiyonlar void noAta(int _no){no=_no;} void vizeAta(int _vize)){vize=_vize;} void finalAta(int _final){final=_final;} }; int main() { Ogrenci sinif [SINIF_MEVCUDU ]; // 50 Ögrencilik dizi tanımı int n,vize,final; float ortalama; for(int i=0; i<SINIF_MEVCUDU; i++) { cout<<endl<“Ogrenci numarasi,vize ve finali giriniz: “; cin>>no>>vize>>final; Ogrenci ogenci; // ogrenci nesnesine deger aktarımı ogrenci.noAta(no); ogrenci.vizeAta(vize); ogrenci.finalAta(final); sinif[i]=ogrenci; // sinif dizisine eleman ekleme } for(int i=0; i<SINIF_MEVCUDU; i++) { ortalama=0.4*sinif[i].vizeAl()+0.6*sinif[i].finalAl(); cout<<sinif[i].noAl()<<” numarali ogrencinin ortalamasi:”<<ortalama<<endl; } return 0; }
4
4
votes
Article Rating