Discussion :

[Invité]

Bonjour,
Sans vouloir vous déranger, j'aurais aimé avoir confirmation sur quand utiliser les références : sur le cours c++ de Henri Garreta il est expliqué ceci :

Code :

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

1
2
&r=i // on initialise la ref à la valeur de i
r=j // ici c'est la valeur référencée qui prend la valeur de j

D'après ce que j'ai un peu compris sur l'utilité des références c'est que ça ne fait pas de copie lors du passage des paramètres dans les fonctions.
Bref : ça fait comme les pointeurs.

Alors quand utiliser les pointeurs et quand utiliser les références ? Je pense notamment à la librairie Qt : certaines fonctions utilisent les réf et d'autres les pointeurs : ma question est pourquoi pas uniquement les références ou uniquement les pointeurs ?

Merci il faudra créer des clans : les "pro-références" et les "pro-pointeurs" et les "pro-centre" (pro-références et pro-pointeurs) mdr

Bonne journée à bientôt.

[gbdivers]

Bonjour

Quelques éléments de réponse dans la discussion sur les pointeurs intelligents, qui aborde aussi les références (et accessoirement dans la discussion sur les const)

Et bien sur, avant cela, lire la FAQ sur les pointeurs et sur les références.

[Invité]

Merci. J'aurais également voulu avoir l'avis de certains programmeurs ici présents. Sans aller jusqu'à créer un débat ça n'est pas le but non-plus.

[mister3957]

Pointeur ou référence.. C'est pas bien une question de "goût" je pense.

La grosse différence est qu'un pointeur peut être nul. Choisir un passage par référence impose que la variable soit définie :

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
 
struct SSize
{
  int Width;
  int Height;
};
 
// Possibilité de récupérer soit la largeur, soit la hauteur, soit les deux, soit rien
void GetSize(int* iWidth, int* iHeight)
{
  if(iWidth)
    *iWidth = [...];
  if(iHeight)
    *iHeight = [...];
}
 
// Obligation de passer une structure
void GetSize(SSize& oSize)
{
  oSize.Set([...], [...]);
}

[koala01]

Salut

Pointeur ou référence.. C'est pas bien une question de "goût" je pense.

La grosse différence est qu'un pointeur peut être nul. Choisir un passage par référence impose que la variable soit définie :

Et, surtout, un pointeur peut être réaffecté, alors qu'une référence ne peut pas l'être.

De plus, les références transmettent beaucoup plus facilement la constance des objets, alors que, au niveau des pointeurs, ce peut être l'objet pointé qui est constant, mais pas le pointeur, le pointeur qui est constant mais pas l'objet pointé, ou enfin, le pointeur et l'objet pointé qui sont constants.

On peut, parfaitement, n'envisager de n'utiliser que des pointeurs (c'est d'ailleurs bien simple: les références n'existent pas en C, et aucun Ciste n'en est mort ), mais on se prive alors d'une série de possibilités qui apportent, au final, une sécurité et une facilité accrue.

Les pointeurs et les références permettent tous deux d'éviter la copie de l'objet passé en argument, mais que se passera-t-il si ce que l'on veut passer n'existe pas encore bien que l'on dispose de toutes les informations pour le créer

Avec un pointeur, nous pouvons décider de créer l'objet "sur le vif" sous une forme proche de

Code :

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

foo(new Type(/* arguments éventuels*/));

mais nous avons aussi toujours la possibilité de prendre l'adresse d'un objet existant sous la forme de

Code :

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

1
2
Type t(/*arguments éventuels*/);
foo(&t);

Le problème vient alors du fait que dans le premier cas, il faudra soit veiller à récupérer le pointeur en sortie de fonction soit veiller à libérer correctement la mémoire qui lui a été allouée au sein de la fonction même, alors que dans le deuxième cas, il n'y a, simplement, rien à faire.

Mais nous ne disposons d'aucun moyen de déterminer dans quel cas nous serons à l'intérieur de foo. Nous risquons donc soit d''oublier de libérer la mémoire allouée dynamiquement au pointeur, et donc de provoquer une fuite mémoire, soit d'essayer de libérer dynamiquement de la mémoire qui n'a pas lieu de l'être.

Avec les références, et surtout les références constantes, il est possible de créer ce que l'on appelle une "variable temporaire anonyme", c'est à dire une variable qui n'existera que pour la durée de l'exécution de la fonction pour laquelle elle est créée.

Et comme les références ne sont pas associées à l'allocation dynamique de la mémoire, nous n'aurons aucun problème: chaque variable sera automatiquement détruite lorsque nous quitterons la portée dans laquelle elle est déclarée.

Au final, la bonne attitude est d'utiliser les références "chaque fois que faire se peut", et surtout, lorsque l'utilisation d'un pointeur nécessiterait le recours à l'opérateur "address of" ( & ), et les pointeurs "lorsque l'on n'a vraiment pas le choix": Quand l'objet peut ne pas exister, que l'on peut décider de changer l'objet référencé en "cours de route", ou, enfin, lorsque l'on a de toutes manière besoin d'un pointeur pour profiter de l'allocation dynamique à but polymorphique.

[Invité]

Merci pour ces réponses Messieurs. C'est toujours bon d'avoir les avis. N'empêche que ça sent le vécu tout ça...
Et effectivement dans la librairie Qt les références semblent être utilisées avec le mot const devant.
Leur utilisation semble toutefois plus simple et moins dangereuses que les pointeurs. J'ai pu voir que l'utilisation des pointeurs paraît ici pour certains dangereux voir "suicidaire".
Ok je mets résolu.

[3DArchi]

Pointeur ou référence.. C'est pas bien une question de "goût" je pense.

La grosse différence est qu'un pointeur peut être nul. Choisir un passage par référence impose que la variable soit définie :

Yep.
Je passe des pointeurs quand la valeur NULL est une valeur valide et des références quand on doit forcément passer un objet valide. Typiquement si dans ton code tu commences par if(ptr==NULL){gestion_erreur();} alors c'est une référence qu'il faut passer.