FAQ C++Consultez toutes les FAQ

Une r�f�rence est un alias, un nom alternatif pour un objet. Le principe � retenir est que tout se passe comme si c'�tait l'objet lui-m�me et non une r�f�rence sur lui.

Les r�f�rences sont souvent utilis�es lors du passage de param�tres, en particulier avec le mot-cl� const (r�f�rence constante : donc le param�tre pass� est non modifiable) afin de rendre l'appel � la fonction plus performant sur des objets volumineux. Sans le mot-cl� const l'usage d'une r�f�rence indique alors que le param�tre est modifi� par la fonction.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// fonction qui �change i et j 
void swap(int& i, int& j) 
{ 
    int tmp = i; 
    i = j; 
    j = tmp; 
} 
  
int main() 
{ 
    int x = 1; 
    int y = 2; 
    swap( x, y ); 
    // x = 2, y = 1 
}

• D�placer le & de l'appelant � l'appel� ;
• Supprimer les notations *s.
  

L'�tat du r�f�rent (le r�f�rent est l'objet auquel la r�f�rence se rapporte) est modifi�.

Le r�f�rent est la r�f�rence, donc toute modification faite � la r�f�rence est faite au r�f�rent. Au niveau du compilateur, une r�f�rence est une � lvalue �, c'est-�-dire qu'il peut appara�tre � la gauche d'un op�rateur d'affectation.

L'appel de fonction peut se trouver � la gauche d'un op�rateur d'assignation.

Cette possibilit� peut sembler �trange au premier abord. Par exemple, personne ne penserait que l'expression f() = 7; ait un sens. Par contre, si a est un objet de la classe Array, la plupart des gens trouveront que a[i] = 7; a un sens, m�me si a n'est qu'un appel de fonction cach� (c'est en fait l'appel de l'op�rateur Array::operator [](int), qui est l'op�rateur d'indexation de la classe Array)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Array { 
public: 
    int size() const; 
    float& operator[] (int index); 
    ... 
}; 
  
int main() 
{ 
    Array a; 
    for (int i = 0; i < a.size(); ++i) 
        a[i] = 7;    // cette ligne appelle Array::operator[](int) 
    ... 
}

Ce n'est pas possible.

On ne peut pas s�parer le r�f�r� de sa r�f�rence.

Contrairement aux pointeurs, lorsqu'une r�f�rence est li�e � un objet, elle ne peut pas �tre r�affect�e � un autre objet. La r�f�rence en elle-m�me n'est pas un objet (elle n'a pas d'identit� : prendre l'adresse d'une r�f�rence retourne l'adresse du r�f�rent).

De ce point de vue, une r�f�rence est similaire � un pointeur constant

int* const p

const int* p

Lorsque l'on compare le code ex�cutable g�n�r� lors de l'utilisation d'un pointeur et celui g�n�r� lors de l'utilisation d'une r�f�rence, on remarque qu'il est strictement identique.

Cependant la r�f�rence a l'�norme avantage sur le pointeur d'apporter une garantie de non nullit�, et de respecter la constance.

De plus, on ne peut envisager de d�clarer une r�f�rence qu'en lui indiquant directement l'objet dont elle se fait l'alias.
Ainsi, alors que Type * ptr; sera accept�, Type & ref; sera refus�.
De plus, lorsque, dans une fonction, on r�cup�re un pointeur, on n'est pas toujours (rarement�?) assur� que ce pointeur est non NULL, il va donc falloir souvent le v�rifier par un

if (mon_pointeur!=NULL) {...}

• que l'on ne peut pas modifier l'objet ;
• que l'on ne peut pas d�cider de se servir de la r�f�rence comme alias pour un autre objet.
  

• Lorsqu'il s'agit de passer un argument optionnel ou pouvant ne pas exister, on passe alors un pointeur NULL�;
• Lorsqu'il s'agit d'avoir une r�f�rence vers un objet optionnel ou pouvant ne pas exister (on utilise alors un pointeur sur l'objet dont l'adresse initialis�e est NULL)�;
• Lorsque tu as besoin de cr�er un objet polymorphique et que le type de l'objet � cr�er se d�termine selon les circonstances�;
• Lorsque, confront� � une relation � conteneur � contenu �, le contenu doit disposer d'une r�f�rence sur le conteneur�;
• Lorsque l'on souhaitera pouvoir modifier l'objet auquel on se r�f�re.
  

1
2
3
4
5
Type& fonction() 
{ 
    Type tmp; 
    return tmp; 
} // tmp est d�truit

Le terme handle est utilis� pour d�signer n'importe quelle technique qui permet de manipuler un autre objet (un genre de pseudo pointeur g�n�ralis�). Ce terme est (volontairement) ambigu et peu pr�cis.

L'ambigu�t� est un avantage dans certains cas. Par exemple, au tout d�but du design vous ne serez peut-�tre pas pr�t � adopter une repr�sentation sp�cifique pour d�signer les handles. Vous ne serez peut-�tre pas s�r du choix � faire entre les simples pointeurs, les r�f�rences, les pointeurs de pointeurs, les r�f�rences de pointeurs, ou encore des tableaux indic�s, ou des tables de hachage, ou des bases de donn�es ou n'importe quelle autre technique. Si vous savez que vous aurez besoin de quelque chose qui identifiera de fa�on unique un objet, appelez cette chose un handle.

Si votre but final est de permettre � une portion de code d'identifier/rechercher un objet sp�cifique d'une classe d'un certain type (par ex. Fred), vous devrez passer un handle sur Fred � cette portion de code. Le handle peut �tre une cha�ne qui peut-�tre utilis�e comme une cl� dans une table de recherche bien connue. Par exemple, une cl� dans

std::map<std::string,Fred>

std::map<std::string,Fred*>

Fred* array = new Fred[maxNumFreds]