沈阳建站平台南通个人网站建设

一、引用的概念

首先明确一下，引用不是定义一个新的变量，而是给已经存在的变量起一个别名，变量和他的引用是共用同一块内存空间。

C++中的引用就是和人的外号一样，人的本名和外号都是指同一个人。比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。

二、引用的语法规则

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

#include<iostream>
using namespace std;int main()
{int a = 10;int& b = a;  // b是a的引用cout << a << endl;cout << b << endl;return 0;
}

变量a 和它的引用b使用的是同一块内存空间

int main()
{int a = 10;int& b = a;cout << &a << endl;cout << &b << endl;  // a 和 b 使用的是同一块内存空间return 0;
}

int main()
{int a = 10;int& b = a;b = 20; cout << a << " " << b << endl;return 0;
}

由于变量和变量的引用是使用的同一块内存地址，这意味着如果改变b，那么a也会随着b的改变而改变。

1、引用特性

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

void testref()
{int a = 10;int& b;  // err 引用是必须初始化
}

2、一个变量可以有多个引用
一个变量被引用后，可以继续被引用，也可以引用变量的引用。

void testref02()
{int a = 10;int& b = a;int& c = a;  // 一个变量可以有多个引用 int& d = b;  // 可以引用变量的引用
}

3、引用一旦引用一个实体（变量），就不能在引用其他实体

void testref02()
{int a = 10;int b = 20;int& c = a;int& c = b;  // c不可以重复引用
}

这里要和C/C++中的指针区分一下，指针可以改变指针指向的对象，但是引用不可以。

2、常引用

一般来说，引用只可以引用变量，不可以直接引用常量的。因为常量是不可以改变的。

void testref03()
{int& a = 10;  // err, 不可以引用常量
}

解决办法
想要引用常量的话，只要在引用的前面加一句const，加上const之后，引用就不可以发生改变。
除了上述情况，引用的类型不同也会导致编译不同过，这是因为在发生类型转化的过程中，会产生临时变量，而临时变量具有常性，和常量一样，需要用const引用。

void testref04()
{char ch = 'a';int& a = ch;  // 不可以引用不同类型的变量，类型转化时会产生临时变量，临时变量具有常性
}

产生临时变量时都要用常引用。

void testref05()
{char ch = 'a';const int& a = ch;
}

二、引用的使用场景

1. 引用做参数

在C语言学习指针的时候一定学过一个交换函数Swap，那时候我们在Swap时参数必须要用传址调用，因为如果用传值调用的话，形参的改变是不影响实参的，无法实现交换功能。

但是如果我们学了引用的话就不需要使用传址调用了，可以直接用引用作为参数，引用的形参就是实参的别名

void func(int& x, int& y)
{cout << &x << endl;cout << &y << endl;
}int main()
{int a = 10;int b = 20;cout << &a << endl;cout << &b << endl;cout << "-------------" << endl;func(a, b);return 0;
}

用引用的话，在函数传参时就不需要传址调用了，更加方便。

void Swap(int& a, int& b)
{int tmp = a;a = b;b = tmp;
}

2. 引用做返回值

是的，你没看错，引用不仅可以做函数的参数，还可以做函数的返回值，我们之前写的具有返回值的函数返回的并不是直接将函数中的变量，而是返回的变量的一份临时拷贝，而拷贝是需要付出一定代价的，这样会降低我们代码的效率，但是如果我们用引用返回的话就可以避免拷贝的代价，在对程序性能要求高且允许使用引用的情况下，尽量使用引用返回。

注意：并不是所有的函数都可以用引用返回，有些强行使用引用返回会造成一些不必要的错误。
函数可以用引用返回的条件：
函数的返回值在出函数作用域后不会被销毁。

int& Count()
{static int n = 0;n++;// ... return n;
}

静态变量出了函数定义域之后不会销毁，可以用引用返回。

int& Count()
{int n = 0;n++;// ...return n;  // n在出函数作用域后就销毁了，不要用引用返回
}

传值、传引用的的效率比较
用值作为参数或返回值时，在传参和返回期间，函数是不会直接传递实参或则是将变量之间返回，而是传递实参或者返回变量的一份临时拷贝，所以用值传参或者做返回值效率是非常低的，尤其是当参数或者返回值类型非常大时，效率更加低下。

值和引用作为函数参数的效率对比：

#include <time.h>
// 传值
struct A{ int a[10000]; }; 
void TestFunc1(A a) {}
// 传引用
void TestFunc2(A& a) {}void TestRefAndValue()
{A a;// 以值作为函数参数size_t begin1 = clock();for (size_t i = 0; i < 10000; i++){TestFunc1(a);}size_t end1 = clock();// 以引用作为函数参数size_t begin2 = clock();for (size_t i = 0; i < 10000; i++){TestFunc2(a);}size_t end2 = clock();// 分别计算两个函数运行结束后的时间cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

传值的效率明显低于传引用。

值和引用作为函数返回值的效率对比：

#include<time.h>
struct A { int a[10000]; };A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }void TestReturnByRefOrValue()
{// 以值作为函数的返回值类型size_t begin1 = clock();for (int i = 0; i < 100000; i++)TestFunc1();size_t end1 = clock();// 以引用作为函数的返回值类型size_t begin2 = clock();for (int i = 0; i < 100000; i++)TestFunc2();size_t end2 = clock();// 计算两个函数运算完成之后的时间cout << "TestFunc1() Time:" << begin1 - end1 << endl;cout << "TestFunc2() Time:" << begin2 - end2 << endl;
}int main()
{TestReturnByRefOrValue();return 0;
}

传值和指针在作为传参以及返回值类型上效率相差很大。

三、引用和指针的区别

1、语义概念上引用就是变量的别名，没有独立空间，和引用实体共用同一块空间。

int main()
{int a = 10;int& b = a;cout << &a << endl;cout << &b << endl;return 0;
}

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

2、引用必须初始化，指针可以在定义时不初始化

int a = 20;
int* pa;  // 指针可以不初始化
int& ra;  // 引用必须初始化

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

4、没有NULL引用，但有NULL指针。

int* pa = NULL;
int& ra = NULL;  // err，没有NULL引用

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

#include<string>
int main()
{string str = "abcdef";string& rstr = str;string* pstr = &str;cout << "string& rstr = str: " << sizeof(rstr) << endl;cout << "string* pstr = &str: " << sizeof(pstr) << endl;return 0;
}

6、 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

int main()
{int a = 10;int& ra = a;int* pa = &a;ra++;pa++;cout << "int& ra = a:  " << ra << endl;cout << "int* pa = &a: " << pa << endl;return 0;
}

7、有多级指针，但是没有多级引用

int a = 10;
int* pa = &a;
int** ppa = &pa;
int& ra = a;
int&& rra = ra;  // 无多级引用

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

int main()
{int a = 10;int* pa = &a;int& ra = a;cout << ra << endl;cout << *pa << endl;return 0;
}

9、引用比指针使用起来相对更安全，毕竟指针存在野指针，而不存在野引用。