c++中引用变量的注意事项，和指针的区别

1. 定义引用时必须初始化（变量或者常量），且初始化后不能再指向其他变量或者常量。指针却可以在定义时不初始化，可以在定义后的任何地方初始化，或者改变指向的对象。

2. 存在指针的引用，但是没有引用的指针，因为引用在概念上只是一个代号，没有实体空间。

3. 不能定义引用数组，即便用类似“ int &b[5] = {a[0],a[1],a[3],a[3],a[4]};”初始化也不可以。却可以有数组的引用，数组的引用用在函数的参数传递上，这样可以让编译器检查实参的数组大小和形参的数组大小是否匹配。

在《C++ Primer 第四版》的第七章中，讲到了通过引用传递数组，和其他类型一样，数组形参可声明为数组的引用。如果形参是数组的引用，编译器不会将数组实参转化为指针，而是传递数组的引用本身。在这种情况下，数组大小成为形参与实参类型的一部分，编译器检查数组实参的大小与形参的大小是否匹配。

[cpp] view plain copy print ?

1. #include <iostream>  
2. using namespace std;  
3. void output(int (&a)[5])  
4. {  
5.     for(int i = 0; i < 5; i++)  
6.         cout<<a[i]<<endl;  
7. }  
8. int main()  
9. {  
10.     int a[5]={0};  
11.     output(a);  
12.     getchar();  
13.     return 0;  
14. }   

#include <iostream>
using namespace std;
void output(int (&a)[5])
{
	for(int i = 0; i < 5; i++)
		cout<<a[i]<<endl;
}
int main()
{
	int a[5]={0};
	output(a);
	getchar();
	return 0;
} 

 

 

输出结果为：

也可以在函数中直接声明一个对数组的引用：

[cpp] view plain copy print ?

1. #include <iostream>  
2. using namespace std;  
3.   
4. int main()  
5. {  
6.     int a[5]={0};  
7.     int (&b)[5] = a;  
8.     for(int i = 0; i < 5; i++)  
9.         cout<<b[i]<<endl;  
10.     cout<<sizeof(b);  
11.     getchar();  
12.     return 0;  
13. }   

#include <iostream>
using namespace std;

int main()
{
	int a[5]={0};
	int (&b)[5] = a;
	for(int i = 0; i < 5; i++)
		cout<<b[i]<<endl;
	cout<<sizeof(b);
	getchar();
	return 0;
} 

 

输出结果为：

 从运行结果中可以看到b的大小和数组a的大小一样，也为20。

可见数组的引用同样可以看做是数组的一个别名。

但如果将上面代码中的 int (&b)[5] = a; 改为 int &b[5] = a;则编译无法通过，因为声明了一个引用数组。即便你将引用数组b中的每一个元素b[i]看做对a[i]的引用，然后对每一个元素进行初始化，也是错误的：

 int &b[5] = {a[0],a[1],a[3],a[3],a[4]};

一句话，你可以创建对数组的引用，但你不能创建一个元素都是引用的数组。

 

附：引用占用内存空间吗？摘自http://topic.csdn.net/u/20090604/10/4d7d6b83-8477-4817-8bd0-b4c3e6df8e20.html

 引用是在汇编代码中是如何实现的，这要看编译器的实现，不过大数多编译器用指针来实现。但并不代码会为它分配空间。

以下面程序为例：

[cpp] view plain copy print ?

1. int ia =1;  
2. int &ib = ia ;  
3. int ic = 2 ;  
4. printf("%p\n",&ia) ;  
5. printf("%p\n",&ib) ;  
6. printf("%p\n",&ic) ;   

int ia =1;
int &ib = ia ;
int ic = 2 ;
printf("%p\n",&ia) ;
printf("%p\n",&ib) ;
printf("%p\n",&ic) ; 

 

经编译器后，可以转换成如下的代码：

[cpp] view plain copy print ?

1. int ia =1;  
2. int *ib = &ia ;    //ib由引用变成指针  
3. int ic = 2 ;  
4. printf("%p\n",&ia) ;  
5. printf("%p\n",ib) ;  //引用取地址＝＞指针本身就是地址  
6. printf("%p\n",&ic) ;   

int ia =1;
int *ib = &ia ;    //ib由引用变成指针
int ic = 2 ;
printf("%p\n",&ia) ;
printf("%p\n",ib) ;  //引用取地址＝＞指针本身就是地址
printf("%p\n",&ic) ; 

 

 

这里为ib分配了一个空间，但由ib这个指针很特殊，在定义的时候一定要有初始化，这就为它的优化提供了很好的依据。
上面的代码完全可以变成下面这样：

[cpp] view plain copy print ?

1. int ia =1;  
2. //int &ib = ia ; 编译只需记住ib是ia的引用，不需要分配空间  
3. int ic = 2 ;  
4. printf("%p\n",&ia) ;  
5. printf("%p\n",&ia) ; //原来是printf("%p\n",&ib) ;ib即ia(引用定义），故直接用ia来替换  
6. printf("%p\n",&ic) ;   

int ia =1;
//int &ib = ia ; 编译只需记住ib是ia的引用，不需要分配空间
int ic = 2 ;
printf("%p\n",&ia) ;
printf("%p\n",&ia) ; //原来是printf("%p\n",&ib) ;ib即ia(引用定义），故直接用ia来替换
printf("%p\n",&ic) ; 

 

最后这个代码就没有为引用分配空间…… 如果标准没有规定这些行为，不同的编译器会有不同的行为。

 

4. 引用总是const，在定义引用的时候如果加上const，说明该变量引用的对象是const。

5. 不能引用null。