c++引用详解

一谈引用
引用（reference）是c++对c语言的重要扩充。

　　一、引用的概念

　　引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似，只是用&代替了*。

　　例如： Point pt1(10,10);

　　Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义，pt1和pt2表示同一对象。

　　需要特别强调的是引用并不产生对象的副本，仅仅是对象的同义词。因此，当下面的语句执行后：

　　pt1.offset（2，2）；

　　pt1和pt2都具有（12，12）的值。

　　引用必须在定义时马上被初始化，因为它必须是某个东西的同义词。你不能先定义一个引用后才初始化它。例如下面语句是非法的：

　　Point &pt3；

　　pt3=pt1；

　　那么既然引用只是某个东西的同义词，它有什么用途呢？

　　下面讨论引用的两个主要用途：作为函数参数以及从函数中返回左值。

　　二、引用参数

　　1、传递可变参数

　　传统的c中，函数在调用时参数是通过值来传递的，这就是说函数的参数不具备返回值的能力。

　　所以在传统的c中，如果需要函数的参数具有返回值的能力，往往是通过指针来实现的。比如，实现

　　两整数变量值交换的c程序如下：

　　void swapint(int *a,int *b)

　　{

　　int temp;

　　temp=*a;

　　*a=*b;

　　*b=temp;

　　}

　　使用引用机制后，以上程序的c++版本为：

　　void swapint(int &a,int &b)

　　{

　　int temp;

　　temp=a;

　　a=b;

　　b=temp;

　　}

　　调用该函数的c++方法为：swapint（x,y); c++自动把x,y的地址作为参数传递给swapint函数。

　　2、给函数传递大型对象

　　当大型对象被传递给函数时，使用引用参数可使参数传递效率得到提高，因为引用并不产生对象的副本，也就是参数传递时，对象无须复制。下面的例子定义了一个有限整数集合的类：

　　const maxCard=100;

　　Class Set

　　{

　　int elems[maxCard];
   // 集和中的元素，maxCard 表示集合中元素个数的最大值。

　　int card; // 集合中元素的个数。

　　public:

　　Set () {card=0;} //构造函数

　　friend Set operator * (Set ,Set ) ; //重载运算符号*，用于计算集合的交集 用对象作为传值参数

　　// friend Set operator * (Set & ,Set & ) 重载运算符号*，用于计算集合的交集 用对象的引用作为传值参数

　　...

　　}

　　先考虑集合交集的实现

　　Set operator *( Set Set1,Set Set2)

　　{

　　Set res;

　　for(int i=0;i<Set1.card;++i)

　　for(int j=0;j>Set2.card;++j)

　　if(Set1.elems==Set2.elems[j])

　　{

　　res.elems[res.card++]=Set1.elems;

　　break;

　　}

　　return res;

　　}

　　由于重载运算符不能对指针单独操作，我们必须把运算数声明为 Set 类型而不是 Set * 。

 

每次使用*做交集运算时，整个集合都被复制，这样效率很低。我们可以用引用来避免这种情况。

　　Set operator *( Set &Set1,Set &Set2)

　　{ Set res;

　　for(int i=0;i<Set1.card;++i)

　　for(int j=0;j>Set2.card;++j)

　　if(Set1.elems==Set2.elems[j])

　　{

　　res.elems[res.card++]=Set1.elems;

　　break;

　　}

　　return res;

　　}

　　三、引用返回值

　　如果一个函数返回了引用，那么该函数的调用也可以被赋值。这里有一函数，它拥有两个引用参数并返回一个双精度数的引用：

　　double &max(double &d1,double &d2)

　　{

　　return d1>d2?d1:d2;

　　}

　　由于max()函数返回一个对双精度数的引用，那么我们就可以用max() 来对其中较大的双精度数加1：

　　max(x,y)+=1.0;
 
二谈引用
 
   引用是C++引入的新语言特性，是C++常用的一个重要内容之一，正确、灵活地使用引用，可以使程序简洁、高效。我在工作中发现，许多人使用它仅仅是想当然，在某些微妙的场合，很容易出错，究其原由，大多因为没有搞清本源。故在本篇中我将对引用进行详细讨论，希望对大家更好地理解和使用引用起到抛砖引玉的作用。

　　引用简介

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

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

　　【例1】：int a; int &ra=a; //定义引用ra,它是变量a的引用，即别名

　　说明：

　　（1）&在此不是求地址运算，而是起标识作用。

　　（2）类型标识符是指目标变量的类型。

　　（3）声明引用时，必须同时对其进行初始化。

　　（4）引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，且不能再把该引用名作为其他变量名的别名。

　　 ra=1; 等价于 a=1;

　　（5）声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。故：对引用求地址，就是对目标变量求地址。&ra与&a相等。

　　（6）不能建立数组的引用。因为数组是一个由若干个元素所组成的集合，所以无法建立一个数组的别名。

　　引用应用

　　1、引用作为参数

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

　　【例2】：

void swap(int &p1, int &p2) //此处函数的形参p1, p2都是引用
{ int p; p=p1; p1=p2; p2=p; }

　　为在程序中调用该函数，则相应的主调函数的调用点处，直接以变量作为实参进行调用即可，而不需要实参变量有任何的特殊要求。如：对应上面定义的swap函数，相应的主调函数可写为：

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

　　上述程序运行时，如果输入数据10 20并回车后，则输出结果为20 10。

　　由【例2】可看出：

　　（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

　　（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

　　（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用'*指针变量名'的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

　　如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。

　　2、常引用

　　常引用声明方式：const 类型标识符 &引用名=目标变量名；

　　用这种方式声明的引用，不能通过引用对目标变量的值进行修改,从而使引用的目标成为const，达到了引用的安全性。

　　【例3】：

int a ;
const int &ra=a;
ra=1; //错误
a=1; //正确

　　这不光是让代码更健壮，也有些其它方面的需要。

　　【例4】：假设有如下函数声明：

string foo( );
void bar(string & s);

　　那么下面的表达式将是非法的：

bar(foo( ));
bar('hello world');

　　原因在于foo( )和'hello world'串都会产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型，这是非法的。

下面我们来看一个例子：

#include <iostream>   
#include <string>   
using namespace std; 
void main(int argc,char* argv[])
{ 
    int a=10; 
    int b=20; 
    int &rn=a; 
    cout<<rn<<"|"<<a<<endl; 
    cout<<&rn<<"|"<<&a<<endl;//c++中是无法取得引用的内存地址的,取引用的地址就是取目标的地址! 
    rn=b;//把引用指向另一个目标----变量b 
    cout<<&rn<<"|"<<&a<<"|"<<&b<<endl; 
    rn=100;//试图改变b的值 
    cout<<a<<"|"<<b<<endl;//输出修改后的结果  
    cin.get(); 
}

　　由于引用本身就是目标的一个别名，引用本身的地址是一个没有意义的值，所以在c++中是无法取得引用的内存地址的。取引用的地址就是取目标的地址，c++本身就根本不提供获取引用内存地址的方法。

　　引用一旦初始化,就不在能够被指向其它的目标，虽然编译不会出错，但操作是不起作用的，实际上还是指向最先指向的目标。

　　上面代码中的rn=b实际在计算机看来就是a=b，所以修改的还是a的值。

#include <iostream>   
#include <string>   
using namespace std; 
 
void main(int argc,char* argv[])     
{ 
    int a=10; 
    void &rn=a;// 错误的,void即无类型的类型 
    int a[100]; 
    int &ra[100]=a;//错误,不能声明引用数组 
    cin.get(); 
}

上面的两错误要记住引用的特性，void修饰是不能够声明引用的，引用是不能够声明数组的，即不能够声明引用数组。

 下面我们要说一下，也是补充中最重要最需要掌握的内容，也是对传统函数操作的内存状态的一个补充学习。

下面我们来看一个例子：

#include <iostream>   
#include <string>   
using namespace std; 
float c; 
float test(float,float); 
void main(int argc,char* argv[])     
{ 
    float pn=test(3.0f,1.2f); 
    cout<<pn; 
    cin.get(); 
} 
 
float test(float a,float b) 
{ 
    c=a*b; 
    return c; 
}

　　在上面的代码中我们可能我们可能以为函数返回的就是c变量，呵呵。这么想可能就错了，普通情况下我们在函数内进行普通值返回的时候在内存栈空间内其实是自动产生了一个临时变量temp，它是返回值的一个副本一个copy，函数在return的时候其实是return的这个临时产生的副本。

　　数据在内存中的情况如下图：

　　上图明确表示了副本领事变量的情况。

 　下面我们再来看一种情况,就是把返回值赋给引用：

#include <iostream>   
#include <string>   
using namespace std; 
 
float c; 
float test(float,float); 
void main(int argc,char* argv[])     
{ 
    float &pn=test(3.0f,1.2f);//警告:返回的将是临时变量,pn引用将成为临时变量的别名! 
    cout<<pn; 
    cin.get(); 
} 
 
float test(float a,float b) 
{ 
    c=a*b; 
    return c; 
}

　　float &pn=test(3.0f,1.2f);这句在bc中能够编译通过，因为bc扩展设置为临时变量设置引用，那么临时变量的生命周期将和引用的生命周期一致，但在vc中却不能通过编译，因为一但test()执行过后临时变量消失在栈空间内，这时候pn将成为一个没有明确目标的引用，严重的时候会导致内存出错。

　　它在内存中的情况见下图：

　　我们在图中看到，由于函数仍然是普通方法返回，所以仍然会有一个副本临时变量产生，只不过，这一次只是返回一个目标地址，在main中目标地址被赋予了引用pn。

 下面我们再看一种情况，这是返回引用给变量的情况：

#include <iostream>   
#include <string>   
using namespace std; 
 
float c; 
float& test(float,float); 
void main(int argc,char* argv[])     
{ 
    float pn=test(3.0f,1.2f); 
    cout<<pn; 
    cin.get(); 
} 
 
float &test(float a,float b) 
{ 
    c=a*b; 
    return c; 
}

　　这种返回引用给变量的情况下，在内存中，test()所在的栈空间内并没有产生临时变量，而是直接将全局变量c的值给了变量pn，这种方式是我们最为推荐的操作方式，因为不产生临时变量直接赋值的方式可以节省内存空间提高效率，程序的可读性也是比较好的。

　　它在内存中的情况见下图：

 最后的一种情况是函数返回引用,并且发值赋给一个引用的情况：

#include <iostream>   
#include <string>   
using namespace std; 
 
float c; 
float& test(float,float); 
void main(int argc,char* argv[])     
{ 
    float &pn=test(3.0f,1.2f); 
    cout<<pn; 
    cin.get(); 
} 
 
float &test(float a,float b) 
{ 
    c=a*b; 
    return c; 
}

　　这种情况同样也不产生临时变量，可读和性能都很好，但有一点容易弄错，就是当c是非main的局部变量或者是在堆内存中临时开辟后来又被fee掉了以后的区域，这种情况和返回的指针是局部指针的后果一样严重，会导致引用指向了一个不明确的地址，这种情况在内存中情况见下图：

　　由于这种情况存在作用域的问题，故我们推荐采用第三种方式处理。

 

 接下来我们说几个利用引用作为左值参与计算的例子，这一点一非常重要,对于理解返回引用的函数是非常有帮助的。

#include <iostream>   
#include <string>   
using namespace std; 
 
float c; 
float& test(float,float); 
void main(int argc,char* argv[])     
{ 
    float &pn=test(3.0f,1.2f); 
    cout<<pn<<endl; 
    test(3.0f,1.2f)=12.1;//把函数作左值进行计算! 
    cout<<pn; 
    cin.get(); 
} 
 
float &test(float a,float b) 
{ 
    c=a*b; 
    return c; 
}

　　通常来说函数是不能作为左值，因为引用可以做为左值，所以返回引用的函数自然也就可以作为左值来计算了。

　　在上面的代码中：

float &pn=test(3.0f,1.2f);

　　进行到这里的时候pn已经指向到了目标c的地址了。

　　接下来运行了

test(3.0f,1.2f)=12.1;

　　把函数作左值进行计算，这里由于test是返回引用的函数，其实返回值返回的地址就是c的地址，自然c的值就被修改成了12.1。