Discussion :

[giopi]

Bonjour à tous !

Je suis néophyte sous C++, ainsi je suis confronté à un certains nombres de problème, probablement triviaux.
Aujourd'hui, j'ai des problèmes pour concevoir un constructeur de copie.
Voici mon code:

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
 
class arbre {
public:
	explicit
	arbre( int valeur );
	~arbre();
	arbre(arbre & a);
[Mes méthodes : hauteur(), new_gauche( arbre_binaire * nouveau_gauche );, gauche(), droite()...]
 
private:
	int valeur_;
	arbre * gauche;
	arbre * droite;
 
arbre::arbre(arbre & a){
	gauche_= a.gauche;
	droit_ =a.droite;
	valeur_= a.valeur;
}

Pour le constructeur de copie, je pensais faire très simplement le code ci-dessus, mais celui-ci ne marche pas. Je sens que je manque toute la profondeur de l'arbre avec celui-ci ? Et imagine donc un appel récursif du type :

Code :

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

1
2
3
4
5
6
arbre_binaire::arbre_binaire(arbre_binaire & a){
	gauche_= arbre_binaire( a.gauche_);
	droit_ = arbre_binaire( a.droit_);
	valeur_= a.valeur_;
	++nombre_instances_;
}

Néanmoins cela ne compile pas, problème de type pointeur/ non-pointeur, mais je ne m'en sors pas trop.

Si jamais vous pouvez m'aider, je vous remercie d'avance!

Bonne journée,
Giopi

[Pyramidev]

Bonjour,

Voici une solution :

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
arbre::arbre(const arbre& a) :
	valeur(a.valeur)
{
	if(a.gauche)
		gauche = new arbre(*a.gauche);
	else
		gauche = nullptr;
 
	try {    
		if(a.droite)
			droite = new arbre(*a.droite);
		else
			droite = nullptr;
 
	} catch(...) {
		delete gauche;
		throw;
	}
}

Cela dit, pour éviter d'alourdir le code avec des try-catch, il est généralement déconseillé de manipuler la mémoire dynamique avec des pointeurs nus.
Si gauche et droite sont de type std::unique_ptr<arbre>, le code devient bien plus simple :

Code :

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

1
2
3
4
5
6
7
8
arbre::arbre(const arbre& a) :
	valeur(a.valeur)
{
	if(a.gauche)
		gauche = std::make_unique<arbre>(*a.gauche);
	if(a.droite)
		droite = std::make_unique<arbre>(*a.droite);
}

[giopi]

Merci beaucoup pour votre aide !
Petit point de détails : est-ce qu'il est conseillé de manipuler exclusivement des pointeurs intelligents, que ce soit unique_ptr ou shared_ptr, ou bien d'utiliser des pointeurs nus ?

[dalfab]

pyramidev a donné deux manières de gérer les pointeurs. Aurais-tu trouvé la première? Si non, il est fortement conseillé d'utiliser les pointeurs intelligents. Essaie maintenant d'écrire l'opérateur de copie dans ces deux cas, d'autant qu'en utilisant les pointeurs bruts il faut impérativement le définir (et tu sembles l'avoir oublié) alors qu'avec les pointeurs intelligents il n'y a pas de risque de bug si on l'oublie.

Code :

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

arbre &arbre::operator=( const arbre& a ) ...

[giopi]

Pour l'opérateur de copie, j'avais suivi les conseils que j'ai reçu par ailleurs, en utilisant la bibliothèque standard, dans le but d'éviter des erreurs :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
arbre & arbre::operator = ( arbre& a){
	swap(a);
	return *this;
}
 
void arbre::swap(arbre& a){
	using std::swap;
	swap(valeur, a.valeur);
	swap(gauche, a.gauche);
	swap(droite, a.droite);
 
}

Je n'aurais pas su gérer les erreur avec le try, catch, throw assurément dans la première réponse apportée !

[Bousk]

En l'état ton code est plus proche d'un déplacement que d'une copie. Les objets sont swap, autant l'objet destination aura bien les valeurs de l'objet source, autant l'objet source est dans un état bien batard puisqu'il se retrouve avec les valeurs de l'objet destination.

[dalfab]

La fonction swap() est nickel.
Cette manière d'écrire l'opérateur de copie est intéressante (et elle fonctionne aussi bien avec des pointeurs bruts que des pointeurs intelligents), mais il y a une petite erreur qui fait qu'il modifie la source alors qu'il ne devrait que la copier.
En utilisant le bon prototype avec le qualificateur const arbre& arbre::operator=( const arbre& a );, le compilateur t'aurait prévenu qu'il y a erreur. On peut aussi utiliser le prototype arbre& arbre::operator=( arbre a );

[Bousk]

Dans le cas où l'objet est un peu lourd, faire une copie pour faire un swap ne me semble pas une bonne idée.
Mais sinon oui, c'est un trick intéressant. A garder dans sa poche, comprendre et maitriser pour l'utiliser au moment opportun.

[oodini]

Petit point de détails : est-ce qu'il est conseillé de manipuler exclusivement des pointeurs intelligents, que ce soit unique_ptr ou shared_ptr, ou bien d'utiliser des pointeurs nus ?

Non. Tu ne dois prendre des pointeurs des intelligents que lorsque la gestion de la durée de vie du pointeur est gérée par "quelqu'un d'autre", et que tu es certain que ton pointeur nu ne survit jamais à l'objet alloué qui lui est associé.

[Médinoc]

Tu ne dois prendre des pointeurs des intelligents que lorsque la gestion de la durée de vie du pointeur est gérée par "quelqu'un d'autre"

Pourquoi cette restriction?
Qu'est-ce qu'il y a de mal avec ce code?

Code C++ :

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

1
2
3
4
5
int SomeFunction()
{
	auto_ptr<SomeType> spObj = make_unique<SomeType>();
	return spObj->SomeOperation();
}

[koala01]

Salut,

Non. Tu ne dois prendre des pointeurs des intelligents que lorsque la gestion de la durée de vie du pointeur est gérée par "quelqu'un d'autre", et que tu es certain que ton pointeur nu ne survit jamais à l'objet alloué qui lui est associé.

Excuses moi, mais là, j'ai envie de m'écrirer "c'est quoi cette connerie"

Tu dois toujours avoir recours au pointeurs intelligents!!!

A toi de déterminer qui sera le propriétaire légitime de la ressource!

C'est l'utilisation des pointeurs bruts qui doit être strictement encadrée et dont on peut éventuellement envisager que celui qui disposera d'un tel pointeur ne pourra faire qu'utiliser la ressource, sans aucun droit de la libérer, et, bien sur, après s'être assurer que le propriétaire légitime de la ressource ne décidera pas de la libérer alors qu'on est occupés avec.

[oodini]

C'est l'utilisation des pointeurs bruts qui doit être strictement encadrée et dont on peut éventuellement envisager que celui qui disposera d'un tel pointeur ne pourra faire qu'utiliser la ressource, sans aucun droit de la libérer, et, bien sur, après s'être assurer que le propriétaire légitime de la ressource ne décidera pas de la libérer alors qu'on est occupés avec.

C'est exactement ce que j'ai dit.

Mea culpa : Ma pensée a bifurqué en cours de rédaction de mon message tant critiqué. J'ai commencé la phrase en partant sur l'utilisation des pointeurs intelligents, pour la terminer en parlant du cas d'utilisation des pointeurs bruts... On peut d'ailleurs voir qu'une syntaxe très hasardeuse matérialise ce "switch".
Je vais mettre ça sur l'heure de la rédaction dudit message...

[koala01]

Ah, méa culpa, mea maxima culpa. Toutes mes excuses, alros, car je n'avais vraiment pas compris ton message en ce sens

[JolyLoic]

Pourquoi cette restriction?
Qu'est-ce qu'il y a de mal avec ce code?

Code C++ :

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

1
2
3
4
5
int SomeFunction()
{
	auto_ptr<SomeType> spObj = make_unique<SomeType>();
	return spObj->SomeOperation();
}

J'imagine que cet ignoble auto_ptr est juste une faute de frappe, et que tu voulais juste écrire :

Code :

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

1
2
3
unique_ptr<SomeType> spObj = make_unique<SomeType>();
// Ou
auto spObj = make_unique<SomeType>();

[Médinoc]

Oui, c'est une faute de frappe. C'est bien unique_ptr des deux côtés.
Ou probablement juste auto. J'ai dû faire l'amalgame des deux.

[Luc Hermitte]

Pourquoi cette restriction?
Qu'est-ce qu'il y a de mal avec ce code?

Code C++ :

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

1
2
3
4
5
int SomeFunction()
{
	auto_ptr<SomeType> spObj = make_unique<SomeType>();
	return spObj->SomeOperation();
}

Hum...

Code C++ :

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

1
2
3
4
5
int SomeFunction()
{
	SomeType spObj;
	return spObj.SomeOperation();
}

Certes, on peut utiliser des pointeurs intelligents localement, c'est très bien, mais régulièrement, ce n'est pas du tout nécessaire.