NESNEYE YÖNELİK PROGRAMLAMA

Transkript

1 NESNEYE YÖNELİK PROGRAMLAMA İŞARETÇİ ELEMANLI SINIFLAR REFERANSLAR OPERATÖRLERİN AŞIRI YÜKLENMESİ ATAMA OPERATÖRÜ Özlem AYDIN Trakya Üniversitesi Bilgisayar Mühendisliği Bölümü

2 İşaretçi Elemanlı Sınıflar - 1 new ve delete operatörlerini bir sınıfın eleman fonksiyonları içinde kullanabilirsiniz. Örnek: Her nesnesinin bir karakter katarı içereceği bir String sınıfı. #include <iostream> #include <cstring> using namespace std; class String { public: String(); String( const char *s ); String( char c, int n ); void belirle( int index, char yenik ); char soyle( int index ) const; int uzunluksoyle() const { return uzunluk; } void goruntule() const { cout << buf; } ~String(); private: int uzunluk; char *buf; };

3 İşaretçi Elemanlı Sınıflar - 2 // Varsayilan Yapici Fonksiyon String::String() { buf = 0; uzunluk = 0; } // const char * alan Yapici Fonksiyon String::String( const char * s ) { uzunluk = strlen( s ); buf = new char[uzunluk + 1]; strcpy( buf, s ); } // char ve int alan Yapici Fonksiyon String::String( char c, int n ) { uzunluk = n; buf = new char[uzunluk + 1]; memset( buf, c, uzunluk ); buf[uzunluk] = \0 ; }

4 İşaretçi Elemanlı Sınıflar - 3 // String içinde bir karakterin belirlenmesi void String::belirle( int index, char yenik) { if( (index > 0) && (index <= uzunluk) ) buf[index - 1] = yenik ; } // String içinden bir karakterin okunmasi char String::soyle( int index ) const { if( (index > 0) && (index <= uzunluk) ) return buf[index - 1]; else return 0; } // Yikici Fonksiyon String::~String() { delete [] buf; }

5 İşaretçi Elemanlı Sınıflar - 4 int main() { String string1( birinci Karakter Katari ); string1.belirle(1, B ); return 0; }

6 İşaretçi Elemanlı Sınıflar - 5 Her String nesnesi, birisi uzunluk ve buf eleman sahalarını içeren ve diğeri karakterlerin kendilerini depolayan iki bloktan oluşur. Nesnelerin içeriğini dinamik olarak değiştirmek mümkündür: void String::ekle( const char *ek ) { char *temp; uzunluk += strlen( ek ); temp = new char[uzunluk + 1]; strcpy( temp, buf ); strcat( temp, ek ); delete [] buf; buf = temp; } int main() { String string1( birinci karakter katari ); string1.ekle( ve devami ); return 0; }

7 İşaretçi Elemanlı Sınıflar - 6 Bir String nesnesi kapsam alanının dışına çıkınca, uzunluk ve buf değerlerini içeren bellek bloğu otomatik olarak serbest bırakılır. Fakat, karakter bloğu new ile alındığı için, açıkça serbest bırakılmalıdır. delete operatörünü kullanan yıkıcı fonksiyon bu işlevi yerine getirir.

8 İşaretçi Elemanlı Sınıflar - 7 Yine de String sınıfı bazı problemlere potansiyel olarak açıktır. main fonksiyonuna aşağıdaki kod parçasını eklediğimizi varsayalım: String string2( ikinci karakter katari ); string2 = string1; Bir nesnenin bir diğerine atanmasını istediğimizde derleyici eleman bazında atama yapar. Yani, yukarıdaki atama deyimi aşağıdaki koda denktir: string2.uzunluk = string1.uzunluk; string2.buf = string1.buf;

9 İşaretçi Elemanlı Sınıflar - 8 Bir String nesnesini diğerine doğrudan atamamız neticesinde karşılaşacağımız problemler şunlardır: String nesnelerinden herhangi birine yapılacak bir değişiklik diğerini de etkileyecektir; bu muhtemelen arzu edilir bir durum olmayacaktır. string1 ve string2 nesnelerinin buf işaretçisi yıkıcı fonksiyonları üzerinden ayrı ayrı silinecektir. İşaretçiler aynı değeri taşıdığı için bu tahmin edilemeyen sorunlara yol açabilir. ikinci karakter katari değerini taşıyan string2 nesnesinin orijinal buffer bloğu serbest bırakılmadan kaybolmuştur.

10 Referanslar Referans (başvuru), bir değişkenin diğer bir ismi (alias) olarak davranan bir işaretçidir. Referanslar üç şekilde kullanılabilir: 1. Bir fonksiyona parametre olarak geçirilebilir. 2. Bir fonksiyon tarafından döndürülebilir. 3. Bağımsız bir referans oluşturulabilir. Referansların en önemli kullanımı bir fonksiyona parametre olarak geçirilmesidir.

11 Alternatif Değişken İsimleri Olarak Referanslar Referansları değişkenler için alternatif isimler (alias) olarak düşünebilirsiniz. Bir referansa ilk değer atanırken, referans bir değişkenle ilişkilendirilir ve hep bu şekilde kalır: int asil_int; int &diger_int = asil_int; //Referans bildirimi Bu ilişkilendirme arka planda diğer_int değişkenine asil_int değişkeninin bellekteki adresi kopyalanarak gerçekleştirilir.

12 Alternatif Değişken İsimleri Olarak Referanslar Bir referans ilk değer verilerek tanımlanmak zorundadır. int &r; double &r=10.2 // Error // Error Referansa verilen ilk değer aynı veri tipinde bir değişken olmak zorundadır. double x=10; int &r=x; /* Error. Farklı türden bir değişkene ilk değer verilmiş. */

13 Örnek - 1 #include <iostream> using namespace std; void main() { int asil_int = 123; int &diger_int = asil_int; cout << "\n" << asil_int; cout << "\n" << diger_int; diger_int++; cout << "\n" << asil_int; cout << "\n" << diger_int; asil_int++; cout << "\n" << asil_int; cout << "\n" << diger_int;} return 0; }

14 Örnek - 1 Program Çıktısı:

15 Referanslar ve İşaretçiler Referansları örtük işaretçiler olarak düşünebiliriz: Fakat, bir işaretçi ile işaret ettiği değişkeni * içerik operatörünü (indirection) kullanarak ayırabilirken bunu referanslar için yapamayız. Dolayısıyla, referanslar üzerinde aşağıdaki işlemleri yapmak olanaksızdır: - Referansa işaret etmek - Referansın adresini almak - Birden fazla referansı karşılaştırmak - Referansa yeni bir değer atamak - Referanslar üzerinde aritmetik işlem yapmak

16 Fonksiyon Parametresi Olarak Referanslar - 1 C de bir fonksiyona parametre geçirmenin iki yolu vardır: 1. Değer ile (değişkenin kendisini) geçirme 2. Adres ile (değişkenin işaretçisini) geçirme C++ da bir üçüncü seçenek mevcuttur: 3. Değişkenin referansını geçirme

17 Fonksiyon Parametresi Olarak Referanslar - 2 #include <iostream> using namespace std; void swap(int &i, int &j); int main() { int a, b, c, d; a = 1; b = 2; c = 3; d = 4; cout << "a ve b: " << a << " " << b << "\n"; swap(a, b); // & operatoru kullanilmamakta cout << "a ve b: " << a << " " << b << "\n"; cout << "c ve d: " << c << " " << d << "\n"; swap(c, d); cout << "c ve d: " << c << " " << d << "\n"; return 0; }

18 Fonksiyon Parametresi Olarak Referanslar - 3 void swap(int &i, int &j) { int t; t = i; // * operatörü kullanılmamakta i = j; j = t; }

19 Fonksiyon Parametresi Olarak Referanslar - 4 Program Çıktısı: a ve b: 1 2 a ve b: 2 1 c ve d: 3 4 c ve d: 4 3

20 Referansları Döndürme Bir fonksiyon referans döndürebilir. #include <iostream> using namespace std; int &f(); // referans döndür int x; int main() { f() = 100; // f() tarafından döndürülen referansa cout << x << \n ; return 0; } int &f() { return x; // x e referans döndür. } //100 ata Burada f() fonksiyonu x değişkenine bir referans döndürmektedir.

21 Bağımsız referans Bağımsız referans başka bir değişken için farklı isim veren bir referans değişkenidir. Pek kullanılmazlar. #include <iostream> using namespace std; int main() { int x; int &ref=x; // bağımsız referans oluştur. x=10; // bu iki atama ref=10; // işlevsel olarak eşdeğerdir ref=100; // bu 100 sayısını iki kere basar cout << x << << ref << \n ; return 0 ; } Burada ref adındaki bağımsız referans x için farklı bir isim sunar. x ve ref aslında eşdeğerdir.

22 Operatörlerin Aşırı Yüklenmesi (Operator Overloading) Nasıl fonksiyon isimleri aşırı yüklenebiliyorsa, (gerçekte birer fonksiyon olan) operatör isimleri de aşırı yüklenebilir. Operatörlere aşırı yükleme ile kullanıcı tanımlı olan operatörlere yeni anlam yükleyebiliriz. Örneğin, tanımlı iki nesnenin birbirine eşit olup olmadığını anlamak için == operatörünü bu işlevi yerini getirmesi için aşırı yükleyebiliriz. Operatörleri aşırı yükleyerek, C++ a operatörlerin nesneler üzerinde çalışabilme yeteneği de verilmiş olur.

23 Operatörlerin Aşırı Yüklenmesi

24 Operatörlerin Aşırı Yüklenmesi Operatörleri aşırı yükleyebilmek için söz konusu operatörün operatör fonksiyonu olarak sınıf tanımında bulunması gerekir. Operatör fonksiyonu tanımlanması aşağıdaki sözdizimdeki gibidir: VeriTipi operator# (parametre listesi) VeriTipi operatör fonksiyonunun döndürdüğü veri tipidir. # aşırı yüklenen operatör bu sembolün yerine yazılır.

25 Operatörlerin Aşırı Yüklenmesi #include <iostream> using namespace std; class Vektor { public: int x,y; Vektor() {}; Vektor(int a,int b); Vektor operator+(vektor); }; Vektor::Vektor(int a, int b) { x = a; y = b; }

26 Operatörlerin Aşırı Yüklenmesi Vektor Vektor::operator+ (Vektor diger) { Vektor gecici; gecici.x = x + diger.x; gecici.y = y + diger.y; return (gecici); } int main () { Vektor a(3,1); Vektor b(1,2); Vektor c; c = a + b; cout << c.x << "," << c.y; return 0; }

27 Atama operatörü - 1 Aşağıda atama operatörünün aşırı yüklenmesini görmekteyiz: #include <iostream> #include <cstring> class String { public: String(); String( const char *s ); String( char c, int n ); void operator=( const String &digeri ); //... }; void String::operator=(const String &digeri) { uzunluk = digeri.uzunluk; delete [] buf; buf = new char[uzunluk+1]; strcpy( buf, digeri.buf ); }

28 Atama operatörü - 2 int main() { String string1( birinci karakter katari ); string1.goruntule(); cout << \n ; String string2( ikinci karakter katari ); string2.goruntule(); cout << \n ; string2 = string1; string2.goruntule(); cout << \n ; return 0; } Derleyici string2 = string1; deyimini aşağıdaki fonksiyon çağrımı gibi yorumlayacaktır: string2.operator=(string1);

29 Atama operatörü - 3 operator=() fonksiyonunun özellikleri: 1. Fonksiyon bir referans parametresi alır. Böylece atamanın sağ tarafındaki nesnenin kopyasının yapılması engellenir. Şöyle ki, fonksiyonlara gönderilen nesnenin kopyası yapılır ve fonksiyon sona erdiğinde bu kopya yok edilir. Bu durumda kopya yok edilseydi yıkıcı fonksiyon çağırılacaktı ve işaretçi serbest kalacaktı. Fakat bu işaretçi nesne tarafından hala gerek duyulan işaretçidir. Referans kullanılması ile bu problem çözülmüştür.

30 Atama operatörü - 4 Eğer operatör fonksiyonlarının geri dönüş değeri tipleri void olarak yazılırsa, x = y = z gibi bir atama yapılamaz. Birden fazla atamanın bu şekilde zincirleme yapılabilmesi için operatör fonksiyonu, üzerinde işlem yapılan nesnenin referansını geri göndermelidir. String &String::operator=(const String &digeri) { // }

31 Atama operatörü operator=() fonksiyonunun referans döndürmesi. Fonksiyon nesne döndürüyorsa geçici bir nesne oluşturulur ve bu nesne döndürme işleminin sona ermesiyle yok edilir. Ancak bu durumda geçici nesnenin yıkıcısı çağrılır ve bu fonksiyon işaretçiyi serbest bırakır. Fakat bu işaretçi değer atanmakta olan nesne için gereklidir. Sonuç olarak referans döndürülürse geçici nesnenin oluşturulmasını ve işaretçinin serbest bırakılmasını engelleriz.