Discussion :

[mister3957]

Bonjour à tous,

Je me remet un peu à jour en terme de connaissances basiques sur le C++.

Je voudrais savoir la différence entre un passage par référence et un par pointeur:

Code :

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

1
2
3
4
 
MaFonction1(int &x); // Par référence
MaFonction2(int *x); // Par pointeur
MaFonction2(int x); // Par valeur

Je vois bien la différence entre par valeur et par référence/pointeur.

Par contre, c'est la différence entre par pointeur et par référence qui me dérange.
Dans le cas d'un pointeur, on économise la copie de l'argument au profit d'une simple copie d'adresse mémoire (donc en général 4 octets).
Concernant les droits de la fonction, on peut faire :

Code :

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

1
2
3
4
5
 
MaFonction2(int *x);
MaFonction2(const int *x);
MaFonction2(int * const x);
MaFonction2(const int * const x);

Quelques question:
est-ce que on peut faire également

Code :

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

1
2
3
4
5
 
MaFonction2(int &x);
MaFonction2(const int &x);
MaFonction2(int & const x);
MaFonction2(const int & const x);

?

Le passage par pointeur ne nécessite qu'une copie du pointeur passé, le passage par référence, comment se débrouille le compilateur?


Merci beaucoup de m'éclairer là dessus

A bientôt

Aurélien

[ram-0000]

Différence pointeur/reference

Lorsque l'on m'a apris cette notion, le collègue qui m'a enseigné m'a dit:
1/ Une référence, c'est comme un pointeur (juste la syntaxe est différente)
2/ Un pointeur peut être NULL,
3/ Une référence ne peut pas être NULL.

Donc on utilise un pointeur quand cela à un sens qu'il soit NULL, sinon on utilise une référence.

En interne, une référence est gérée comme un pointeur donc c'est les mêmes performances lors du passage de paramètres

[mister3957]

Ok, merci beaucoup

[Jean-Marc.Bourguet]

Différence pointeur/reference

Lorsque l'on m'a apris cette notion, le collègue qui m'a enseigné m'a dit:
1/ Une référence, c'est comme un pointeur (juste la syntaxe est différente)
2/ Un pointeur peut être NULL,
3/ Une référence ne peut pas être NULL.

C'est une première approximation (du moins si on ajoute qu'une référence est automatiquement référencée et ne peut pas être rebindée). Il y a un certains nombres de détails qui font que s'attacher trop fort à cette première approximation pose des problèmes.

Une référence introduit un nom supplémentaire pour un objet. Et si cet objet est temporaire, sa durée de vie va être prolongée pour correspondre à celle de la référence.

Code :

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

std::string const& foo = std::string("bar") + std::string("quux");

par exemple a des effets sur la durée de vie du temporaire qu'il n'est pas possible d'avoir avec des pointeurs.

En interne, une référence est gérée comme un pointeur donc c'est les mêmes performances lors du passage de paramètres

Pour le passage de paramètre, il y a de grandes chances que ce soit le cas. D'autres utilisations de références peuvent être plus transparentes.

Code :

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

struct s { int a, b } x; int & b = x.b;

le compilateur peut très bien ne jamais utiliser de la mémoire pour b.

Donc on utilise un pointeur quand cela à un sens qu'il soit NULL, sinon on utilise une référence.

C'est un critère permettant de choisir. Pas le plus pertinent à mon avis. J'ai beaucoup de mal à préférer

Code :

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

1
2
3
void f(Type& x) {
   delete &x;
}

à l'alternative avec des pointeurs. Même si on ne passe jamais un pointeur nul. Je crois avoir expliqué dans le passé mon point de vue en détail.

[Médinoc]

Bonjour,
Alors, déjà, les réponses "académiques" :

Code C++ :

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

1
2
3
4
int MaFonction2(int &x);              // Oui
int MaFonction2(const int &x);        // Oui
int MaFonction2(int & const x);       // Non: La référence est déjà non-modifiable
int MaFonction2(const int & const x); // Non, pour la même raison.

Puis les réponses "personnelles": Au début, venant du C, j'étais partisans de "Références seulement là où les pointeurs ne marchent pas".
..Mais j'ai, lentement mais sûrement, changé d'avis.

À présent, je conseille d'utiliser les références partout où c'est possible, SAUF s'il est question d'allocation dynamique ou de tableau C-style : Pour moi, une référence désigne un élément et un seul.
Et encore, j'ai aussi tendance à utiliser les pointeurs plutôt que les références dès que je joues avec les fonctions virtuelles.
Ce qui donne:

• Paramètre optionnel : forcément pointeur (pour pouvoir être NULL)
• Paramètre vector : référence
• Paramètre tableau : pointeur
• Paramètre élément particulier d'un tableau ou d'un vector : référence
• Valeur de retour née d'un new : pointeur
• Paramètre sur lequel on fera un delete : pointeur
• Paramètre sur lequel on appelle une méthode virtuelle : Pour moi, généralement pointeur.

[NiamorH]

Paramètre optionnel : forcément pointeur (pour pouvoir être NULL)

Il m'est arrivé d'avoir à écrire ça :

Code :

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

void Truc( const Objet & = Objet() );

[loufoque]

La surchage permet déjà de définir des paramètres optionnels.
Sinon, il y aussi boost.optional.