5. kurucu, yok edici ve kopyalama fonksiyonları

5. Kurucu ve yok ediciler
Kurucular(Constructor)
Kurucu fonksiyonlar sınıfların üye verilerine(değişkenlerine) başlangıç değerlerini
vermek için kullanılan özel fonksiyonlardır. Kurucu fonksiyonlar nesneler
tanımlandıkları anda otomatik olarak çalışan fonksiyonlardır. Kurucu fonksiyonlar
sınıf bildirimleri yapılırken sınıf isimleri ile aynı ismi alırlar. Bu fonksiyonlarda diğer
fonksiyonlarda olduğu gibi parametreli veya parametresiz olarak tanımlanabilirler.
5. HAFTA
NESNEYE DAYALI PROGRAMLAMA

BLM225
Nesneye Dayalı Programlama
2
Aynı sınıf için birden fazla kurucu fonksiyon tanımlanabilir. Bu durumda kurucu
foksiyonların aşırı yüklenmesi durumu ortaya çıkar. Aşırı yüklenmiş fonksiyonlar
bilindiği gibi parametrelerin sayısına, veya türüne göre hangi fonksiyonun
çağrılacağna karar verilir. Aşağıda iki tür kurucu fonksiyon prototipi görülmektedir.
SinifIsmi :: SinifIsmi();
SinifIsmi::SinifIsmi(parametre1, parametre2, … , parametren);
Dortgen::Dortgen() ; //parametresiz kurucu
Dortgen::Dortgen(int,int,int,int); //parametreli kurucu
Kurucu fonksiyonların dönüş tipi yoktur. Geri dönüş tipi
olarak herhangi bir tip (void bile) belirtilmez. Kurucu fonksiyonlar public olarak
tanımlanmalıdır.
Yok ediciler(Destructors)
Yok edici fonksiyonlar Nesneler yok edildiklerinde, bellekten atıldıklarında otomatik
olarak çalışan fonksiyonlardır. Yok edici fonksiyonlarda sınıf ismi ile aynı ismi alırlar
ancak önlerine ‘~’ işareti konulur. Yok edici fonksiyonlar sınıf üyeleri için dinamik
olarak bellekten yer alındığında, alınan yerleri geri vermek için kullanılır. Aşağıda
yok edici fonksiyon prototipi görülmektedir. Yok ediciler parametre almazlar
ve geriye değer döndürmezler. Bir sınıfta sadece bir adet yok edici fonksiyon
olabilir.
~SinifIsmi();
SinifIsmi :: ~SinifIsmi();
{
// komutlar;
}
Dortgen::~Dortgen();
Şimdi daha önceki derslerimizde kullandığımız Dörtgen sınıfını biraz değiştirelim.
Dörtgen sınıfı aşağıdaki resimde görüldüğü gibi özellikleri belirlensin. x, y
değişkenleri dörtgenin üst köşe koordinatını, yuk değişkeni yüksekliği ve gen
değişkeni de genişliği belirtsin.
Karabük Üniversitesi Uzaktan Eğitim Araştırma ve Uygulama Merkezi
Mühendislik Fakültesi No: 215 Balıklarkayası Mevkii 78050 Karabük TÜRKİYE
2

BLM225
3
#include <iostream>
using namespace std;
class Dortgen {
int x, y,gen,yuk ;
public:
Dortgen() ; //parametresiz kurucu
Dortgen(int,int,int,int); //parametreli kurucu
~Dortgen(); //yok edici fonksiyon
void DegerVer(int,int,int,int);
int Alan (void);
};
//Yok edici fonksiyon
Dortgen::~Dortgen() {
cout<<"yok edici calisti"<<endl; //Yok edici bu örnekte hiçbir işe
yararamıyor.
//Sadece ekrana mesaj veriyor
}
//parametresiz kurucu fonksiyonu
Dortgen::Dortgen() {
x = 5;
y = 5;
gen=10;
yuk=3;
cout<<"Parameresiz kurucu calisti"<<endl;
}
//parametreli kurucu fonksiyonu
Dortgen::Dortgen(int a, int b, int g, int h) {
x = a;
3

BLM225
4
y = b;
gen=g;
yuk=h;
cout<<"Parametreli kurucu calisti"<<endl;
}
void Dortgen::DegerVer(int a, int b, int g, int h) {
x = a;
y = b;
gen=g;
yuk=h;
}
int Dortgen::Alan (void) {
return gen*yuk;
}
int main ()
{
{
Dortgen D1,D2(3,7,10,4); //Bu satırda D1 ve D2 nesneleri tanımlanıyor
// Önce D1 için paramertresiz kurucu, Sonra
// D2 nesnesi için parametreli kurucu çalışıyor
//D1.DegerVer(3,4,7,9); // Daha sonra D1 ve D2 nesnelerinin
verilerine
//D2.DegerVer(7,2,6,60); //değer verilebilir
cout << "Alan1: " << D1.Alan()<<'n';
cout << "Alan2: " << D2.Alan()<<endl;
}
//Burada D1 ve D2 için yok ediciler çalıştı
return 0;
}
4

BLM225
5
#include <conio.h>
#include <iostream.h>
#include <iostream>
class Agac{
private:
string tur; int boy;
public:
Agac(){ cout<<"DC calisti"<<endl;
tur="Kavak"; boy=10;}
Agac(int by){ cout<<"PC1 calisti"<<endl;
tur="Belirsiz"; boy=by;}
Agac(string tr, int by){
cout<<"PC2 calisti"<<endl;
tur=tr; boy=by;}
~Agac(){cout<<"Dst calisti"<<endl;}
void kes(int by){ boy=boy-by;
cout<<tur<<" Agacinin kesildikten sonraki boyu="<<boy<<endl;}
};
int main (){
{
Agac a1;
Agac a2("Cam",8);
Agac a3(5);
Agac a4;
a4=a2;
a1.kes(3);
a2.kes(2);
a3.kes(1);
a4.kes(8);
}
5

BLM225
6
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <list>
const float pi=3.14;
class Daire{
private:
double ycap;
int x,y;
public:
Daire();
Daire(double,int,int);
~Daire();
void degerVer(double, int, int);
double alan();
};
Daire::Daire()
{
6

BLM225
7
ycap=5.0;
x=50;
y=50;
cout<<"nesne olusturuldu"<<endl;
}
Daire::~Daire()
{
cout<<"nesne silindi"<<endl;
}
Daire::Daire(double r, int a, int b)
{
ycap=r; x=a; y=b;
}
void Daire::degerVer(double r, int a, int b)
{
ycap=r; x=a; y=b;
}
double Daire::alan()
{
return (pi*ycap*ycap);
}
int main ()
{
{
Daire d,d2;
Daire d1(10.0,100,100);
cout<<"Alan="<<d.alan()<<endl;
cout<<"Alan 1="<<d1.alan()<<endl;
d2.degerVer(1, 10, 10);
}
getch();
7

BLM225
8
}
Aşağıdaki programda kurucu ve yok edici fonksiyonların işlevleri daha iyi
anlaşılmaktadır. Bu programda Dortgen sınıfının üye verileri int *x, *y,*gen,*yuk ;
şeklinde pointer olarak tanımlanmakta ve kurucu fonksiyonlarda bu pointerlere
dinamik olarak ayrılan yerler atanmaktadır.Daha sonra yok edici fonksiyon ile de
ayrılan yerler geri verilmektedir.
//Bir başka örnek
#include <iostream>
class Dortgen {
int *x, *y,*gen,*yuk ;
public:
Dortgen() ; //parametresiz kurucu
Dortgen(int,int,int,int); //parametreli kurucu
~Dortgen(); //yok edici fonksiyon
void DegerVer(int,int,int,int);
int Alan (void);
};
//Yokedici fonksiyon
Dortgen::~Dortgen() {
delete x;
delete y;
delete gen,yuk;
cout<<"yok edici calisti"<<endl;
}
//parametresiz kurucu fonksiyonu
Dortgen::Dortgen() {
x = new int; //Dinamik olarak bellekten yer alınıyor
y = new int;
gen=new int;
yuk=new int;
8

BLM225
9
*x=10;
*y=20;
*gen=5;
*yuk=6;
cout<<"Parameresiz kurucu calisti"<<endl;
}
//parametreli kurucu fonksiyonu
Dortgen::Dortgen(int a, int b, int g, int h) {
x = new int; //Dinamik olarak bellekten yer alınıyor
y = new int;
gen=new int;
yuk=new int;
*x = a;
*y = b;
*gen=g;
*yuk=h;
cout<<"Parametreli kurucu calisti"<<endl;
}
void Dortgen::DegerVer(int a, int b, int g, int h) {
*x = a;
*y = b;
*gen=g;
*yuk=h;
}
return *gen*(*yuk);
}
int main ()
{
{
Dortgen D1,D2(3,7,10,4);
Dortgen *D3=new Dortgen;
D1.DegerVer(3,4,7,9);
D2.DegerVer(7,2,6,60);
D3->DegerVer(5,5,12,3); //D3 pointer nesne
9

BLM225
10
cout << "Alan1: " << D1.Alan()<<'n';
cout << "Alan3: " << D3->Alan()<<endl;
delete D3;
}
return 0;
}
Kurucu fonksiyonlarda ilk değer ataması
Kurucu fonksiyonlarda nesnelerin verilerine ilk değerlerini atamak için atama ‘=’
operatörün kullanılmaktadır. Ancak sabit verilere değer atamak için atama ‘=’
operatörü kullanılmaz. Aşağıdaki örneği inceleyiniz.
class C{
int s; // sabit olmayan veri
const float pi; // sabit veri
public:
C() { // Kurucu fonksiyon
s = 0; // Doğru, çünkü s sabit değil
pi = 3.14; // HATA! pi sabit veri
}
};
Aşağıdaki gibi bir yazım da derleme hatasına neden olur.
class C{
int s=0; // sabit olmayan veri
const float pi=3.14; // HATA! S sabit veri
}
Bu problem 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 adından sonra iki
nokta üst üste (:) konur, ardından ilk değer atanacak verinin adı ve parantez içinde
atanacak değer yazılır.
class C{
10

BLM225
11
int s; // sabit olmayan veri
const float pi; // sabit veri
public:
C( ):pi(3.14) { // Kurucu fonksiyon pi ye 3.14 değeri veriliyor.
s = 0; // Doğru, çünkü s sabit değil
}
};
Tüm üye verilere değer atamak için bu yapı kullanılabilir. Eğer kurucu
fonksiyonun başka bir görevi yoksa gövdesi boş kalabilir.
C():pi(3.14), s(0)
{ } //gövde boş kalabilir
#include <conio.h>
#include <iostream>
#include <list>
class Insaat{
private:
char tur;
int yyili;
double taban;
int kat;
public:
void degerVer(char, int,double,int);
char getTur();
int getYyili();
double insaatAlan();
Insaat();
Insaat(char, int,double, int);
Insaat(char);
~Insaat();
};
void Insaat::degerVer(char c, int y, double t, int k){tur=c; yyili=y; taban=t;
kat=k;}
double Insaat::insaatAlan(){return taban*kat;}
int Insaat::getYyili(){return yyili;}
char Insaat::getTur() {return tur;}
Insaat::Insaat() {tur='1'; yyili=2015; taban=0; kat=0;}//1
Insaat::Insaat(char c, int y, double m, int k) {tur=c; yyili=y; taban=m; kat=k;}//1
Insaat::Insaat(char c){tur=c;}//1
11

BLM225
12
Insaat::~Insaat() { cout<<"nesne silindi"<<endl;}//4
int main ()
{
{
Insaat i;
Insaat i1('2',2016, 458.56, 3);
Insaat i2('3');
Insaat i3;
i3.degerVer('2',2013,254.8,2);
cout<<"insaat turu: "<<i.getTur()<<endl;
cout<<"Yapim yili : "<<i.getYyili()<<endl;
cout<<"insaat alan: "<<i.insaatAlan()<<endl;
cout<<"-----------"<<endl;
cout<<"insaat turu: "<<i1.getTur()<<endl;
cout<<"Yapim yili : "<<i1.getYyili()<<endl;
cout<<"insaat alan: "<<i1.insaatAlan()<<endl;
cout<<"-----------"<<endl;
cout<<"-----------"<<endl;
}
getch();
return 0;
}
Kopyalama Kurucusu
Kopyalama kurucusu özel bir kurucu fonksiyondur. Daha önceden tanımlanmış var
olan bir nesnenin istediğimiz verilerini yeni oluşturulan nesneye kopyalarlar. Böylece
yeni oluşturulan nesne var olan nesnenin bir kopyası olur. Bu fonksiyonlar parametre
olarak kendisi ile aynı sınıftan bir nesneyi referans alır.
SinifIsmi( SinifIsmi &);
#include <iostream>
class Dortgen {
public:
int x, y;
Dortgen(); //Kurucu
12

BLM225
13
Dortgen(const Dortgen &); //Kopyalama kurucusu
void DegerVer(int,int);
int Alan (void);
};
Dortgen::Dortgen() { //parametresiz kurucu
x = 5;
y = 5;
}
Dortgen::Dortgen(const Dortgen &nesne) { //Kopyalama kurucusu
x = nesne.x;
y = nesne.y;
}
void Dortgen::DegerVer(int a, int b) {
x = a;
y = b;
}
return x*y;
}
int main ()
{
Dortgen D1;
D1.DegerVer(9,10);
Dortgen D2=D1;
Dortgen D3(D1); //Kopyalama Kurucusu calisti
D1=D2;
13

BLM225
14
cout << "Alan1: " << D1.Alan()<<'n';
return 0;
}
#include <conio.h>
#include <iostream>
#include <list>
class Insaat{
private:
char tur;
int yyili;
double taban;
int kat;
public:
void degerVer(char, int,double,int);
char getTur();
int getYyili();
double insaatAlan();
Insaat();
Insaat(const Insaat &);
};
void Insaat::degerVer(char c, int y, double t, int k){tur=c; yyili=y; taban=t; kat=k;}
double Insaat::insaatAlan(){return taban*kat;}
int Insaat::getYyili(){return yyili;}
char Insaat::getTur() {return tur;}
Insaat::Insaat() {tur='1'; yyili=2015; taban=0; kat=0;}//1
Insaat::Insaat(const Insaat &in) {tur=in.tur; yyili=in.yyili; taban=in.taban;}
int main ()
{
14

BLM225
15
Insaat i2;
i2.degerVer('2',2016, 125.0,4);
Insaat i3(i2); //Insaat i3=i2;
cout<<"-----------" <<endl;
cout<<"-----------"<<endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <list>
class Dortgen {
public:
char tur;
int x, y;
Dortgen();
Dortgen( const Dortgen &); //Kopyalama kurucusu
void DegerVer(int,int);
int Alan (void);
char getTur(){
return tur;
}
};
Dortgen::Dortgen()
{
x=5; y=6;
}
Dortgen::Dortgen(const Dortgen &nesne) { //Kopyalama kurucusu
x = nesne.x;
y = nesne.y;
tur='c';
}
void Dortgen::DegerVer(int a, int b) {
15

BLM225
16
x = a;
y = b;
tur='a';
}
return x*y;
}
int main ()
{
Dortgen d1;
Dortgen d2(d1);
Dortgen d3;
d1.DegerVer(9,10);
d3=d1;
cout << "Alan1: " << d1.Alan()<<endl;
cout <<"nesne turu: "<<d1.getTur()<<" Alan1: " << d1.Alan()<<endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
class Daire{
private:
char tur;
double ycap;
int x,y;
public:
double alan();
Daire(); // parametresiz kurucu
char getTur();
Daire( Daire &);
};
char Daire::getTur(){
return tur;
}
Daire::Daire()
{ tur='a';
16

BLM225
17
ycap=1.0;
}
Daire::Daire( Daire &d){
ycap=d.ycap;
tur='c';
d.ycap=100;
}
double Daire::alan(){
return 3.14*ycap*ycap;
}
int main () {
Daire d;
Daire d1(d);
cout<<"Alan d="<<d.alan()<<endl;
cout<<"Daire turu :"<<d.getTur()<<endl;
cout<<"Daire 1 alan :" << d1.alan()<<endl;
cout<<"Daire 1 turu :"<<d1.getTur()<<endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
class Daire{
double ycap;
char type;
public:
double alan();
Daire();
double getYcap();
char getType();
Daire(Daire &);
};
Daire::Daire()
{
ycap=10.0;
type='a';
}
Daire::Daire(Daire &d)
{
type=d.type;
ycap=1.0;
d.ycap=2;
}
double Daire::getYcap()
{ return ycap; }
char Daire::getType()
{ return type;}
17

BLM225
18
double Daire::alan()
{ return (3.14*ycap*ycap); }
int main () {
Daire d1;
cout<<d1.getType()<<endl;
cout<<d1.getYcap()<<endl;
cout<<d1.alan()<<endl;
Daire d2(d1);
getch();
return 0;
}
#include <conio.h>
#include <iostream>
class Line
{
public:
int getLength( void );
Line( int len ); // simple constructor
//Line( const Line &obj); // without using copy constructor
~Line(); // destructor
private:
int *ptr;
};
// Member functions definitions including constructor
Line::Line(int len)
{
cout << "Normal constructor allocating ptr" << endl;
// allocate memory for the pointer;
ptr = new int;
18

BLM225
19
*ptr = len;
}
/*
Line::Line(const Line &obj)
{
cout << "Copy constructor allocating ptr." << endl;
ptr = new int;
*ptr = *obj.ptr; // copy the value
}
*/
Line::~Line(void)
{
cout << "Freeing memory!" << endl;
delete ptr;
}
int Line::getLength( void )
{
return *ptr;
}
void display(Line obj)
{
cout << "Length of line : " << obj.getLength() <<endl;
}
// Main function for the program
int main( )
{
Line line1(10);
Line line2(line1);
display(line1);
display(line2);
getch();
return 0;
}
#include <conio.h>
19

BLM225
20
#include <iostream>
class Line
{
public:
int getLength( void );
Line( int len ); // simple constructor
Line( const Line &obj); // copy constructor
~Line(); // destructor
private:
int *ptr;
};
// Member functions definitions including constructor
Line::Line(int len)
{
cout << "Normal constructor allocating ptr" << endl;
// allocate memory for the pointer;
ptr = new int;
*ptr = len;
}
Line::Line(const Line &obj)
{
cout << "Copy constructor allocating ptr." << endl;
ptr = new int;
*ptr = *obj.ptr; // copy the value
}
Line::~Line(void)
{
cout << "Freeing memory!" << endl;
delete ptr;
}
int Line::getLength( void )
{
return *ptr;
}
void display(Line obj)
{
cout << "Length of line : " << obj.getLength() <<endl;
}
// Main function for the program
int main( )
{
20

BLM225
21
Line line1(10);
Line line2(line1);
display(line1);
display(line2);
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <string>
#include <list>
class Sinif {
private:
int a; int b;
public:
Sinif(){a=0; b=0; cout<<"DC run"<<endl;}
Sinif(int x, int y) {a=x; b=y; cout<<"PC run"<<endl;}
~Sinif(){cout<<"Delete constructor"<<endl;}
Sinif(const Sinif &ns){a=1; b=ns.b;}
int size(){ return a*b;}
void degerAta(int x, int y) {a=x; b=y;}
void goster() {cout<<a<< " , " <<b<<endl;}
};
int main ()
{ Sinif *nesne=new Sinif();
Sinif nesne1(50,10);
nesne->goster(); nesne1.goster();
nesne->degerAta(2,6);
cout<<nesne->size()<<endl;
nesne->goster();
Sinif nesne2(nesne1);
cout<<"nesne2 size="<<nesne2. <<endl;
nesne1.goster();
delete nesne;
21

BLM225
22
getch();
return 0;
}
#include <conio.h>
#include <iostream>
class Agac{
private:
string tur; int boy;
public:
Agac(){ tur="Kavak"; boy=10;}
Agac(string tr, int by){ tur=tr; boy=by;}
Agac(const Agac &a){
tur="belirsiz";
boy=a.boy;
}
void kes(int by){ boy=boy-by;
cout<<tur<<" Agacinin kesildikten sonraki boyu="<<boy<<endl;}
};
int main (){
Agac a1;
Agac a2("Cam",8);
Agac a3;
Agac a4(a2);
a3=a2;
a1.kes(1);
a2.kes(1);
a3.kes(1);
a4.kes(1);
getch();
return 0;
}
22

5. kurucu, yok edici ve kopyalama fonksiyonları

Recommended

Recommended

More Related Content

Similar to 5. kurucu, yok edici ve kopyalama fonksiyonları

Similar to 5. kurucu, yok edici ve kopyalama fonksiyonları (9)

More from karmuhtam

More from karmuhtam (20)

5. kurucu, yok edici ve kopyalama fonksiyonları