Lab 2

Ministerul Educaţiei a Republicii Moldova
Universitatea Tehnică a Moldovei

Catedra calculatoare și rețele
Raport
LA DISCIPLINA „PROGRAMAREA ORIENTATĂ PE OBIECTE”
A efectuat: Cojuhari Clara,gr.CR-191
A verificat: Lisnic Inga
Chişinău 2020
LUCRARE DE LABORATOR NR. 2
Tema: Constructorul – funcţie de iniţializare a obiectelor clasei
Scopul lucrării:
 Studierea principiilor de definire şi utilizare a constructorilor
 Studierea principiilor de definire şi utilizare a destructorilor
 Studierea tipurilor de constructori
Noţiuni de bază
Una din cele mai răspîndite erori de programare (în orice limbaj) constă în utilizarea
obiectelor fără iniţializare anterioară, aşa precum nu toate limbajele asigură iniţializare
automată. Desigur, poate fi definită funcţia de iniţializare şi de distrugere a obiectului:
class Book{
char *author;
int year;
int pages;
public:
void Init(char*, int, int);
void Destroy();
};
void Book::Init(char* a, int y, int p){
author = new char[strlen(a)+1];
strcpy(author,a);
year=y;
pages=p;
void Book::Destroy(){
delete[] author;
}
În acest exemplu, însă, nimeni nu garantează că iniţializarea va avea loc, sau că va fi
eliberată memoria alocată. Alt neajuns al exemplului dat constă în pericolul scurgerii de
memorie, deoarece funcţia de iniţializare poate fi apelată de nenumărate ori. De asemenea
se poate bloca sistemul din cauza utilizării eronate a memoriei dinamice, motivul fiind
apelul funcţiei Destroy fără iniţializare.
Definire şi utilizare
Pentru a evita această eroare, C++ asigură mecanismul de iniţializare automată pentru
clasele definite de utilizator – constructorul clasei. Iar pentru operaţiile de distrugere –
destructorul clasei.
Constructorul – este o funcţie membru specială, de acelaşi nume cu numele clasei, care se
apelează automat la crearea obiectului de tipul clasei. Constructorul nu returnează nici un
rezultat, chiar nici void. Compilatorul garantează apelarea unică a constructorului pentru un
singur obiect.
Destructorul – este o funcţie membru specială, care se apelează automat la distrugerea

obiectului. Numele unui destructor este numele clasei precedat de caracterul „~”.Compilatorul
garantează apelarea unică a destructorului pentru un singur obiect. Un destructor nu are
parametri, de aceea nu poate fi supraîncărcat, şi el este unic pentru o clasă.
Pentru un obiect local, destructorul se apelează cînd controlul programului iese din
domeniul lui (se iese din blocul în care este declarat). Obiectele dinamice nu pot fi distruse
automat. Distrugerea se realizează de către programator prin intermediul operatorului delete,
care apelează, propriu zis, destructorul.
Fie un exemplu analogic cu cel precedent, utilizînd constructorul şi destructorul:
class Book{
char *author;
int year;
int pages;
public:
Book(char*, int, int);
~Book();
};
Book::Book(char* a, int y, int p){
author = new char[strlen(a)+1];
strcpy(author,a);
year=y;
pages=p;
Book::~Book(){
delete[] author;
void main(){
Book b(“Stroustrup”,2000,890);
// Book b1; // încercarea de a crea obiectul fără apelul //constructorului duce la erori
Book* ptr = new Book(“Lippman”,1996, 1200);
// crearea dinamică a obiectului
delete ptr;
// în acest caz eliberarea memoriei se realizează de //către programator
// aici se apelează automat destructorul pentru b.
Tipurile constructorilor
Există patru tipuri de constructori: implicit, de copiere, de conversie a tipului şi general.

Această clasificare este bazată pe regulile de definire şi utilizare a constructorilor.
 Constructorul implicit – constructor fără parametri, sau constructor cu toţi parametrii

impliciţi.
 Constructorul de copiere – constructor care are ca parametru referinţă la obiectul clasei
respective. Constructorul de copiere poate avea şi alţi parametri care însă trebuie să fie
impliciţi.
 Constructorul de conversie a tipului - constructorul, care transformă un tip de obiect în
altul.
 Constructorul general – constructorul care nu corespunde categoriilor enumerate mai
sus.
Fie exemplul:
class Book{
char *author;
int year;
int pages;
public:
Book(); // constructor implicit
Book(const Book&); // constructor de copiere
Book(const char*); // constructor de conversie a tipului
Book(char*, int, int); // constructor general
...
};
...
void main(){
Book b(“Stroustrup”,1997,890); // general
Book b1 = b, b11(b); // de copiere
Book b2 = “Stroustrup”, b21(“Bjarne”);
// de schimbare a tipului
Book b3; // implicit
Constructori generaţi de compilator. Interacţiunea lor cu constructorii definiţi de utilizator
Prezenţa constructorilor nu este obligatorie. Se pot defini clase şi fără constructori. În

acest caz, compilatorul C++ generează în mod automat un constructor implicit şi de copiere.
Constructorul implicit generat nu realizează absolut nimic, iar constructorul de copiere

generat automat implică copierea bit cu bit, ceea ce nu întotdeauna este satisfăcător. În cazul
definirii unui constructor de către utilizator se generează automat numai constructorul de
copiere.
Recomandări
Fiecare clasă trebuie să conţină constructori. Dacă clasa conţine elemente pointeri trebuie
neapărat să se supraîncarce constructorul de copiere, care se utilizează pentru crearea copiilor
obiectului, la apelul obiectului în funcţie. Motivul supraîncărcării constructorului de copiere
constă în necesitatea utilizării acţiunilor suplimentare în comparaţie cu algoritmul standard de
copiere, deoarece se poate întîmpla ca două obiecte diferite să refere una şi aceeaşi memorie,
ceea ce poate duce la pierderea informaţiei şi la erori în sistemul de operare.
Exemplu de constructori de copiere:
Book::Book(const Book& b){
author = new char[strlen(b.author)+1];
strcpy(author, b.author);
year = b.year;
pages = b.pages;
Constructorii trebuie să utilizeze mecanisme numite iniţializatori (lista de iniţializare).

Această regulă contribuie la evitarea cheltuielilor necesare pentru iniţializarea cîmpurilor clasei,
deoarece la execuţia constructorului cîmpurile trebuie să fie deja iniţializate, iar la execuţia
iniţializatorilor – nu.
Book::Book(const Book& b): year(b.year),pages(b.pages),
author(new char[strlen(b.author)+1])
strcpy(author, b.author);
// apelul funcţiei strcpy a rămas în afara iniţializatorului.
În cazul utilizării tabloului de obiecte se defineşte în mod obligatoriu un constructor

implicit, care se apelează pentru iniţializarea elementelor tabloului.
1. Explicaţi termenul de iniţializare.

Inițializare- crearea unei clase cu scopul de a manipula datele.
2. Ce cuvinte cheie se utilizează pentru definirea constructorului şi a

destructorului?
Cuvintul cheie utilizat pentru difinirea constructorului este doar denumirea clasei, iar
destructorului se adaugă simbolul ~ (tilda).
3. Poate oare un constructor să returneze o valoare?
Nu e posibil ca constructorul sa returneze o valoare (din corpul lor lipseste intrucțiunea
return; în antetul constructorilor nu se specifică niciodată- la tipul valorii returnate -
cuvântul cheie void)
4. Pot oare să existe clase fără constructori?
Da,e posibil să existe clase fără constructori.
5.Cîţi constructori poate conţine o clasă? Dar destructori? De ce?
O clasa poate conține un număr nelimitat de constructori, iar destructori doar unul.
5. Enumeraţi tipurile de constructori?

Constructori impliciți
definit de utilizator – constructor ce nu are niciun parametru
generat de compilator – dacă o clasă nu are niciun constructor definit atunci compilatorul
generează unul automat, fară parametri al cărui corp nu conține nicio instrucțiune
constructor cu toți parametri impliciți
Constructori cu parametri
cu parametri ce nu iau valori implicite
cu parametri ce iau valori implicite
Constructori de conversie de tip
Constructori de copiere - iniţializarea obiectelor la declarare cu alte obiecte deja create
definiți de utilizator
generați de compilator
6. Cum se apelează un constructor?
Nume_clasei
var_clasei(parametri)
7. De ce este nevoie de definit un constructor de copiere?
Este nevoie de a defini constructor de copiere pentru a putea copia obiectele clasei, și a
manipula mai comod cu datele.
8. De ce este nevoie de definit un constructor de conversie a tipului?
Un astfel de constructor este binevenit la supraincarcarea operatorilor, și la conversiile
dintr-un tip în altul.
9. În ce cazuri se apelează constructorul de copiere? Care este sintaxa apelului?
Constructorii de copiere apelaţi în următoarele situaţii:
• explicit de către programator la iniţializarea unui alt obiect:
// apelare constructor de copiere
Complex c2 = c1;
// sau
Complex c2(c1);
ATENŢIE: constructorii de copiere se apelează numai la iniţializare, nu şi la atribuire;
construcţia Complex c2; c2 = c1; nu va apela constructorul de copiere
. • automat de către compilator când este necesară crearea unei copii temporare (de
exemplu când obiectul este trimis ca parametru prin valoare într-o funcţie)
void AfisareComplex(Complex c)
{ cout << "(" << c.getReal() << "," << c.getImag() << ")" << endl; }
// trimitere ca parametru
AfisareComplex(c1);
Constructorii de copiere sunt utili atunci când comportamentul implicit sintetizat de către
compilator nu este satisfăcător. Un astfel de caz sunt clasele care conţin atribute pointeri.
Constructorul de copiere implicit va copia doar pointerul, nu şi zona de memorie adresată.
10. Ce sunt listele de iniţializare (iniţializatori)?

11. În C ++, un constructor al unei clase / structuri poate avea o listă de
inițializatoare în cadrul definiției, dar înainte de corpul constructorului și valorile nu
sunt atribuite variabilei. Ele sunt inițializate. În exemplul de mai jos, 0 este inițializat în
re și im. Exemplu:
12. struct IntComplex {

13. IntComplex () : re ( 0 ), im ( 0 ) {}
14.
15. int re ;
16. int im ;
17. };
12.În care caz se defineşte obligatoriu constructorul implicit?

Clasele pe care le-am creat până acum însă nu au avut nici un constructor. În acest caz, se
crează automat un constructor implicit (în terminologia POO, default constructor) care face
iniţializarea câmpurilor neinițializate, astfel:
 referințele la obiecte se inițializează cu null

 variabilele de tip numeric se inițializează cu 0
 variabilele de tip logic (boolean) se inițializează cu false
Varianta 2
а) Să se creeze clasa Time – timp cu cîmpurile: ore (0-23), minute (0-59), secunde (0-59). Să se
definească constructorii, funcţiile membru de setare a timpului; de returnare a orei, minutelor şi
secundelor; funcţiile de afişare conform şablonului: „ora 17 şi 18 minute şi 4 secunde” şi „5
p.m. 18 minute 4 secunde”. Funcţiile de setare a cîmpurilor clasei trebuie să verifice
corectitudinea parametrilor primiţi.
b) Să se creeze clasa Matrix – matrice. Clasa conţine pointer spre double, numărul de rînduri şi
de coloane şi o variabilă – codul erorii. Să se definească constructorul fără parametri
(constructorul implicit), constructorul cu un parametru – matrice pătrată şi constructorul cu doi
parametri – matrice dreptunghiulară ş. a. Să se definească funcţiile membru de acces: returnarea
şi setarea valorii elementului (i,j). Să se definească funcţiile de adunare şi scădere a două
matrice; înmulţirea unei matrice cu alta; înmulţirea unei matrice cu un număr. Să se testeze
funcţionarea clasei. În caz de insuficienţă de memorie, necorespondenţă a dimensiunilor
matricelor, depăşire a limitei memoriei utilizate să se stabilească codul erorii.
Codul:
a)
#include <iostream.h>
#include <conio.h>
class Time{
private: int ore,min,sec;
public:
Time(); //Constructor inplicit
Time(int o, int m, int s); // cu parametru
Time(const Time &s); // de copiere
~Time(); //Desctructorul
void setare();
void afisare(void);
void sabl1();
void sabl2();
void col();
void colo();
void modifivare();
};
Time a;
int am[]={1,2,3,4,5,6,7,8,9,10,11},i=0;
int pm[]={13,14,15,16,17,18,19,20,21,22,23};
//Constructor*******************************************************************
inline Time::Time(){
ore=min=sec=0;
}
//Desctructor*******************************************************************
inline Time::~Time(){
ore=min=sec=0;
}
void Time::setare(){
sus:clrscr();
cout<<"Introdu ora/min/sec"<<endl;
cout<<"Introdu ora: ";
cin>>a.ore;
Beep(800,200);
if ((a.ore>=0) && (a.ore<=23)) {
cout<<"Minute: ";
cin>>a.min;Beep(800,200);
if ((a.min>=0) && (a.min<=59)) {
cout<<"Secunde: ";
cin>>a.sec; Beep(800,200);
if ((a.sec>=0) && (a.sec<=59)) goto stop;
else goto jos;
} else goto jos;
}
else {jos: cout<<"Ati introdus date gresite !"; Sleep(800); goto sus;}
stop: getch();
}
//******************************************************************************
void Time::afisare(){
char com;
sus:clrscr();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 14);
cout<<"Alege sablonul: "<<endl;
cout<<"1 - Sablonu 1 \"ora 17 18 minute si 4 secunde\""<<endl;
cout<<"2 - Sablonu 2 \" 5 p.m 18 minute 4 secunde \""<<endl;
cout<<"Backspace - Inapoi"<<endl;
com=getch();
switch (com) {
case '1' : {a.sabl1(); break;};
case '2' : {a.sabl2(); break;};
case 8 : goto jos;
default: goto sus;
}
jos:
}
//******************************************************************************
void Time:sabl1()
{
int k=0;
clrscr();
cout<<"Sablonul 1"<<endl;
for (i = 0; i < 12; i++) {
if (pm[i]==a.ore){
a.col();
k++; }}
if (k==0) a.colo();
cout<<"Tastati tasta Enter pentru a alege alt sablon:"<<endl;
getch();
a.afisare();
}
//******************************************************************************
void Time::col(){
cout<<"ora ";
cout<<am[i];
cout<<" si ";
cout<<a.min;
cout<<" minute ";
cout<<a.sec;
cout<<" secunde"<<endl;}
//******************************************************************************
void Time::colo(){
cout<<"ora ";
cout<<a.ore;
cout<<" si ";
cout<<a.min;
cout<<" minute ";
cout<<a.sec;
cout<<" secunde"<<endl;}
//******************************************************************************
void Time::sabl2(){
int k=0;
clrscr();
cout<<"Sablonul 2"<<endl;
for (i = 0; i < 12; i++) {
if (am[i]==a.ore){
a.col(); k++;}}
if (k==0) colo();
cout<<"Tastati tasta Enter pentru a alege alt sablon:"<<endl;
getch();
a.afisare();
}
//******************************************************************************
void Time::modifivare(){
char com;
sus:clrscr();
cout<<"Modificati: "<<endl;
cout<<"1 - Ora"<<endl;
cout<<"2 - Minute"<<endl;
cout<<"3 - Secunde"<<endl;
cout<<"0 - Inapoi"<<endl;
com=getch();
switch (com) {
case '1': {cout<<"Ora: ";
cin>>a.ore;
if ((a.ore>=0) && (a.ore<=23)){
cout<<endl<<"Succes !";
Sleep(800); }
else {cout<<"Eroare ati introdus ora gresita !";
Sleep(800);
goto sus;}
break;}
case '2': {cout<<"Minute: ";
cin>>a.min;
if ((a.min>=0) && (a.min<=59))
{cout<<endl<<"Succes !";
Sleep(800); }
else {cout<<"Eroare ati introdus minute gresite !";
Sleep(800);
goto sus;}
break;}
case '3': {cout<<"Secunde: ";
cin>>a.sec;
if ((a.sec>=0) && (a.sec<=59))
{cout<<endl<<"Succes !";
Sleep(800); }
else {cout<<"Eroare ati introdus secunde gresite !";
Sleep(800);
goto sus;}
break;}
case '0': {goto iesire; break;}
default: goto sus;
iesire:
}
//******************************************************************************
void main(void){
a.setare();
char com;
sus:clrscr();
cout<<"1 - Introdu ora/min/sec"<<endl;
cout<<"2 - Afisarea "<<endl;
cout<<"3 - Modificare"<<endl;
cout<<"Esc - Iesire"<<endl;
com=getch();
Beep(800,100);
switch (com) {
case '1': {a.setare(); break;}
case '2': {a.afisare(); break; }
case '3': {a.modifivare(); break;}
case 27:exit(1);
default: goto sus;
}
goto sus;
getch();
}
b)
#include<stdio.h>
#include<conio.h>
#include<iostream.h>
#include<math.h>
#include<stdlib.h>
class matrix{
private:
double **p;
int rind,col,cod_eror;
public:
matrix();
matrix(int); // matricie patratica
matrix(int,int); //matricie dreptunghiulara
~matrix();
//*******Inscrierea*************************************************************
void inscriere(int i, int j, int elem){
p[i][j]=elem;
}
//*******Afisarea**************************************************************
void afisare(){
for (int i = 0; i < rind; i++) {
cout<<" ";
for (int j = 0; j < col; j++)
cout<<p[i][j]<<" ";
cout<<endl;
} }
int valoare(int i, int j){

return p[i][j];
}
};
matrix :: matrix(){
p=NULL;
rind=col=0;
};
matrix :: matrix(int n){

rind=col=n;
p=new double*[rind];
p[i]=new double[rind];
for (int j = 0; j < rind; j++)
p[i][j]=0;
}}
matrix :: matrix(int r, int c){

rind=r; col=c;
p=new double *[rind];
p[i]= new double [col];
p[i][j]=0;
}
}
matrix ::~matrix(){
for (int i=0; i < rind; i++)
delete[] p[j];
delete [] p;
}
//******************************************************************************
void inmultirea_2matrici(){
int l1,c1,l2,c2,s;
sus:clrscr();
cout<<"Introdu dimensiunea matriciei I:"<<endl;
cout<<"Linii= "; cin>>l1;
cout<<"Coloane= "; cin>>c1;
cout<<"Introdu dinemsiunea matrici II:"<<endl;
if (c1!=l2) { // nu se poate de efectuat *
cout<<endl<<"Nu se poate efectua inmultirea
matricilor !"<<endl<<"Introdu alte dimesiuni";
Sleep(800);
Beep(600,900);
goto sus;
}
else {
matrix mat1(l1,c1);
matrix mat2(l2,c2);
cout<<"Introdu elementele I matrici: "<<endl;

for (int i = 0; i < l1; i++) {
for (int j = 0; j < c1; j++) {
cout<<"M1["<<i<<"]["<<j<<"]= ";
cin>>s;
mat1.inscriere(i,j,s);
}}
//mat1.afisare();
//*******************
cout<<"Introdu elementele II matrici: "<<endl;
for (int i = 0; i < l2; i++) {
for (int j = 0; j < c2; j++) {
cout<<"M2["<<i<<"]["<<j<<"]= ";
cin>>s;
}}
clrscr();
cout<<"Matricea I "<<endl; mat1.afisare();
cout<<endl<<endl<<"Matricea II"<<endl; mat2.afisare();
// se efectueaza *
matrix matf(l1,c2);
for (int i = 0; i < l1; i++)
for (int j = 0; j < c2; j++) {
for (int k = 0; k < l1; k++)
s+=mat1.valoare(i,k)*mat2.valoare(k,j);
matf.inscriere(i,j,s);
s=0;
}
cout<<endl<<"Iata matricea rezultanta "<<endl;
matf.afisare();
}
getch();
}
//******************************************************************************
void inmultirea_numar(){
int l,c,s,nr;
clrscr();
cout<<"Introdu dimensiunea matrici: "<<endl;
cout<<"Linii= "; cin>>l;
cout<<"Coloane= "; cin>>c;
matrix matr_nr(l,c);
for (int i = 0; i < l; i++)
for (int j = 0; j < c; j++) {
cout<<"M["<<i<<"]["<<j<<"]= ";
cin>>s;
matr_nr.inscriere(i,j,s);
}
cout<<endl<<"Matricia dreptunghiulara: "<<endl;
matr_nr.afisare();
cout<<"Inmulteste cu numarul: ";
cin>>nr;
matrix matr_rsp(l,c);
for (int i = 0; i < l; i++) {
for (int j = 0; j < c; j++) {
matr_rsp.inscriere(i,j,matr_nr.valoare(i,j)*nr);
}
}
cout<<endl<<"Raspuns:"<<endl;
matr_rsp.afisare();
getch(); }
//******************************************************************************
void adunarea_2matrici(){
int l1,c1,l2,c2,s;
sus:clrscr();
if ((l1!=l2)&&(c1!=c2)){ // nu se poate de efectuat *
cout<<endl<<"Nu se poate efectua adunarea
Sleep(800);
Beep(600,900);
goto sus;
}
else {
matrix mat1(l1,c1);
matrix mat2(l2,c2);
for (int i = 0; i < l1; i++) {
for (int j = 0; j < c1; j++) {
cout<<"M1["<<i<<"]["<<j<<"]= ";
cin>>s;
}}
//*******************
for (int i = 0; i < l2; i++) {
for (int j = 0; j < c2; j++) {
cout<<"M2["<<i<<"]["<<j<<"]= ";
cin>>s;
}}
clrscr();
// se efectueaza +
matrix matf(l1,c2);
for (int i = 0; i < l1; i++)
for (int j = 0; j < c1; j++) {
s=mat1.valoare(i,j)+mat2.valoare(i,j);
s=0;
}
matf.afisare();
}
getch();
}
//******************************************************************************
void scaderea_2matrici(){
int l1,c1,l2,c2,s;
sus:clrscr();
if ((l1!=l2)&&(c1!=c2)){ // nu se poate de efectuat *
cout<<endl<<"Nu se poate efectua inmultirea
Sleep(800);
Beep(600,900);
goto sus;
}
else {
matrix mat1(l1,c1);
matrix mat2(l2,c2);
for (int i = 0; i < l1; i++) {
for (int j = 0; j < c1; j++) {
cout<<"M1["<<i<<"]["<<j<<"]= ";
cin>>s;
}}
//*******************
for (int i = 0; i < l2; i++) {
for (int j = 0; j < c2; j++) {
cout<<"M2["<<i<<"]["<<j<<"]= ";
cin>>s;
}}
clrscr();
// se efectueaza -
matrix matf(l1,c2);
for (int i = 0; i < l1; i++)
for (int j = 0; j < c1; j++) {
s=mat1.valoare(i,j)-mat2.valoare(i,j);
s=0;
}
matf.afisare();
}
getch();
}
void main(void){
char com;
sus:clrscr();
cout<<"1 - Inmultirea a 2 matrici"<<endl;

cout<<"2 - Inmultirea unei matrice cu un numar"<<endl;
cout<<"3 - Adunarea a 2 matrici"<<endl;
cout<<"4 - Scaderea a 2 matrici"<<endl;
cout<<"Esc - Iesire"<<endl;
com=getch();
switch (com) {
case '1':{inmultirea_2matrici(); break;}
case '2':{inmultirea_numar(); break;}
case '3':{adunarea_2matrici(); break;}
case '4':{scaderea_2matrici(); break;}
case 27:{exit(1); break;}
}
goto sus;
getch();
}
Concluzie
În această lucrare de laborator nr.2 m-am folosit de cunoștințele
anterioare despre structura programului C++ astfel am utilizat noțiunele
noi ca constructor.Am pus în practică noțiunea de constructor
implicit,cu un parametru,doi și am format mai multe matrice.

Lab 2

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Lab 2

Încărcat de

Drepturi de autor:

Formate disponibile

Ministerul Educaţiei a Republicii Moldova

Universitatea Tehnică a Moldovei

A efectuat: Cojuhari Clara,gr.CR-191

A verificat: Lisnic Inga

void Init(char*, int, int);

void Book::Init(char* a, int y, int p){

author = new char[strlen(a)+1];

Destructorul – este o funcţie membru specială, care se apelează automat la distrugerea

Fie un exemplu analogic cu cel precedent, utilizînd constructorul şi destructorul:

Book(char*, int, int);

Book::Book(char* a, int y, int p){

author = new char[strlen(a)+1];

Book* ptr = new Book(“Lippman”,1996, 1200);

// crearea dinamică a obiectului

// în acest caz eliberarea memoriei se realizează de //către programator

// aici se apelează automat destructorul pentru b.

Există patru tipuri de constructori: implicit, de copiere, de conversie a tipului şi general.

 Constructorul implicit – constructor fără parametri, sau constructor cu toţi parametrii

Book(); // constructor implicit

Book(const Book&); // constructor de copiere

Book(const char*); // constructor de conversie a tipului

Book(char*, int, int); // constructor general

Book b(“Stroustrup”,1997,890); // general

Book b1 = b, b11(b); // de copiere

Book b2 = “Stroustrup”, b21(“Bjarne”);

Book b3; // implicit

Constructori generaţi de compilator. Interacţiunea lor cu constructorii definiţi de utilizator

Prezenţa constructorilor nu este obligatorie. Se pot defini clase şi fără constructori. În

Constructorul implicit generat nu realizează absolut nimic, iar constructorul de copiere

Book::Book(const Book& b){

author = new char[strlen(b.author)+1];

Constructorii trebuie să utilizeze mecanisme numite iniţializatori (lista de iniţializare).

Book::Book(const Book& b): year(b.year),pages(b.pages),

// apelul funcţiei strcpy a rămas în afara iniţializatorului.

În cazul utilizării tabloului de obiecte se defineşte în mod obligatoriu un constructor

1. Explicaţi termenul de iniţializare.

2. Ce cuvinte cheie se utilizează pentru definirea constructorului şi a

5. Enumeraţi tipurile de constructori?

10. Ce sunt listele de iniţializare (iniţializatori)?

12. struct IntComplex {

12.În care caz se defineşte obligatoriu constructorul implicit?

 referințele la obiecte se inițializează cu null

int valoare(int i, int j){

matrix :: matrix(int n){

matrix :: matrix(int r, int c){

cout<<"Introdu elementele I matrici: "<<endl;

cout<<"1 - Inmultirea a 2 matrici"<<endl;

S-ar putea să vă placă și