Programarea orientată obiect

Constructori şi destructori

Elemente noi în C++

• Transferul parametrilor prin adresă

void suma(int a, int b, int &c)

{ c = a + b; }

int x, y, z;

suma(x, y, z);

• Operatorii new şi delete ( new TIP, delete VAR)

int *p, *q;

p = new int; p = (int*) malloc (sizeof(int));

q = new int[10]; q = (int*) malloc (10*sizeof(int));

delete p;

delete q;

Constructor

• Metodă specială care creează un obiect– Alocă spaţiu (spaţiu propriu, spaţiu extins, modelul referinţă)

– Iniţializează atributele (atribute private)

Seg. date / stivă Heap

Obiect (referinţă)

Obiect propriu-zis

Obiect propriu-zis

Constructor

• Acelaşi nume ca şi clasa

• Nu are rezultat (nici void)

• Pot fi mai mulţi

• Există un constructor implicit – alocă spaţiul propriu

• Nu se apelează explicit

• Prototip (în descrierea clasei): nume_clasa(lista_parametri_formali);

• Utilizarenume_clasa nume_obiect(lista_parametri_actuali);

Complex a = Complex(2,5);

Constructor• Exemplu:Care poate fi starea iniţială pentru un obiect din clasa Matrice? (dinamic -> spaţiu extins)

class Matrice { float** a; int l, c, lmax, cmax;

public:Matrice();Matrice(float**x, int m, int n, int lm, int

cm); };

Matrice::Matrice(){ a = NULL; l = c = lmax = cmax = 0; }Matrice::Matrice(float**x, int m, int n, int lm, int cm){ int i,j; l = m; c = n; lmax = lm; cmax = cm; a = new float*[lmax]; for(i=0; i<lmax; i++) a[i] = new float[cmax]; for(i=0; i<l; i++) for(j=0; j<c; j++) a[i][j] = x[i][j];}

Matrice a;

Matrice b(z, 5, 5, 10, 10);

Constructor

• Transferul parametrilor– 1 constructor: conversii obişnuite

– >1 constructori: se alege cel cu cea mai potrivită listă de parametri

• Parametri impliciţi– tip nume = valoare_implicită

ConstructorExemplu:class Complex { float p_reala, p_imaginara;

public: Complex(float a = 0, float b = 0 ); };

Complex::Complex(float a,float b){ p_reala = a; p_imaginara = b; }

Complex a; // a reprezintă numarul 0 + i*0Complex b(-1); // b reprezintă numarul -1+ i*0Complex c(2,3); // c reprezintă numarul 2 + i*3

Complex(float a, float b = 0 ); Complex(float a = 0, float b );

Complex a = 1; // a reprezintă numarul 1+i*0

Constructor vid

• Şi obiecte iniţializate şi obiecte neiniţializate:– Constructor(i) cu parametri– Constructor(i) cu parametri impliciţi– Constructor vid – simulează constructorul implicit

Complex::Complex()

{

}

Complex a; // a este obiect neinitializat

Constructor de copiere

• Parametrii unui constructor pot fi– Orice tip, inclusiv pointer sau referinţă la clasa curentă– Excepţie: clasa curentă

• Constructor de copiere– Realizează o copie binară a unui obiect (doar spaţiul

propriu - atenţie la spaţiul extins)– Se generează unul implicit, acolo unde nu există unul

explicit

– 1 parametru referinţă către clasa curentă– Eventual alţi parametri, dar cu valori implicite

Constructor de copiere• Exemplu:

class Matrice { float** a; int l, c, lmax, cmax;

public: Matrice(Matrice &x);

… };

Matrice::Matrice(Matrice &x){ int i,j; l = x.getl(); c = x.getc(); lmax = x.getlm(); cmax = x.getcm(); a = new float*[lmax]; for(i=0; i<lmax; i++) a[i] = new float[cmax]; for(i=0; i<l; i++) for(j=0; j<c; j++) a[i][j] = x.get(i,j);}

Matrice a; // matrice “vidă”Matrice b = a; // b este o copie a lui aMatrice c(b); // c este o copie a lui b

Destructor

• Metodă specială care încheie existenţa unui obiect– Dezalocă spaţiul de memorie

– Acelaşi nume ca şi clasa, precedat de ~ (tilda)

– Nu are rezultat (nici void)

– Nu are parametri

– Un singur destructor explicit

– Destructor implicit

– Poate fi apelat explicit

Destructor class Matrice { float ** a;

int l, c, lmax, cmax; public: ~Matrice(); };Matrice::~Matrice()

{ int i;

if(a)

{ for(i=0; i<lmax; i++)

delete a[i];

delete a;

l = c = lmax = cmax = 0;

a=NULL;

}}

Matrice a; …a.~Matrice();

Clasa Nodclass Nod { float info; Nod* next; public: float GetInfo(); Nod* GetNext(); Nod(float a, Nod* n); };

float Nod::GetInfo(){ return info;}

Nod* Nod::GetNext(){ return next;}

Nod::Nod(float a, Nod* n){ info = a; next = n;}

Clasa Stivă Dinamicăclass Stiva { Nod* Cap; public: Stiva(); Stiva(float a); ~Stiva(); void Push(float a); float Pop(); int Empty(); void Afiseaza(); };

Stiva::Stiva(){ Cap = NULL;}

Stiva::Stiva(float a){ Cap = new Nod(a, NULL);}

Stiva::~Stiva(){ Nod* x; while(Cap) { x = Cap; Cap = Cap->GetNext(); delete x; }}

Clasa Stivă Dinamicăfloat Stiva::Pop(){ float x; Nod* y; y = Cap; x = Cap->GetInfo(); Cap = Cap->GetNext(); delete y; return x;}

void Stiva::Push(float a){ Cap=new Nod(a,Cap);}

int Stiva::Empty(){ return Cap?0:1;}

void Afiseaza(){ Nod* x; x = Cap; while(x) { printf("%5.2f ", x->GetInfo()); x = x->GetNext(); }}

Clasa Stivă Dinamicăvoid main(){ Stiva s; int i; float x; if(s.Empty()) printf("\nStiva este goala"); else printf("\nStiva contine date");

for(i=0;i<10;i++) s.Push((float)i);

s.Afiseaza(); x=s.Pop(); s.Afiseaza();

if(s.Empty()) printf("\nStiva este goala"); else printf("\nStiva contine date");

s.~Stiva();

if(s.Empty()) printf("\nStiva este goala"); else printf("\nStiva contine date");}

Spor la învăţat !