Documente Academic
Documente Profesional
Documente Cultură
Raport
LA DISCIPLINA „PROGRAMAREA ORIENTATĂ PE OBIECTE”
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 Destroy();
};
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.
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.
class Book{
char *author;
int year;
int pages;
public:
~Book();
};
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
delete ptr;
Tipurile constructorilor
class Book{
char *author;
int year;
int pages;
public:
...
};
...
void main(){
// de schimbare a tipului
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:
strcpy(author, b.author);
year = b.year;
pages = b.pages;
author(new char[strlen(b.author)+1])
strcpy(author, b.author);
1. struct IntComplex {
2. IntComplex () : re ( 0 ), im ( 0 ) {}
3.
4. int re ;
5. int im ;
6. };
7.
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();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 2);
cout<<"Tastati tasta Enter pentru a alege alt sablon:"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
getch();
a.afisare();
}
//******************************************************************************
void Time::col(){
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
cout<<"ora ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 14);
cout<<am[i];
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
cout<<" si ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 14);
cout<<a.min;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
cout<<" minute ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 14);
cout<<a.sec;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
cout<<" secunde"<<endl;}
//******************************************************************************
void Time::colo(){
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
cout<<"ora ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 14);
cout<<a.ore;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
cout<<" si ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 14);
cout<<a.min;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
cout<<" minute ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 14);
cout<<a.sec;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
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();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 2);
cout<<"Tastati tasta Enter pentru a alege alt sablon:"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
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();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
cout<<"1 - Introdu ora/min/sec"<<endl;
cout<<"2 - Afisarea "<<endl;
cout<<"3 - Modificare"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 14);
cout<<"Esc - Iesire"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
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;
} }
matrix :: matrix(){
p=NULL;
rind=col=0;
};
matrix ::~matrix(){
for (int i=0; i < rind; i++)
for (int j = 0; j < col; j++)
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;
// 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();
cout<<"Introdu dimensiunea matriciei I:"<<endl;
cout<<"Linii= "; cin>>l1;
cout<<"Coloane= "; cin>>c1;
cout<<"Introdu dinemsiunea matrici II:"<<endl;
cout<<"Linii= "; cin>>l2;
cout<<"Coloane= "; cin>>c2;
if ((l1!=l2)&&(c1!=c2)){ // nu se poate de efectuat *
cout<<endl<<"Nu se poate efectua adunarea 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);
}}
//*******************
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;
mat2.inscriere(i,j,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 < c1; j++) {
s=mat1.valoare(i,j)+mat2.valoare(i,j);
matf.inscriere(i,j,s);
s=0;
}
cout<<endl<<"Iata matricea rezultanta "<<endl;
matf.afisare();
}
getch();
}
//******************************************************************************
void scaderea_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;
cout<<"Linii= "; cin>>l2;
cout<<"Coloane= "; cin>>c2;
if ((l1!=l2)&&(c1!=c2)){ // 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);
}}
//*******************
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;
mat2.inscriere(i,j,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 < c1; j++) {
s=mat1.valoare(i,j)-mat2.valoare(i,j);
matf.inscriere(i,j,s);
s=0;
}
cout<<endl<<"Iata matricea rezultanta "<<endl;
matf.afisare();
}
getch();
}
void main(void){
char com;
sus:clrscr();
getch();
}
Concluzie
În această lucrare de laborator nr.2 „Constructorul – funcţie de iniţializare a
obiectelor clasei„ m-am folosit de cunoștințele anterioare despre structura
programului C++ astfel ,eventual 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.