referencias C ++

Una variable de referencia es un alias , es decir, es un nombre de otra variable que ya existe. Una vez que la referencia se inicializa a una variable, puede utilizar el nombre de referencia o el nombre de la variable a punto a la variable. Otra forma de realización está representada por puntero de referencia.

Referencias y diferencias de puntero:

Es fácil confundir con las referencias de puntero, hay tres principales diferencias entre ellos:

La referencia no puede estar vacío.
No se puede modificar después de la referencia especificada.
Referencia debe ser inicializado cuando se creó.

Uso básico

Type& ref = val;

caso:

#include <iostream>
using namespace std;

int main ()
{
    // 声明简单的变量
    double d;

    // 声明引用变量
    // 相当于给变量取一个别名
    double& s = d;

    // 操作引用就相当于操作本身
    s = 11.7;
    cout << "Value of d : " << d << endl;
    cout << "Value of d reference : " << s  << endl;

    // 一个变量可以有多个别名
    double& y = d;
    cout << "Value of other reference : " << y  << endl;

    // 引用的地址都相同
    cout << "d:" << &d << endl;
    cout << "s:" << &s << endl;
    cout << "y:" << &y << endl;

    return 0;
}

los resultados

Value of d : 11.7
Value of d reference : 11.7
Value of other reference : 11.7
------------
d:0x7ffc8cd21468
s:0x7ffc8cd21468
y:0x7ffc8cd21468

Notas referencias

#include <iostream>
using namespace std;

int main ()
{
    //1. 引用必须初始化
    //int& ref; //报错:必须初始化引用
    
    //2. 引用一旦初始化，不能改变引用
    int a = 10;
    int b = 20;
    int& ref = a;
    ref = b; //不能改变引用
    // ref = b; 作用等价于 a = b;
    
    //3. 不能直接对数组建立引用
    int arr[10];
    //int& ref2[10] = arr;
    return 0;
}

En referencia a una matriz

//1. 建立数组引用方法一
//   通过 typedef 定义类型来使用引用
typedef int ArrRef[10];
int arr[10];
ArrRef& aRef = arr;
for (int i = 0; i < 10;i ++){
    aRef[i] = i+1;
}
for (int i = 0; i < 10;i++){
    cout << arr[i] << " ";
}
cout << endl;

//2. 建立数组引用方法二
int(&f)[10] = arr;
for (int i = 0; i < 10; i++){
    f[i] = i+10;
}
for (int i = 0; i < 10; i++){
    cout << arr[i] << " ";
}
cout << endl;

Los resultados:

1 2 3 4 5 6 7 8 9 10 
10 11 12 13 14 15 16 17 18 19

En referencia a la función

** El lugar más común para ver las referencias en los parámetros de función y los valores de retorno. ** Cuando el parámetro de función se utiliza como referencia, cualquier modificación a las referencias, fuera de los parámetros producirán un cambio en la función de la función. Por supuesto, por los que pasa un puntero a hacer lo mismo, pero la referencia a una sintaxis más clara.

Si devuelve una referencia desde una función, debe ser tratado como un puntero devuelto desde la función de la misma. Cuando la función devuelve debe existir un valor asociado con una memoria de referencia.

parámetros de referencia utilizados en la función

//值传递
void ValueSwap(int m,int n){
	int temp = m;
	m = n;
	n = temp;
}
//地址传递
void PointerSwap(int* m,int* n){
	int temp = *m;
	*m = *n;
	*n = temp;
}
//引用传递
void ReferenceSwap(int& m,int& n){
	int temp = m;
	m = n;
	n = temp;
}
void test(){
	int a = 10;
	int b = 20;
	//值传递 没有交换效果
	ValueSwap(a, b);
	cout << "a:" << a << " b:" << b << endl;
	//地址传递
	PointerSwap(&a, &b);
	cout << "a:" << a << " b:" << b << endl;
	//引用传递
	ReferenceSwap(a, b);
	cout << "a:" << a << " b:" << b << endl;
}

los resultados

a:10 b:20
a:20 b:10
a:10 b:20

Referencia sintaxis más clara simple:

Argumentos pasados cuando la llamada de función no añaden &carácter
En la función llamada no necesita ser añadido antes del parámetro *Fu

Existen alias incorporado otras variables, por lo tanto, en algunas aplicaciones puede reemplazar el puntero. C ++ defensor aprobada por modo de transferencia de dirección de referencia, y menos propenso a errores sustituido porque la sintaxis es fácil referencia.

Se utiliza en referencia al valor de retorno de la función

//返回局部变量引用
int& TestFun01(){
	int a = 10; //局部变量
	return a;
}
//返回静态变量引用
int& TestFunc02(){	
	static int a = 20;
	cout << "static int a : " << a << endl;
	return a;
}
int main(){
	//不能返回局部变量的引用
    // 返回错误: warning: reference to local variable ‘a’ returned
	int& ret01 = TestFun01();
	//如果函数做左值，那么必须返回引用
	TestFunc02();
	TestFunc02() = 100;
	TestFunc02();

	return 0;
}

los resultados

static int a : 20
static int a : 20
static int a : 100

precauciones

No se puede devolver una variable hace referencia locales .
Cuando el valor de función izquierda , debe devolver una referencia.

El puntero de referencia

En lugar de señalar que apunta al contenido, las declaraciones de funciones en lenguaje C si desea cambiar un puntero poder de esta manera:

void fun(int**); // 声明二级指针

variable de puntero a un alias.

Type* pointer = NULL;  
Type*& = pointer;

caso:

struct Person{
	int mAge;
};
//指针间接修改teacher的年龄
void AllocateAndInitByPointer(Person** person){
	*person = (Person*)malloc(sizeof(Person));
	(*person)->mAge = 200;  
}
//引用修改teacher年龄
void AllocateAndInitByReference(Person*& person){
	person->mAge = 300;
}
void test(){
	//创建Teacher
	Person* person = NULL;
	//指针间接赋值
	AllocateAndInitByPointer(&person);
	cout << "AllocateAndInitByPointer:" << person->mAge << endl;
	//引用赋值,将teacher本身传到ChangeAgeByReference函数中
	AllocateAndInitByReference(person);
	cout << "AllocateAndInitByReference:" << person->mAge << endl;
	free(person);
}

los resultados

AllocateAndInitByPointer:200
AllocateAndInitByReference:300

parámetros de puntero de función conviertan en una referencia, no es necesario para obtener la dirección del puntero.

Las constantes referencias

constante referencia a la definición del formato:

const Type& ref = val;

nota:

referencias literales no se pueden asignar, pero se puede asignar una referencia const
referencia const modificado, no puede ser modificado .

void test01(){
	int a = 100;
	const int& aRef = a; // 此时aRef就是a
	// aRef = 200; 不能通过aRef的值
	a = 100; //OK
	cout << "a:" << a << endl;
	cout << "aRef:" << aRef << endl;
    // 执行结果:
    // a:100
	// aRef:100
}
void test02(){
	// 不能把一个字面量赋给引用
	// int& ref = 100;
	// 但是可以把一个字面量赋给常引用
	const int& ref = 100; 
    // 等价于: int temp = 100; const int& ret = temp;
}

const escenarios de uso de referencia

referencia Constant utiliza principalmente en el parámetro de la función , en particular, las copias de clase / constructor de copia. El parámetro de forma se define como una función de los beneficios de constantes referencias:

No nueva variable de referencia, para reducir la sobrecarga de paso real y parámetro.
Dado que los argumentos de referencia pueden causar cambios con el cambio de parámetro, que se define como una referencia constante puede eliminar tales efectos secundarios .

Si desea cambiar a medida que se cambia el parámetro argumento, a continuación, utilizando una referencia general, yo no quiero cambiar el parámetro como argumento, a continuación, utilizar una referencia constante.

//const int& param防止函数中意外修改数据
void ShowVal(const int& param){}

La naturaleza de las referencias

Naturaleza de referencia interna se implementa en c ++ puntero es una constante

Type& ref = val; // Type* const ref = &val;

compilador de C ++ durante la compilación se utiliza a menudo como un indicador de referencia interno implementado, el mismo espacio de referencia ocupado por el puntero, pero este proceso es una implementación del compilador interno, invisible para el usuario.

//发现是引用，转换为 int* const ref = &a;
void testFunc(int& ref){
	ref = 100; // ref是引用，转换为*ref = 100
}
int main(){
	int a = 10;
	int& aRef = a; //自动转换为 int* const aRef = &a;这也能说明引用为什么必须初始化
	aRef = 20; //内部发现aRef是引用，自动帮我们转换为: *aRef = 20;
	cout << "a:" << a << endl;
	cout << "aRef:" << aRef << endl;
	testFunc(a);
	return 0;
}