(1)在实际的程序中,引用主要被用做函数的形式参数--通常将类对象传递给一个函数.引用必须初始化. 但是用对象的地址初始化引用是错误的,我们可以定义一个指针引用.
int ival = 1092;
int &re = ival; //ok
int &re2 = &ival; //错误
int *pi = &ival;
int *&pi2 = pi; //ok
(2)一旦引用已经定义,它就不能再指向其他的对象.这就是为什么它要被初始化的原因.
(3)const引用可以用不同类型的对象初始化(只要能从一种类型转换到另一种类型即可),也可以是不可寻址的值,如文字常量。例如double dval = 3.14159;//仅对const引用才是合法的
const int &ir = 1024;
const int &ir2 = dval;
const double &dr = dval + 1.0;
上面,同样的初始化对于非const引用是不合法的,将导致编译错误。原因有些微妙,需要适当做些解释。引用在内部存放的是一个对象的地址,它是该对象的别名。对于不可寻址的值,如文字常量,以及不同类型的对象,编译器为了实现引用,必须生成一个临时对象,引用时间上指向该对象,但用户不能访问它。例如:
double dval = 23;
const int &ri = dval;
编译器将其转换为:
int temp = dval;
const int &ri = temp;
(4)不允许非const引用指向需要临时对象的对象或值const int ival = 1024;
int *&pi_ref = &ival; //错误,非const引用是非法的
const int *&pi_ref = &ival; //错误,pi_ref是一个非常量指针,而指针,而ival不可变
const int * const &pi_ref = &ival; //正确
//补充const int *p = &ival;
const int *&pi_ref = p; //正确
********对于const int *const & pi_ref = &iva; 具体的分析如下:*********
1.不允许非const引用指向需要临时对象的对象或值
int a = 2; int & ref1 = a; // OK.有过渡变量。
int const & ref2 = 2; // OK.编译器产生临时变量,直接引用。
2.地址值是不可寻址的值
int * const &ref3 = &a; // OK;
3.于是,用const对象的地址来初始化一个指向指针的引用
const int b=23;
const int *p=&b;
const int *&ref4=p;
const int *const &ref5=&b;//ok
注:1、引用
int a;
int &a=b;
2、参数引用
void swap(&a,&b){
int temp;
temp=a;
a=b;
b=temp;
}
3、返回引用
complex & complex::operator+=( complex &x)
4、const引用
(1)引用实参不可改变 complex complex::operator+(const complex &x){...}
(2)可实现类型转换
double dval = 23;
const int &ri = dval;
编译器将其转换为:
int temp = dval;
const int &ri = temp;
(3)实参能使用不可寻址的值,非const引用只能接受左值
complex complex::operator+( double d){...}
d=0.5;
.......;
complex c1(1.0,1.0),c;
c=c1+d;//ok
c=c1+0.5;//error
又如:
complex complex::operator+( const double &d){...}
d=0.5;
.......;
complex c1(1.0,1.0),c;
c=c1+0.5;//ok