Vecteur Template - Stocker des objets d'une classe dedans

Vecteur Template - Stocker des objets d'une classe dedans - Problème

Bonjour,

Pour donner + d'infos sur l'application que je dois réaliser, je vais parler de ce que je dois faire avec mon Template.

En gros, je dois créer une Classe VECTEUR template, qui permettra dans un premier temps (pour test) de stocker des ENTIERS (int) dans mon vecteur, ensuite de stocker des OBJETS d'une de mes autres classe.

Mon problème : Avec des entiers, ça fonctionne nickel lorsque mes méthodes d'insertion et d'affichage n'utilisent pas les références.
Mais vu que je dois insérer des objets d'une autre classe, je dois utiliser les références (je pense) dans ces mêmes fonctions d'insertion et d'affichage de ma classe template. A partir du moment où jutilise les références, ça foire !
-> lorsque j'utilise des entiers, j'obtiens une valeur (dans mon vecteur) qui n'est pas mon entier. (un truc du style "1864490").
-> lorsque j'introduis des objets de mon autre classe, les valeurs stockées dans le vecteur ne correspondent pas, c'est également n'importe quoi ...

Je vais fournir les parties de codes nécéssaire.

Il faut savoir que les objets de la classe que j'insère dans le vecteur, proviennent d'une classe héritée d'une super-classe :

Mes fichiers :

CPieceMusee.h :

Code:

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
62
63
64
65
#ifndef __CPIECEMUSEE_H__
#define __CPIECEMUSEE_H__
 
#include <iostream.h>
//#include <sstream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include "CIdentifiant.h"
 
//class CIdentifiant;
 
class CPieceMusee
{
 
	//private: 
	protected:
		CIdentifiant *p_id;
		//char p_id[7];
		char p_cat[12];
		char p_desc[30];
		char p_dateentree[10];
		int p_prix;
		int p_expose;
		int p_pret;
 
	public:
 
		CPieceMusee(void);
		CPieceMusee(CPieceMusee &p);
		CPieceMusee(CIdentifiant* id, char cat[], char desc[], char dateentree[], int prix, int expose, int pret);
		CPieceMusee(CIdentifiant* id); //constructeur d'initialisation de l'id (pour l'appeller dans CPieceMuseeArt)
		~CPieceMusee(void);
 
		//inline char* getId() { return p_id; }
		CIdentifiant* getId() { return p_id; }
		inline char* getCat() { return p_cat; }
		inline char* getDesc() { return p_desc; }
		inline char* getDateentree() { return p_dateentree; }
		inline int getPrix() { return p_prix; }
		inline int getExpose() { return p_expose; }
		inline int getPret() { return p_pret; }
 
		//inline void setId(char *id) { strcpy(p_id, id); }
		void setId(CIdentifiant *id) { p_id = id; }
		inline void setCat(char *cat) { strcpy(p_cat, cat); }
		inline void setDesc(char *desc) { strcpy(p_desc, desc); }
		inline void setDateentree(char *date) { strcpy(p_dateentree, date); }
		inline void setPrix(int prix) { p_prix=prix; }
		inline void setExpose(int expose) { p_expose=expose; }
		inline void setPret(int pret) { p_pret=pret; }
 
		virtual void affichePiece();
		virtual void encodePiece();	
 
		void operator + (int valeur);
		void operator - (int valeur);
 
		friend ostream& operator << (ostream& s, CPieceMusee& p);
		friend istream& operator >> (istream& s, CPieceMusee& p);
 
};
 
#endif

CPieceMusee.cpp :

Code:

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
#include "CPieceMusee.h"
#include "CInvalidVE.h"
 
CPieceMusee::CPieceMusee()
{
	p_id = new CIdentifiant();
	memset(p_cat,0,sizeof(p_cat));
	memset(p_desc,0,sizeof(p_desc));
	memset(p_dateentree,0,sizeof(p_dateentree));
	p_prix = 0;
	p_expose = 0;
	p_pret = 0;
}
 
 
CPieceMusee::CPieceMusee(CIdentifiant* id, char cat[], char desc[], char dateentree[], int prix, int expose, int pret)
{
	id = new CIdentifiant();
	memcpy(p_cat,cat,sizeof(p_cat));
	memcpy(p_desc,desc,sizeof(p_desc));
	memcpy(p_dateentree,dateentree,sizeof(p_dateentree));
	p_prix = prix;
	p_expose = expose;
	p_pret = pret;
}
 
CPieceMusee::CPieceMusee(CIdentifiant* id)
{
	id = new CIdentifiant();
	memset(p_cat,0,sizeof(p_cat));
	memset(p_desc,0,sizeof(p_desc));
	memset(p_dateentree,0,sizeof(p_dateentree));
	p_prix = 0;
	p_expose = 0;
	p_pret = 0;
}
 
CPieceMusee::CPieceMusee(CPieceMusee &p)
{
	setId(p.p_id);
	memcpy(p_cat,p.p_cat,sizeof(p_cat));
	memcpy(p_desc,p.p_desc,sizeof(p_desc));
	memcpy(p_dateentree,p.p_dateentree,sizeof(p_dateentree));
	p_prix = p.p_prix;
	p_expose = p.p_expose;
	p_pret = p.p_pret;
}
 
CPieceMusee::~CPieceMusee()
{
	delete p_id;
}
 
void CPieceMusee::affichePiece()
{
	cout<<endl<<endl<<"- Identifiant: "<<p_id->getIdentifiant();
	cout<<endl<<"- Catégorie: "<<getCat();
	cout<<endl<<"- Description: "<<getDesc();
	cout<<endl<<"- Date d'entrée: "<<getDateentree();
	cout<<endl<<"- Prix: EUR "<<getPrix();
	cout<<endl<<"- Exposé: "<<getExpose();
	cout<<endl<<"- Preté: "<<getPret();
	cout<<endl;
}
 
void CPieceMusee::encodePiece()
{
 
	int valeur;
	char valchar[30];
 
	//cout<<"- Identifiant de la piece ? ";
	p_id->encodeId();
	fflush(stdin);
 
	cout<<endl<<"- Catégorie ? ";
	fflush(stdin);
	cin.ignore(1,'\n');
	cin.getline(valchar,30);
	setCat(valchar);
 
	cout<<endl<<"- Description ? (max 30 caract.) ";	
	fflush(stdin);
	cin.ignore(0,'\n');
	cin.getline(valchar,30);
	//cin>>valchar;
	setDesc(valchar);
 
	cout<<endl<<"- Année d'entrée ? (2001) ";
	fflush(stdin);
	cin.ignore(0,'\n');
	cin.getline(valchar,5);
	setDateentree(valchar);
	while(1)
	{
		try
		{	
			cout<<endl<<"- Prix ? (EUR) ";
			fflush(stdin);
			cin.ignore(1,'\n');
			cin>>valeur;
 
			if(valeur < 0)
				throw CInvalidValueException();
			else
			{
				setPrix(valeur);
				break;
			}
		}
		catch(CInvalidValueException exception)
		{
			exception.afficheException();
		}
	}
 
	cout<<endl<<"- Exposé ? ";
	do
	{
		cout<<"(1 = Oui ; 0 = Non) ? ";
		cin>>valeur;
	}
	while(valeur!=1 && valeur!=0);
 
	if(valeur==1)
	{
		setExpose(1);
		cout<<endl<<"[*] La pièce est en exposition, impossible d'être en status PRET."<<endl;
		setPret(0);
	}
 
	if(valeur==0)
	{
		setExpose(0);
		valeur=getPrix();
		if(valeur >= 50000)
		{
			cout<<endl<<"[*] La valeur de la pièce est trop importante pour être pretée."<<endl;
			setPret(0);
		}
		else
		{
			cout<<endl<<"- Pretée ou pas ? ";
			do
			{
				cout<<"(1 = Oui ; 0 = Non) ? ";
				cin>>valeur;
			}
			while(valeur!=1 && valeur!=0);
			setPret(valeur);
		}
 
	}
 
	cout<<endl<<endl<<"Données envoyées."<<endl;
}
 
void CPieceMusee::operator + (int valeur)
{
	int prix = getPrix();
	int nouveauprix = prix + valeur;
 
	setPrix(nouveauprix);
 
	if(nouveauprix >= 50000)
	{
		cout<<endl<<"[*] La valeur de la pièce est trop importante pour être pretée."<<endl;
		setPret(0);
	}
}
 
void CPieceMusee::operator - (int valeur)
{
	int prix = getPrix();
	int nouveauprix = prix - valeur;
 
	setPrix(nouveauprix);
 
	if(nouveauprix >= 50000)
	{
		cout<<endl<<"[*] La valeur de la pièce est trop importante pour être pretée."<<endl;
		setPret(0);
	}
}
 
ostream& operator << (ostream& s, CPieceMusee& p)
{
	p.affichePiece();
 
	return s;
}
 
istream& operator >> (istream& s, CPieceMusee& p)
{
	p.encodePiece();
 
	return s;
}

CPieceMuseeArt.h :

Code:

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
#ifndef __CPIECEMUSEEART_H__
#define __CPIECEMUSEEART_H__
 
#include <iostream.h>
//#include <sstream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include "CPieceMusee.h"
//#include "CIdentifiant.h"
 
class CPieceMuseeArt:public CPieceMusee
{
	private:
		char p_epoque[20];
		char p_auteur[30];
		int p_largeur;
		int p_hauteur;
	public:
		//CPieceMuseeArt(void) : CPieceMusee() {};
		CPieceMuseeArt(void);
		//CPieceMuseeArt(char epoque[], char auteur[], int largeur, int hauteur) : CPieceMusee() {};
		CPieceMuseeArt(CIdentifiant *id, char epoque[], char auteur[], int largeur, int hauteur);
		CPieceMuseeArt(CPieceMuseeArt &pa);
		~CPieceMuseeArt() {};
 
		inline char* getEpoque() { return p_epoque; }
		inline char* getAuteur() { return p_auteur; }
		inline int getLargeur() { return p_largeur; }
		inline int getHauteur() { return p_hauteur; }
 
		inline void setEpoque(char* epoque) { strcpy(p_epoque,epoque); }
		inline void setAuteur(char* auteur) { strcpy(p_auteur,auteur); }
		inline void setLargeur(int largeur) { p_largeur = largeur; }
		inline void setHauteur(int hauteur) { p_hauteur = hauteur; }
 
		void affichePiece();
		void encodePiece();
};
 
#endif

CPieceMuseeArt.cpp :

Code:

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
62
63
64
65
66
67
68
69
70
71
72
#include "CPieceMuseeArt.h"
 
CPieceMuseeArt::CPieceMuseeArt(CIdentifiant *id, char epoque[], char auteur[], int largeur, int hauteur):CPieceMusee(id)
{
	memcpy(p_epoque,epoque,sizeof(p_epoque));
	memcpy(p_auteur,auteur,sizeof(p_auteur));
	p_largeur = largeur;
	p_hauteur = hauteur;
}
 
CPieceMuseeArt::CPieceMuseeArt():CPieceMusee()
{
	memset(p_epoque,0,sizeof(p_epoque));
	memset(p_auteur,0,sizeof(p_auteur));
	p_largeur = 0;
	p_hauteur = 0;
}
 
CPieceMuseeArt::CPieceMuseeArt(CPieceMuseeArt &pa):CPieceMusee(pa)
{
	memcpy(p_epoque,pa.p_epoque,sizeof(p_epoque));
	memcpy(p_auteur,pa.p_auteur,sizeof(p_auteur));
	p_largeur = pa.p_largeur;
	p_hauteur = pa.p_hauteur;
}
 
void CPieceMuseeArt::affichePiece()
{
	CPieceMusee::affichePiece();
	cout<<endl<<"- Epoque: "<<getEpoque();
	cout<<endl<<"- Auteur: "<<getAuteur();
	cout<<endl<<"- Largeur: "<<getLargeur();
	cout<<endl<<"- Hauteur: "<<getHauteur();
	cout<<endl;
}
 
void CPieceMuseeArt::encodePiece()
{
	int valeur;
	char valchar[30];
 
	CPieceMusee::encodePiece();
 
	cout<<endl<<"- Pièce d'Art de Musée : Spécifications : "<<endl;
 
	cout<<endl<<"- Epoque ? (max 20 caract.) ";
	fflush(stdin);
	cin.ignore(1,'\n');
	cin.getline(valchar,20);
	setEpoque(valchar);
 
	cout<<endl<<"- Auteur ? (max 30 caract.) ";	
	fflush(stdin);
	cin.ignore(0,'\n');
	cin.getline(valchar,30);
	//cin>>valchar;
	setAuteur(valchar);
 
	cout<<endl<<"- Largeur ? ";
	fflush(stdin);
	cin.ignore(0,'\n');
	cin>>valeur;
	setLargeur(valeur);
 
	cout<<endl<<"- Hauteur ? ";
	fflush(stdin);
	cin.ignore(1,'\n');
	cin>>valeur;
	setHauteur(valeur);
 
	cout<<endl<<endl<<"Données envoyées."<<endl;
}

Mon Vecteur Template :
CVecteurTemplate.h :

Code:

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#ifndef __CVECTEUR_H__
#define __CVECTEUR_H__
 
#include <iostream.h>
//#include <sstream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
 
template <class XTYPE>
struct noeud
{
	XTYPE valeur;
	//int position; 
	noeud<XTYPE> *pSuiv;
	noeud(XTYPE n, noeud<XTYPE> *s):valeur(n),pSuiv(s) {valeur=n;};
};
 
 
template <class XTYPE> class CVecteurIter;
 
template <class XTYPE> 
class CVecteur
{
	private:
		noeud<XTYPE> *v_pVec;
 
	public:
		CVecteur():v_pVec(0) {};
		~CVecteur(void)
		{
 
			noeud<XTYPE> *pCur, *pPrec;
			pCur = v_pVec;
			while(pCur != NULL)
			{
				pPrec = pCur;
				pCur = pCur->pSuiv;
				delete pPrec;
			}
		};
 
		char empty(void) { return v_pVec ? 0:1; }
		XTYPE head(void) { return v_pVec->valeur; }
 
		void insert(XTYPE &n)
		{
			v_pVec = new noeud<XTYPE> (n,v_pVec);
		};
 
		void display(void)
		{			
			CVecteurIter<XTYPE> it(*this);
 
			cout<<"(";
			while(!it.end())
			{
				XTYPE t( (XTYPE)it );
				cout<<t<<", ";
				it++;
			}
 
			cout<<"\x8\x8)"<<endl;
		};
 
		void removeAll(void)
		{
			noeud<XTYPE> *pCur, *pPrec;
			pCur = v_pVec;
 
			while(pCur != NULL)
			{
				pPrec = pCur;
				pCur = pCur->pSuiv;
				delete pPrec;
			}
 
			v_pVec = pCur;
		}
 
		friend class CVecteurIter<XTYPE>;
 
};
 
template<class XTYPE>
class CVecteurIter
{
	private:
		CVecteur<XTYPE>& v_vec;
		noeud<XTYPE> *v_pCur;
 
	public:
		CVecteurIter(CVecteur<XTYPE>& v):v_vec(v),v_pCur(v.v_pVec) {};
		int end() { return v_pCur == 0; }
		void reset () { v_pCur = v_vec.v_pVec; }
 
		char operator ++ ()
		{
			if(v_pCur)
			{
				v_pCur = v_pCur->pSuiv;
				return 1;
			}
			else 
				return 0;
		}
 
		char operator ++ (int) { return operator ++ (); }
		operator XTYPE() const { return v_pCur->valeur; }
		XTYPE& operator& (void) { return v_pCur->valeur; }
 
};
 
 
#endif

CVecteurTemplate.cpp

Code:

1
2
3
4
5
 
#include "CVecteurTemplate.h"
#include "CPieceMuseeArt.h"
 
template class CVecteur<CPieceMuseeArt>;

Et ensuite, une partie de mon fichier MAIN :

main.cpp :

Code:

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
 
 
#include <iostream.h>
//#include <sstream>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
 
#include "CPieceMusee.h"
#include "CPieceMuseeArt.h"
#include "CIdentifiant.h"
#include "CVecteurTemplate.h"
 
 
void main()
{
	int valeur,position;
 
	CPieceMusee piece;
	CPieceMuseeArt pieceArt;
	CIdentifiant identifiant;
 
	// Création de la liste d'entiers
	/////////////////////////////////
	CVecteur<int> listint;
 
	// Création de la liste des PieceMuseeArt
	//////////////////////////////////////////
	CVecteur<CPieceMuseeArt> listePiece;
 
 
 
			cout<<"[ Création d'une Pièce d'Art de Musée ]"<<endl<<endl;
			//pieceArt.encodePiece();
			cin>>pieceArt;
 
			listePiece.insert(pieceArt);
 
//insertion d'un entier = 1 dans le vecteur d'entier, pour tester..
			position=1;
			listint.insert(position);
			cout<<endl<<"---> OCCUPATION : ";
			listint.display();
 
			getchar();
 
			cout<<"[ Récapitulatif de la Pièce d'Art ]"<<endl;
			pieceArt.affichePiece();
 
//Affichage de mon vecteur template contenant les PieceMuseeArt :
			listePiece.display();
 
			getchar();
			cout<<endl;
 
 
}

*Je dois ajouter que CIdentifiant, est une classe qui crée un identifiant pour chacune des PieceMusée créées.
C'est donc une classe qui est instanciée dans la création d'une PieceMuseeArt (via sa super-classe : CPieceMusee)

2) J'aimerais savoir, comment je peux créer correctement, un constructeur de copie pour ma classe CPieceMuseeArt ?
Car dans cette classe, j'ai l'impression que ma déclaration de ce constructeur de copie n'est pas correct :

Code:

1
2
3
4
5
6
7
CPieceMuseeArt::CPieceMuseeArt(CPieceMuseeArt &pa):CPieceMusee(pa)
{
	memcpy(p_epoque,pa.p_epoque,sizeof(p_epoque));
	memcpy(p_auteur,pa.p_auteur,sizeof(p_auteur));
	p_largeur = pa.p_largeur;
	p_hauteur = pa.p_hauteur;
}

Pourriez-vous me dire d'où vient le problème avec le vecteur, je n'arrive pas à l'implémenter correctement et stocker mes objets dans cette classe ... Une idée ?

D'avance,
Merci ;)

Bon, ya clairement trop de code pour que je le lise dans le détail... L'idée est de poster un code minimum et suffisant :
- Minimum = le plus petit possible, dont on a enlevé tout ce qui ne concerne pas le problème en cours.
- Suffisant = qui permet de reproduie le problème. De préférence compilable tel quel.
C'est un équilibre parfois délicat à trouver.

Avantages :
- Plus rapide à gérer pour les lecteurs => plus de chance de réponse
- Une fois sur deux, dans le processus de nettoyage, on se rend compte tout seul du problème.

Juste une question préalable : Tu implémentes une structure complètement classique, je suppose que c'est donc à des fins d'apprentissage, et non pas pour une vraie utilisation. Même dans ce cas, t'inspirer de l'existant (std::list en l'occurence) pourrait être fructueux.
Citation:
Envoyé par ExSter
Code:

1 2 noeud(XTYPE n, noeud<XTYPE> *s):valeur(n),pSuiv(s) {valeur=n;};
Là, tu initialises valeur à n, puis tu copies n dans valeur, tu fais donc deux fois la même chose.
Citation:
Envoyé par ExSter
main.cpp :
Code:

1 2 void main()
Détail, mais main retourne un int...
Citation:
Envoyé par ExSter
Code:

1 2 3 4 5 6 7 8 9 10 { int valeur,position; // Création de la liste d'entiers ///////////////////////////////// CVecteur<int> listint; //insertion d'un entier = 1 dans le vecteur d'entier, pour tester.. position=1; listint.insert(position);
Ca ne te semble pas étrange de passer par une variable ici ? Si ton code était const-correct, tu pourrais écrire : listint.insert(1);
Le problème apparaît encore plusieurs fois. Le passage par référence, c'est quand on veut modifier l'objet passé uniquement. Autrement, on passe par copie (petits objets, ou objet dont on voudra mmodifier la copie localement) ou référence constante.
Citation:
Envoyé par ExSter
2) J'aimerais savoir, comment je peux créer correctement, un constructeur de copie pour ma classe CPieceMuseeArt ?
Car dans cette classe, j'ai l'impression que ma déclaration de ce constructeur de copie n'est pas correct :
Code:

1 2 3 4 5 6 7 CPieceMuseeArt::CPieceMuseeArt(CPieceMuseeArt &pa):CPieceMusee(pa) { memcpy(p_epoque,pa.p_epoque,sizeof(p_epoque)); memcpy(p_auteur,pa.p_auteur,sizeof(p_auteur)); p_largeur = pa.p_largeur; p_hauteur = pa.p_hauteur; }
On préfèrera mettre dans la liste d'initialisation le maximum de choses :
Code:

1 2 3 4 5 CPieceMuseeArt::CPieceMuseeArt(CPieceMuseeArt &pa):CPieceMusee(pa), p_largeur (pa.p_largeur), p_hauteur(pa.p_hauteur) { memcpy(p_epoque,pa.p_epoque,sizeof(p_epoque)); memcpy(p_auteur,pa.p_auteur,sizeof(p_auteur)); }
A noter que dans ce cas, il ne sert à rien de le définir : Celui par défaut qui copie membre à membre correspond à ce que tu fais. Idem pour l'opérateur= (en général, quand on défini l'un, on défini l'autre).

C'est bien ce que je pensais. Tu as un problème de copie d'une donnée responsable d'une ressource brute.

Reprends les bases. Les ECMs sont nos amis, pars donc de
Code:

1 2 3 4 5 6 7 8 9 10 struct Toto { Toto(); ~Toto(); void trace() const { std::cout << "this=" << this << "\t&i=" << m_pi << std::endl; } private: int *m_pi; };
La classe Toto doit être responsable d'un entier alloué dynamiquement.
Soit, son constructeur devra allouer m_i, et son destructeur le libérer. De plus, rajoutes des traces dans ces fonctions pour voir ce qui passe et quand.
La classe devra être utilisée dans les cas suivants:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 void fc(Toto toto); // je te laisse compléter leurs corps void frc(Toto const& toto); Toto g(); int main() { std::cout << "1-" << std::endl; Toto toto; std::cout << "2-" << std::endl; f(toto); std::cout << "3-" << std::endl; frc(toto); std::cout << "4-" << std::endl; Toto titi = g(); std::cout << "5-" << std::endl; toto = g(); std::cout << "6-" << std::endl; return EXIT_SUCCESS; }
Amuses-toi avec tout cela, et analyse ce qui ce passe.
Quand tu auras compris et corrigé Toto en conséquence, tu verras que l'on n'a pas grand chose de plus à dire pour que tu sois capable de corriger le problème que tu nous as soumis.
Au détail que tu as un mutateur qui souffre d'un problème excessivement similaire.

Dernier point sans rapport direct. Définir une sémantique de copie sur des classes tirées d'une hiérarchie de classes polymorphes est très piégeux. En fait, c'est incompatible. Cela va passer dans ton cas car le vecteur est un vecteur d'objets du type fils. Bien que tu utilises un héritage public, en fait tu réutilises du code, et ne demandes pas à être utilisé en place de. C'est l'héritage vendu par les (mauvais) bouquins des années 80-90.
On y reviendra, commence par le petit exercice que je t'ai laissé.

PS: ma bal étant globalement pleine, merci de ne pas remplir pour des questions qui ont leur place ici, et qui sont identiques aux messages que tu as pondus. :sm: