引用的使用

1 引用的定义

一个引用就是某对象的另一个名字, 通常叫做" 别名" 。通过引用我们可以间接地操纵对象, 使用方式类似于指针, 但是不需要指针的语法。例如:
int a =1;
int &refa =a ;refa 是int 型变量a 的引用, 也就是a 的另一个名字,

2 引用的初始化

引用和其它变量不同, 它必须要被初始化。例如:
int a =1;
int &refa =a ; // 正确, 引用refa 被初始化。
int &r; // 错误, 引用r 没有被初始化。
一旦引用被初始化后, 它就不能再指向其它的对象。例如:
int a =1,b=2;
int &re fa =a ;
re fa =b; //re fa 和a 的值都变成了2 。
在这个程序段中, refa 被初始化为a 的引用。语句refa =b; 并不能将re fa 修改成为b 的引用, 只是把re fa 的值改变成了2 。由于re fa 是a 的引用, 所以a 的值也变成了2 。

 

3 引用不能为空

引用必须是某个对象的别名, 它不能为空。例如:
int a =1;
int &re fa =a ; // 正确, 引用re fa 是int 型变量a 的别名。
int &r=NULL; // 错误, 引用r 不能为空。
由于引用不能为空, 因此在使用之前不用检查它是否为空。
void Print(int &ref)
{
cout <<ref; // 不需要检查re f, 它一定是某个int 型变量的引
用。
}
这一点和指针不同。指针在使用前往往要检查它是否为空。
void Print(int *ptr)
{
if(ptr) // 检查ptr 是否为空指针
cout<<*ptr;
}

 

4 做函数的参数

在C++ 中, 函数调用有三种方式: 传值调用、传地址调用和引用调用
   C++ 中参数传递的缺省初始化方法是把实参的值拷贝到参数的存储区中。这被称为按值传递。按值传递时, 函数不会访问当前调用的实参。函数处理的值是它本地的拷贝, 这些拷贝被存储在运行栈中, 因此改变这些值不会影响实参的值。一旦函数结束了, 函数的活动记录将从栈中弹出, 这些局部值也就消失了
    在按值传递的情况下, 实参的内容没有被改变。这意味着程序员在函数调用时无需保存和恢复实参的值。按值传递的危害最小, 需要用户做的工作也最少。毫无疑问, 按值传递是参数传递合理的缺省机制。但是, 按值传递并不是在所有的情况下都适合。不适合的情况包括:
一、当实参的值必须被修改时。在按值传递的情况下无法做到。
二、当大型的类对象必须作为参数传递时。对实际的应用程序而言, 分配对象并拷贝到栈中的时间和空间开销往往过大。

例1 :

传值调用
#include <iostream.h>
void swap(int x, int y)
{ int temp;
temp=x; x=y; y=temp;
}
int main()
{ int a=3,b=5;
swap(a,b); cout<<" a=" <<a<<" ,b=" <<b<<endl;
return 0;
}
执行该程序后, 输出结果如下:
a =3,b=5
在例1 中, 实参a 和b 的值并没有交换过来, 仍然是3 和5 。
为了使实参的值被修改, 有两种方法。

一种是将形参声明成指针。如下所示:

传地址值调用
例2 :
#include <iostream.h>
void swap(int *x, int *y)
{ int temp;
temp=*x;*x=*y;*y=temp;
}
int main()
{ int a=3,b=5;
swap(&a,&b); cout<<" a=" <<a<<" ,b=" <<b<<endl;

return 0;
}
执行该程序后, 输出结果如下:
a =5,b=3
我们必须修改ma in()来调用swa p()。现在必须传递两个对象的地址而不是对象本身。这样来间接修改实参的值的方法较为复杂, 且容易出错。

使实参的值被修改的第二种方法是将形参声明成引用。如

// // 引用调用
下所示:
例3 :
#include <iostream.h>
void swap(int &x, int &y)
{ int temp;
temp=x; x=y; y=temp;

}
int main()
{ int a=3,b=5;
swap(a,b);cout<<" a=" <<a<<" ,b=" <<b<<endl;
return 0;
}
执行该程序后, 输出结果如下:
a =5,b=3
把形参声明成引用, 实际上改变了缺省的按值传递参数的传递机制。在按值传递时, 函数操纵的是实参的本地拷贝。当形参是引用时, 函数接收的是实参的左值而不是值的拷贝。这意味着函数知道实参在内存中的位置, 因而能够改变它的值或取它的地址。什么时候将一个参数指定为引用比较合适呢? 像swap ()的情况, 它必须将一个形参改变成指针来允许改变实参的值时就比较合适。引用的使用比指针更简单, 也更安全。引用参数的第二种普遍用法是向函数传递大型类对象。我们来看下面这个例子。

 

5 做函数的返回值

说明：

（1）以引用返回函数值，定义函数时需要在函数名前加&

（2）用引用返回一个函数值的最大好处是，在内存中不产生被返回值的副本。函数返回值时，要生成一个值的副本。而用引用返回值时，不生成值的副本。

n 避免了临时变量的产生，当s是一个用户自定义类型时，直接带来了程序执行效率和空间利用的利益。

//以下程序是错误的///

        float& fn2(float r)
　　　　{
　　　　　float temp；
　　　　　temp=r*r*3.14；
　　　　　return temp；
　　　　}
　　　　void main()
　　　　{
　　　　　fn2(5.0)=12.4； //错误：返回的是局部作用域内的变量
　　　　}

 

例如：
#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。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。 

一个返回引用的调用函数可以做左值。