D'après la définition de la fonction push_back, cette dernière fait une copie de l'objet et l'ajoute au conteneur:

The content of this new element is initialized to a copy of x.
Donc, j'ai fait un petit exemple illustrant le problème:

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#include <iostream>
#include <vector>
 
using namespace std;
 
class Foo
{
public:
	Foo()
	{
		cout << "Constructeur Foo()" << endl;
	}
 
	Foo(const Foo& foo)
	{
		cout << "Constructeur par copie Foo(Foo& foo)" << endl;
		*this = foo;
	}
 
	Foo& operator=(const Foo& foo)
	{
		cout << "Operateur de copie operator=(const Foo& foo)" << endl;
		return *this;
	}
};
 
void addFoo();
void displayListFoo();
 
vector<Foo> listFoo;
 
int main( )
{
	addFoo();
	displayListFoo();
	addFoo();
	displayListFoo();
	addFoo();
	displayListFoo();
 
	return 0;
}
 
void addFoo()
{
	Foo foo;
	cout << "&foo: " << &foo << endl;
	listFoo.push_back(foo);
	Foo& rFoo = listFoo.back();
	cout << "&rFoo: " << &rFoo << endl;
	cout << endl;
}
 
void displayListFoo()
{
	for (vector<Foo>::const_iterator itr = listFoo.begin(); itr != listFoo.end(); ++itr)
	{
		cout << "&*itr: " << &*itr << endl;
	}
	cout << endl;
}
Et voici le résultat:

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
31
32
Constructeur Foo()
&foo: 0012FE8F
Constructeur par copie Foo(Foo& foo)
Operateur de copie operator=(const Foo& foo)
&rFoo: 003459B8
 
&*itr: 003459B8
 
Constructeur Foo()
&foo: 0012FE8F
Constructeur par copie Foo(Foo& foo)
Operateur de copie operator=(const Foo& foo)
Constructeur par copie Foo(Foo& foo)
Operateur de copie operator=(const Foo& foo)
&rFoo: 003459E9
 
&*itr: 003459E8
&*itr: 003459E9
 
Constructeur Foo()
&foo: 0012FE8F
Constructeur par copie Foo(Foo& foo)
Operateur de copie operator=(const Foo& foo)
Constructeur par copie Foo(Foo& foo)
Operateur de copie operator=(const Foo& foo)
Constructeur par copie Foo(Foo& foo)
Operateur de copie operator=(const Foo& foo)
&rFoo: 003459BA
 
&*itr: 003459B8
&*itr: 003459B9
&*itr: 003459BA
Normal que foo et rFoo n'aient pas la même adresse mémoire vu que la fonction effectue une copie.

Par contre, je ne comprends pas pourquoi à chaque fois que j'ajoute un nouvel élément à mon conteneur, alors tous les précédents sont égalément reconstruits.

Quelqu'un pourrait m'expliquer? Car ce problème que j'ai réussi à isoler fait planter mon application et je ne comprends pas pourquoi.

Concrètement, après avoir ajouter un élément dans mon vecteur, je garde une trace à l'aide d'un pointeur de l'élément ajouté (rFoo), mais vu que dans mon vecteur les éléments ont changé, alors je perds la concordance

Autre problème:

Si les objets sont lourds et que j'ajoute pas mal d'éléments dans mon conteneur, alors ça va faire autant de copies qu'il y a d'éléments, donc chaque ajout va devenir de plus en plus gourmand !!!

Par exemple, si j'ai 1000 éléments, alors j'aurais 1 + 2 + 3 + ... + 1000 copies !!!