引用、函数形参

2019独角兽企业重金招聘Python工程师标准>>>

其实一直都知道引用，一直都在用引用。但是有些细小的地方还是没有弄明白，尤其是对于const引用，以及当引用作为形参的时候；今天上午看书，看到函数参数那一节 ，突然对前面的知识豁然开朗起来，特此整理笔记。

引用

一、定义：对象的另一个名字。在实际程序中，应用主要用作函数的形式参数，是一种复合类型；

注意：1、不能定义引用类型的引用，但可以定义任何其他类型的引用；

        2、引用必须用与该引用同类型的对象初始化（在接下的介绍中我们会看到也有特例）；

        3、引用在定义是必须初始化；

二、const引用

const引用：指向const对象的引用

1、const对象的引用只能赋值给指向const对象的引用，不能赋值给普通的引用；非const对象的引用也能赋值给指向const对象的引用；

2、const引用可以绑定到不同但相关的类型的对象或者右值（这就是上面所说的注意2中的特例）；

3、非const引用只能绑定到完全相同的类型的对象（下面讲到的函数实参和形参的匹配也用到了这一点）；

假设：

double val;
int &refFirst = val;  //是错误的

以上这句话会变成：
int temp = val;
int &refFirst = temp;
这时我们可以给refFirst赋一新值。但这样做不会修改val，只会修改temp，原本想通过refFirst修改val，发现它并没有修改；

const int &refSecond = val;
以上这句话也会变成：
int temp = val;
const int &refSecond = temp;
允许const引用绑定到需要临时使用的值就避免了上述的问题，因为const引用本身就是只读的，不存在重新赋值的情况

关于引用我的测试：

#include <iostream>
using namespace std;

int main()
{
	int val = 7;
	int &a = val;     
	//int &c;  //错误，引用在定义时必须进行初始化

	int b = 8;
	a = b;	//正确，重新赋值

	const int constVal = 2;
	//int &ref = constVal;  //错误
	const int &ref = constVal;  //正确，对const对象的引用，只能定义const引用
	
	double x = 2.1;
	double y = 3.2;

	/*int &refFirst = x + y;  //错误，非const引用只能绑定到相同类型的对象
	int &refSecond = x;		//错误
	int &refThird = 9;      //错误  */

	const int &refForth = 9;  //正确
	const int &refFifth = 9+10; //正确
	const int &refSixth = x;    //正确,但编译器会发出警告：从“double”转换到“const int”，可能丢失数据
	const int &refSeven = x+y;  //正确, 但编译器会发出警告：从“double”转换到“const int”，可能丢失数据

	cout<<refForth<<endl;
	cout<<refFifth<<endl;
	cout<<refSixth<<endl;
	cout<<refSeven<<endl;
	
	system("pause");
	return 0;
}

讲到这里，我们就不得不提函数参数了：

函数参数

前提要点：对于实参和形参的匹配，我们只需要记住一点：函数调用时，使用实参来初始化形参（记住这一点，下面的多种情况就很容易理解了）

1、非引用形参：（略）

2、指针形参：（注意理解指向const对象的指针）

形参	实参
指向const对象的指针	普通指针、指向const对象的指针、
普通指针	不能是指向const对象的指针

注：这里的普通指针是指向非const对象的指针

3、const形参、引用形参

形参	实参
非引用的非const形参	const对象、非const对象
非引用的const形参	const对象、非const对象
非const引用形参 （这种情况就是如何给一个非const引用初始的问题，非const引用只能与完全同类型的非const对象关联）	非const对象 不能是const对象 不能是一个左值 不能是一个需要转换的类型的对象
const引用形参	非const对象 const对象 字面值或者产生右值的表达式实参

对于非引用的const形参：

//假如我们在一个文件中定义了两个这样的函数，编译器并不会把它们当成是重载的函数，反而会将第二个函数的定义视为其形参被声明为普通的int型
//这样两个函数在编译后就是一样的函数原型，程序会报错
//但是在对于第二个函数，我们在使用的时候a仍然是一个const int型变量，不能对其赋值，如下面的代码，会报错
void function(int a)  //错误
{
	cout<<a<<endl;
}

//
void function(const int a)
{
	a = 7;   //错误
	cout<<a<<endl;
}

同理，不能基于指针本身是否为const来实现函数的重载，正如"对于非引用的const形参"，当形参以副本传递时，不能基于形参是否为const来实现重载！

昨晚和同学说道另外一个问题：也就是在effective C++上面看到的，类的两个成员函数如果只是常量性（constness）不同，可以被重载：也就是说如果一个成员函数是const函数，我们可以定义另外一个非const函数实现重载。原因就是：对于const函数，其隐含的this指针是一个指向const对象的指针(当然它也是一个指针常量)，当然可以重载，例如：

void function(cont int *p)
{
......
}
void function(int *p)
{
......
}

int a = 2;
int *q = &a;
cont int *p = &a;
function(q);  //调用的是funciton(int *)函数，当然如果这个时候没有funciton(int *)这个函数，程序
就会调用function(const int *)函数，因为 const int *var = q (可以转换)！

function(p);  //调用的是function(const int*)函数，当然如果这时没有function(const int *)这个
函数，程序就会报错，它不会调用function(int *)函数，因为  int * var = p(错误！)；
当两者都存在时，编译器当然会找最佳匹配方案啊！

总结：讲的太多了，不过关键还是要抓住定义即可，很多时候某些知识看似你懂了。明白了，其实还是没明白！要多看多看！！！！！！

转载于:https://my.oschina.net/eillenme/blog/122307