Lucrarea nr.

FUNCŢII CONSTRUCTOR ŞI DESTRUCTOR

Pentru a simplifica procesul de iniţlizare a membrilor de date, C++ permite definirea unei funcţii
speciale constructor, specifică fiecărei clase, care va fi apelată la fiecare craeare a unui obiect. În mod
simetric, C++ permite şi specificarea unei funcţii destructor pe care o apelează la distrugerea unui
obiect.
• Funcţiile constructor sunt metode ale claselor ce înlesnesc iniţializarea membrilor de date ai
claselor
• Funcţiile constructor au acelaşi nume cu clasa respectivă, numele funcţieie constructor nu
se precde, însă, cu cuvântul cheie void.
• Funcţiile constructor nu întorc nici o valoare
• De fiecare dată când un program creează o variabilă de tipul uni clase, C++ apelează funcţia
constructor, în cazul în care aceasta există
• Rularea unui program implică alocarea de memorie în scopul stocării de infpormaţii ale
diferitelor obiecte. La distrugerea unui obiect, C++ apelează o funcţie specială destructor care
poate elibera această memorie.
• Funcţiile destructor au acelaţi nume cu clasa respectivă, dar acest nume trebuie precedat de
caracterul (~).
• Funcţiile destructor nu întorc nici o valoare. Asemeni funcţiilor constructor, numele unei
funcţii destructor nu sunt precedate de cuvântul cheie void.

De exemplu, utilizând o clasă Carte, funcţia constructor va avea acelaşi nume ca în

programul următor:

#include <iostream.h>
#include <string.h>
#include <stdlib.h>
class Carte
{
public:
Carte(char *btitlu,char *bautor,char *beditura,
float bpret); //Constructorul clasei
char titlu[256];
char autor[64];
float pret;
void arata_titlu(void)
{ cout<<titlu<<'\n';}
float da_pret(void)
{ return(pret);};
void arata_carte(void)
{
arata_titlu();
arata_editura();
};
void atrib_editura(char *nume)
{strcpy(editura,nume);};
private:
char editura[256];
void arata_editura(void)
{cout<<editura<<'\n';};
};
Carte::Carte(char *btitlu,char *bautor,char *beditura, float bpret)
{
strcpy(titlu,btitlu);
strcpy(autor,bautor);
strcpy(editura,beditura);
pret=bpret;}
void main(void)
{
Carte volum("Print si cersetor","Mark Twain","Teora",100000);
volum.arata_carte();
cout<<"Pretul cartii este:"<<volum.da_pret()<<endl;
system("pause");
}
Programul poate defini funcţia constructor în cadrul clasei sau în exteriorul acesteia. Atunci
când programele declară ulterior un obiect, el poate transmite parametri către funcţia constructor,
după care funcţia constructor se execută automat, iniţializând varibilele membre ale clasei.
Dacă numele parametrilor funcţiei constructor s-ar iniţializa cu aceleaşi nume cu numele
datelor membre ale clasei acestea s-ar confunda şi de aceea trebuie folosit operatorul :: astfel:

Carte::Carte(char *btitlu,char *bautor,char *beditura, float bpret)

{
strcpy(titlu,btitlu);
strcpy(autor,bautor);
strcpy(editura,beditura);
pret=bpret;}

se înlocuieşte cu :

Carte::Carte(char *titlu,char *autor,char *editura, float pret)

{ strcpy(Carte::titlu,titlu);
strcpy(Carte::autor,autor);
strcpy(Carte::editura,editura);
Carte::pret=pret;}

În continuare se defineşte o clasă Angajat, numele funcţiei constructor este deasemenea

Angajat :

#include <iostream.h>
#include <string.h>
#include <stdlib.h>
class Angajat
{
public:
Angajat(char *,long, float);
void arata_Angajat(void);
int schimba_salariu(float);
long get_id(void);
private:
char nume[64];
long angajat_id;
float salariu;

};

Angajat::Angajat(char *nume,long angajat_id,float salariu)

{
strcpy(Angajat::nume,nume);
 Angajat::angajat_id=angajat_id;
if (salariu<500)
Angajat::salariu = salariu;
else
Angajat::salariu = 0.0;
}
void Angajat::arata_Angajat(void)
{
cout<<"Angajat:"<<nume<<endl;
cout<<"Id:"<<angajat_id<<endl;
cout<<"Salariu:"<<salariu<<endl;
}

void main(void)
{
Angajat muncitor ("Popescu Ion",11,6000);
muncitor.arata_Angajat();
system("pause");
}

C++ permite şi supraîncărcarea funcţiilor constructor în acelaşi mod ca la orice funcţie

obişnuită. Diferenţa între mai multe funcţii constructor se face prin numărul şi tipul de parametrii
trimişi:

Exemplul 1:

#include <iostream.h>
#include <string.h>
#include <stdlib.h>
#include <iomanip.h>
class Carte
{
public:
Carte(char *btitlu,char *bautor,char *beditura,
float bpret); //Primul constructor
Carte(void); //Al doilea constructor
char titlu[256];
char autor[64];
float pret;
void arata_titlu(void)
{ cout<<titlu<<'\n';}
float da_pret(void)
{ return(pret);};
void arata_carte(void)
{
arata_titlu();
arata_editura();
};
void atrib_editura(char *nume)
{strcpy(editura,nume);};
private:
char editura[256];
void arata_editura(void)
{cout<<editura<<'\n';};
};
Carte::Carte(char *btitlu,char *bautor,char *beditura, float bpret)
{
strcpy(titlu,btitlu);
strcpy(autor,bautor);
strcpy(editura,beditura);
pret=bpret;}
Carte::Carte(void)
{ cerr<<"\nTrebuie sa specificati valori initiale la crearea obiectului\n";
exit(1);}
void main(void)
{
Carte volum("Print si cersetor","Mark Twain","Teora",100000);
volum.arata_carte();
cout<<"Pretul cartii este:"<<volum.da_pret();
Carte volum1;
volum1.arata_carte();
system("pause");
}

Exemplu 2 :

#include <iostream.h>
#include <string.h>
#include <stdlib.h>
class Angajat
{
public:
Angajat(char *, long, float);
Angajat(char *, long);
void arata_Angajat(void);
int schimba_salariu(float);
long get_id(void);
private:
char nume[64];
long angajat_id;
float salariu;

};

Angajat::Angajat(char *nume,long angajat_id,float salariu)

{
strcpy(Angajat::nume,nume);
Angajat::angajat_id=angajat_id;
if (salariu<500)
Angajat::salariu = salariu;
else
Angajat::salariu = 0.0;
}
Angajat::Angajat(char *nume,long angajat_id)
{
strcpy(Angajat::nume,nume);
Angajat::angajat_id=angajat_id;
do {
cout<<"Introduce un salariu (mai mic de 500) pentru: "<<nume<<endl;
cin>>Angajat::salariu;
} while (salariu>=500.0);
}

void Angajat::arata_Angajat(void)
 {
cout<<"Angajat:"<<nume<<endl;
cout<<"Id:"<<angajat_id<<endl;
cout<<"Salariu:"<<salariu<<endl;
}

void main(void)
{
Angajat muncitor1 ("Popescu Ion",11,150);
Angajat muncitor2 ("Ionescu Ion",12);
muncitor1.arata_Angajat();
muncitor2.arata_Angajat();
system("pause");
}

În mod asemănător, C++ permite definirea unei funcţii destructor ce rulează de obicei în una
din următoarele două situaţii: fie când programul se termină fie când este utilizat operatorul delete
pentru a elibera memoria alocată instanţei. Funcţiile destructor au aceeai denumire cu clasa şi
diferă de funcţia constructor prin caracterul tilda(~) care precedă numele funcţiei destructor.
Funcţiile destructor nu acceptă parametri şi nu declararea lor se face fără valoare de returnat.

#include <iostream.h>
#include <string.h>
#include <stdlib.h>

class Carte
{
public:
Carte(char *btitlu,char *bautor,char *beditura,
float bpret); //Constructorul clasei
~Carte(void);
char titlu[256];
char autor[64];
float pret;
void arata_titlu(void)
{ cout<<titlu<<'\n';}
float da_pret(void)
{ return(pret);};
void arata_carte(void)
{
arata_titlu();
arata_editura();
};
void atrib_editura(char *nume)
{strcpy(editura,nume);};
private:
char editura[256];
void arata_editura(void)
{cout<<editura<<'\n';};
};
Carte::Carte(char *btitlu,char *bautor,char *beditura, float bpret)
{
strcpy(titlu,btitlu);
strcpy(autor,bautor);
strcpy(editura,beditura);
pret=bpret;}
Carte::~Carte(void)
{
cout<<"\nA fost distrus obiectul cu titlul: "<<titlu<<'\n';
}
void main(void)
{
Carte volum1("Print si cersetor","Mark Twain","Teora",100000);
volum1.arata_carte();
Carte volum2("Insula cu elice","Jules Vernes","Teora",200000);
volum2.arata_carte();

system("pause");
}

Exemplul 2 :

#include <iostream.h>
#include <string.h>
#include <stdlib.h>
class Angajat
{
public:
Angajat(char *, long, float);
~Angajat(void);
void arata_Angajat(void);
int schimba_salariu(float);
long get_id(void);
private:
char nume[64];
long angajat_id;
float salariu;

};

Angajat::Angajat(char *nume,long angajat_id,float salariu)

{
strcpy(Angajat::nume,nume);
Angajat::angajat_id=angajat_id;
if (salariu<500)
Angajat::salariu = salariu;
else
Angajat::salariu = 0.0;
}
Angajat::~Angajat(void)
{
cout<<"Destructorul pentru: "<<nume<<endl;
}

void Angajat::arata_Angajat(void)
{
cout<<"Angajat:"<<nume<<endl;
cout<<"Id:"<<angajat_id<<endl;
cout<<"Salariu:"<<salariu<<endl;
}

void main(void)
{
 Angajat muncitor ("Popescu Ion",11,150);
muncitor.arata_Angajat();
system("pause");
}

Este posibil în C++ ca un obiect să apeleze alt obiect. Programul următor creează două tipuri
de obiecte: un obiect care conţine informaţii despre o carte şi un obiect care conţine informaţii despre
un cititor. Obiectul Cititor apelează obiectul Carte pentru a afişa informaţii despre cartea preferată a
unui cititor:

#include <iostream.h>
#include <string.h>
#include <stdlib.h>

class Carte
{
public:
Carte(char *titlu)
{
strcpy(Carte::titlu,titlu);
}
void arata_carte(void)
{
cout<<titlu;
}
private:
char titlu[64];
};
class Cititor {
public:
Cititor (char *nume)
{
strcpy(Cititor::nume,nume);
}
void arata_cititor(class Carte carte)
{
cout<<"Cititor: "<<nume<<endl<<"Carte preferata: ";
carte.arata_carte();
}
private:
char nume[64];
};
void main(void)
{
Cititor cititor("Ionel");
Carte carte_preferata("Shogunul");
Cititor.arata_cititor(carte_preferata);
system("pause");
}
Modul de lucru:

1. Se vor edita şi rula toate programele din cuprinsul lucrării.

2. Să se realizeze un program ce foloseşte o clasă Film cu următorii membrii: nume, actor
principal, actor secundar. Se cere afişarea membrilor. Se vor utiliza funcţii constructor şi
destructor.
3. Să se realizeze un program care utilizează o clasă Grupa ce conţine ca date numele,
prenumele, vârsta, notele la 5 examene şi media acestora pentru 10 studenţi. Clasa va avea o
funcţie constructor pentru iniţializarea numelui şi prenumelui iar notele se vor citi de la
tastatură. Media notelor va fi de tip privat.
4. Să se realizeze un program care conţine două clase: o clasă ce va conţine un tip de maşină,
culoarea acesteia şi preţul şi o clasă care conţine numele, prenumele şi vârsta unui şofer.
Obiectele celei de-a doua clase vor apela obiectele primei clase pentru a specifica maşina fiecărui
şofer. Se vor utiliza funcţii constructor şi destructor