[C++] copie d'objets - copier l'objet, ou un pointeur vers lui?

Bonjour

J'arrive pas a saisir correctement le fonctionement des passages d'objets en parametres.

Une petit exemple :

une structure :



et une classe :


Donc si dans mon main je cree une structure et une classe et que je veux copier cette structure dans ma classe grace au constructueur, ca va poser probleme comme je l'ai fait si "mon_objet" est detruit non?

exemple :

Dans le cas de référence, oui. Tu peux passer par copie, ou par pointeur. Dans ce cas, à toi de gérer la libération de l'autre structure quand elle n'est plus utilisée.

passage par copie :
c' est a dire comme ca? :


j' ai essaye, et si j' efface la structure dans mon main, alors elle n'est plus accessible non plus dans ma classe... (segmentation fault)...

Pour te faciliter la tâche, pourquoi tu passes pas par un vecteur de struct, il passe par pointeur et à tout ce qu'il faut pour gérer sa liste tout bien comme il faut.
Je suis pas trop full oop donc ce n'est qu'une idée

KarLKoX a écrit:
Pour te faciliter la tâche, pourquoi tu passes pas par un vecteur de struct, il passe par pointeur et à tout ce qu'il faut pour gérer sa liste tout bien comme il faut.
Je suis pas trop full oop donc ce n'est qu'une idée 

parce que je veux passer une seule structure.
Tu veux dire passer un vecteur de struct de taille 1?
Si c'est ca je prefererai faire autrement, ca me plait pas trop de creer un vecteur pour un objet

Ou alors tu parlait de "mon_objet" ?
En fait mon_objet je ne le passe pas directement, mais a l'interieur de ma strucure.

Je parlais bien de la structure que tu veux copier mais c'est vrai que s'il n'y en a qu'une, ça ne sert à rien dans ce cas la, je dirais même que tu n'as pas vraiment de problème lors de la copie par pointeur car tu dois quand même savoir ce que tu fais c'est à dire quand le pointeur existe toujours ou pas, non ?

Ah mais attends, je t'ai mal lu : je croyais que c'était la structure que tu passe en référence le problème.

Non, pour mon_objet s'il est détruit, c'est pas à ton constructeur de faire attention à ça, ni à ton destructeur, mais à l'appelant : si tu crée un objet avec la structure, c'est que quelqu'un (la méthode appelante) en a besoin. A elle de gérer ça donc, je dirais.

Je sais pas si je répond à la question.

Sans-Nom a écrit:
Ah mais attends, je t'ai mal lu : je croyais que c'était la structure que tu passe en référence le problème.

Je te rassure, j'avais compris la même chose que toi

Ben oui sauf que c'est bien de passer en référence en général. j'avais pas fait attention au fait qu'il faisait pas de référence sur la structure. Bref.

Sans-Nom a écrit:
Ah mais attends, je t'ai mal lu : je croyais que c'était la structure que tu passe en référence le problème.

Non, pour mon_objet s'il est détruit, c'est pas à ton constructeur de faire attention à ça, ni à ton destructeur, mais à l'appelant : si tu crée un objet avec la structure, c'est que quelqu'un (la méthode appelante) en a besoin. A elle de gérer ça donc, je dirais.

Je sais pas si je répond à la question.

oui ca parait logique.

merci

Sinon tu peux aussi essayer de faire du reference counting pour détruire l'objet automatiquement.

Ton problème est lié à ton pointeur "monObjet* mon_objet".
La copie d'objet est automatique en c++, pas cette copie est dite "superficielle". Cad les variables membres sont copiées une à une, sans faire de réallocation sur les pointeurs.
Ce qu'il te faut est une copie dite "en profondeur", afin que les copies soient inépendantes (c'est pour cela que la surcharge de l'opérateur = existe).

________________________________

En supposant que monObjet est
struct monObject {
int membre1;
}

maStructure {
int toto;
monObjet* mon_objet;
}
maClasse {
private :
maStructure ma_structure;
public :
maClasse(maStructure& ms){
ma_structure.toto = ms.toto;
ma_structure.mon_object = new monObjet();
ma_structure.mon_object->membre1 = ms.mon_object->membre1;
}
}

_________________________________

Le mieux étant bien sûr de faire des classes, par exemple:
class maStructure {
public:
maStructure() {}
maStructure(const maStructure& ms) {
copy(ms);
}

maStructure& operator=(const maStructure& ms) {
copy(ms);
return *this;
}

protected:
void copy(const maStructure& ms) {
ma_structure.toto = ms.toto;
ma_structure.mon_object = new monObjet();
ma_structure.mon_object->membre1 = ms.mon_object->membre1;
}
}

Ainsi maClasse devient
maClasse {
private :
maStructure ma_structure;
public :
maClasse(maStructure& ms){
ma_structure = ms;
}
}