Discussion :

[gregoire.stein]

Bonjour, bonsoir, j'ai fait quelques recherches sur les différences entre un constructeur de copie et l'opérateur d'affectation (entre 2 objets d'une même classe)

seulement, j'ai l'impression que ça fait exactement la même chose. Y'a-t-il une différence ? Si oui, où se trouve-t-elle ?

Merci

[Médinoc]

L'opérateur d'affectation modifie un objet déja existant, et doit donc gérer la libération de ressources en plus de la copie.

Un moyen exception-safe de faire ça est l'idiome copy-and-swap, qui utilise simplement le constructeur de copie et le destructeur existants.

Imaginons une classe contenant simplement un pointeur nu vers un int (un truc qu'on n'aura pratiquement jamais en vie rélle, mais un bon cas d'école).
Son constructeur de copie et son destructeur seront ainsi:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
UneClasse(UneClasse const & src)
{
	pInt = new int;
	*pInt = *(src.pInt);
}
 
~UneClasse()
{
	delete pInt;
}

Et avec l'idiome copy-and-swap, l'opérateur d'affectation sera ainsi:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
UneClasse& operator=(UneClasse copieDeSrc) //Passage par copie
{
	Swap(copieDeSrc);
	return *this;
}
 
void Swap(UneClasse & autre)
{
	int* tmp = src.pInt;
	src.pInt = pInt;
	pInt = tmp;
}

Avec ce code, si le constructeur de copie cause une exception (par exemple, plus de mémoire), l'objet ne sera pas affecté.

[Neckara]

Bonjour,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
MaClasse a, b;
MaClasse c(a); // constructeur par copie
MaClasse b = a; // opérateur de copie

La principale différence est que le constructeur par copie initialise ton instance et que l'opérateur de copie va souvent libérer certaines des anciennes ressources de ta classe, puis copier l'autre classe grosso-modo on va devoir retrouver certains éléments du destructeur dans l'opérateur de copie.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
MaClasse & operator=(const MaClasse & o)
{
    disconnect();
    for(auto & element : m_vector)
           element.close(); // inutile si le principe RAII est respecté.
    m_vector = o.m_vector;
}

Mais il est vrai qu'avec les pointeurs intelligents et le RAII, c'est dur de trouver un exemple parlant.

[gregoire.stein]

Merci pour vos réponses, je pense avoir compris

La copie, c'est bêtement copier collé les variables (sauf s’il s'agit de pointeurs)

L'affectation, c'est de faire des calculs (comme le disconnect) et ensuite de copier ?

Je crois que j'ai encore du mal, je ne comprends pas l'intérêt

[Ehonn]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
MaClasse c(a); // constructeur par copie
MaClasse b = a; // opérateur de copie

MaClasse b = a; // opérateur de copie est faux. Ici c'est le constructeur par copie qui est appelé. Il s'agit juste d'une notation différente.
Si on veut appeler l'opérateur d'affectation, on aurait écrit : MaClasse b; b = a; // Constructeur par défaut + opérateur d'affectation.

Voici un code pour illustrer ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++98 -pedantic -fopenmp main.cpp -o main && ./main
 
#include <iostream>
 
 
class A
{
public:
 
	A() { std::cout << "Constructeur par défaut" << std::endl; }
 
	A(A const & /*a*/) { std::cout << "Constructeur par copie" << std::endl; }
 
	A & operator =(A const & /*a*/) { std::cout << "Opérateur =" << std::endl; return *this; }
};
 
 
int main()
{
	// Constructeur
	A a;     // par défaut
	A b(a);  // par copie
	A c = b; // par copie
 
	// Operateur =
	a = c;
 
	return 0;
}

[Neckara]

MaClasse b = a; // opérateur de copie est faux. Ici c'est le constructeur par copie qui est appelé. Il s'agit juste d'une notation différente.

C'est encore faux, ici, c'est le compilateur qui râle parce que j'ai :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
MaClasse a, b;
MaClasse c(a); // constructeur par copie
MaClasse b = a; // opérateur de copie

Les joies du copié-collé, j'ai mis un "MaClasse" de trop .

[Ehonn]

C'est pas pour rien que j'ai extrait la ligne
Et rien n'indique que les lignes sont "liées" entre elles.

[Neckara]

C'est pas pour rien que j'ai extrait la ligne

C'est pas gentil, maintenant on va croire que je confond opérateur de copie et constructeur par copie .