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

Logiciel & apps Programmation
1

Bonjour

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

Une petit exemple :

une structure :


maStructure {
     int toto;
     monObjet* mon_objet;
}

et une classe :


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

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 :


maStructure ma_structure;
ma_structure.mon_objet = new monObjet[10];
//ici je remplit mon_objet avec des valeurs
//puis je veux copier cette structure qui contient mon_objet dans ma classe :
maClasse ma_classe(ma_structure);

//si plus tard mon_objet est detruit, il ne sera plur accessible dans ma_classe non plus?
2

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.

3

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


 maClasse(maStructure ms){
     ma_structure = ms;
  }

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)…

4

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 :neutre:

5

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 :slight_smile:

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

6

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 ?

7

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.

8

Je te rassure, j’avais compris la même chose que toi :ane:

9

Ben oui :slight_smile: 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.

10

oui ca parait logique.

merci :slight_smile:

11

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

12

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;
}
}