文章目录

一、引用的概念二、引用的语法规则1、引用特性2、常引用

二、引用的使用场景1. 引用做参数2. 引用做返回值

三、引用和指针的区别

一、引用的概念

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

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

二、引用的语法规则

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

<code>#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使用的是同一块内存空间

<code>int main()

{

int a = 10;

int& b = a;

cout << &a << endl;

cout << &b << endl; // a 和 b 使用的是同一块内存空间

return 0;

}

<code>int main()

{

int a = 10;

int& b = a;

b = 20;

cout << a << " " << b << endl;

return 0;

}

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

1、引用特性

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

<code>void testref()

{

int a = 10;

int& b; // err 引用是必须初始化

}

2、一个变量可以有多个引用

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

<code>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、常引用

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

<code>void testref03()

{

int& a = 10; // err, 不可以引用常量

}

解决办法

想要引用常量的话，只要在引用的前面加一句const，加上const之后，引用就不可以发生改变。

除了上述情况，引用的类型不同也会导致编译不同过，这是因为在发生类型转化的过程中，会产生临时变量，而临时变量具有常性，和常量一样，需要用const引用。

<code>void testref04()

{

char ch = 'a';

int& a = ch; // 不可以引用不同类型的变量，类型转化时会产生临时变量，临时变量具有常性

}

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

<code>void testref05()

{

char ch = 'a';

const int& a = ch;

}

二、引用的使用场景

1. 引用做参数

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

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

<code>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;

}

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

<code>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;

}

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

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

<code>#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、语义概念上引用就是变量的别名，没有独立空间，和引用实体共用同一块空间。

<code>int main()

{

int a = 10;

int& b = a;

cout << &a << endl;

cout << &b << endl;

return 0;

}

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

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

<code>int a = 20;

int* pa; // 指针可以不初始化

int& ra; // 引用必须初始化

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

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

<code>int* pa = NULL;

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

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

<code>#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，指针自加即指针向后偏移一个类型的大小

<code>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、有多级指针，但是没有多级引用

<code>int a = 10;

int* pa = &a;

int** ppa = &pa;

int& ra = a;

int&& rra = ra; // 无多级引用

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

<code>int main()

{

int a = 10;

int* pa = &a;

int& ra = a;

cout << ra << endl;

cout << *pa << endl;

return 0;

}

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