nesneye dayal ı programlama

Harran Üniversitesi Bilgisayar Mühendisliği Yrd.Doç.Dr.Nurettin Beşli

Nesneye Dayalı Programlama

DERS 3


NESNE MODELLERİ : SINIFLAR Bu bölümden itibaren C++ programlama dilinin

nesneye dayalı programlamaya yönelik özellikleri tanıtılacaktır.

Bu özellikler yazılımların kalitesini yükseltmek amacıyla geliştirilmişlerdir.

Bilgisayar programı yazmak, aslında gerçek dünyadaki unsurların bilgisayarda

birer modellerinin oluşturulması anlamına gelir. Gerçek dünya nesnelerden oluşmaktadır. Bu

nedenle bilgisayar programları da bu nesnelerin modellerinden oluşturulmaktadır.


Nesne Nedir?

Gerçek dünyada bir nesne iki kısımdan oluşur:

1. Nitelikler. Buna durumlar ya da özellikler de denir.

2. Davranışlar (yetenekler). Nesnelerin bilgisayarda kurulan modellerinde ise

aşağıda gösterildiği gibi nitelikleri belirtmek için veriler, davranışları belirtmek için de fonksiyonlar kullanılacaktır.

Gerçek dünyada nesne = Nitelikler + Davranışlar

Yazılım dünyasında nesne = Veriler + Fonksiyonlar


Sınıflar ve Nesneler

C++'da nesnelerin modellerini oluşturmak için sınıf ( class) adı verilen bir yapı kullanılmaktadır.

Bu yapı bir nesneyi oluşturacak olan verileri ve fonksiyonları birlikte barındırmaktadır.

Sınıflar, nesnelerin modeli diğer bir deyişle şablonudur. Programda bir kez sınıf yazılıp şablon oluşturulduktan sonra o sınıftan gerektiği kadar nesne yaratılabilir.


ÖRNEK 1

Örnek 1: Grafik programlarında kullanılacak nokta nesnelerini tanımlamak üzere bir model.

Noktalar iki boyutlu düzlemde yer alacağından özellik olarak iki adet koordinat bilgisine sahiptirler:

• x ve y koordinatları. Bu özellikler tamsayı değişkenler ile ifade edilebilirler. Örnek programımızda noktaların sahip olması gereken yetenekler (davranışlar) ise şunlardır:

• Noktalar, düzlemde herhangi bir yere konumlanabilmeli: git fonksiyonu

• Noktalar bulundukları koordinatları ekrana çıkartabilmeli: goster fonksiyonu

• Noktalar, sıfır (0,0) koordinatında olup olmadıkları sorusunu yanıtlayabilmeli: sifir_mi fonksiyonu


Nokta sınıfı:class Nokta{ // Nokta Sınıfıint x,y; // Nitelikler: x ve y koordinatlarıpublic:void git(int, int); // Noktanın hareket etmesini sağlayan fonksiyonvoid goster(); // Noktanın koordinatlarını ekrana çıkartırbool sifir_mi(); // Noktanın (0,0) koordinatlarında olup olmadığı};

Bildirim class sözcüğü ile başlar, daha sonra sınıfın ismi gelir (Nokta).

Yukarıdaki örnekte önce veriler sonra fonksiyonlar yazılmıştır. Bu sıra ters de olabilir.

Sınıfın içindeki veri ve fonksiyonlara o sınıfın üyeleri ( member) denir.

Sınıf bildirimi noktalı virgül (;) ile bitirilir. Örnek sınıf bildiriminin içinde fonksiyonların sadece prototipleri yer

almaktadır. Fonksiyonların gövdeleri ise ayrı bir yerde tanımlanabilir. Üye fonksiyonlara o sınıfın metotları da ( method) denilmektedir.


Üye Fonksiyonların Gövdeleri

// ***** Üye Fonksiyonların Gövdeleri *****// Noktanın hareket etmesini sağlayan fonksiyonvoid Nokta::git(int yeni_x, int yeni_y){x = yeni_x; // x koordinatına yeni değer atandıy = yeni_y; // y koordinatına yeni değer atandı}// Noktanın koordinatlarını ekrana çıkaran fonksiyonvoid Nokta::goster(){cout << "X= " << x << ", Y= " << y << endl;}// Noktanın (0,0) koordinatlarında olup olmadığını belirten

fonksiyonbool Nokta::sifir_mi(){return (x == 0) && (y == 0); // x=0 VE y=0 ise doğru}


Üye fonksiyonların gövdeleri de yazıldıktan sonra Nokta modeli (şablon) tamamlanmıştır. Artık bu sınıftan gerektiği kadar nokta nesnesi yaratılabilir.

int main(){Nokta n1,n2; // 2 adet nesne tanımlandı n1 ve n2n1.git(100,50); // n1 (100,50)'ye gönderiliyorn1.goster(); // n1'in koordinatları ekrana çıkartılıyorn1.git(20,65); // n1 (20,65)'e gönderiliyorn1.goster(); // n1'in koordinatları ekrana çıkartılıyorif(n1.sifir_mi()) // n1 sıfır da mı?cout << "n1 şu anda sıfır noktasındadır." << endl;elsecout << "n1 şu anda sıfır noktasında değildir." << endl;n2.git(0,0); // n2 (0,0)'a gönderiliyorif(n2.sifir_mi()) // n2 sıfır da mı?cout << "n2 şu anda sıfır noktasındadır." << endl;elsecout << "n2 şu anda sıfır noktasında değildir." << endl;return 0;}


Programda iki adet nesne (n1 ve n2) tanımlanmıştır. Bu nesnelerin üye fonksiyonları çağırılarak nesnelerin belli davranışlarda bulunmaları sağlanmıştır.

Nesnelerin metotlarının canlandırılmasına o nesneye mesaj göndermek denir.


Kurucu Fonksiyonlar (Constructors) Kurucu fonksiyonlar üyesi oldukları sınıftan bir nesne yaratılırken

kendiliğinden canlanırlar. Bu tür fonksiyonlar bir nesnenin kurulması aşamasında

yapılması gereken işleri,örneğin verilere uygun başlangıç değerleri atamak için kullanılırlar.

Kurucu fonksiyonlar üyesi oldukları sınıf ile aynı ismi taşırlar. Kurucular parametre alırlar, ancak geri dönüş değerleri yoktur.

Geri dönüş tipi olarak herhangi bir tip (void bile) yazılmaz. Kurucu fonksiyonlar nesne yaratılırken sınıfın dışından sınıfın

açık (public) üyeleri arasında yer almalıdırlar. Kurucu fonksiyonlar işlevlerine ve yapılarına göre bazı alt

gruplara ayrılırlar. İlk grupta parametre verilmeden çağrılabilen parametresiz kurucu

fonksiyonlar yer alır.


Parametresiz Kurucu Fonksiyonlar ( Default Constructor) Bu tür kurucu fonksiyonların ya parametre listeleri boştur, ya da tüm

parametrelerin bir başlangıç değeri vardır.class Nokta{ // Nokta Sınıfıint x,y; // Nitelikler: x ve y koordinatlarıpublic:Nokta(); // Kurucu fonksiyon bildirimibool git(int, int); // Noktanın hareket etmesini sağlayan

fonksiyonvoid goster(); // Noktanın koordinatlarını ekrana çıkartır};// Parametresiz Kurucu FonksiyonNokta::Nokta(){cout << "Kurucu fonksiyon çalışıyor..." << endl;x = 0; // Koordinatlar sıfırlanıyor.y = 0;} Ana programda kurucu fonksiyonların çağrılması için özel bir deyim yazılmaz. Nesnelerin yaratıldığı satırlarda kurucu fonksiyon her nesne için bir defa çalışır.


Parametreli Kurucu Fonksiyonlar Kurucu fonksiyonlar da diğer üye fonksiyonlar gibi gerektiğinde

parametre alacak şekilde tanımlanabilirler Bu durumda sınıftan nesne yaratan programcılar, nesneleri

tanımladıkları satırlarda kurucu fonksiyonlara uygun tipte ve sayıda argümanı vermek zorundadırlar.

class Nokta{ // Nokta Sınıfıint x,y; // Nitelikler: x ve y koordinatlarıpublic:Nokta(int,int); // Kurucu fonksiyon bildirimibool git(int, int); // Noktanın hareket etmesini

sağlayan fonksiyonvoid goster(); // Noktanın koordinatlarını ekrana

çıkartır};


// Parametreli Kurucu FonksiyonNokta::Nokta(int ilk_x, int ilk_y){cout << "Kurucu fonksiyon çalışıyor..." << endl;if ( ilk_x < 0 ) // Verilen değer negatifsex = 0; // Koordinat sıfırlanıyorelsex = ilk_x;if ( ilk_y < 0 ) // Verilen değer negatifsey = 0; // Koordinat sıfırlanıyorelsey = ilk_y;}// -------- Ana Program -------------int main(){Nokta n1(20,100), n2(-10,45); // Kurucu 2 kez çalışırNokta *pn = new Nokta(10,50); // Kurucu 1 kez çalışır.// Nokta n3; // HATA! Parametresiz kurucu yokn1.goster(); / n1'in koordinatları ekrana çıkartılıyorn2.goster(); //n2'nin koordinatları ekrana çıkartılıyorpn->goster(); //pn2'nin işaret ettiği nesne ekrana çıkarreturn 0;}


Kurucu Parametrelerine Başlangıç Değeri Verilmesi:

Diğer fonksiyonlarda olduğu gibi kurucu fonksiyonların parametrelerine de başlangıç değeri verilebilir. Bu durumda nesne yaratılırken verilmeyen argümanların yerine parametrelerin başlangıç değerleri kullanılacaktır.

// Kurucu FonksiyonNokta::Nokta(int ilk_x = 0, int ilk_y = 0){cout << "Kurucu fonksiyon çalışıyor..." << endl;if ( ilk_x < 0 ) // Verilen değer negatifsex = 0; // Koordinat sıfırlanıyorelsex = ilk_x;if ( ilk_y < 0 ) // Verilen değer negatifsey = 0; // Koordinat sıfırlanıyorelsey = ilk_y; }


Bu sınıftan aşağıdaki gibi nesneler yaratılabilir.

Nokta n1(15,75); // x=15, y=75

Nokta n2(100); // x=100, y=0 Bu fonksiyon parametresiz bir kurucu olarak

da kullanılabilir.

Nokta n3; // x=0, y=0


Bir Sınıfta Birden Fazla Kurucu Fonksiyon Olması: Bir sınıfta birden fazla kurucu fonksiyon bulunabilir. Fonksiyon

isimlerinin yüklenmesi ( function overloading) konusunda da değinildiği gibi isimleri aynı olan bu fonksiyonların bir belirsizlik olmadan çağrılabilmeleri için parametrelerinin tipleri ve/veya sayıları farklı olmalıdır.

Nokta::Nokta() // Parametresiz kurucu fonksiyon{............... // Gövdesi önemli değil}Nokta::Nokta(int ilk_x, int ilk_y) // Parametreli

kurucu fonksiyon{................. // Gövdesi önemli değil}


İki kurucuya sahip bir Nokta sınıfından farklı şekillerde nesneler yaratılabilir.

Nokta n1; // Parametresiz kurucu çalışır Nokta n2(30,10); // Parametreli kurucu çalışır

Örnek sınıfta tek parametreli bir kurucu olmadığından aşağıdaki satır hatalıdır.

Nokta n3(10); // HATA! Bir parametreli kurucu yok


Kurucuların Nesne Dizileri ile Kullanılması Bir sınıfta parametresiz bir kurucu fonksiyon varsa

bu sınıftan bir nesne dizisi yaratıldığında dizinin her elemanı için kurucu fonksiyon kendiliğinden canlanır.

Nokta dizi[10]; // Parametresiz kurucu 10 defa çalışır

Eğer bir parametre alan kurucu fonksiyona sahip bir sınıftan nesne dizisi yaratılacaksa, kurucuya gerekli argümanları göndermek için başlangıç değerleri listesi kullanılır. Bu listenin başı ve sonu kıvırcık parantezler ({ }) ile belirlenir.Ayrıca kurucuya gönderilecek her değer de kıvırcık parantezler içine yazılır.


// Kurucu Fonksiyon Nokta::Nokta(int ilk_x, int ilk_y = 0) Nokta dizi[]= { {10} , {20} , Nokta(30,40) }; //

3 elemanlı nesne dizisi Eğer Nokta sınıfında yukarıdaki kurucu fonksiyona ek olarak

parametresiz bir kurucu fonksiyon da yer alsaydı aşağıda gösterildiği gibi 5 elemanlı bir dizi yaratılabilirdi.

Nokta dizi[5]= { {10} , {20} , Nokta(30,40) }; // 5 elemanlı nesne dizisi

Yukarıda başlangıç değerleri listesine sadece üç değer vardır. Bu durumda dizinin ilk üç elemanına listedeki değerler sırasıyla gönderilecektir. Son iki eleman için ise parametresiz kurucu fonksiyon çalıştırılacaktır.


Kurucu Fonksiyonlarda İlk Değer Atama ( Constructor Initializers) Kurucu fonksiyonlarda nesnelerin verilerine

ilk değerlerini atamak için C++'nın atama deyiminden daha farklı bir yapı da kullanılabilmektedir. Özellikle sabit verilere ilk değerlerini atamak için bu yapının kullanılması zorunludur.

Bir sınıfın kurucu fonksiyonunda sabit veriye başlangıç değeri atanmaya çalışılırsa derleme hatası oluşur, çünkü sabit bir veri bir atama işleminin solunda yer alamaz.


class C{ // Örnek C sınıfıconst int ci; // sabit üye veriint x; // sabit olmayan üye veripublic:C() { // Kurucu fonksiyonx = -2; // Doğru, çünkü x sabit değilci = 0; // HATA! Çünkü ci sabit}}; Aşağıdaki gibi bir yazım da derleme hatasına neden olur.class C{ // Örnek C sınıfıconst int ci = 10; // HATA! sabit üye veriint x; // sabit olmayan üye veri};


Bu problemin kurucu fonksiyonlarda ilk değer atama yapısı ( constructor initializer) kullanılarak çözülür. Kurucularda verilere ilk değer atamak için kurucu fonksiyonun imzasından sonra iki nokta üst üste (:) konur, ardından ilk değer atanacak verinin adı gelir ve parantez içinde atanacak değer yazılır.

class C{ // Örnek C sınıfıconst int ci; // sabit üye veriint x; // sabit olmayan üye veripublic:C():ci(0) { // Kurucu fonksiyon. ci'ye sıfır

atanıyor.x = -2; // Doğru, çünkü x sabit değil}};


Tüm üye verilere değer atamak için bu yapı kullanılabilir. Eğer kurucu fonksiyonun değer atamaktan başka bir görevi yoksa gövdesi boş kalabilir.

class C{ // Örnek C sınıfıconst int ci; // sabit üye veriint x; // sabit olmayan üye veripublic:C():ci(0), x(-2) // Kurucu fonksiyon, ilk değerler atanıyor

{ } // Gövde boş};


Yok Edici Fonksiyonlar ( Destructors) Bu fonksiyonlar üyesi oldukları sınıftan

yaratılmış olan bir nesne bellekten kaldırılırken kendiliğinden çalışırlar.

Bir nesnenin bellekten kaldırılması için ya nesnenin yaşam alanı sona ermelidir (tanımlandığı blok sona ermiştir) ya da dinamik bellekte tanımlanmış olan bir nesne delete operatörü ile bellekten silinmelidir.


Yok edici fonksiyonlar da kurucular gibi sınıf ile aynı ismi taşırlar, ancak isimlerinin önünde 'tilda' simgesi (~) yer alır. Yok ediciler parametre almazlar ve geriye değer döndürmezler. Bir sınıfta sadece bir adet yok edici fonksiyon olabilir.

class String{ // Örnek (karakter katarı) String sınıfı

int boy; // Katarın boyuchar *icerik; // Katarın içeriğipublic:String(const char *); // Kurucuvoid goster(); // Katarları ekrana çıkaran üye

fonksiyon~String(); // Yok edici fonksiyon};C++ standart arşivinde katarları tanımlamak için string adında hazır

bir sınıf vardır.


// Kurucu FonksiyonString::String(const char *gelen_veri){cout<< "Kurucu çalıştı" << endl;boy = strlen(gelen_veri); // gelen dizinin boyu hesaplandıicerik = new char[boy +1]; // icerik için yer ayrıldı. +1 null içinstrcpy(icerik, gelen_veri); // gelen veri icerik'in gösterdiği yere}void String::goster(){cout<< icerik << ", " << boy << endl; // Katar içeriği ve boyu

ekrana}// Yok edici FonksiyonString::~String(){cout<< "Yok edici çalıştı" << endl;delete[] icerik; }


//-------- Ana Program ----------------

int main()

{

String string1("Katar 1");

String string2("Katar 2");

string1.goster();

string2.goster();

return 0; // Yok edici iki defa çalışır

}


Kopyalama Kurucusu (Copy Constructor) Kopyalama kurucusu özel bir kurucu fonksiyondur. Diğer kurucu fonksiyonlar gibi bir nesne yaratılırken

kendiliğinden canlanırlar. Var olan bir nesnedeki verileri yeni yaratılan

nesnenin içine kopyalarlar. Böylece yeni yaratılan nesne var olan eski bir nesnenin kopyası olur.

Bu fonksiyonlar giriş parametresi olarak aynı sınıftan bir nesneye referans alırlar.

Bu kopyası çıkarılacak olan nesneye bir referanstır.


Eğer programcılar sınıflarının içine bir kopyalama kurucusu koymazlarsa, derleyici standart bir kurucuyu sınıfa yerleştiriri. Standart kopyalama kurucusu bir nesnenin elemanlarını bire bir yeni nesnenin veri alanlarına kopalar. İçinde işaretçi olmayan nesneler için bu genellikle yeterlidir.

Örneğin bir önceki örnekteki String sınıfı için derleyicinin yerleştireceği kopyalamakurucusu aşağıdaki işlemleri yapacaktır.


String sınıfı için verilen örnekte de görüldüğü gibi derleyicinin sağladığı kopyalama fonksiyonu sadece nesnenin elemanlarını kopyalamaktadır.

İşaretçilerin işaret ettiği veriler kopyalanamaz. Bu alanların da kopyalanması isteniyorsa programcı kendi kopyalama fonksiyonunu yazmalıdır.


class String{ // Örnek (karakter katarı) String sınıfıint boy; // Katarın boyuchar *icerik; // Katarın içeriğipublic:String(const char *); // KurucuString(const String &); // Kopyalama kurucusuvoid goster(); // Katarları ekrana çıkaran üye fonksiyon~String(); // Yok edici fonksiyon};String::String(const String &gelen_nesne) // Kopyalama kurucusu{boy = gelen_nesne.boy;icerik = new char[boy + 1]; // +1 null karakteri icinstrcpy(icerik, gelen_nesne.icerik);}int main() // Ana fonksiyon{String string1("Katar 1");string1.goster();String diger = string1; // Kopyalanma kurucusu çalışırString baska(string1); // Kopyalanma kurucusu çalışırdiger.goster();baska.goster();return 0;}


Sabit Nesneler ve Sabit Fonksiyonlar Diğer veri tiplerinde olduğu gibi bir nesne de

sabit (const) olarak tanımlanabilir. Bunun anlamı nesnenin veri alanlarının program boyunca doğrudan ya da dolaylı olarak (fonksiyon çağırarak) değiştirilemeyeceğidir.

const Nokta sn(10,20); // Sabit nokta Derleyiciler sabit olarak tanımlanan

nesnelerin içeriklerinin değişmemesi için bu nesnelerin üye fonksiyonlarının çağırılmasına izin vermezler.


Sınıfın yazarları üye veriler üzerinde değişiklik yapmayan fonksiyonları da sabit (const) olarak bildirmelidirler. Sabit nesneler için sadece sabit fonksiyonlar çağırılabilirler.

class Nokta{ // Nokta Sınıfıint x,y; // Nitelikler: x ve y koordinatlarıpublic:Nokta(); // Kurucu fonksiyon bildirimibool git(int, int); // Noktanın hareket etmesini

sağlayan fonksiyonvoid goster() const; // sabit fonksiyon,

koordinatları ekrana çıkartır};


void Nokta::goster() const{cout << "X= " << x << ", Y= " << y << endl;}int main(){const Nokta sn(10,20); // sabit noktaNokta n(0,50); // sabit olmayan noktasn.goster(); // Doğrusn.git(30,15); // HATA!n.git(100,45); // Doğrureturn 0;} Sınıfın verileri üzerinde değişiklik yapmayan fonksiyonların sabit olarak

tanımlanmaları hata olasılığını ve hata çıktığında incelenmesi gereken fonksiyonların sayısını azaltmaktadır. Bu nedenle bu özelliğe uyan tüm üye fonksiyonlar sabit olarak tanımlanmalıdır.


Statik Üyeler

Bir sınıftan tanımlanan her nesne için bellekte farklı veri alanları yaratılır.

Ancak bazı durumlarda tüm nesnelerin ortak bir veriyi (bellek gözünü) paylaşmaları gerekli olabilir.

Bellekte sadece tek kopyasının yaratılması istenen üye veriler static olarak tanımlanmalıdırlar.

class A{ char c; static int i; }; int main() { A p,q,r; : }


Statik üyeler nesne tanımlanmadan önce bellekte yaratılırlar.

Statik üyeler de diğerleri gibi özel (private) veya açık (public) olabilirler. Açık statik üyeler, global veriler gibi programın tüm alanlarından erişilebilirler. Bunun için sınıfın ismi ve ‘scop’ operatörü (::) kullanılır. A::i= 5;

Statik üyeler özel (private) olarak tanımlanırsa bu üyelere doğrudan erişmek mümkün olmaz. Henüz nesne yaratılmadan önce bu verilere başlangıç değeri atamak için statik fonksiyonlar tanımlanır.


Nesnelerin Fonksiyonlara Parametre Olarak Aktarılması Aksi zorunlu olmadıkça, nesneler fonksiyonlara

referanslar yoluyla aktarılmalı. Benzer şekilde fonksiyonlardan geri döndürülen nesneler için de eğer mümkünse referanslar kullanılmalıdır.

Parametre aktarımında referanslar kullanılmazsa nesnelerin içerdiği değerler yığına kopyalanır ( call by value). Eğer sınıfın içinde bir kopyalama fonksiyonu varsa yığına kopyalama işi için de programcının yazdığı bu fonksiyon canlanacaktır.


Örnek 2: Nesnelerin fonksiyonlara değer olarak aktarılması// o47.cpp// Nesnelerin fonksiyonlara değer olarak aktarılması// Uygun Yöntem DEĞİLDİR!

#include <iostream>using namespace std;

// Karmaşık (Kompleks) sayıları tanımlamak için oluşturulan sınıfclass ComplexT{

float re,im; // reel ve sanala kısımlarstatic unsigned int sayac; // Bu sınıftan yaratılan nesne sayisinı tutar

public:ComplexT(float re_in=0,float im_in=1); // KurucuComplexT(const ComplexT &); // Kopyalama kurucusuComplexT topla(ComplexT) const; // Parametre olarak nesne alan metotvoid goster() const; // Bilgileri ekrana çıkarırstatic void sifirla(){sayac=0;} // Sayacı sıfırlayan static metot~ComplexT(); // Yok edici

};


//Parametrsiz çağırılabilen kurucu// İlk değerleri atar. Yaratılan nesne sayisinı arttırır.ComplexT::ComplexT(float re_in,float im_in){

re=re_in;im=im_in;sayac++; // Nesne sayisi arttırıldıcout<< endl << "Kurucu calisti. ";cout<< "Nesne sayisi = "<< sayac;

}

// Kopyalama Kurucusu// Nesnenin verilerini kopylar// Yaratılan nesne sayisinı arttırırComplexT::ComplexT(const ComplexT &c){

re=c.re; // Elemanlar kopyalanıyorim=c.im;sayac++; // Nesne sayisi arttırıldıcout<< endl << "Kopyalama kurucusu calisti. ";cout<< "Nesne sayisi = "<< sayac;

}


// İki karmaşık sayıyı toplayıp üçüncü bir sayı elde eden metot// Giriş parametresi değer olarak (call by value) alınan bir nesnedir.// Parametrenin bu şekilde alınması uygun DEĞİLDİR!ComplexT ComplexT::topla(ComplexT c) const{

cout<< endl << "Toplama metodu calisiyor";ComplexT sonuc; // Sonucun yazılacağı 3. nesnesonuc.re=re+c.re; // Alt alanlar toplanıyorsonuc.im=im+c.im;return sonuc; // sonuc nesnesi geri döndürülüyor.

}

// Nesne ile ilgili bilgileri ekrana çıkaran metotvoid ComplexT::goster() const{

cout << endl << "re= " << re << " , im= " << im;cout << " Nesne sayisi= " << sayac;

}// Yok edici fonksiyon// Yaratrılan nesne sayisinı bir azaltırComplexT::~ComplexT(){

sayac--; // Nesne sayisi azaltıldıcout<< endl << "Yok edici calisti. ";cout<< "Nesne sayisi = "<< sayac;

}


unsigned int ComplexT::sayac; // static sayac icin bellekte yer ayrıldı

//------ Ana program -------int main(){

ComplexT::sifirla(); // sayac sıfırlandıComplexT z1,z2,z3; // Üç adet nesne yarıtıldız3=z1.topla(z2); // z3 = z1 + z2 işlemi yapılıyor.z3.goster();return 0;

}


Nesnelerin fonksiyonlara değer olarak aktarılması hem bellekte daha fazla yer harcanmasına neden olur hem de programın çalışmasını yavaşlatır.

Bu nedenle, eğer aksi zorunlu değilse, fonksiyonlara nesnelerin değerleri değil referansları aktarılmalıdır.

Referans yoluyla aktarılan nesnelerin içeriklerinin fonksiyon içinde değiştirilmesi istenmiyorsa bu aktarım sabit referanslar ile yapılmalıdır.


Örnek 3: Nesnelerin fonksiyonlara referans olarak aktarılması// o48.cpp// Nesnelerin fonksiyonlara referans olarak aktarılması

#include <iostream>using namespace std;


float re,im; // reel ve sanala kısımlarstatic unsigned int sayac; // Bu sınıftan yaratılan nesne sayisinı tutar

public:ComplexT(float re_in=0,float im_in=1); // KurucuComplexT(const ComplexT &); // Kopyalama kurucusuComplexT topla(const ComplexT &) const; // Parametre olarak nesneye referans alan metotvoid goster() const; // Bilgileri ekrana çıkarırstatic void sifirla(){sayac=0;} // Sayacı sıfırlayan static metot~ComplexT(); // Yok edici

};




}// Kopyalama Kurucusu// Nesnenin verilerini kopylar// Yaratılan nesne sayisinı arttırırComplexT::ComplexT(const ComplexT &c){


}


// İki karmaşık sayıyı toplayıp üçüncü bir sayı elde eden metot// Giriş parametresi referans olarak (call by address) alınan bir nesnedir.ComplexT ComplexT::topla(const ComplexT & c) const{

cout<< endl << "Toplama metodu calisiyor";ComplexT sonuc; // Sonucun yazılacağı 3. nesnesonuc.re=re+c.re; // Alt alanlar toplanıyorsonuc.im=im+c.im;return sonuc; // sonuc nesnesi geri döndürülüyor.

}

// Nesne ile ilgili bilgileri ekrana çıkaran metotvoid ComplexT::goster() const{


}

// Yok edici fonksiyon// Yaratrılan nesne sayisinı bir azaltırComplexT::~ComplexT(){


}





}


Fonksiyonlardaki Geçici Nesnelerin Azaltılması Örnek 4’de toplama fonksiyonunda iki nesneyi toplamak için

geçici bir nesne yaratılmaktadır. Bu işlem kurucu ve yok edici fonksiyonların çalışmasına neden olmaktadır.

Ardından bu geçici nesne fonksiyondan geri gönderileceği için (return gecici;) yığına kopyalanmaktadır.

Bu işlemleri azaltmak için geçici bir nesne yaratmak yerine, işlemler geçici değişkenler üzerinde yapılır. Daha sonra fonksiyondan değer döndürülürken nesne yaratılır.

ComplexT ComplexT::topla(const ComplexT & z) const{float gecici_re, gecici_im; // Bütün bir nesne yerine sadece

geçici değişkenlergecici_re = re + z.re; // Toplama işlemi yapılıyorgecici_im = im + z.im;return ComplexT(gecici_re,gecici_im); // Nesne yaratılıyor, kurucu

canlanır}


Örnek 4:Fonksiyonlardaki yerel nesnelerin azaltılması#include <iostream>using namespace std;


float re,im; // reel ve sanal kısımlarstatic unsigned int sayac; // Bu sınıftan yaratılan nesne sayisinı tutar

public:ComplexT(float re_in=0,float im_in=1); // KurucuComplexT(const ComplexT &); // Kopyalama kurucusuComplexT topla(const ComplexT &) const; // Parametre olarak nesneye referans alan metotvoid goster() const; // Bilgileri ekrana çıkarırstatic void sifirla(){sayac=0;} // Sayacı sıfırlayan static metot~ComplexT(); // Yok edici

};




}// Kopyalama Kurucusu// Nesnenin verilerini kopylar// Yaratılan nesne sayisinı arttırırComplexT::ComplexT(const ComplexT &c){


}


// İki karmaşık sayıyı toplayıp üçüncü bir sayı elde eden metot// Giriş parametresi referans olarak (call by address) alınan bir nesnedir.ComplexT ComplexT::topla(const ComplexT & z) const{ cout<< endl << "Toplama metodu calisiyor. ";

float gecici_re, gecici_im; // Bütün bir nesne yerine sadece geçici değişkenler

gecici_re = re + z.re; // Toplama işlemi yapılıyor

gecici_im = im + z.im; return ComplexT(gecici_re,gecici_im); // Nesne yartılıyor, kurucu canlanır}// Nesne ile ilgili bilgileri ekrana çıkaran metotvoid ComplexT::goster() const{


}

// Yok edici fonksiyon// Yaratrılan nesne sayisinı bir azaltırComplexT::~ComplexT(){


}





}


İç içe nesneler: Nesnelerin başka sınıfların üyesi olması Bir sınıfın üyeleri sadece hazır veri tipleri (char, int,

double....) olmak zorunda değildir. Bir sınıfın üyeleri başka sınıftan tanımlanmış nesneler de olabilirler.

Sınıflar arası bu ilişkiye sahip olma ilişkisi

(has a relation) adı verilir. Şekildeki örnekte karmaşık sayıları tanımlamak

üzere bir sınıf (ComplexKes) oluşturulmuştur. Bu sınıfın reel ve sanal kısımları bayağı kesirlerden oluşacaklardır. Bayağı kesirler ise (Kesir) sınıfından tanımlanan nesneler ile oluşturulacaktır.


Burada ComplexKes sınıfının kurucusunu yazan programcı, kullandığı nesnelerin (Kesir sınıfından re ve im) kurucularına uygun parametreleri göndermekle yükümlüdür.


Örnek olarak hazırlanan Kesir sınıfı:

class Kesir{ // Bayağı kesirleri tanımlamak içinint pay,payda;public:Kesir(int, int); // Kurucuvoid goster() const;};Kesir::Kesir(int py, int pyd) // KURUCU{pay=py;if (pyd==0) payda=1; // Payda olarak 0 verilirse payada=1 olurelse payda=pyd;cout << "Kesir'in kurucusu" << endl;}// Bayağı kesiri ekrana çıkaran fonksiyonvoid Kesir ::goster() const{cout << pay << "/" << payda << endl;}


Örnek olarak hazırlanan ComplexKes sınıfı:// Elemanları bayağı kesir olan karmaşık sayıları tanımlayan sınıfclass ComplexKes{Kesir re,im; // üye nesnelerpublic:ComplexKes(int,int); // Kurucuvoid goster() const;};// Kurucu fonksiyon// Önce üye nesnelerin kurucularına gerekli parametreler gönderiliyorComplexKes::ComplexKes(int re_in,int im_in) : re(re_in,1), im(im_in,1){....}// Karmaşık sayı ekrana çıkarılıyorvoid ComplexKes::goster() const{re.goster();im.goster();

Üye nesnelerin kurucuları canlanır

int main() // Ana program{ComplexKes ck(2,5); // Bir karmaşık sayı tanımlanıyorck.goster(); // Karmaşık sayı ekranaçıkarılıyorreturn 0; }


Değerlendirme:

Sınıflar ve nesneler hakkında bu aşamaya kadar öğrendiklerimizi değerlendirdiğimizde şu sonuçlara varabiliriz:

Sınıflar 'aktif' veri tipleridir. Bu tiplerden nesneler tanımlanır. Nesnelere mesajlar gönderildiğinde nesneler bir davranışta bulunarak cevap verirler.

Sınıflar hem verileri hem de bu veriler üstünde işlem yapan fonksiyonları aynı paket içinde barındırırlar ( encapsulation). Bunun sonucu olarak:

Nesneler gerçek dünyadakine benzer şekilde modellenebilir, Program daha kolay okunabilir, çünkü birbirleriyle ilgili olan

veriler ve fonksiyonlar bir aradadır, Hataları bulmak kolay olur, çünkü bu veriler üzerinde işlem

yapabilen fonksiyonlar bellidir.


Metotların inline Fonksiyon (Makro) Olarak Tanımlanmaları: Örnek 1'deki Nokta sınıfının bildiriminde

metotların (üye fonksiyonların) sadece prototipleri yer almaktadır. Fonksiyonların gövdeleri ise sınıfın dışında tanımlanmıştı. Metotların gövdeleri de sınıf bildiriminin içine yazılabilir. Bu durumda o fonksiyon makro (inline) olarak tanımlanmış olur.

Aşağıdaki örnekte sifir_mi adlı üye fonksiyon sınıfın içine yazılarak makro olarak tanımlanmıştır.


class Nokta{ // Nokta Sınıfıint x,y; // Nitelikler: x ve y koordinatlarıpublic:void git(int, int); // Noktanın hareket etmesini


çıkartırbool sifir_mi() // Noktanın (0,0) koordinatlarında

olup olmadığı (makro){return (x == 0) && (y == 0);}};


Nesnelerin Dinamik Olarak Yaratılması: Derleyicinin hazır veri tipleri (int, float, char vs.) veri

tanımlamak için nasıl kullanılıyorsa sınıflar da nesne tanımlamak için aynı şekilde kullanılabilir. Örneğin nesnelere işaret edebilen işaretçiler tanımlanabilir ve bu işaretçiler için dinamik bellekten yer alınabilir ve daha önce alınmış olan yerler geri verilebilir.

Aşağıdaki programda nesnelere işaret edebilen iki işaretçi (pn1 ve pn2) tanımlanmakta, dinamik bellekte bu işaretçiler tarafından işaret edilen nesneler yaratılmaktadır.


int main(){Nokta*pn1 = new Nokta; //pn1'in gösterdiği nesne için bellekten

yer alındıNokta*pn2 = new Nokta; //pn2'nin gösterdiği nesne için bellekten

yer alındıpn1->git(50,50); //pn1'in gösterdiği nesneye git mesajıpn1->goster(); //pn1'in gösterdiği nesneye goster mesajıpn2->git(100,150); //pn2'nin gösterdiği nesneye git mesajıif(pn2->sifir_mi()) // pn2'nin gösterdiği nesne sıfır da mı?cout << "pn2'nin nesnesi şu anda sıfır noktasındadır." << endl;elsecout << "pn2'nin nesnesi şu anda sıfır noktasında değildir." <<

endl;delete pn1; // Dinamik bellekten alınan yerler geri veriliyordelete pn2;return 0;}


Nesnelerin Dizi Olarak Yaratılması: Sınıflardan, nesne dizileri de tanımlamak mümkündür. Aşağıdaki

örnekte Nokta sınıfından, adı dizi olan 10 elemanlı bir nesne dizisi yaratılmış ve kullanılmıştır.

int main(){Nokta dizi[10]; // 10 elemanlı dizi yaratılıyor.dizi[0].git(15,40); // dizinin ilk elemanına (0

indisli) git mesajıdizi[1].git(75,35); //dizinin ikinci elemanına (1

indisli) git mesajı : // Diğer elemanlar da konumlandırılırfor (int i= 0; i < 10; i++) // dizideki tüm nesneler

ekrana çıkartılıyordizi[i].goster();return 0;}


Sınıf Üyelerine Erişimin Denetlenmesi Programcılar, sınıfların oluşturulması ve kullanılması

açısından ikiye ayrılırlar. Birincisi sınıfları yazan programcılardır. İkincisi ise sınıfları kullanarak nesneler yaratan ve

bu nesnelere mesajlar göndererek onların canlandıran programcılardır.

Sınıfı oluşturan programcı sınıf yapısının doğru çalışmasından sorumludur.

Sınıfı nesne tanımlamak için kullanan programcı sınıfın iç yapısını bilmek zorunda değildir. Bilmesi gereken tek şey nesnelere nasıl mesaj yollanacağıdır.


Bu özellikleri sağlamak için, sınıfı yazan programcı, sınıfın bazı üyelerini gizleyerek ( data hiding) onlara sınıf dışından erişilmesini engelleyebilir. Bir sınıfın içindeki üyelere erişimi denetleyen üç farklı etiket bulunmaktadır: public (açık), private (özel) ve protected (korumalı).


Açık (public) olarak tanımlanan üyelere, bu sınıftan yaratılan tüm nesneler yoluyla erişilebilir.

Özel (private) olarak tanımlanan üyelere (veri ve fonksiyon) ise sadece sınıfın içindeki fonksiyonlar erişebilir. Bu sınıftan yaratılan nesneler üzerinden özel üyelere erişmek mümkün değildir.

Korumalı (protected) üyeler ise kalıtım ( inheritance) özelliği ile birlikte kullanılmaktadır. Kalıtım konusu anlatılırken korumalı erişim yöntemi de açıklanacaktır.


Bir sınıfın içindeki açık elemanlar o sınıfın dışarıya verdiği hizmetleri ( services) tanımlarlar. Bunların tümüne sınıfın arayüzü ( interface) denir.

Özel üyeler sınıfın gerçeklenmesiyle ( implementation) ilgili olduklarından sınıfın kullanıcılarını ilgilendirmezler.

Bir sınıftaki üyelerin erişim tipi normalde özeldir (private). Sınıfın yazarı dışarıya açmak istediği üyelerin tanımından önce public: etiketini koyar. Bu nedenle örnekteki Nokta sınıfındaki ilk iki üye (x , y) özeldir ve dışarıya kapalıdır. Ana programda yaratılan nesneler üzerinden bu verilere erişmek mümkün değildir.


Örnek olarak Nokta sınıfından üretilen noktaların hareket alanlarının x ekseninde 0-500, y ekseninde ise 0-300 aralığında olması ve noktalar bu alanın dışına çıkamamaları istensin.

class Nokta{ // Nokta Sınıfıint x,y; // özel (private) Nitelikler: x ve y koordinatlarıpublic: // açık (public) üyelerbool git(int, int); // Noktanın hareket etmesini sağlayan fonksiyonvoid goster(); // Noktanın koordinatlarını ekrana çıkartırbool sifir_mi(); // Noktanın (0,0) koordinatlarında olup olmadığı};// Noktanın hareket etmesini sağlayan fonksiyonbool Nokta::git(int yeni_x, int yeni_y){if( yeni_x > 0 && yeni_x < 500 && // yeni_x 0-500 aralığında ise yeni_y > 0 && yeni_y < 300) // yeni_y 0-300 aralığında ise{x = yeni_x; // x koordinatına yeni değer atandıy = yeni_y; // y koordinatına yeni değer atandıreturn true; // atama yapıldı, hata yok}return false; // Giriş değerleri kabul edilmedi}


Yeni yazılan git fonksiyonu geriye bir mantıksal değer döndürmektedir. Bu değer sayesinde fonksiyona gönderilen koordinatların kabul edilip edilmediği anlaşılmaktadır.

int main(){Nokta n1; // n1 nesnesi yaratıldıint x,y; // Tuş takımından değer okumak için iki

değişken tanımlandıcout << "Noktanın gideceği koordinatları veriniz "cin >> x >> y; // Tuş takımından iki değer okunuyorif( n1.git(x,y) ) // git fonksiyonu çağırılıyor ve

sonuç değerlendiriliyorn1.goster(); // Atama yapıldıysa ekrana yeni

koordinatlar çıkacakelsecout << "\nGirilen değerler kabul edilmemiştir";}


Erişim Etiketlerinin Geçerlilik Alanları: Bir erişim etiketi yazıldığı yerden aşağıya

doğru geçerli olur. Bu etiketin altında yer alan tüm veriler ve fonksiyonlar etikette belirtilen erişim türüne sahip olurlar. Bir etiketin geçerlilik alanı, başka bir etiket yazıldığında ya da sınıfın sonuna gelindiğinde sona erer.


C++'da struct Yapısı:

C++'da struct yapısı da class ile aynı işlevi yerine getirmekte ve sınıf bildirimleri için kullanılmaktadır.

struct ile class arasındaki tek fark üyelerin erişim haklarında ortaya çıkmaktadır.

class bildirimlerinde aksi bildirilmedikçe üyelerin erişim tipi özeldir (private). struct bildirimlerinde ise aksi bildirilmedikçe üyelerin erişim tipi açıktır (public).


Sınıflarda Arkadaşlık (friend) İlişkisi Bir A sınıfı oluşturulurken B sınıfı A'nın arkadaşı olarak bildirilebilir.

Bu durumda B'nin tüm üye fonksiyonları erişim tipleri ne olursa olsun A'nın tüm üyelerine (public, private, protected) erişebilirler.

class A{friend class B; // B sınıfı A'nın arkadaşıdırprivate: // A'nın özel üyeleriint i;float f;public: // A'nın açık üyelerivoid fonk1(char *c);};class B{ // B sınıfıint j;public:void fonk2(A &s){cout << s.i;} // B, A'nın özel üyesi

i'ye erişebiliyor};


Sınıflar arası arkadaşlık ilişkisi tek yönlüdür. Yukarıdaki örnekte B, A'nın arkadaşıdır ve onun tüm üyelerine erişmektedir. Ancak A, B'nin arkadaşı değildir.

Bir fonksiyon da bir sınıfın arkadaşı olarak bildirilebilir. Fonksiyonlar arkadaşları oldukları sınıfların tüm üyelerine (public, private, protected) erişebilirler.


class Nokta{ // Nokta Sınıfıfriend void sifirla(Nokta &); // Nokta sınıfının

arkadaşı olan sifirla fonksiyonuint x,y; // özel (private) Nitelikler: x ve y

koordinatlarıpublic: // açık (public) üyelerbool git(int, int); // Noktanın hareket etmesini


çıkartırbool sifir_mi(); // Noktanın (0,0) koordinatlarında

olup olmadığı};void sifirla (Nokta &n) // Hiçbir sınıfın üyesi değil{n.x = 0; // n'nin x elemanı sıfırlanıyorn.y = 0; // n'nin x elemanı sıfırlanıyor}

nesneye dayal ı programlama

Documents