Discussion :

[Matthieu76]

Bonjour, ma question est simple :
Y-a-t'il une différence entre

Code :

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

1
2
3
4
void foo(int* v);
// ...
int* x;
foo(x);

et

Code :

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

1
2
3
4
void foo(int &v);
// ...
int x;
foo(*x);

?

[dalfab]

Aucun des exemples ne passe un pointeur par référence!
Le premier passe un pointeur par valeur.
Le second utilise une l-reférence (et il ne faut pas utiliser d'étoile à l'appel)

Un pointeur référence, c'est cela

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int a;
void fct( int*& r ) {  // passage par référence d'un pointeur
   r = &a;
}
int main() {
   int *x;             // pointeur pas encore initialisé
   fct( x );
   assert( x == &a );  // le pointeur pointe bien sur a
}

[Matthieu76]

Code :

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

1
2
3
4
void foo(truc &v);
// ...
truc* x;
foo(*x);

Pardon, je voulais écrire ça pour le 2e cas.
Comme ça je peux utiliser truc.machin() au lieu de truc->machin() dans la fonction foo.

Ça fonctionne correctement mais j'ai l'impression que c'est ultra stupide de faire comme ça

[survivals]

Intéressant

Je vais bientôt refaire du C/C++

Il n'y avait pas de différences réellement entre les pointeurs et les références ? Sûr ? Il me semble pourtant, c'est pas qu'une question de confort, il aurait pas fait ça ? Si ?

[dalfab]

Les pointeurs et mes références sont deux principes différents.

• Le pointeur est une variable qui peut en désigner une autre.
  Un pointeur peut ne rien désigner (pointeur nul) et peut changer de valeur pour désigner autre chose. On peut pointer sur un pointeur ou avoir un tableau de pointeurs ou les référencer.
• Une référence c'est un alias vers une variable.
  Elle est associée à toujours la même variable et ne correspond jamais à nul. On ne peut pas pointer sur une référence, référencer une référence ou les mettre en tableau.
  On distingue les l-références qui référencent une l-value (donc une variable ou une allocation du tas) et les r-références qui référencent les temporaires et les x-values.
  Une référence peut "prolonger la vie" d'un temporaire; La temporaire associée à une const l-référence ou à une r-référence ne sera détruite qu'à la fin de vie de la référence.

On peut donc choisir de passer un paramètre par référence ou son adresse par un pointeur. Les 2 rendent un service similaire dans ce cas. On doit normalement préférer l'utilisation de la référence à celui d'un pointeur.

Code :

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

1
2
3
4
5
6
7
8
9
Objet fct();
void fct2( Objet const& );
void fct3( Objet const* );
{  Objet const& x = fct(); // La fct a retourné un 1er objet, x le référence
    fct2( fct() );         // La fct a retourné un 2nd objet qui est détruit dès le retour de fct2() 
    fct3( &fct() );        // impossible!!
    fct3( &x );            // Ok, on transmet un pointeur sur 1er objet
   ...
}             // x est détruite, Le 1er objet est détruit

[Bousk]

Code :

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

1
2
3
4
void foo(truc &v);
// ...
truc* x;
foo(*x);

Pardon, je voulais écrire ça pour le 2e cas.
Comme ça je peux utiliser truc.machin() au lieu de truc->machin() dans la fonction foo.

Ça fonctionne correctement mais j'ai l'impression que c'est ultra stupide de faire comme ça

Si tu espères passer un pointeur par référence, il faut commencer par l'écrire.
Là tu as... une référence. Où vois-tu un pointeur dans ta signature ?
void foo(truc* &v);
Et à moins que ta fonction modifie le pointeur (et non que les données pointées), oui ça n'a aucun intérêt.

[Luc Hermitte]

Code :

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

1
2
3
4
void foo(truc &v);
// ...
truc* x;
foo(*x);

Pardon, je voulais écrire ça pour le 2e cas.
Comme ça je peux utiliser truc.machin() au lieu de truc->machin() dans la fonction foo.

Ça fonctionne correctement mais j'ai l'impression que c'est ultra stupide de faire comme ça

Au contraire. C'est très intelligent: tu affirmes depuis la fonction appellée "Tu DOIS me passer un truc valide". Il te manque toutefois une vérification depuis la fonction appelante.

Dit autrement, les codes clients valides (à supposer que tu partes d'un pointeur) sont:

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
// truc *x = ...
 
// soit 1:
assert(x && "Ouhla! ce n'est pas censé se produire ce truc!!"); // si tu sais que la nullité n'a pas de sens
foo(*x);
// C'est un cas à rapprocher de 
// gsl::non_null<truc> x = ... // Cf les C++ Core Guidelines et GSL
 
 
// soit 2:
// si tu sais que la validité de x est liée à une entrée externe que tu ne peux pas controler et que tu ne pourras pas connaitre avant l'exécution
if (!x) throw std::runtime_error("entrée utilisateur non valide");
foo(x);

Mais on peut aussi partir de valeurs optionnelles (C++17)

Code c++ :

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

1
2
std::optional<truc> x = ...;
if (x) foo(*x);

Tu peux te reférer à mes 3 billets sur la programmation par contrat en C et C++. Les deux premiers ont été republiés sur dvpz -- j'ai de la relecture à faire avant de faire pareil avec le 3e.

Il n'y avait pas de différences réellement entre les pointeurs et les références ? Sûr ? Il me semble pourtant, c'est pas qu'une question de confort, il aurait pas fait ça ? Si ?

Il y a une différence côté invariants: avec une référence que tu affirmes que ce n'est pas censé être nul donc. C'est plus qu'une simple question de confort.

Après, techniquement parlant, dans le cas des variables, avec une référence, il y a plus de chances que le compilateur dégage la variable qu'avec un pointeur.

Code C++ :

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

1
2
3
4
int a = 42;
int &j = a; // aucune chance d'avoir une existance propre
 
int *p = a; // aura une existance propre en debug, en release, je ne saurai dire

[ternel]

Après, si ta question est "Est-il idiot de passé un pointé par référence?", la réponse est non.

Un pointeur et une référence remplissent un rôle similaire: désigner quelque chose.
Le pointeur est comme un panneau, tu peux le changer de direction, mais il faut aller à la destination pour y trouver la chose.
La référence est plus comme un hologramme du désigné, tu ne peux pas changer ce qui est reproduit, mais tu n'as pas besoin d'aller le chercher.