C++引入了引用这个类型，引用实际是给变量起了一个别名，实际上，引用只是别名没有独立的内存空间，和它所引用的变量共享内存空间。

    变量的属性有两种：名称和空间。

    而引用只有名称没有独立的空间。

    对引用的改变就是对它所引用的变量的改变。

    格式:int a = 1; int& b = a;

    Δ定义引用时一定要初始化，指明该引用变量是谁的别名。

    Δ引用一经初始化不能重新指向其他变量。

    实际引用中，引用一般用作参数传递与返回值。

 

  1. # include <iostream> 
  2. using namespace std; 
  3.  
  4. int main(void) 
  5. { 
  6.     int val = 100; 
  7.     //定义引用 
  8.     int& refval = val; //引用必须初始化 
  9.     //int& refval; error  引用必须初始化 
  10.     cout<< "val =    " << val << endl; 
  11.     refval = 200;  //实际上改变的是val变量 
  12.     cout << "refval = " << refval  << endl;  //结果是200 
  13.      
  14.     int val2 = 500; 
  15.     refval = val2 ; //这只是简单的赋值，不代表refval引用至val2这个变量    
  16.  
  17.     cout << "val2 =   " << val2 << endl; //500 
  18.  
  19.     return 0; 
  20. } 

运行结果：

 

C++引用的学习_C++

    const引用，指向const对象的引用

    const int ival = 1024; const int& refval = ival;

    Δ普通变量引用const变量是非法的

    const int ival = 1024;  int& refval = ival ; //error 

    Δconst变量引用普通变量是合法的。

 

  1. # include<iostream> 
  2. using namespace std; 
  3.  
  4. int main(void) 
  5. { 
  6.     const int val = 1024; 
  7.     const int& refval = val; 
  8.     //  int& ref2 = val;  error,nonconst reference to a const object 
  9.     cout<<"refval = " << val << endl; 
  10.  
  11.     int val2 = 1024; 
  12.     const int& ref3 = val2;  //允许的 
  13.    //ref3 = 200; 错误的，不能更改const常量 
  14.     cout << "ref3   = " << ref3 << endl; 
  15.  
  16.     double val3 = 3.4; 
  17.     //warning C4244: “初始化”: 从“double”转换到“const int”，可能丢失数据 
  18.     const int& ref4 = val3; //等价于产生了一个临时变量，int temp = val3; const int& ref4 = temp 
  19.     cout << "val3   = " << val3 << endl; 
  20.     cout << "ref4   = " << ref4 << endl; 
  21.      
  22. //  int& ref5 = val3;   非const不能引用double类型的变量 
  23.  
  24.     return 0; 
  25. } 

 

运行结果：

 

C++引用的学习_函数传参数_02

 引用做函数参数传递：

 

  1. //按引用传递 
  2.  
  3. //swap(int &a, int &b); 
  4. //C语言里面： 
  5. // 值传递    形参不能更改实参 
  6. // 指针传递 
  7.  
  8. //地址传递方式通过形参的改变使相应的实参改变 
  9. //引用传递也是可以的 
  10. //引用作为参数传递 
  11.  
  12. # include <iostream> 
  13. using namespace std; 
  14.  
  15. void swap(int &x, int &y); 
  16.  
  17. int main(void) 
  18. { 
  19.     int a = 5; 
  20.     int b = 6; 
  21.     cout<<"交换前" << "a = " << a <<" b = " << b << endl; 
  22.     swap(a,b);//在函数调用的时候，引用被初始化 ， x = a ,y = b 
  23.     cout<<"交换后" << "a = " << a <<" b = " << b << endl; 
  24.  
  25.     return 0; 
  26. } 
  27. void swap(int &x, int &y) //形参是引用，调用的时候被初始化 
  28. { 
  29.     int temp = x; 
  30.     x = y; 
  31.     y = temp; 
  32. } 

运行结果：

 

C++引用的学习_const引用_03

下面总结下引用于指针的区别：

 

引用访问一个变量是直接访问，

指针是间接访问

 

引用只是别名，本身不分配内存空间

指针本身就是一个变量，有自己的内存空间

 

引用一经初始化就不能再引用其他变量，

指针初始化后引用其他变量，除非const

 

 

值传递的时候，实参要初始化形参，就好分配一个形参变量，将实参内容拷贝到形参

如果是类传递的话，还要调用拷贝函数

指针传递 实参初始化形参的时候也是要分配空间的，

引用传递 实参初始化形参时不分配空间，效率会高点

 

指针传递 本质还是值传递，如果要修改指针的地址，单纯用指针传递也不能的

仅仅修改指针指向的内容，**，指针引用*&

 

引用作为函数返回值：

  1. //引用作为返回值,将函数放在赋值运算符的左边 
  2.  
  3. # include <iostream> 
  4. using namespace std; 
  5.  
  6. int a[] = {0,1,2,3,4}; 
  7.  
  8. int& index(int i) 
  9. { 
  10.     return a[i];  
  11.     //函数返回引用，引用在函数返回的时候初始化 
  12.     //index(3) 在函数返回的时候被初始化为a[3] 
  13. } 
  14.  
  15. int main(void) 
  16. {//引用作为函数返回值，使得函数可以放在运算符的左边 
  17.     index(3) = 100;  
  18.     cout << "a[3] = " << a[3] << endl;  //100 
  19.  
  20.     return 0; 
  21. } 

 运行结果：

 

C++引用的学习_变量模型_04

不能返回对局部变量的引用，或自动化变量的引用:

  • //不能返回对局部变量的引用，或自动化变量的引用 
  •  
  • # include <iostream> 
  • using namespace std; 
  •  
  • int& add(int a, int b) 
  • { 
  •     int sum; 
  •     sum = a+b; 
  •      
  •     return sum; 
  • } 
  • int main(void) 
  • { 
  •     int n = add(3,4); 
  • //n2是引用没有自己独立的空间，依赖于所引用的变量 
  • //如果n2所引用的变量生命期已经结束了， 
  • //n2也就是无用的引用，也就是不确定的 
  •     int& n2 = add(5,6);  
  •     //cout << "n2 =" << endl; 
  •     cout << "n = " << n  << endl; 
  •     cout << "n2 =" << n2 << endl;//输出不确定的数 
  •      
  •     return 0; 
  • } 

运行结果：

 

C++引用的学习_C++_05