C++复习第三章:引用

基本用法

****引用是c++对c的重要扩充。****在c/c++中指针的作用基本都是一样的，但是c++增加了另外一种给函数传递地址的途径，这就是按引用传递(pass-by-reference)，它也存在于其他一些编程语言中，并不是c++的发明。

1. 变量名实质上是一段连续内存空间的别名，是一个标号(门牌号)

2. 程序中通过变量来申请并命名内存空间

3. 通过变量的名字可以使用存储空间

#include<iostream>

using namespace std;


void test01()
{
    int a = 10;
    int a1 = 20;
    int &b = a;

    cout << b << endl;

    //引用必须初始化
    //int &c;

    //初始化后不能修改
    int &d = a;//初始化
    d = 20;//赋值操作

    cout << d << endl;

}
//对数组起别名
void test02()
{
   int arr[10];
   int i;
   for(i = 0;i < 10;i++)
   {
       arr[i] = i;

   }

    //引用
   int (&parr)[10] = arr;
   for(i = 0;i < 10;i++)
   {
       cout << parr[i] << endl;

   }

   //typedef 引用
   typedef int(&arr2)[10];

   arr2 a2 = arr;

   for(i = 0;i < 10;i++)
   {
       cout << parr[i] << endl;

   }

}
int main()
{
    test02();

    return 0;
}

函数中的引用

最常见看见引用的地方是在函数参数和返回值中。当引用被用作函数参数的时，在函数内对任何引用的修改，将对还函数外的参数产生改变。当然，可以通过传递一个指针来做相同的事情，但引用具有更清晰的语法。

如果从函数中返回一个引用，必须像从函数中返回一个指针一样对待。当函数返回值时，引用关联的内存一定要存在。

三种参数传递方式

/*------------------------------------------------------
*参数的三种传递方式
*1.传值
*2.传地址
*3.引用(内存空间起别名)
*
-----------------------------------------------------*/
#include<iostream>

using namespace std;

void swap01(int a,int b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

void test01()
{
    int a = 10;
    int b = 20;
    swap01(a,b);
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

}
//传地址
void swap02(int *a,int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void test02()
{
    int a = 10;
    int b = 20;
    swap02(&a,&b);
    cout << "a2 = " << a << endl;
    cout << "b2 = " << b << endl;

}

//引用
void swap03(int &a,int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

void test03()
{
    int a = 10;
    int b = 20;
    swap03(a,b);
    cout << "a3 = " << a << endl;
    cout << "b3 = " << b << endl;

}

通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单：

1. 函数调用时传递的实参不必加“&”符

2. 在被调函数中不必在参数前加“*”符

引用作为其它变量的别名而存在，因此在一些场合可以代替指针。C++主张用引用传递取代地址传递的方式，因为引用语法容易且不易出错。

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

引用的实质

引用的本质在c++内部实现是一个指针常量

c++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同，只是这个过程是编译器内部实现，用户不可见。

//发现是引用，转换为 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 EXIT_SUCCESS;
}

常量引用

1. 字面量不能赋给引用，但是可以赋给const引用

2. const修饰的引用，不能修改。

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

*[const引用使用场景]*

常量引用主要用在函数的形参，尤其是类的拷贝/复制构造函数。

将函数的形参定义为常量引用的好处:

1. 引用不产生新的变量，减少形参与实参传递时的开销。
2. 由于引用可能导致实参随形参改变而改变，将其定义为常量引用可以消除这种副作用。

如果希望实参随着形参的改变而改变，那么使用一般的引用，如果不希望实参随着形参改变，那么使用常引用。

//const int& param防止函数中意外修改数据
void ShowVal(const int& param){
	cout << "param:" << param << endl;
}