【C++】引用

1. 基本使用

int main()
{
  int a = 10;
  int &b = a;
  b = 100;
  cout << a << endl;
  cout << b << endl;
  return 0;
}
1
2
3
4
5
6
7
8
9

100
100
1
2

注意：

1. 引用必须初始化（为一个变量（存在地址），否则报错：cannot bind non-const lvalue reference of type 'int&' to an rvalue of type 'int'）。
2. 引用在初始化后，不可以更改指向（但是可以赋值）。
3. 引用的本质在c++内部实现是一个指针常量。

   //发现是引用，转换为 int* const ref = &a;
   void func(int& ref){
   	ref = 100; // ref是引用，转换为*ref = 100
   }
   int main(){
   	int a = 10;
   
       //自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改
   	int& ref = a; 
   	ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
       
   	cout << "a:" << a << endl;
   	cout << "ref:" << ref << endl;
       
   	func(a);
   	return 0;
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17

2. 应用场景

1. 函数传参，引用可以代替指针，简化写法。

//  地址传递
void mySwap02(int* a, int* b) {
	int temp = *a;
	*a = *b;
	*b = temp;
}

//  引用传递
void mySwap03(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2. 引用是可以作为函数的返回值。不要返回局部变量引用。
3. 常量引用，防止误操作。

   //引用使用的场景，通常用来修饰形参
   void showValue(const int& v) {
   	//v += 10;
   	cout << v << endl;
   }
   
   int main() {
   //int& ref = 10;  引用本身需要一个合法的内存空间，因此这行错误
   //加入const就可以了，编译器优化代码，int temp = 10; const int& ref = temp;
   const int& ref = 10;
   //ref = 100;  //加入const后不可以修改变量
   cout << ref << endl;
   
   //函数中利用常量引用防止误操作修改实参
   int a = 10;
   showValue(a);
   
   return 0;
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18

}
```