Constructorul

Constructorul

1. Initializarea obiectelor prin constructor

Initializarea obiectelor se face cu o functie membru specifica numita constructor. Numele constructorului trebuie sa coincida cu numele clasei. O clasa poate sa aiba mai multi constructori. In acest caz aceste functii membru au numele comun, ceea ce se poate face datorita posibilitatii de supraincarcare a functiilor. Bineinteles in acest caz numele si/sau tipul parametrilor formali trebuie sa fie diferit, altfel compilatorul nu poate sa aleaga constructorul corespunzator.

Constructorul nu returneaza o valoare. In acest caz nu este permis nici folosirea cuvantului cheie void.

Prezentam in continuare un exemplu de tip clasa cu mai multi constructori, avand ca date membru numele si prenumele unei persoane, si cu o functie membru pentru afisarea numelui complet. Fisierul pereche1.cpp (contine definitia clasei persoana):

#include <string.h>

#include <iostream.h>

class persoana ;

persoana::persoana()

persoana::persoana(char* n, char* p)

persoana::persoana(const persoana& p1)

persoana::~persoana()

void persoana::afiseaza()

Fisierul pereche2.cpp (contine functia main):

#include 'pereche1.cpp'

int main()

Observam prezenta a doi constructori specifici: constructorul implicit si constructorul de copiere. Daca o clasa are constructor fara parametri atunci el se va numi constructor implicit. Constructorul de copiere se foloseste la initializarea obiectelor folosind un obiect de acelasi tip (in exemplul de mai sus o persoana cu numele si prenumele identic). Constructorul de copiere se declara in general in forma:

nume_clasa(const nume_clasa& obiect);

Cuvantul cheie const exprima faptul ca argumentul constructorului de copiere nu se modifica.

Apelarea constructorilor in cazul in care datele membru sunt obiecte

O clasa poate sa contina ca date membru obiecte ale unei alte clase. Declarand clasa sub forma:

class nume_clasa ;

antetul constructorului clasei nume_clasa va fi de forma:

nume_clasa(lista_de_argumente):

ob_1(l_arg_1), ob_2(l_arg_2), , ob_n(l_arg_n)

unde lista_de_argumente respectiv l_arg_i reprezinta lista parametrilor formali ai constructorului clasei nume_clasa respectiv ai obiectului ob_i.

Din lista ob_1(l_arg_1), ob_2(l_arg_2), , ob_n(l_arg_n) pot sa lipseasca obiectele care nu au constructori definiti de programator, sau obiectul care se initializeaza cu un constructor implicit, sau cu toti parametrii impliciti.

Daca in clasa exista date membru de tip obiect atunci se vor apela mai intai constructorii datelor membru, iar dupa aceea corpul de instructiuni al constructorului clasei respective. Fisierul pereche3.cpp

#include 'pereche1.cpp'

class pereche //pentru obiectele sot si sotie

pereche(persoana& sotul, persoana& sotia);

pereche(char* nume_sot, char* prenume_sot,

char* nume_sotie, char* prenume_sotie):

sot(nume_sot, prenume_sot),

sotie(nume_sotie, prenume_sotie)

void afiseaza();

};

inline pereche::pereche(persoana& sotul, persoana& sotia):

sot(sotul), sotie(sotia)

void pereche::afiseaza()

int main()

Observam ca in cazul celui de al doilea constructor, parametrii formali sot si sotie au fost declarati ca si referinte la tipul persoana. Daca ar fi fost declarati ca parametri formali de tip persoana, atunci in cazul declaratiei:

pereche AB(A, B);

constructorul de copiere s-ar fi apelat de patru ori. In astfel de situatii se creaza mai intai obiecte temporale folosind constructorul de copiere (doua apeluri in cazul de fata), dupa care se executa constructorii datelor membru de tip obiect (inca doua apeluri).