Recopie de pointeur

Version imprimable

15/06/2008, 01h16
krahzi

Recopie de pointeur

Bonsoir,
pour expliquer un peu mon problème j'ai une classe solution dont je crée un pointeur de solution dans une classe rechercheTabou. Ensuite je voudrais recopier ce que pointe mon pointeur dans une nouvelle occurrence de la classe solution.
Forcément j'ai pensé au constructeur par recopie que j'ai écrit. Tout passe à la compilation mais quand j'affiche ma nouvelle solution et mon pointeur je n'ai pas la même chose pour tous les attributs et si je mets des lignes de code entre l'appel au constructeur par recopie et l'affichage je n'ai plus du tout la même chose.
A mon avis j'ai mal saisi comment il faut recopier ce qui est pointé par un pointeur.

Merci pour votre aide, j'espère que je me suis assez bien expliqué.
15/06/2008, 01h44
Montag

Salut,

Le plus simple serait que tu postes ton code.

ça pourrait être simple si mon code était simple... Je vais essayer de faire ça par parties.
Les attributs de ma classe Solution:

Code:

1
2
3
4
5
6
7
8
9
 
class solution
{
private:
    double fitness;
    int* tab_verif_contrainte;
    int* tab_solution;
    int nombre_ap;
    int nombre_contr;

Mon constructeur par recopie:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
solution::solution(const solution& s)
    {
        fitness=s.fitness;
        nombre_ap=s.nombre_ap;
        nombre_contr=s.nombre_contr;
        tab_verif_contrainte=new int[nombre_contr];
        tab_solution=new int[nombre_ap];
        for(int i=0;i<nombre_contr;i++)
            tab_verif_contrainte[i]=s.tab_verif_contrainte[i];
        for(int i=0;i<nombre_ap;i++)
            tab_solution[i]=s.tab_solution[i];
    }

Les attributs de la classe rechercheTabou:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class rechercheTabou
{
private:
	solution *sol_actuelle;
    solution *meilleure_sol;
    int nb_tabou;
    int** liste_tabou;
    contrainte* tab_contraintes;
    sp* tab_sp;
    string nb_AP;
    int nb_contr;
    int nb_sp;
    string* contr_Ap;
    vector<int>* Ap_contr;

La classe rechercheTabou:

Code:

1
2
sol_actuelle=new solution(tab_sp, tab_contraintes, nb_AP, nb_contr, nb_sp);
new_sol=solution(*sol_actuelle);

Je pense qu'il y a l'essentiel pour voir où j'en suis.

15/06/2008, 11h55
Lucien63

Une question as tu redefini l'opérateur d'affectation de ta classe solution ?
15/06/2008, 12h23
krahzi

non je ne l'ai pas fait. Ca pourrait être le problème?
15/06/2008, 14h50
buzzkaido
Code:

1 2 sol_actuelle=new solution(tab_sp, tab_contraintes, nb_AP, nb_contr, nb_sp); new_sol=solution(*sol_actuelle);
Comment sont déclarés sol_actuelle et new_sol ?

Est-ce des pointeurs ?

Parce que si tu fais :
Code:

1 2 3 4 5 6 solution* sol_actuelle; solution new_sol; sol_actuelle=new solution(tab_sp, tab_contraintes, nb_AP, nb_contr, nb_sp); new_sol=solution(*sol_actuelle);
il serait surement plus adapté de faire :
Code:

1 2 3 4 5 6 solution* sol_actuelle; solution new_sol; sol_actuelle=new solution(tab_sp, tab_contraintes, nb_AP, nb_contr, nb_sp); new_sol=(*sol_actuelle);
Le constructeur par recopie étant automatiquement appellé lors de l'affectation, il me semble.

Maintenant, vu la signature du constructeur par recopie :

Code:

solution::solution(const solution& s)

Il faut que (*sol_actuelle) soit convertible en const solution&, et donc que le pointeur soit declaré comme const.

Essaie de placer un point d'arrêt dans le constructeur par recopie, et au debuggage, regarde si il passe bien par là.

Par contre, si tu fait :
Code:

1 2 3 4 5 6 solution* sol_actuelle; solution* new_sol; sol_actuelle=new solution(tab_sp, tab_contraintes, nb_AP, nb_contr, nb_sp); new_sol=solution(*sol_actuelle);
Ca ne compile surement même pas... par contre il est possible de faire :
Code:

1 2 3 4 5 6 solution* sol_actuelle; solution* new_sol; sol_actuelle=new solution(tab_sp, tab_contraintes, nb_AP, nb_contr, nb_sp); new_sol=sol_actuelle->cloner();
En implémentant solution comme une classe clonable (cf. designs patterns) ce qui a plusieurs avantages : clonage d'une classe polymorphique sans connaitre son type exact, allocation dynamique du clone...

En tout cas, travailler un coup avec des pointeurs alloués dynamiquement et un autre avec des objets alloués "statiquement" (déclarés dans une fonction en tant que variable, pas en tant que pointeur) est une mauvaise idée car tu va avoir des problèmes de durée de vie de tes objets (dès que tu sors de la fonction, la variable est détruite, pas le pointeur)
15/06/2008, 15h21
Lucien63

Citation:

Envoyé par buzzkaido

Le constructeur par recopie étant automatiquement appellé lors de l'affectation, il me semble.

Il me semble que l'objet est déjà crée dans ce cas là. Donc ça serait plustôt l'opérateur d'affectation qui serait appelé.
15/06/2008, 17h21
krahzi

Merci pour vos réponses. Je suis un peu pressé donc j'ai réussi à détourner mon problème d'une façon un petit peu bizarre mais au moins ça marche maintenant.
15/06/2008, 17h25
Davidbrcz

pourquoi ne pas remplacer ces tableaux tout moche par des std::vector ?
Sachant que tu en utilise déjà (pas du mieux, mais c'est déjà ca).

Citation:
Envoyé par krahzi
ça pourrait être simple si mon code était simple... Je vais essayer de faire ça par parties.
Les attributs de ma classe Solution:
Code:

1 2 3 4 5 6 7 8 9 class solution { private: double fitness; int* tab_verif_contrainte; int* tab_solution; int nombre_ap; int nombre_contr;
Mon constructeur par recopie:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 solution::solution(const solution& s) { fitness=s.fitness; nombre_ap=s.nombre_ap; nombre_contr=s.nombre_contr; tab_verif_contrainte=new int[nombre_contr]; tab_solution=new int[nombre_ap]; for(int i=0;i<nombre_contr;i++) tab_verif_contrainte[i]=s.tab_verif_contrainte[i]; for(int i=0;i<nombre_ap;i++) tab_solution[i]=s.tab_solution[i]; }
Tu dois aussi écrire un operateur d'affection comme ça:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 solution solution::operator =(const solution& s) { fitness=s.fitness; nombre_ap=s.nombre_ap; nombre_contr=s.nombre_contr; delete[] tab_verif; tab_verif_contrainte=new int[nombre_contr]; delete[] tab_solution; tab_solution=new int[nombre_ap]; for(int i=0;i<nombre_contr;i++) tab_verif_contrainte[i]=s.tab_verif_contrainte[i]; for(int i=0;i<nombre_ap;i++) tab_solution[i]=s.tab_solution[i]; }
Parce que:
Code:

1 2 3 4 5 6 7 8 9 10 // 1 solution *solution_actuelle; solution nouvelle_solution; // 2 solution_actuelle = new solution(....); // 3 nouvelle_solution = solution(*solution_actuelle);
Ligne 3 copie *solution_actuelle dans un objet "solution" temporaire, et puis elle assigne l'objet sur l'object "nouvelle_solution". Puis, ligne 3 détruit l'objet temporaire.

Mais (il y a toujours un "mais"! :aie:), parce que la classe "solution" n'a pas d'operateur d'affection, le compilateur écrit un operateur automatiquement, et cet operateur ne copie que les pointeur, et ne copie pas les tableaux.

Quand "nouvelle_solution" est détruit, son destructeur détruit les mêmes tableaux que le destructeur de l'objet temporaire a détruit, et ça plantera :aie::evilred:.

Si tu ajoute un operateur d'affection comme le mien au dessous, le compilateur l'utilisera au lieu de l'operateur automatique.

Tu peux aussi remplacer les pointeurs des tableaux avec les std::vector<int> (sans pointeurs!). Les std::vector<int> ont les operateurs, les constructeurs et un destructeur, et dans chaque situation, ta classe marchera mieux. Tu n'auras pas besoin d'éviter les operateurs et constructeurs automatique.

16/06/2008, 11h12
krahzi

Merci, je vais suivre tes conseils, je vais d'abord essayer l'opérateur d'affectation, puis si ça ne fonctionne toujours pas correctement je passerai au vecteur. :)

En règle générale.... Dans nos classes ici, on a:

ou bien:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Toto { public: Toto(... parameters ...); ~Toto(); ... private: inline Toto(const Toto& t) {} inline Toto& operator=(const Toto& t) { return *this; } };
ou bien:
Code:

1 2 3 4 5 6 7 8 9 10 class Toto { public: Toto(... parameters ...); ~Toto(); Toto(const Toto& t); Toto& operator=(const Toto& t); };
De fait, ou bien l'operateur est défini, ou bien il est interdit.... Et du coup, le compilo va très vite râler au lieu de créer son propre opérateur d'affectation.

C'est comme pour les conversions, (operator Tata() ou Toto(const Tata& t) )... elle sont systématiquement (sauf rares exceptions) définies explicites...

Pour éviter de recopier son code de copie dans l'opérateur d'affectation, on utilise l'idiome copy-and-swap :

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
#include <algorithm>
 
class solution
{
private:
	double fitness;
	int* tab_verif_contrainte;
	int* tab_solution;
	int nombre_ap;
	int nombre_contre;
 
public:
	void Swap(solution & other);
	solution();
	~solution();
	solution(solution const &src);
	solution & operator= (solution const &src);
};
 
namespace std
{
	template<>
	void std::swap(solution &x, solution &y)
	{
		return x.Swap(y);
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//Idiome non-throwing swap
void solution::Swap(solution &other)
{
	std::swap(fitness, other.fitness);
	std::swap(tab_verif_contrainte, other.tab_verif_contrainte);
	std::swap(tab_solution, other.tab_solution);
	std::swap(nombre_ap, other.nombre_ap);
	std::swap(nombre_contre, other.nombre_contre);
}
 
	//idiome copy-and-swap
solution & solution::operator= (solution const &src)
{
	//copy
	solution tmp(src);
 
	//and swap
	Swap(tmp);
 
	return *this;
}