C++ POO Lab Lucrarea 3 - Revizia istoricului

Costin.vasile1003 la 24 martie 2026 13:23

2026-03-24T13:23:40Z

Afișare diferențe

Rhobincu: /* Metode const-qualified */

2022-04-12T20:08:36Z

Metode const-qualified

Rhobincu: /* Metode const-qualified */

2022-04-12T19:51:07Z

Metode const-qualified

Rhobincu: /* Referințe constante (const) */

2022-04-12T19:26:16Z

Referințe constante (const)

Rhobincu: /* Introducere */

2022-04-12T19:24:56Z

Introducere

Rhobincu: /* Introducere */

2022-04-12T19:15:59Z

Introducere

Rhobincu: /* Operatorul de copiere prin atribuire */

2022-04-12T13:45:29Z

Operatorul de copiere prin atribuire

Rhobincu: /* Introducere */

2022-04-12T13:22:56Z

Introducere

Rhobincu: /* Exemplu */

2022-04-12T13:20:25Z

Exemplu

Rhobincu: /* Constructorul de copiere */

2022-04-12T13:10:22Z

Constructorul de copiere

← Versiunea anterioară		Versiunea de la data 12 aprilie 2022 20:08
Linia 278:		Linia 278:

	= Metode ''const-qualified'' =		= Metode ''const-qualified'' =
		+
		+	În cazul în care un obiect este declarat <code>const</code>, sau se accesează printr-o referință constantă, acest obiect nu poate fi modificat. Modificarea unui obiect înseamnă modificarea valorilor câmpurilor sale. Astfel, pe lângă faptul că nu putem atribui valori noi câmpurilor în cazul în care avem acces la ele, nu putem nici apela metode care au ca efect modificarea obiectului. Iată un exemplu mai jos:
		+
		+	<syntaxhighlight lang="C++">
		+	class Animal {
		+	public:
		+	std::string mName;
		+	std::string mColor;
		+	int mAge;
		+	bool mHasFeathers;
		+
		+	public:
		+	void makeSound() {
		+	printf("Animal %s makes a sound!\n", mName.c_str());
		+	}
		+
		+	// this is a getter method
		+	std::string getName() {
		+	return mName;
		+	}
		+
		+	// this is a setter method
		+	void setAge(int age) {
		+	if(age > 0) {
		+	mAge = age;
		+	}
		+	}
		+	};
		+
		+	int main() {
		+	const Animal animal;
		+	animal.mName = "Cat"; // eroare de compilare - nu se poate modifica acest camp
		+	animal.makeSound(); // eroare de compilare - nu se poate apela aceasta metoda
		+	return 0;
		+	}
		+	</syntaxhighlight>
		+
		+	În exemplul de mai sus, este evident că nu putem modifica membrul <code>mName</code> al obiectului <code>animal</code> pentru că acesta este declarat <code>const</code>. Cu toate acestea, metoda <code>makeSound</code> nu modifică obiectul (nu modifică niciunul din câmpurile sale la apelare), dar nici aceasta nu poate fi apelată. Motivul este dat de faptul că programatorul trebuie să specifice explicit către compilator care sunt metodele care nu modifică obiectul, compilatorul nu face aceste verificări automat. O metodă care nu modifică obiectul pentru care se apelează se declară <code>const</code> și se numește ''const-qualified'':
		+
		+	<syntaxhighlight lang="C++">
		+	class Animal {
		+	public:
		+	std::string mName;
		+	std::string mColor;
		+	int mAge;
		+	bool mHasFeathers;
		+
		+	public:
		+	void makeSound() const {
		+	printf("Animal %s makes a sound!\n", mName.c_str());
		+	}
		+
		+	// this is a getter method
		+	std::string getName() const {
		+	return mName;
		+	}
		+
		+	// this is a setter method
		+	void setAge(int age) {
		+	if(age > 0) {
		+	mAge = age;
		+	}
		+	}
		+	};
		+
		+	int main() {
		+	const Animal animal;
		+	animal.mName = "Cat"; // eroare de compilare - nu se poate modifica acest camp
		+	animal.makeSound(); // aici nu se mai produce nicio eroare de compilare, metoda makeSound este const-qualified
		+	return 0;
		+	}
		+	</syntaxhighlight>
		+
		+	Deci, pentru obiecte constante sau folosind referințe constante, se pot apela doar metode const-qualified.

	= Supraîncărcarea operatorilor =		= Supraîncărcarea operatorilor =

@@ Linia 222: / Linia 222: @@
 <div class="sfat"><font color="darkgreen">Sfat:</font> Deoarece mecanismul folosit pentru referințe este de fapt tot bazat pe adrese de memorie (pointeri), evitarea copierii valorii are sens doar pentru valori mai mari decât dimensiunea unui pointer. Astfel, pentru valori primitive (int, float, long, double, uint64_t, char, etc.) nu este necesară transmiterea lor ca referință pentru evitarea copierii, ci doar dacă doriți modificarea variabilelor în funcție.</div>
 == Referințe constante (const) ==
@@ Linia 279: / Linia 276: @@
+}
 </syntaxhighlight>
 = Supraîncărcarea operatorilor =

← Versiunea anterioară		Versiunea de la data 12 aprilie 2022 19:26
Linia 222:		Linia 222:

	<div class="sfat"><font color="darkgreen">Sfat:</font> Deoarece mecanismul folosit pentru referințe este de fapt tot bazat pe adrese de memorie (pointeri), evitarea copierii valorii are sens doar pentru valori mai mari decât dimensiunea unui pointer. Astfel, pentru valori primitive (int, float, long, double, uint64_t, char, etc.) nu este necesară transmiterea lor ca referință pentru evitarea copierii, ci doar dacă doriți modificarea variabilelor în funcție.</div>		<div class="sfat"><font color="darkgreen">Sfat:</font> Deoarece mecanismul folosit pentru referințe este de fapt tot bazat pe adrese de memorie (pointeri), evitarea copierii valorii are sens doar pentru valori mai mari decât dimensiunea unui pointer. Astfel, pentru valori primitive (int, float, long, double, uint64_t, char, etc.) nu este necesară transmiterea lor ca referință pentru evitarea copierii, ci doar dacă doriți modificarea variabilelor în funcție.</div>
		+
		+	= Metode ''const-qualified'' =
		+

	== Referințe constante (const) ==		== Referințe constante (const) ==

@@ Linia 4: / Linia 4: @@
 * Destructorul
 * Referința
 * Supraîncărcarea operatorilor
 * Constructorul de copiere

@@ Linia 531: / Linia 531: @@
 </syntaxhighlight>
-Prin urmare, operatorul de copiere prin atribuire va lua ca argument o referință constantă la un alt obiect de același fel, care reprezintă sursa copierii de date. Acesta poate fi de tip <code>void</code>, dar că se se respecte specificația care spune că rezultatul operatorului de atribuire este valoarea atribuită, este recomandat ca întotdeauna această să întoarcă o referință la obiectul curent. Astfel, se pot realiza lanțuri de atribuiri.
+Prin urmare, operatorul de copiere prin atribuire va lua ca argument o referință constantă la un alt obiect de același fel, care reprezintă sursa copierii de date. Acesta poate fi de tip <code>void</code>, dar ca să se respecte specificația care spune că rezultatul operatorului de atribuire este valoarea atribuită, este recomandat ca întotdeauna această să întoarcă o referință la obiectul curent. Astfel, se pot realiza lanțuri de atribuiri.
 == Exemplu ==

← Versiunea anterioară		Versiunea de la data 12 aprilie 2022 13:45
Linia 520:		Linia 520:

	= Operatorul de copiere prin atribuire =		= Operatorul de copiere prin atribuire =
		+	== Introducere ==
		+	În situația numărul 3 de mai sus (atunci când se atribuie un obiect unui alt obiect, în altă parte decât la inițializare), această copiere se realizează de un operator special, numit operatorul de copiere prin atribuie (copy-assignment operator). Acesta, similar cu constructorul de copiere, există în mod implicit, și copiază conținutul obiectului la nivel de byte. Și exact în același fel, câteodată este necesar să putem modifica acest comportament.
		+
		+	Forma unui operator de copiere prin atribuire pentru o clasă oarecare <code>T</code> este:
		+	<syntaxhighlight lang="C++">
		+	T& operator=(const T & source) {
		+	//aici se realizeaza copierea
		+	return *this;
		+	}
		+	</syntaxhighlight>
		+
		+	Prin urmare, operatorul de copiere prin atribuire va lua ca argument o referință constantă la un alt obiect de același fel, care reprezintă sursa copierii de date. Acesta poate fi de tip <code>void</code>, dar că se se respecte specificația care spune că rezultatul operatorului de atribuire este valoarea atribuită, este recomandat ca întotdeauna această să întoarcă o referință la obiectul curent. Astfel, se pot realiza lanțuri de atribuiri.
		+
		+	== Exemplu ==
		+
		+	Continuând exemplul de mai sus, vom adăuga acum operatorul de copiere prin atribuire:
		+	<syntaxhighlight lang="C++">
		+	#include <cstdint>
		+	#include <cstring>
		+	#include <iostream>
		+
		+	// clasa Array modeleaza un array alocat dinamic
		+	class Array{
		+	public:
		+	int *arr;
		+	size_t dim;
		+
		+	// constructorul aloca memorie si stocheaza adresa primului element in *arr
		+	Array(int dimensiune){
		+	arr = (int) malloc(dimensiune sizeof(int));
		+	dim = dimensiune;
		+	std::cout << "Acest mesaj provine din constructor" << std::endl;
		+	}
		+
		+	Array(const Array & source) {
		+	arr = (int) malloc(source.dim sizeof(int));
		+	dim = source.dim;
		+	memcpy(arr, source.arr, dim * sizeof(int));
		+	std::cout << "Acest mesaj provine din constructorul de copiere" << std::endl;
		+	}
		+
		+	Array & operator=(const Array & source) {
		+	free(arr); // obiectul curent aici exista deja, deci trebuie sa stergem memoria alocata in constructor inainte de a aloca altceva
		+	arr = (int) malloc(source.dim sizeof(int));
		+	dim = source.dim;
		+	memcpy(arr, source.arr, dim * sizeof(int));
		+	std::cout << "Acest mesaj provine din operatorul de copiere prin atribuire" << std::endl;
		+	return *this;
		+	}
		+
		+	// destructorul se asigura ca memoria alocata este eliberata atunci cand obiectul este distrus
		+	~Array(){
		+	free(arr);
		+	std::cout << "Acest mesaj provine din destructor" << std::endl;
		+	}
		+	};
		+
		+	int main() {
		+	Array array(4);
		+	Array other(5);
		+	other = array;
		+	return 0;
		+	}
		+	</syntaxhighlight>
		+
		+	Ieșire:
		+	<syntaxhighlight lang="text">
		+	Acest mesaj provine din constructor
		+	Acest mesaj provine din constructor
		+	Acest mesaj provine din operatorul de copiere prin atribuire
		+	Acest mesaj provine din destructor
		+	Acest mesaj provine din destructor
		+	</syntaxhighlight>
		+
		+	<div class="regula"><font color="#ff0000">The Rule of Three:</font> O regulă cunoscută în limbajul C++ este următoarea: dacă aveți de nevoie să implementați explicit constructorul de copiere SAU operatorul de copiere prin atribuire SAU destructorul, atunci trebuie să le implementați pe toate trei!.</div>

@@ Linia 442: / Linia 442: @@
 # Atunci când se inițializează un obiect (i se atribuie o valoare la declarație);
 # Atunci când se transmite un obiect către o funcție cu argumente de tip ''pass-by-value'', deci nu ca referință.
-Această copiere se realizează de un constructor special, numit '''constructor de copiere'''. Acest constructor există implicit în toate clasele fiind adăugat de compilator. Copierea implicită pe care o face acesta este prin a duplica tot conținutul obiectului sursă, așa cum este acesta salvat în memorie. În multe situații, acest comportament este cel corect. Totuși, există și situații când acest comportament implicit trebuie modificat. Prin urmare trebuie definit explicit acest constructor de copiere în cadrul clasei.
+În primele două situații, această copiere se realizează de un constructor special, numit '''constructor de copiere'''. Acest constructor există implicit în toate clasele fiind adăugat de compilator. Copierea implicită pe care o face acesta este prin a duplica tot conținutul obiectului sursă, așa cum este acesta salvat în memorie. În multe situații, acest comportament este cel corect. Totuși, există și situații când acest comportament implicit trebuie modificat. Prin urmare trebuie definit explicit acest constructor de copiere în cadrul clasei.
 Forma unui constructor de copiere pentru o clasă oarecare <code>T</code> este:

@@ Linia 456: / Linia 456: @@
 == Exemplu ==
-Reluând exemplul de la capitolul {{Section link|C++ POO Lab Lucrarea 3|Destructorul}}, vom adăuga acum constructorul de copiere, pentru a evita crearea mai multor obiecte care să aibă pointer intern la aceeași zonă de memorie:
+Reluând exemplul de la capitolul [[#Destructorul]], vom adăuga acum constructorul de copiere, pentru a evita crearea mai multor obiecte care să aibă pointer intern la aceeași zonă de memorie:
 = Operatorul de copiere prin atribuire =

← Versiunea anterioară		Versiunea de la data 12 aprilie 2022 13:10
Linia 437:		Linia 437:

	= Constructorul de copiere =		= Constructorul de copiere =
		+
		+	== Introducere ==
		+	Obiectele se copiază în două situații:
		+	# Atunci când se inițializează un obiect (i se atribuie o valoare la declarație);
		+	# Atunci când se transmite un obiect către o funcție cu argumente de tip ''pass-by-value'', deci nu ca referință.
		+
		+	Această copiere se realizează de un constructor special, numit '''constructor de copiere'''. Acest constructor există implicit în toate clasele fiind adăugat de compilator. Copierea implicită pe care o face acesta este prin a duplica tot conținutul obiectului sursă, așa cum este acesta salvat în memorie. În multe situații, acest comportament este cel corect. Totuși, există și situații când acest comportament implicit trebuie modificat. Prin urmare trebuie definit explicit acest constructor de copiere în cadrul clasei.
		+
		+	Forma unui constructor de copiere pentru o clasă oarecare <code>T</code> este:
		+	<syntaxhighlight lang="C++">
		+	T(const T & source);
		+	</syntaxhighlight>
		+
		+	Prin urmare, constructorul de copiere ca lua ca argument o referință constantă la un alt obiect de același fel, care reprezintă sursa copierii de date.
		+
		+	<div class="regula"><font color="#ff0000">Atenție:</font> Argumentul constructorului de copiere trebuie obligatoriu să fie de tip referință, pentru că în caz contrar, acesta trebuie copiat la apelul constructorului, copiere care se realizează folosind chiar constructorul de copiere, și deci rezultă un apel recursiv infinit. În acest caz veți primi o eroare de compilare.</div>
		+
		+	== Exemplu ==
		+
		+	Reluând exemplul de la capitolul {{Section link\|C++ POO Lab Lucrarea 3\|Destructorul}}, vom adăuga acum constructorul de copiere, pentru a evita crearea mai multor obiecte care să aibă pointer intern la aceeași zonă de memorie:
		+
	= Operatorul de copiere prin atribuire =		= Operatorul de copiere prin atribuire =