引用

引用

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

引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

	int a = 10;
	//引用必须初始化
	//int& ra编译错误;
	int& ra = a;
	//变量有多个引用
	int& ra1 = a;
	int& ra2 = a;
	//不是修改引用的指向，而是把b的内容赋值给ra1指向的实体
	int b = 100;
	ra1 = b;

常引用

引用指向的实体不能修改。

int  c = 1;
	const  int& d = c;
	//不能通过引用对目标变量的值进行修改,从而使引用的目标成为const，达到了引用的安全性。
	//d=2;//编译错误 error c3892: “d”: 不能给常量赋值
	c = 2; //正确

注意：
  如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

示例：

int& add(int& a, int& b)
{
	int c = a + b;
	return c;
}

int main()
{
	
	int a = 10;
	int b = 20;
	int& ret = add(a,b);
	cout << "Add(10,20) is :" << ret << endl;
	system("pause");
	return 0;
}

此时ret是一个随机值，因为c已经返回。

int& add(int& a, int& b)
{
	return a += b;
}

int main()
{
	
	int a = 10;
	int b = 20;
	int& ret = add(a,b);
	cout << "Add(10,20) is :" << ret << endl;
	system("pause");
	return 0;
}

传值、传引用效率比较

#include <stdio.h>
#include <time.h>
#include <iostream>
using namespace std;
struct A
{
	int a[100000];

};
void fun1(A a){};
void fun2(A& a){};

int main()
{
	A a;
	size_t b1 = clock();
	for (size_t i = 0; i < 100000; i++)
	{
		fun1(a);
	}
	size_t e1 = clock();
	size_t b2 = clock();
	for (size_t i = 0; i < 100000; i++)
	{
		fun2(a);
	}
	size_t e2 = clock();

	cout << "time:" << e1 - b1 << endl;
	cout << "time:" << e2 - b2 << endl;
	system("pause");
	return 0;
}

结论：传引用效率更高。

#include <stdio.h>
#include <time.h>
#include <iostream>
using namespace std;
struct A
{
	int a[100000];

};
A a;
A fun1(){ return a; };
A& fun2(){ return a; };

int main()
{

	size_t b1 = clock();
	for (size_t i = 0; i < 100000; i++)
	{
		fun1();
	}
	size_t e1 = clock();
	size_t b2 = clock();
	for (size_t i = 0; i < 100000; i++)
	{
		fun2();
	}
	size_t e2 = clock();

	cout << "time:" << e1 - b1 << endl;
	cout << "time:" << e2 - b2 << endl;
	system("pause");
	return 0;
}

结论：传引用效率更高。

引用和指针的不同点

1. 引用在定义时必须初始化，指针没有要求。
2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
3. 没有NULL引用，但有NULL指针。
4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)。
5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
6. 有多级指针，但是没有多级引用。
7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
8. 引用比指针使用起来相对更安全。