Discussion :

[asprog]

bonjour tout le monde;

je veux comprendre pourquoi utiliser un pointeur à l'interieur d'une classe à quoi ça sert ?? par exemple :

Code :

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

1
2
3
4
5
6
7
 
class Toto { public:
Bubu * pbu;
int y;
Toto(int, int);
~Toto();
};

pourquoi déclarer pbu comme pointeur et pourquoi ne pas écrire Bubu pbu simplement merci de m'avoir éclaircir les choses

[Invité]

Bonjour,

La différence entre les deux cas, c'est le moment où l'objet sera instancié.
- Dans le cas d'un objet, l'instanciation de l'objet Bubu se fera lors de l'instanciation de l'objet Toto.
- Dans le cas d'un pointeur, l'instanciation de l'objet Bubu se fera quand on le voudra.

Et la réponse à la question est que ça dépend du contexte.
Certains objets doivent être instanciés contextuellement en fonction de paramètres variants.
Il est possible aussi qu'un objet doive être désinstancié puis réinstancié par la suite.
Et il y a mille autres raisons.

En revanche, ça ne veut pas dire que c'est mieux: ce choix induit des contraintes particulières notamment en terme de gestion mémoire.
Il faut donc faire ce choix seulement si ça s'avère pertinent.

[asprog]

merci pour votre réponse;
mais je veux savoir si j'ai écris dans le main() ce code:
Toto t;
t.pbu->x=1;

et ensuite ce code:
Toto t;
Bubu pbu;
pbu.x=1;
est ce que sera la même chose??

[koala01]

Salut,

Comme l'a dit Nudger, l'utilisation de pointeur peut se justifier dans plusieurs cas de figures, parmi lesquels:

• Si l'objet pointé (de type Bubu selon ton exemple) ne doit pas être construit (ou détruit) en même temps que l'objet de type Toto. On se trouve donc face à ce que l'on appelle une "agrégation" en uml (l'objet contenu et l'objet contenant ont des durées de vie indépendantes, comme la remorque et le tracteur )
• Si tu as une relation de contenu à contenant dans laquelle le type dans lequel apparait le pointeur (Toto, selon ton exemple) est le contenu et le type pointé (Bubu) est le contenant, pour permettre au contenu (Toto) de s'adresser directement à l'objet qui le contient (de type Bubu).
• Si le conteneur (Toto) peut manipuler indifféremment différents type dérivés du type contenu (Bubu): cela permet de mettre en place une gestion polymorphe
• j'en oublie surement

A partir du moment où le pointeur aura reçu une adresse valide (comprends: à laquelle on trouvera effectivement un objet (dérivé) de type Bubu) il sera tout à fait possible d'accéder à l'objet de type Bubu pointé par le pointeur au départ de l'objet de type Toto, sous réserve cependant d'utiliser la syntaxe adéquate (la flèche " -> " )
Il faut en effet être attentif au fait que le pointeur doit impérativement pointer vers un objet valide de type adéquat, sous peine d'obtenir une fantastique erreur, parfois très difficile à isoler: dans le meilleur des cas, tu obtiendra une erreur de segmentation, dans le pire, tu obtiendra "simplement" des résultats aberrants

Ainsi, un code proche de

Code :

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

1
2
3
4
5
int main()
{
    Toto t;
    t.pbu->x = 3 ; // à supposer que Bubu ait un champs x
}

est syntaxiquement correct (il faut effectivement utiliser la flèche pour accéder au contenu d'un pointeur) mais logiquement erroné: le pointeur ne représente absolument pas une adresse à laquelle se trouve un objet valide de type Bubu

De même, un code proche de

Code :

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

1
2
3
4
5
6
7
int main()
{
    Toto t;
    Bubu b;
    t.pbu =  & b;
    t.pbu.x = 3; // à supposer que Bubu contienne un champs x
}

est logiquement correct (t.pbu pointe bel et bien vers un objet de type Bubu valide), mais syntaxiquement incorrect (il faut utiliser la flèche et non le point pour accéder au contenu d'un pointeur).

Par contre, un code proche de

Code :

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

1
2
3
4
5
6
7
8
int main()
{
    Bubu b;
    b.x = 3; // à supposer que Bubu contienne un champs x
             // NOTA: ce n'est pas un pointeur !!!!
    Toto t;
    t.pbu = & b;
}

ou de

Code :

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

1
2
3
4
5
6
7
8
 
int main()
{
    Bubu b;
    Toto t;
    t.pbu = & b;
    t.pbu->x = 3; // à supposer que Bubu contienne un champs x
}

ou encore de

Code :

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

1
2
3
4
5
6
7
8
9
int main()
{
    Toto t;
    t.pbu = new Bubu;
    t.pbu->x = 3;
    /*...*/
    /* n'oublions pas de libérer correctement la mémoire en temps utile */
   delete t.pbu;
}

sera correct aussi bien du point de vue syntaxique (on utilise la fleche -> quand on a affaire à un pointer et le point quand ce n'est pas le cas) que du point de vue logique: le pointeur pointe, effectivement, vers un objet de type Bubu valide