标准C++程序设计学习笔记（七）——★C++的引用

引用

• 引用即别名  (一开始引用是出现是想取代指针，没想到没做到，反而指针和引用都保留了下来)

• 数据类型& 别名 = 目的对象;

• 注意：

  • 引用必须直接初始化 形参列表引用没有直接初始化（在函数调用的时候初始化）

  • 引用一旦初始化 不能更改引用对象(不能指向其他对象) 从一而终

    • 对引用对象的操作，直接影响其目标对象

#include <iostream>        //01ref.cpp
using namespace std;
void swap(int *pa,int *pb){
	int tmp = *pa;//pa = &a;
	*pa = *pb;
	*pb = tmp;
}
//引用
void exchange(int& m,int& n){// m和n是实参a和b的别名  操作m和n 其实 就是操作实参
	int tmp = m;
	m = n;
	n = tmp;
}

int main(){
	int a = 1024, b = 9527;
	cout << "a=" << a << ",b=" << b << endl;

	exchange(a,b);

	cout << "a=" << a << ",b=" << b << endl;

	int m = 1, n = 2;
	exchange(m,n);
	cout << m << "," << n << endl;

	return 0;	
}

引用的应用

• 函数参数 在函数内部可以直接修改实参的值

#include <iostream>    //02ref.cpp
using namespace std;


int main(){
	int a = 1024;
	cout << &a << endl;
	cout << a << endl;

	int& r = a;//定义引用变量r 引用 a

	cout << &r << endl;
	cout << r << endl;
	
	r = 9527;
	cout << r << endl;
	cout << a << endl;

	a = 1212;
	cout << a << endl;
	cout << r << endl;
	

	double d = 3.14;
	double& rd = d;



	return 0;	
}

• 函数的返回值 需要确保在函数调用之后，返回的对象依然有效

  能够返回全局变量、静态变量、动态内存对象引用参数的引用

  不能返回局部变量的引用，编译警告；引用的对象的值不确定、行为不确定

  不能返回局部变量的引用

#include <iostream>    //03initref.cpp
using namespace std;

void func(int& ra){
	cout << ra << endl;
	ra = 1111;
}

double& getd(void){
	double d = 6.666;
	return d;//不能返回局部变量的引用
}

int main(){
	//int& r;
	int a = 10;
	int& r1 = a,r2;//r1是引用 int&, r2是int

	func(a);
	cout << a << endl;
	double& rd = getd();
	cout << rd << endl;
	return 0;	
}

• 多态 父类的引用类型引用子类对象

★引用与指针

• 1.引用的本质就是指针，C++对指针的一个封装 很多场合引用和指针可以互换

• 2.C++层面 上引用和指针有以下方面的不同

  • A.指针是实体变量,但是引用不是实体变量

    • sizeof(指针) == 4/8 当平台和编译器确定，大小唯一

    • int a = 1;int & ra = a; sizeof(ra) == 4

    • double d = 1.0;double& rd = d; sizeof(rd) == 8
       

      #include <iostream>    //04sizeof.cpp
      using namespace std;
      
      
      int main(){
      	cout << sizeof(void*) << endl;
      	cout << sizeof(int*) << endl;
      	cout << sizeof(double*) << endl;
      	
      	cout << "------------" << endl;
      
      	cout << sizeof(int&) << endl;
      	cout << sizeof(double&) << endl;
      	//cout << sizeof(void&) << endl;
      	return 0;
      }
      

  • B.指针可以不初始化，但是引用必须初始化

    • int *p; //OK

    • int& r; //Error

  • C.指针可以修改目标(指向不同的目标) 但是引用不能修改引用方向

    • int *p = &a; //指向a

    • p = &b; //指向b

    • int& r = a; //引用a

    • r = b; //对a进行赋值 &r = b;

  • D.可以声明void指针 void* 但不能声明void引用 void&

    void* p; //OK

    void& r = v; //Error

  • E.可以声明指针的指针(二级指针) 但不可以定义引用的引用

    int **p;

    int a; int &r = a;

    int&& rra = r; //引用的引用 Error

    int& rra = r; //OK

  • F.可以定义指针的引用 但不可以定义引用的指针

    int *p;

    int*& rp = p; //指针的引用 本质是引用 引用一个指针

    int& *pr; //错误的 引用的指针 本质是指针 指针指向引用
     

    #include <iostream>        //05refpointer.cpp
    using namespace std;
    
    
    int main(){
    	int a = 1024;
    	int *p = &a;
    	
    	int*& rp = p;//指针的引用
    	int b = 9527;
    
    
    	rp = &b;
    
    	*rp = 1111;
    
    	int& r = a;
    	int& *pr = &r;
    
    	return 0;	
    }
    

  • G.可以定义数组的引用 但不能定义引用的数组

    数组的引用本质是引用，引用了一个数组

    int arr[5] = {1,2,3,4,5};

    int (&rar)[5] = arr; //数组的引用 和 数组的指针 很类似

    int a,b,c,d,e;

    int& brr[5] = {a,b,c,d,e};//引用的数组 Error
     

    #include <iostream>    //06refarr.cpp
    using namespace std;
    
    int main(){
    	int arr[5] = {1,2,3,1023,1024};
    	//数组的引用
    	//数组的指针   int (*arr)[5]
    	int (*par)[5] = &arr;
    
    	int (&rar)[5] = arr;//数组的引用
    	
    	cout << arr << endl;
    	cout << rar << endl;
    
    
    	cout << rar[0] << endl;
    	cout << rar[1] << endl;
    	rar[4] = 9527;
    
    	cout << arr[4] << endl;
    	
    	int a,b,c,d,e;
    	int& brr[5] = {a,b,c,d,e};
    
    
    	return 0;	
    }
    

  • H.指针有自己的一块空间，而引用只是一个别名

  • I.作为参数传递时，指针需要被解引用才可以对对象进行操作，而直接对引用的修改都会改变引用所指向的对象

  • J.可以有const指针，但是没有const引用

  • K.指针和引用使用++运算符的意义不一样

  • L.如果返回动态内存分配的对象或者内存，必须使用指针，引用可能引起内存泄露