c++中引用的作用

引用的基本语法

1. 用途起别名

2. Type &别名=原名

3. 引用必须初始化

4. 一旦初始化后，不能修改

5. 对数组建立引用

    #include<iostream>
   
    using namespace std;
    
    //1.引用基本语法 Type &别名=原名
    void test01()
    {
    
    	int a = 10;
    	int &b = a;
    	cout << "a=" << a << endl;
    	cout << "b=" << b << endl;
    }
    //2.引用必须初始化
    void test02(){
    
    	//int &a;  必须初始化
    	int a = 10;
    	int &b = a; //引用初始化后不可修改
    
    	int c = 20;
    	b = c;		//这个不叫初始化叫赋值
    	cout << "b=" <<b<< endl;
    }
    //3.对数组建立引用
    void test03()
    {
    	int arr[10];
    	for (int i = 0; i < 10; i++)
    	{
    		arr[i] = i;
    
    	}
    	//给数组起别名
    	int(&pArr)[10] = arr;
    	for (int i = 0; i < 10; i++)
    	{
    		cout << pArr[i] << " ";
    	}
    	cout << endl;
    
    	//第二种方式起别名
    	typedef int(ARRAYREF)[10];//一个具有10元素的int类型的数组
    	ARRAYREF & pArr2 = arr;
    	for (int i = 0; i < 10; i++)
    	{
    		cout << pArr2[i] << " ";
    	}
    	cout << endl;
    
    
    }
    
    
    int main()
    {
    
    	//test01();
    	//test02();
    	test03();
    	system("pause");
    	return 0;
    }
   

参数3种传递方式

1. 值传递

2. 地址传递

3. 引用传递

    #include<iostream>
    
    using namespace std;
    
    void mySwap(int a, int b)
    {
    	int tmp = a;
    	a = b;
    	b = tmp;
    	cout << "mySwap::a= " << a << endl;
    	cout << "mySwap::b= " << b << endl;
    
    }
    
    void test01()
    {
    	int a = 10;
    	int b = 10;
    	mySwap(a, b);	//值传递
    	cout << "a= " << a << endl;
    	cout << "b= " << b << endl;
    }
    //地址传递
    void mySwap2(int *a,int *b){
    	int tmp = *a;
    	*a = *b;
    	*b = tmp;
    }
    void test02(){
    	int a = 10;
    	int b = 20;
    	mySwap2(&a, &b);	//地址传递
    	cout << "a= " << a << endl;
    	cout << "b= " << b << endl;
    }
    //引用传递  类似传地址
    void mySwap3(int &a, int &b)//&a=a
    {
    	int tmp = a;
    	a = b;
    	b = tmp;
    }
    
    void test03(){
    	int a = 10;
    	int b = 20;
    	mySwap3(a, b);	//值传递
    	cout << "a= " << a << endl;
    	cout << "b= " << b << endl;
    }
    //引用的注意事项
    //1.引用必须引用一块合法的内存空间
    //2.不要返回局部变量的引用
    //3.不能有NULL引用，必须是合法内存空间
    //4.必须在声明引用变量时进行初始化
    int &doWork()
    {
    	int a = 10;	//a为局部变量，引用接受返回值，应该乱码
    	return a;
    }
    void test04()
    {
    	//int &a = 10;引用必须引用一块合法的内存空间
    	int &ret = doWork();
    	cout << "ret= " << ret << endl;//第一次10是编译器做了优化
    	//如果多次打印就不行
    	cout << "ret= " << ret << endl;
    	cout << "ret= " << ret << endl;
    	cout << "ret= " << ret << endl;
    }
    int &doWork02()
    {
    	static int a = 10;
    	return a;
    
    }
    void test05()
    {
    	
    	int& ret = doWork02();
    	//如果函数的返回值是引用，那么这个函数调用可以作为左值
    	doWork02() = 1000;//相当于a=1000
    
    	cout << "ret= " << ret << endl;
    	cout << "ret= " << ret << endl;
    	cout << "ret= " << ret << endl;
    	cout << "ret= " << ret << endl;
    }
    
    
    
    int main()
    {
    	//test01();
    	//test02();
    	//test03();
    	//test04();
    	test05();
    	system("pause");
    	return 0;
    }
   

注意事项：

1. 不要返回局部变量的引用
2. 如果函数返回值是引用，那么函数的调用可以作为左值
3. 引用的本质就是一个指针常量

指针的引用

用一级指针引用可以代替二级指针

常量引用

1. 使用场景，修饰形参为只读，尤其是拷贝构造函数
2. const int &a=10;会分配内存
3. 引用不产生新的变量，减少形参与实参传递时的开销
4. 由于引用可能导致实参随形参改变而改变，将其定义为常量引用可以消除这种副作用
5. 如果希望实参随着形参改变而改变，那么使用一般的引用，如果不希望实参随着形参改变，那么使用常引用