À propos des références, laissez-moi d'abord raconter une histoire : dans la cour où nous vivons, il y a un petit enfant nommé Luo XX. Nous aimons lui donner un surnom. Voyant qu'il n'était pas bien nourri, avec une tête relativement grosse et un corps relativement petit, nous lui avons donné le surnom de « Tête de radis ». Donc Luo XX est son vrai nom, et Tête de radis est son alias. Alors, qu'est-ce qu'une référence ??

Définition :Référence : c'est un alias d'une variable.

Remarque :Pour ce qui est d'un alias, une variable ne peut pas avoir uniquement un alias sans son propre nom réel.

Références vers les types de données de base

Comme dans l'extrait de code suivant :

Exemple

#include <iostream> using namespace std; { int a = 3; int &b = a; //b est une référence à a, c'est-à-dire que b est un alias de a. //Une référence doit être initialisée, sinon la compilation signalera une erreur b = 10; cout<< a << endl; //À ce stade, la valeur de a est passée de 3 à 10, car quoi que nous fassions avec l'alias, nous opérons en réalité sur la variable elle-même. Comme si nous demandions à Tête de Radis de faire quelque chose, c'est Luo XX lui-même qui le fera. return 0; }

Références aux types de structure

Comme dans l'extrait de code suivant :

Exemple

#include <iostream> using namespace std; //Définir une structure nommée Coor, qui est une coordonnée. typedef struct { int x; int y; }Coor; int main(void) { Coor c1; //Définir une variable de structure nommée c1. Coor &c = c1; //Donner à c1 un alias appelé c. c.x = 10; //Attribuer des valeurs aux membres de données de la variable de structure par la référence c.y = 20; cout<< c1.x << c2.y; //Le résultat affiché : 10 20 return 0; }

Références aux types de pointeur

Les références de type pointeur sont la partie la plus complexe et la plus difficile à comprendre des références, et elles possèdent également des particularités dans leur forme syntaxique.

Définition :

Type *&pointerReferenceName = pointer;

Regardons un exemple :

Exemple

#include <iostream> using namespace std; int main(void) { int a = 10; //Définir une variable entière a, avec la valeur de a valant 10. int *p = &a; //Définir un pointeur pointant vers la variable a int *&q = p; //Définir une référence vers un pointeur, c'est-à-dire que q est un alias de p. Méthode de définition : Type *&pointer_reference_name = pointer; *q = 20; //Affecter 20 à *q, ce qui équivaut à affecter 20 à *p, et donc à affecter 20 à a. cout<< a << endl; //La valeur de sortie de a est 20. return 0; }

Les références en tant que paramètres de fonction

Avant d'apprendre les références, lorsque nous étudiions le langage C, nous avons appris un programme classique comme celui-ci :

//Échanger les deux valeurs void fun( int *a,int *b) //Les paramètres formels sont deux variables de pointeur d'entier { int temp = 0; //Définir une variable temporaire. Une bonne habitude consiste à définir une variable et à l'initialiser ; c = *a; //Assigner *a à c ; *a = *b; //Assigner *b à *a ; *b = c; //Ensuite, assigner c à *b ; cela termine l'échange des valeurs de a et b } int x = 10,y = 20; fun(&x,&y); //Lors de l'appel dans la fonction main, les arguments effectifs transmis doivent être écrits sous la forme &a, &b, ce qui est fastidieux et difficile à comprendre.

Maintenant que nous avons appris les références, à quoi cela devrait-il ressembler pour obtenir la même fonctionnalité ?

Exemple

void fun (int &a, int &b) //Les paramètres formels sont deux références d'entiers { int temp = 0; temp = a; a = b; b = temp; } int x = 10,y = 20; fun(x,y); //Lors de l'appel dans la fonction main, après que les arguments effectifs sont transmis, a est un alias de x, et b est un alias de y.

Adresse d'origine : https://blog.csdn.net/stop_and_go/article/details/51334137