Discussion :

[alen]

Bonjour,

J'ai une classe B encapsulée dans la class A.
Je déclare ensuite un map de n class B. Je désire ensuite de l'extérieur pouvoir accéder aux fonctions de B, j'ai donc déclaré une fonction GetpB(index); qui me retourne un pointeur sur ma class B de position index. J'utilise enfin ce pointeur pour accéder aux fonctions membres de B.
Est-ce que cette approche est valable?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
class A
{
public:
   class B
   {
       f1();
       f2();
   };
protected:
   std::map<int,B> m_map;
public:
    B* GetpB(int index);
};
 
...
 
A::B* A::GetpB(int index)
{
   std::map<int,B>::iterator it;
   it = m_map.find(index);
   if (it!=m_mapBV.end())
       return (&it->second);
}

plus loin dans le code principal

Code :

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

1
2
3
 
    A a;
    a->GetpB(1)->f1();

[hiko-seijuro]

euh je crois que si tu ne mets pas de pointeur dans la map autant ne pas retourner de pointeur dans ta méthode

[alen]

euh je crois que si tu ne mets pas de pointeur dans la map autant ne pas retourner de pointeur dans ta méthode

Je pensais pouvoir faire quelque chose comme:

Code :

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

1
2
3
4
5
6
 
A a;
A::B *pb = a->GetpB(1);
pb->f1();
pb->f2();
...

[icer]

Est-ce que cette approche est valable?

Pour moi, elle ne pose pas de poblème.

euh je crois que si tu ne mets pas de pointeur dans la map autant ne pas retourner de pointeur dans ta méthode

Et pourquoi pas ? Un pointeur c'est une addresse, et l'opérateur & retourne bien une addresse.

Par contre :

Code :

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

1
2
3
4
5
6
7
A::B* A::GetpB(int index)
{
   std::map<int,B>::iterator it;
   it = m_map.find(index);
   if (it!=m_mapBV.end())
       return (&it->second);
}

Les paranthèse n'aportent pas plus de précision : retour l'addresse de it ou celle de second.

Pour enlever l'ambiguïté :

Code :

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

1
2
 
return &(it->second);

[koala01]

Salut,

En fait, à moins que tu n'aie une bonne raison d'utiliser un pointeur, il est toujours préférable d'utiliser les références (éventuellement constante) quand tu veux renvoyer un membre (ou un élément d'un conteneur qui est membre) de ton objet...

D'abord parce que ca te permet de travailler consemment avec des . plutot qu'avec des déréférencements -> (on n'imagine pas, mais le simple fait de ne pas avoir à se poser la question de savoir lequel utiliser, ca facilite la vie ), ensuite parce que si tu utilise un pointeur, tu risque toujours d'être tenté de libérer la mémoire de celui-ci avec delete, croyant que tu n'en a plus besoin, alors la gestion de cet élément échoit à une autre variable

[hiko-seijuro]

je me suis mal exprimé ce que je voulais dire c'est que tel que je voyais son truc il allait manipulé 2 trucs différents enfin bref

[r0d]

Je ne serais pas si cathégorique sur l'utilisation de référence. Je m'explique:
Pour commencer, le code suivant est faux:

Code :

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

1
2
3
4
5
6
7
 A::B* A::GetpB(int index)
{
        std::map<int,B>::iterator it;
        it = m_map.find(index);
        if (it!=m_mapBV.end())
        return (&it->second);
}

puisqu'il ne retourne rien si l'élément n'est pas trouvé. Je suppose que c'est une erreur de copier/coller, mais cela pose la question: que renvoie-t-on si l'élément n'est pas trouvé?

Si c'est un pointeur, on va sans doute renvoyer un pointeur NULL.
Mais si c'est une référence, que fait-on?
On peut opter pour un accesseur qui prend une référence en paramètre et renvoie un booleen pour spécifier si l'élément recherché a été trouvé. Mais cette solution nous obligera a créer un objet B (celui que l'on va passer en paramètre), alors qu'un pointeur ne nécéssite pas de construction supplémentaire.

Donc bon, ça dépend du contexte. Je pense que nous n'en savons pas assez pour trancher.

Perso, j'utilise de plus en plus les pointeurs intelligents, en particulier ceux de boost. Ca règle tous les problèmes relevés dans ce topic (y compris ceux sur la syntaxe).

That's my point