Discussion :

[damien77]

Bonjour,

J'aimerais avoir votre aide parce que je suis un peu perdu et je ne sais pas comment faire. En effet dans quel cas utiliser un pointeur ou une référence ?

Exemple dans le code suivant :

Code :

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

1
2
3
4
5
6
7
8
9
 
class Node
{
    public:
       Node *getParent() const;
       void setParent(const Node *);
   private:
       Node *parent ;
}

Nous utilisons les pointeurs. Mais serais-il possible d'utiliser les références ?...

merci de votre aide

[Luc Hermitte]

Non. Une référence est un alias qui ne peut être ré-attaché.

[damien77]

Peux tu donner un peu plus de détail. Ca ne m'aide pas beaucoup.

[koala01]

Salut,

En gros, un pointeur doit être utilisé, principalement, dans quatre circonstances:

• Quand tu veux pouvoir bénéficier du polymorphisme
• Quand une structure doit disposer de membre de son propre type (ou d'un type dérivé/parent).
• *éventuellement* quand un membre doit "survivre" à la classe qui le contient ou quand il doit pouvoir ne pas être initialisé... et que tu dois pouvoir tester s'il l'est ou non.
• Quand un argument passé en fonction peut ne pas exister (ce qui est tout à fait différent de "peut etre vide" )

En effet, il est impossible qu'un Noeud en contienne "physiquement" un autre... Tout ce qu'il peut contenir, c'est un rappel de l'adresse à laquelle il se trouve

Dans tous les cas, il s'agira de t'assurer que la libération de la mémoire allouée au pointeur soit correctement libérée au bon moment: ni trop tôt, ni trop tard

Si tu veux éviter la copie d'un élément, et que tu n'est pas dans l'un de ces quatre cas bien particulier, c'est donc une référence qu'il te faudra utiliser

Pour être précis: un pointeur est l'adresse à laquelle tu trouvera une variable du type donné, alors que la référence n'est qu'un alias (un autre nom) d'une instance donnée du type en question...

[ram-0000]

Je rajouterai une autre utilité

Dans un passage de paramètres à une fonction, une référence doit être utilisée lorsque cela n'a pas de sens que son équivalent pointeur soit NULL.

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
 
bool OpenFile(const string *Filename /*= NULL*/)
{
   if(Filename != NULL)
   {
      // open the file
      ...
   }
   else
   {
      // open stdin
      ...
   }
   ...
}

Dans ce cas, le fait que Filename soit NULL a un sens (pour ma fonction) donc je peux (et même je dois) utiliser un pointeur

[koala01]

Je rajouterai une autre utilité

Dans un passage de paramètres à une fonction, une référence doit être utilisée lorsque cela n'a pas de sens que son équivalent pointeur soit NULL.

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
 
bool OpenFile(const string *Filename /*= NULL*/)
{
   if(Filename != NULL)
   {
      // open the file
      ...
   }
   else
   {
      // open stdin
      ...
   }
   ...
}

Dans ce cas, le fait que Filename soit NULL a un sens (pour ma fonction) donc je peux (et même je dois) utiliser un pointeur

Non, car tu pourrais très bien vérifier si la chaine est vide (ou non), et, en tout cas, la passer en tant que référence, idéalement constante

Je suis d'accord avec le fait qu'un argument qui peut ne pas exister sera fourni sous la forme d'un pointeur, vallant NULL s'il n'existe effectivement pas, ce qui se rapproche du troisième cas cité (allez, je vais rajouter le cas des arguments )

Mais on déconseille fortement de fournir un pointeur sur tout ce qui vient de la S(T)L:

std::string, conteneurs flux et, d'ailleurs l'ensemble de la S(T)L sont à fournir "par principe" et de préférence en tant que référence, constante s'il échoit

[ac_wingless]

Peux tu donner un peu plus de détail. Ca ne m'aide pas beaucoup.

Le point crucial pour cette classe est bien celui qu'indique Luc hermitte: une référence est une sorte de pointeur constant dépointé. Il est donc impossible de changer vers quoi pointe la référence après sa création, ce qui élimine la possibilité d'implémenter le "parent" en tant que référence ET d'avoir une fonction setParent.
D'une manière générale, les références membres de classe sont à manipuler avec encore plus de précautions que les pointeurs membres. Certes, les pointeurs membres "nus" nécessitent en général la définition du destructeur, du constructeur de copie, et de l'opérateur d'affectation, ce qui n'est pas aussi simple d'utilisation que les boost::smart_ptr. Par contre, lorsqu'on a un membre référence, la sémantique de l'opérateur d'affectation va être très difficile à respecter (impossible de changer la référence après-coup), et il n'y a pas de constructeur par défaut automatiquement généré. Cela limite fortement les algorithmes génériques pouvant être appliqués à la classe, car ces deux opérations font très souvent partie des pré-requis des paramètres de classes génériques.

[screetch]

une reference indique une relation 1:1 avec une autre classe. c'est a dire que tu referencesune et une seule instance d'une autre classe ( tu la partage, tu ne la possedes pas ). De plus, tu ne peux pas changer l'objet que tu references.

les pointeurs sont souvent utilisés en relation 0:1 ou meme 0:n (comme une reference optionnelle, ou bien comme un tableau de 0 a n references). de plus cette reference vers une autre instance peut etre changée.

Si tu as une relation "forte" 1:1, alors tu devrais utiliser des references.

En résumé, reference =
-> pointeur faible (pas de partage de propriété)
-> non optionnel (tu dois des le debut pointer vers quelque chose)
-> impossible de "rebinder" sur autre chose

utiliser un pointeur (intelligent ou pas) si l'une de ces contraintes est relachée.

Tu peux verifier que pour les parametres de fonction c'est exactement le cas :
-> pointeur faile (tu ne possedes pas le parametre, c'est l'appelant qui le possede)
-> non optionnel (tu dois toujours passer un parametre ou bien le parametre par defaut)
-> non rebindable : tu ne peux plus, une fois dans la fonction, revenir en arriere pour passer j au lieu de i