一、引用

1.1 什么是引用？

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。简单来说就是，比如张三，在学校的外号可能叫小张，但是本质上张三和小张都是同一个人，小张只不过是张三的别名而已。
如何定义引用：
类型& 引用变量名(对象名) = 引用实体
例如：int a=10; int& b=a;
那么b就是a的引用。b和a都是指向同一块空间，也就是说，改变a的同时也会改变b，相反，改变b也会改变a。
注意：引用类型必须和引用实体是同种类型的。

1.2 引用的特性

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

int main()
{int a = 10;//int& b;//这种写法是错误的，引用在定义的时候必须初始化int& b = a;//这种写法才是正确的int x = 20;int& y = x;int& z = x;printf("%p\\n", &x);printf("%p\\n", &y);printf("%p\\n", &z);return 0;
}

1.3 常引用

1.4 引用的使用场景

1. 引用可以做参数
2. 引用也可以做返回值

1、引用做参数：
相信大家对C语言的指针都已经相当的熟悉了，指针传参也是用得非常多了，但是应该在指针的使用上也吃过不少亏了，指针传参确实可以较少拷贝，提高效率，但是指针使用起来还是非常的繁琐的，传参的时候要取地址，访问的时候要解引用等等。正是基于这样的一些原因，C++才增加了引用，引用做参数既能做到减少拷贝，使用起来又比较简单，不容易出错。用引用做参数可以说是既拥有了指针的优点，又弥补了指针使用复杂的缺点，堪称完美。
下面我们就来看看如何用引用做参数：

//用指针做参数
void swap1(int* x, int* y)
{int tmp = *x;*x = *y;*y = tmp;
}//用引用做参数
//引用传参的x是a的引用，y是b的引用
//也就是说x就是a，y就是b，所以在函数
//里面直接交换即可，改变x和y就是改变
//a和b，能达到交换a和b的结果
void swap2(int& x, int& y)
{int tmp = x;x = y;y = tmp;
}int main()
{int a = 10;int b = 20;cout << "a=" << a << " b=" << b << endl;//用指针做参数swap1(&a, &b);cout << "a=" << a << " b=" << b << endl;//用引用做参数swap2(a, b);cout << "a=" << a << " b=" << b << endl;return 0;
}

引用可以作为输出型参数。
引用做参数，可以减少拷贝，提高效率。

2、引用做返回值（重点）

以下这段代码的输出结果是多少？

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

有人说：“这还不简单吗？10+20当然等于30啊！”确实10+20=30是没错的，但是这里的运行结果真的是30吗？我们来看一下。

这是个什么情况？10+20=10？看来数学是体育老师教的实锤了哈哈哈。我们看一下到底是什么原因导致这个10+20会等于10。

特别需要注意：函数返回时，出了函数作用域，如果返回对象还在(还没还给操作系统)，则可以使用引用返回，如果已经还给操作系统了，则必须使用传值返回。（切记）

1.5 传值和传引用效率比较

1.5.1 传值和传引用做参数的性能对比

以值作为参数或者返回值类型，在传参和传返回值期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。比如说返回值是一个很大的对象的时候，拷贝的消耗就太大了。

struct A 
{ int a[10000] = { 0 };
};
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{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(A)-time:" << end1 - begin1 << endl;cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}int main()
{TestRefAndValue();return 0;
}

1.5.2 传值和传引用做返回值的性能对比

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

通过上述代码的比较，明显看到传值和传引用做参数或者返回值的时候效率相差很大，显然传引用是更高效的，因为传引用可以减少拷贝。

1.6 引用和指针之间的区别

在语法层面上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。实际在底层实现上是有空间的，因为引用是按照指针方式来实现的。

引用和指针的不同点：

1. 引用在概念上是变量的一个别名，指针变量是存储了这个变量的地址。
2. 引用在定义是必须初始化，指针不一定要初始化。
3. 引用一旦有了它引用的实体之后就不能修改，即不能再引用别的实体，但是指针可以先指针一个变量，后指向另一个变量。
4. 引用不能有空引用，但是可以有空指针。
5. 引用在sizeof下的大小是这个引用的实体的大小，但是指针是固定大小的，在32位平台下是4个字节，在64位下是8个字节。
6. 引用的自加是引用的实体的值增加1，而指针自加即指针向后偏移一个类型的大小。
7. 有多级指针，但是没有多级引用。
8. 访问实体的方式不同，指针访问实体需要显示地解引用，引用访问实体由编译器处理。
9. 引用比指针使用起来更安全，例如引用不会存在越界引用等等的问题。

二、内联函数

2.1 什么是内联函数？

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数能够提升程序运行的效率。

不使用内联函数：

使用内联函数：

2.2 内联函数的特性

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用。缺陷：可能会使目标文件变大，代码膨胀。优势：少了调用开销，提高程序运行效率。
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。即一个函数是否为内联函数最终取决于编译器。
3. 建议 inline 的声明和定义不分离，分离会导致链接错误。因为inline在编译时是被展开的，没有函数地址进符号表，链接就会找不到。
   

2.3 内联函数和宏对比

宏的优缺点？
优点：

1. 增强代码的复用性。
2. .提高性能。

缺点：

1. 不方便调试宏。（因为预编译阶段进行了替换）
2. 导致代码可读性差，可维护性差，容易误用。
3. 没有类型安全的检查 。

C++有哪些技术可以替代宏？

1. 常量定义 换用const enum
2. 短小函数定义 换用内联函数

三、auto关键字

3.1 auto关键字的介绍

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

1. 类型难于拼写
2. 含义不明确导致容易出错

例如：

int main()
{map<string, string> dict;//当我们需要使用迭代器时//std::map<std::string, std::string>::iterator迭代器是一个类型，//这未免也太长了,所以在写的时候不仅难写，还容易出错std::map<std::string, std::string>::iterator it = dict.begin();return 0;
}

由于在写程序的时候有些类型实在是太长了，所以在C++中给auto赋予了新的含义。
其实在早期就存在auto这个关键字，使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它。在C++11中，标准委员会赋予了auto全新的含义：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

需要注意的是：使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto关键字并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

3.2 auto关键字的使用细则

一、auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

int main()
{int a = 10;//这里的auto会被推导为int*auto pa1 = &a;//这里的auto会被推导为intauto* pa2 = &a;//auto推导引用必须带上&auto& b = a;return 0;
}

二、在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

三、auto不能推导的场景
1、 auto不能作为函数的参数。

2、auto不能直接用来声明数组。

3、为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法。
4、auto在实际中最常见的优势用法就是跟C++11提供的新式for循环，还有lambda表达式等进行配合使用。

四、 基于范围的for循环(C++11引入)

4.1 范围for的用法

对于一个有范围的集合而言，由程序员来说明循环的范围是明显是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

int main()
{int a[] = { 1,2,3,4,5 };//C++98遍历数组的方式int sz = sizeof(a) / sizeof(a[0]);for (size_t i = 0; i < sz; i++){cout << a[i] << " ";}cout << endl;//C++11遍历数组的方式//显然，这种新型的范围for循环//使用起来会更加的方便auto在//这里使用就非常的吃香了，因为//由auto你根本就不需要知道数组//里面放的元素是什么类型，自动//推导就好了//建议auto带上&，当数组是大对象//的时候可以减少拷贝，提高效率for (auto& e : a){cout << e << " ";}cout << endl;return 0;
}

需要注意的是：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

4.2 范围for的使用条件

1、for循环迭代的范围必须是确定的。
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的迭代器，begin和end迭代器就是for循环迭代的范围。

void Print(int a[])
{//编译报错，因为a的范围不明确for (auto& e : a){cout << e << " " << endl;}cout << endl;
}int main()
{int a[] = { 1,2,3,4,5 };Print(a);return 0;
}

2、 迭代的对象要实现++和==的操作。

五、指针空值（nullptr）

C++98下的指针空值：
在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

int main()
{int a = 10;int* p1 = NULL;int* p2 = 0;return 0;
}

NULL实际上是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。但无论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些问题，比如：

void func(int x)
{cout << x << endl;
}
void func(int* px)
{cout << *px << endl;
}int main()
{int a = 10;int* p1 = NULL;int* p2 = 0;func(NULL);return 0;
}

以上程序的本意是用NULL调用func(int* px)函数的，但是由于NULL是一个被定义成整数0的宏，所以这里func(NULL)在编译的时候变成了func(0)，因此与程序的初衷相悖。证明如下：

可以看出，确实进入了func(int x)的函数里面。
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量0，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。

因此在C++11中引入了新的表示指针空值的关键字nullptr。
关键字nullptr也是一个宏，是(void*)0。证明如下：

可以看到，当传nullptr作为参数的时候进入了函数func(int* px)，证明nullptr是一个指针类型，空指针的值为0是固定的，所以nullptr就是 (void*)0 。

nullptr有几点需要注意的地方：
1、在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2、在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3、为了提高代码的健壮性，在C++中表示指针空值时建议最好使用nullptr。

以上就是今天要分享的内容，你学会了吗？如果对你有所帮助，那就留下一个小心心，点点关注呗，后期还会持续输出C++的知识哦，我们下期见！！！！