Qu'est-ce qu'une variable de référence en C++?
Quelle serait une brève définition d'une variable de référence en C++?
Un reference est une entité qui est un alias pour un autre object.
Une référence n'est pas une variable, car une variable n'est introduite que par la déclaration d'un objet. Un objet est une région de stockage et, en C++, les références n'utilisent pas (nécessairement) de stockage.
Comme objects et references sont des groupes distincts d’entités en C++, le terme "variable de référence" n’a pas de sens.
Une variable de référence fournit un alias (nom alternatif) pour une variable définie précédemment . Par exemple:
float total=100;
float &sum = total;
Cela signifie que total et sum sont les mêmes variables.
cout<< total;
cout << sum;
Les deux vont donner la même valeur, 100. Ici l'opérateur & n'est pas l'opérateur d'adresse; float & signifie une référence à float.
Une variable de référence est un alias (un nom alternatif) pour un objet . [De la FAQ C++].
Le premier paragraphe de l'article Wikipedia pourrait facilement servir de brève définition:
Dans le langage de programmation C++, une référence est un type de données de référence simple, moins puissant mais plus sûr que le type de pointeur hérité de C.
Et citant le même article:
Les références C++ diffèrent des pointeurs de plusieurs manières essentielles:
Il n'est pas possible de se référer directement à un objet de référence après sa définition. toute occurrence de son nom fait directement référence à l'objet référencé.
Une fois la référence créée, il ne peut plus être fait référence à un autre objet. il ne peut pas être remis en place. Cela se fait souvent avec des pointeurs.
Les références ne peuvent pas être nulles, alors que les pointeurs peuvent; chaque référence fait référence à un objet, bien que cela puisse être valide ou non.
Les références ne peuvent pas être non initialisées. Comme il est impossible de réinitialiser une référence, celles-ci doivent être initialisées dès leur création. En particulier, les variables locales et globales doivent être initialisées à l'endroit où elles sont définies, et les références qui sont des données membres d'instances de classe doivent être initialisées dans la liste des initialiseurs du constructeur de la classe.
Lectures complémentaires:
Une variable référence est un alias pour le nom de variable .
Il est différent des pointeurs des manières suivantes:
- Vous ne pouvez pas avoir de références NULL. Vous devez toujours pouvoir supposer qu'une référence est connectée à un élément de stockage légitime.
- Une fois qu'une référence est initialisée à un objet, elle ne peut pas être modifiée pour pointer vers un autre objet, tandis que dans le cas d'un pointeur, nous pouvons le faire pointer vers un autre objet à tout moment.
- Une référence doit être initialisée à l'heure de sa création. Les pointeurs peuvent être initialisés à tout moment.
C'est une variable qui références une autre:
int foo;
int& bar = foo;
bar est maintenant une référence, ce qui revient à dire que bar contient l'emplacement de la mémoire où se trouve foo.
Voir ici pour plus d'informations.
Les références C++ vous permettent de créer un second nom pour la variable que vous pouvez utiliser pour lire ou modifier les données d'origine stockées dans cette variable.
Pour plus de détails, visitez:
Les variables de référence permettent à deux noms de variable d’adresser le même emplacement mémoire:
int main()
{
int var1;
// var2 is a reference variable, holds same value as var1
int &var2 = var1;
var1 = 10;
std::cout << "var1 = " << var1 << std::endl;
std::cout << "var2 = " << var2 << std::endl;
}
Ressource: LINK
Une référence est une étiquette alternative, un alias, pour l'objet avec lequel elle est initialisée. Une fois qu'une référence est initialisée, elle ne peut plus être modifiée pour devenir une étiquette ou un alias alternatif d'un autre objet. Après l’initialisation, la référence ou la variable d’objet peuvent être utilisées de manière interchangeable.
Une référence présente certaines des caractéristiques d'un pointeur const sur un objet en ce sens qu'elle est initialisée lorsqu'elle est définie. Et bien que ce qui est référencé ou pointé puisse être changé, la référence ou le pointeur const lui-même ne peut pas être changé. Cependant, étant donné qu'une référence est une étiquette ou un alias alternatif, elle peut ou non exister en tant qu'objet de données, contrairement à un pointeur const qui existera probablement à moins que le compilateur ne puisse l'optimiser. Et même si une référence est créée en tant qu’entité réelle par le compilateur, il s’agit bien de la gestion interne du compilateur et elle doit être ignorée car elle n’existe officiellement pas beaucoup comme l’homme qui se cache derrière le rideau dans la Cité d’Émeraude.
Les exemples de code suivants donnent des exemples de comparaison et de contraste de référence avec pointeur et pointeur const:
int myInt; // create a variable of type int, value not initialized
int myInt2 = 3; // create a second variable of type int with a value of 3
int &rInt = myInt; // create a reference to the variable of type int, myInt
rInt = 5; // myInt now has a value of 5, the reference is an alias for myInt
rInt++; // myInt now has a value of 6, the reference is an alias for myInt
rInt = myInt2; // myInt now has the same value as myInt2, a value of 3
int *pInt = &rInt; // pInt points to myInt
(*pInt)++; // increments myInt
pInt++; // increments the pointer which formerly pointed to myInt
int &rInt2; // error C2530: 'rInt2' : references must be initialized
int *pInt2; // just fine, uninitialized pointer is ok
int * const pInt3; // error C2734: 'pInt3' : const object must be initialized if not extern
int * const pInt4 = &myInt; // define and initialize const pointer
pInt4 = &myInt2; // error C3892: 'pInt4' : you cannot assign to a variable that is const
Il existe en fait deux types de références: une référence lvalue et une référence rvalue.
Une référence lvalue est la même référence dans le langage C++ avant C++ 11. Une référence rvalue a été introduite dans C++ 11 pour permettre la référence à un objet temporaire afin de faciliter le déplacement plutôt que la copie, ainsi que d'autres actions pour lesquelles une copie est une mauvaise approche alors qu'un déplacement est une bonne approche.
Par exemple, une comparaison des références lvalue et rvalue dans les lignes sources simples suivantes. Comme il s’agit de références int, cela signifie qu’une affectation d’une valeur autre qu’un entier entraîne l’obtention par le compilateur d’une conversion qui aboutit à une variable temporaire. Une référence rvalue peut se lier à une variable temporaire et une référence lvalue ne le peut pas.
// assign a double to an int causing creation of temporary
int &rIntd1 = 1.2; // error C2440: 'initializing' : cannot convert from 'double' to 'int &'
int &&rIntd2 = 1.2; // warning C4244: 'initializing' : conversion from 'double' to 'int', possible loss of data
rInt = rIntd2; // myInt from the code above now has a value of 1, 1.2 was truncated when converting from double to int
Une variable référence et une variable pointeur sont identiques à la machine (le compilateur générera le même code machine).
Les avantages les plus évidents de l'utilisation d'une variable de référence par rapport à une variable de pointeur à ma connaissance:
- Facile à comprendre (pas d'adresse, déréférencer toutes sortes de maux de tête)
- Vous enregistre un petit peu de typing, et donc probablement moins sujet aux erreurs.
Dans le code ci-dessous, le côté gauche utilise une variable de référence et le côté droit utilise une variable de pointeur. C’est la même chose pour la machine, mais vous voyez que la variable de référence using vous épargne un peu de frappe.
Reference variable Pointer variable
int a = 1; ~~~~~~ int a = 1;
int &b = a; ~~~~~~ int *b = &a;
b = 2; ~~~~~~ *b = 2;
cout << a << '\n' ~~~~~~ cout << a << '\n'
==============================================
2 ~~~~~~ 2
Une référence est un nom alternatif pour un objet. Une variable de référence fournit un alias pour les variables précédemment définies. Une déclaration de référence consiste en un type de base et une variable de référence assimilée à un nom de variable.
Variables de référence (let a), dites simplement, pour faciliter la compréhension, un autre nom de variable (let x), qui contient exactement le même emplacement mémoire que celui de x.
int &a = x; indique qu'un emplacement contient le même emplacement mémoire que celui de x.
Par exemple, supposons que deux colocataires partagent la même pièce. Un nom d'amis est x et un autre nom d'amis est a. Si a modifie l'emplacement de la table placée dans la salle, de la position (x,y,z) à (x1,y1,z1), les modifications sont alors visibles pour l'ami x et vice versa.
Page 79 ~ 80 C++ Primer 5th ed.
Object : Une région de la mémoire qui a un type
Variable : Objet nommé ou référence
Référence: Un alias pour un autre objet.