Discussion :

[_fav_]

Bonjour ! Je rencontre un petit soucis et je m'embrouille un peu dans la manipulation des pointeurs. Voila le topo :

j'ai une classe MonObjetA qui a comme variable membre un pointeur sur un autre objet de type MonPointeurSurMonObjetB.

A cote, j'ai une autre classe MaClasseDeTravail, dont une variable membre est un objet de type MonObjetA, et dont une méthode MaClasseDeTravail::execute(MonPointeurSurMonObjetB* &input) a en argument un objet MonPointeurSurMonObjetB passe par référence.

Ce que je voudrais faire, c'est quand j’exécute cette méthode, le pointeur en argument, input, soit mis dans le membre MonPointeurSurMonObjetB du membre MonObjetA de l'instance courante de MaClasseDeTravail afin de pouvoir stocker l'objet pointé et le réutiliser plus loin.

Un traitement est fait en aval : en utilisant directement input, tout marche. Si j'utilise MonObjetA.MonPointeurSurMonObjetB, ca ne marche plus. Évidemment ca vient de l'affectation que je fais :

MaClasseDeTravail.hpp

Code :

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

1
2
3
4
5
6
7
8
9
10
 
Class MaClasseDeTravail 
{
private
//variables membres ...
MonObjetA unObjetA;
 
void execute(MonPointeurSurMonObjetB* &input)
 
}

MaClasseDeTravail.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include MaClassDeTravail.hpp
 
MaClasseDeTravail::execute(MonPointeurSurMonObjetB* &input)
{
//code divers (...)
 
unObjetA.MonPointeurSurMonObjetB = input;
 
//code divers (...)
 
// partie de code ou j'utilise un objet de type MonPointeurSurMonObjet*
 
}

Est il possible de faire ce que je tente de faire ? Je sais pas trop si j'ai reussi a me faire comprendre Merci par avance pour votre attention et votre aide.

[Médinoc]

Tant que rien n'est déclaré const, c'est censé être possible.
Par contre,

1. ça viole les principes d'encapsulation
2. il faut faire attention à la durée de vie de l'objet pointé (c'est pourquoi on déconseille l'usage des pointeurs "bêtes" en C++).

[_fav_]

Salut et merci de la réponse rapide.

Concernant l'encapsulation, si je crée un setter, est ce que les principes sont respectés ? Mais dans l'absolu, le setter c'est juste une façon plus correcte de donner une valeur a un membre, non ? Le sens en lui même est le meme ? Ou cela pourrait corriger le probleme ? Quelque chose comme :

MaClasseDeTravail.cpp

Code :

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

1
2
 
unObjetA.setterMonPointeurSurMonObjetB(input);

et
MonObjetA.hpp

Code :

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

1
2
3
4
5
 
void setterMonPointeurSurMonObjetB(MonPointeurSurMonObjetB* &valeurASetter)
{
MonPointeurSurMonObjetB = valeurASetter;
}

Je n'ai pas accès (cad le droit de modifier ou ajouter une méthode) a la classe MonPointeurSurMonObjetB, du coup est ce que quand je fais :

Code :

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

unObjetA.MonPointeurSurMonObjetB = input;

je n'aurais pas recours a l'operateur = qui pourrait ne pas être surchargé pour la classe MonPointeurSurMonObjetB ?

Pour la durée de vie des pointeurs, quelle serait l'alternative aux pointeurs ? je suis toujours prets a me debarasser des pointeurs !

[Médinoc]

Pour la pertinence d'un setter au niveau philosophique, ce n'est pas vraiment décidable avec des noms abtraits et une situation abstraite. C'est seulement dans un cas réel qu'on peut décider si un setter est approprié plutôt qu'une fonction plus orientée "rendre un service".
Mais dans tous les cas (sauf type POD - "Plain Old Data"), le setter est plus approprié qu'une variable membre nue.

Affecter un pointeur n'appelle pas l'opérateur = sur le type pointé.

L'alternative, quand on objet gère la durée de vie d'un autre, c'est les pointeurs intelligents. Quand l'objet ne gère pas la durée de vie, on peut parfois garder un pointeur "bète" parce qu'on n'a pas vraiment mieux sauf dans des cas précis (shared_ptr+weak_ptr).

[r0d]

Bonjour,

l'idée même de setter est de plus en plus considérée comme une mauvaise pratique en c++. Et je suis assez d'accord avec cette façon de voir les choses:

On encapsule un comportement, pas des propriétés.

Un peu d'excellente lecture

[_fav_]

Merci pour les réponses, j'y vois un peu plus clair. Cependant je me suis creusé la tête mais je vois pas de raisons quelconque a mon problème.

Quand ma méthode reçoit en argument (MonPointeurSurMonObjetB* &input) c'est pourtant bien un passage par référence d'un pointeur sur un type MonPointeurSurMonObjetB, donc le passage par référence ne change pas le type...

Bon en tout cas je vous remercie pour votre attention. Je vais continuer a chercher une solution et le cas échéant je la posterais ici.

[r0d]

Il y a plusieurs choses que je ne comprend pas dans ton problème.

1. Tout d'abord, pourquoi vouloir passer un pointeur par référence? En plus de 10 ans de c++, je n'ai jamais eu besoin de faire ça, et j'ai bien peur que ça cache un problème plus sérieux.

2. Tu reçois un pointeur libre (membre de personne à priori), et tu veux l'utiliser en tant que membre d'une classe. Pour pouvoir faire ça, il faudrait que tu assigne d'abord le pointeur (mon_instance_A->le_pointeur = le_pointeur_passé_en_paramètre; ) avant de pouvoir l'utiliser. Mais faire ça est assez dangereux parce que tu modifies l'instance de la classe A de façon cachée et sournoise.

[_fav_]

Bonjour, je reviens vers vous car j'ai trouve pourquoi mon pointeur était nul : c'est tout simplement parce que le pointeur reçu en argument l’était aussi !

Bref, en fait d’après ce que j'ai compris, je reçois un pointeur sur un objet, il est nul de base mais lorsqu'il est utilise par la suite, il est initialise et modifier par des méthodes de plus bas niveau. Je pense que c'est pour cela qu'il est passe par référence.

En effet, maintenant je vois que si je copie mon pointeur en argument dans l'autre pointeur membre, et que j'utilise ce dernier en aval, il est bien assignes en fin de process, alors que celui en argument reste nul : ma prochaine tache est de remédier a ce problème.

Encore merci pour vos réponses rapides.

EDIT : en utilisant un pointeur sur le pointeur en argument, mon problème est entièrement résolu !