c++中的引用

概念　

引用就是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。

使用方法

引用的声明方法：类型标识符 &引用名=目标变量名；

与指针的区别

引用是C++对C语言的一个重要的扩展，与指针类似，但仍有一些不同点，主要分为以下几点：

• 从内存上讲，系统为指针分配内存空间，而引用与绑定的对象共享内存空间，系统不为引用变量分配内容空间（内容空间不是其自身空间，在C++内部实现是一个常指针，4字节）；
• 指针初始化以后可以更改指向对象，而引用定义的时候必须要初始化，且初始化以后不允许重新再绑定对象；
• 所以引用空间对象是直接访问，指针访问对象是间接；
• 如pa是指针，*pa就是引用；

引用应用

1.引用作为参数

引用的一个重要作用就是作为函数的参数。以前的C语言中函数参数传递是值传递，如果有大块数据作为参数传递的时候，采用的方案往往是指针，因为这样可以避免将整块数据全部压栈，可以提高程序的效率。但是现在（C++中）又增加了一种同样有效率的选择（在某些特殊情况下又是必须的选择），就是引用。

例：数据交换(引用 使用方式）

#include<iostream>
using namespace std;
void swap(int &p1, int &p2) //此处函数的形参p1, p2都是引用
{
     int p;
     p = p1; 
     p1 = p2; 
     p2 = p; 
}

int main( )
{
 int a, b;
 cin >> a>> b; //输入a,b两变量的值
 swap(a, b); //直接以变量a和b作为实参调用swap函数
 cout << a<<  ' ' << b; //输出结果
 return 0;
}

例：数据交换（指针使用方式）

#include<iostream>
using namespace std;
void swap(int *p1, int *p2)
{
    int *p;
    p = p1;
    p1 = p2;
    p2 = p;
}

int main()
{
    int a,b;
　 cin>>a>>b; //输入a,b两变量的值
    swap(&a, &b);
    return 0;
}    

　　优劣势比较：

1. 使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给 形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效 率和所占空间都好。
2. 使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的 形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

2.常引用

使用方法：const 类型标识符 &引用名 = 目标变量名；

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include<iostream> using namespace std; int main() {     int a ;     const int &ra=a;     ra=1; //错误     a=1; //正确     return 0; } string foo( ); void bar(string & s); //那么下面的表达式将是非法的： bar(foo( )); bar("hello world"); /*　原因在于foo( )和"hello world"串都会产生一个临时对象，<br>    而在C++中，这些临时对象都是const类型的。因此上面的表达式<br>    就是试图将一个const类型的对象转换为非const类型，这是非法的。*/

　　

3.引用作为返回值

使用方法：

 　　类型标识符 &函数名（形参列表及类型说明）
　　{函数体}

 优势：用引用返回一个函数值的最大好处是，在内存中不产生被返回值的副本。

例：f1 和 f2 两个函数都是计算圆面积，返回不同类型的数值，f1 返回值，f2返回temp的引用。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

#include <iostream.h> float temp; //定义全局变量temp float fn1(float r); //声明函数fn1 float &fn2(float r); //声明函数fn2 float fn1(float r) //定义函数fn1，它以返回值的方法返回函数值 { 　temp = (float)(r * r * 3.14); 　return temp; } float &fn2(float r) //定义函数fn2，它以引用方式返回函数值 { 　temp = (float)( r * r * 3.14); 　return temp; } void main() //主函数 { 　float a = fn1(10.0); //第1种情况，系统生成要返回值的副本（即临时变量） 　float &b = fn1(10.0); //第2种情况，可能会出错（不同 C++系统有不同规定） 　//不能从被调函数中返回一个临时变量或局部变量的引用 　float c = fn2(10.0); //第3种情况，系统不生成返回值的副本 　//可以从被调函数中返回一个全局变量的引用 　float &d = fn2(10.0); //第4种情况，系统不生成返回值的副本 　//可以从被调函数中返回一个全局变量的引用 　cout << a << c << d; }

　　！！！引用作为返回值，必须遵守以下规则：

         1.不能返回局部变量的引用。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。

　　  2.不能返回函数内部new分配的内存的引用。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一 个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。

　　  3.可以返回类成员的引用，但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常 量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。

　　  4.引用作为左值时：

　　例：用返回引用的函数值作为赋值表达式的左值。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include <iostream.h> int &put(int n); int vals[10]; int error = -1; void main() {     put(0) = 10; //以put(0)函数值作为左值，等价于vals[0]=10;     put(9) = 20; //以put(9)函数值作为左值，等价于vals[9]=20;     cout << vals[0];     cout << vals[9]; } int &put(int n) {     if (n>=0 && n<=9 ) return vals[n];     else     {      cout<<"subscript error"; return error;      } }

　　  5.一些操作符中，却千万不能返回引用：+-*/ 四则运算符。它们不能返回引用，主要原因是这四个操作符没有side effect。

4.引用和多态

　　概念：引用是除指针外另一个可以产生多态效果的手段。这意味着，一个基类的引用可以指向它的派生类实例。

1 2 3 4

class 　A; class 　B：public A{……}; B 　b; A 　&Ref = b; // 用派生类对象初始化基类对象的引用

　Ref 只能用来访问派生类对象中从基类继承下来的成员，是基类引用指向派生类。如果A类中定义有虚函数，并且在B类中重写了这个虚函数，就可以通过Ref产生多态效果。

5.指针的引用

下例有助理解指针方面的知识，指针的指针，指针的引用进行比较。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

#include <iostream> using namespace std; struct Teacher {     int age;     char name[64];  };<br>//指针的指针 int getTeacherWayFirst(Teacher **p) {     Teacher *tmp = NULL;     if(p == NULL)     {         return -1;     }     tmp = (Teacher *)malloc(sizeof(Teacher));     if(tmp == NULL)     {         return -2;     }     tmp->age = 33;     *p = tmp;  } <br>//指针的引用  int getTeacherWaySecond(Teacher * &p)  {      p = (Teacher *)malloc(sizeof(Teacher));     if(p == NULL)     {         return -1;      }     p->age = 36;        }<br>//释放分配的空间  void freeTeacher(Teacher *pT1)  {     if (pT1 == NULL)     {         return ;      }      free(pT1);  } int main() {     Teacher *pT1 = NULL;           getTeacherWayFirst(&pT1);     cout << pT1->age << endl;     freeTeacher(pT1);           getTeacherWaySecond(pT1);     cout << pT1->age << endl;     freeTeacher(pT1);     return 0; }

　　

总结

　　（1）在引用的使用中，单纯给某个变量取个别名是毫无意义的，引用的目的主要用于在函数参数传递中，解决大块数据或对象的传递效率和空间不如意的问题。

　　（2）用引用传递函数的参数，能保证参数传递中不产生副本，提高传递的效率，且通过const的使用，保证了引用传递的安全性。

　　（3）引用与指针的区别是，指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。

　　（4）使用引用的时机。流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。