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]