【C++】函数引用

概念：

引用不是新定义一 个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

用法：

类型&  引用变量名(对象名) =引用实体;

void Test()
{
    int a=10;
    int& ra = a;//定义引用类型（相当于ra是a的别名）

    printf("%p\n"。&a);
    printf("%p\n"，&ra);
}

注意: 引用类型必须和引用实体是同种类型的

引用特性：

1.引用在定义时必须初始化；

int main()
{
    int a = 10;
    int& ra ;//不进行初始化，代码编译时出错

2.一个变量可以有多个引用（还可以给别名取别名）；

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

int main()
{
	int a = 10;
	int& ra = a;//定义引用类型（相当于ra是a的别名）
	int& qa = ra;

	printf("%p\n",&a);
	printf("%p\n",&ra);
	printf("%p\n", &qa);
	system("pause");
	return 0;
}

3.引用一旦引用一个实体，再不能引用其它实体。

int main()
{
	int a = 10;
	int& ra = a;//定义引用类型（相当于ra是a的别名）
	int b = 0;
	int& ra = b;

	printf("%p\n",&a);
	printf("%p\n",&ra);
	printf("%p\n", &ra);
	system("pause");
	return 0;
}
//该代码编译时出错，因为ra既引用了a，又引用了b

常引用

void testRef()
{
	const int a = 10;
	int& ra = a;//该语句编译时会出错,a为常量
	const int& ra = a;//正确
	
	int b=10;//该语句编译时会出错,a为常量
	const int& b = 10;正确

	int i = 10;
	double& rd =i;//该语句编译时会出错,类型不同
	const double& rd = i;//正确

}
int main()
{
	testRef();
	system("pause");
	return 0;
}

其中：

int i = 10;
double& rd =i;//该语句编译时会出错,类型不同

这个代码出错的真正原因并不是因为类型，而是因为在隐式转换中，会生成临时变量，而临时变量是由编译器生成的，具有常属性，不能被修改，而rd也就相当于给这个临时变量起别名，所以只有加上const时，代码才能运行通过。

引用时，对权限有一个要求：权限只能缩小，不能放大，比如：

void testRef()
{
	const int a = 10;
	int& b = a;

}

此时这个别名是取不出来的，因为类型匹配不上，a是const int类型，也就是说a是不能被改变的，b变成a的别名，b的类型是int，意味着b可以被修改，相当于a的权限被扩散化（修改），所以不能这样。加上const就可以了。

void testRef()
{
    const int a = 10;
    const int& b = a;

}

权限扩大化不可以，但是缩小又是可以的，如：

void testRef()
{
    int c = 20;
    const int& d = c;

}

这个是正确的，c是可读可修改，给d后，可读但不修改。

引用作用：

1.做参数（效率高）

void Swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}

2.做返回值（相当于少开辟一个空间，效率高）

int& TestRef(int& a)
{
	a += 10;
	return 0;
}

传值和传引用的效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时拷贝，因此用值作为参数或返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。那指针和引用作为参数和返回值类型的效率呢？

（1）指针和引用作为参数的性能比较

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <time.h>
using std::cout;
using std::endl;

struct A
{
	int a[100000];
};
void TestFunc1(A* a)//指针
{

}
void TestFunc2(A& a)//引用
{

}

void TestRefAndPtr()//
{
	A a;
	//以指针作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; i++)
		TestFunc1(&a);
	size_t end1 = clock();
	//以指针作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; i++)
		TestFunc2(a);
	size_t end2 = clock();
	//分别计算两个函数运行结束后的时间
	cout << "TestFunc1(int*)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(int&)-time:" << end2 - begin2 << endl;

}
//运行多次，检测指针和引用在传参方面的效率差别
int main()
{
	for (int i = 0; i < 10; i++)
	{
		TestRefAndPtr();
	}
	system("pause");
	return 0;
}

很明显，引用要比指针效率更高一些：

（2）指针和引用作为返回值类型的性能比较

//作为返回值类型的性能比较
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <time.h>
using std::cout;
using std::endl;

struct A
{
	int a[100000];
};
A a;
A* TestFunc1()//指针
{
	return &a;
}
A& TestFunc2()//引用
{
	return a;
}

void TestRefAndPtr()//
{

	//以指针作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000000; i++)
		TestFunc1();
	size_t end1 = clock();
	//以指针作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000000; i++)
		TestFunc2();
	size_t end2 = clock();
	//分别计算两个函数运行结束后的时间
	cout << "TestFunc1-time:" << end1 - begin1 << endl;
	cout << "TestFunc2-time:" << end2 - begin2 << endl;

}
//运行多次，检测指针和引用在传参方面的效率差别
int main()
{
	TestRefAndPtr();
	system("pause");
	return 0;
}

显而易见：依旧是引用的效率高

引用和指针的区别：

在语法概念上，引用就是一个别名，没有独立空间，和其引用实体共用一块空间。（概念上来说，引用是别名，而指针是地址。引用概念上虽然不是存地址，但是在底层，还是用存地址的方式实现的）

  引用和指针的不同点:

      1.引用在定义时必须初始化，指针没有要求

      2.引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

      3.引用没有NULL引用，但指针有NULL指针

      4.在sizeof中含义不同:引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)

      5.引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小6.有多级指针，但是没有多级引用

      7.访问实体方式不同，指针需要显式解引用，引用是编译器自己处理

      8.引用比指针使用起来相对更安全

问题：如何定义一个8字节的指针？

控制一个64位的编译器即可（把编译器修改为64位的）。