目录
1.引用
1.1引用的概念
引用 不是新定义一个变量，而 是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
间，它和它引用的变量 共用同一块内存空间。
引用的声明方法：类型& 引用变量名(对象名) = 引用实体；
看到 & 这个符号是否会觉得熟悉，在C语言中，我们用&来取变量的地址，还可以表示进行按位与操作，在C++中我们沿用了这两种表达方式，新增了引用。
区分使用&的三种情况：
&a ；表示取地址
a&b ；a,b进行按位与
int& b = a ;b是a的引用，即b是a的别名
可以给一个变量定义多个引用 ，即取多个别名，也可以给别名取别名。
int a = 10;
int& b = a; //给a取别名
int& c = a; //给a取别名
int& d = b; //给b取别名
1.2引用的特性
（1)引用必须初始化
（2）一个变量可以有多个引用
（3）引用定以后不能改变指向
int& b = a;
b = c; //该操作是将c的值赋给a
引用的一个使用场景：
在学习引用之前，在交换两数的Swap函数中，传过去的参数是两数的地址，函数参数用指针接收，使用引用时参数写为 类型& 别名
void Swap1(int* x,int* y) //x,y是a,b的地址
{
int tmp = *x;
*x =*y;
*y = tmp;
}
void Swap2(int& x, int& y) //x,y是a,b的别名
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 1;
int b = 2;
Swap1(&a,&b);
Swap2(a,b);
return 0;
}
既然能这样使用，那么引用能否替代指针？
不能完全替代，指针和引用的功能类似，C++的引用对指针使用比较复杂的场景进行一些替换，让代码更简单，不能完全替代的原因：引用定以后，不能改变指向。
1.3使用场景
（1）做参数
a、输出型参数
像下面这道题中的returnSize，就是一个输出型参数。
b、如果对象比较大，减少拷贝，提高效率。
虽然指针也能达到目的，但是引用效率更高，更省时。
（2）做返回值
a、修改返回对象
b、减少拷贝、提高效率
以下代码是引用做返回值的形式吗？
代码（1）是传值返回，返回a的值用ret接收，因为a是局部变量，fun1函数结束，ret收到的值取决于函数栈帧销毁时对这块空间清不清零，如果清零就收到的返回值就是随机值；
代码（2）是引用返回，返回a的引用，但因为a仍是局部变量，与（1）相同，对这片空间清零的话ret收到的值就是随机值；
代码（3）中返回a的引用，ret也是a的引用，但出了作用域a的空间就被反还给操作系统，ret成了野引用，就找不到a了；
总结：如果返回变量出了函数作用域生命周期到了要销毁，就不能用引用返回
**所以以上都不是。**以上是传值返回和传引用返回的区别，前者是传返回值的拷贝，后者是传返回值的引用。
可以用引用返回的情况有：全局变量/静态变量/堆上变量等
int& func()
{
static int a = 0;
return a;
}
int main()
{
int ret = func();
cout << ret << endl;
}
1.4引用与指针的区别
语法上：
a、引用是别名，不需要开额外的空间；指针是地址，需要开辟空间存放地址
b、引用必须初始化，指针可以初始化也可以不初始化
c、引用不能改变指向，指针可以改变
d、引用相对更安全，没有空引用，但是有空指针。所以容易出现空指针，不容易出现空引用
e、在 sizeof 中含义不同 ：引用 结果为引用类型的大小 ，但指针 始终是地址空间所占字节个数
f、有多级指针，没有多级引用
g、引用++是对所引用的实体增1，指针++是指针向后偏移一个类型的大小
h、指针需要显示解引用，引用编译器自己处理
用法和底层：
汇编层面上，没有引用，都是指针，引用在编译后也转换成指针了
2.内联函数
2.1内联函数的概念
每调用一次函数就建立一个栈帧，如果频繁调用就需要频繁建立栈帧，在C语言中，使用宏函数解决了这个问题。但是宏函数在书写时语法比较复杂不好控制，所以C++中引入了内联函数。
以 inline修饰 的函数叫做内联函数， 编译时 C++编译器会在 调用内联函数的地方展开，没有函数调
用建立栈帧的开销，内联函数提升程序运行的效率。
2.2内联函数的特征
（1）inline是一种以空间换时间 的做法，如果编译器将函数当作内联函数处理，在编译阶段，会用函数体替换函数调用。（空间不是内存空间，是指编译好的可执行程序）缺点：可能会使目标文件变大，即发生代码膨胀；优点：减少了调用开销，提高程序运行效率。
（2）inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同 ，一般将函数规模小的、不是递归的、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
（3）inline不建议声明和定义分离，否则会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
如果在头文件内定义一个函数，在多个文件包含该头文件，程序将会报错。报错信息如下：
这是因为在生成的code.o和test.o内都有函数定义，该函数地址进入符号表了，在链接时两文件的符号表需要合并，合并时发生存在两个一样的函数，便发生了链接错误。
链接错误的解决方法：
①声明与定义分离
这种方法是我们最常使用的一种，在头文件声明，其他文件定义。
②static修饰
如果不想将声明和定义分离，便可使用static修饰函数。static修饰函数是改变了函数的链接属性，语法上说是只在当前文件可见，从底层讲是该函数地址不会进入符号表，因此不会发生链接冲突。
③inline修饰
声明与定义不可分离，与静态修饰的原理类似。一般我们对小函数用inline修饰，大函数用static修饰。
3.auto关键字（C++11）
3.1引入
随着程序越来越复杂，程序用到的类型也越来越复杂，比如含义不明确、类型难拼写等。
#include<map>
#include<string>
int main()
{
std::map<std::string, std::string>m{ {"apple","苹果"},{"orange","橘子"}};
std::map<std::string, std::string>::iterator it = m.begin();
//...
return 0;
}
std::map<std::string, std::string>::iterator 是一个类型名，但是该类型太长了，写起来很麻烦，所以我们可以通过给它取别名来减少失误。
在C语言的学习中，我们使用typedef给类型取别名，比如添加 typedef std::map<std::string, std::string> Map 。
#include<map>
#include<string>
typedef std::map<std::string, std::string> Map ；
int main()
{
std::map<std::string, std::string>m{ {"apple","苹果"},{"orange","橘子"}}；
Map::iterator it = m.begin();
//...
return 0;
}
那么在C++中，使用什么可以简化代码呢？由此我们引出了关键字auto。
写为：
auto it = m.begin();
3.2auto的含义
auto的作用是自动推导类型，在使用的时候必须初始化。
在早期的C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量。
C++11中，auto被赋予了新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推到而得。
#include<iostream>
using namespace std;
int main()
{
int i = 1;
auto j = i;
cout << typeid(j). name() << endl; //typeid用于打印参数类型
auto p = &i;
auto* ps = &j;
cout << typeid(p).name() << endl;
cout << typeid(ps).name() << endl;
auto& k = j;
cout << typeid(k).name() << endl;
//auto m; error C3531: "m": 类型包含"auto"的符号必须具有初始值设定项
return 0;
}
【注意】auto使用时必须初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此，auto并非是一种"类型"的声明，而是一个类型声明时的"占位符"，编译器在编译期会将auto替换为变量实际的类型。
3.3auto的使用场景
3.3.1auto与指针和引用结合起来使用
通过前面例子可以看出用auto声明指针类型时使用 auto 和 auto* 没有区别，但在用auto声明引用类型时必须写为auto&。
3.3.2在同一行声明多个变量
在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器会报错。因为编译器只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0;
}
报错如下：
3.4auto不能推导的场景
（是规定，记住就可以了）
①auto不能作函数的参数
②auto不能用来声明数组
③与新式for循环，lambad表达式等配合使用。
4.基于范围的for循环（C++11）
4.1引入
在C++98中，我们要遍历一个数组通常使用下面的方式进行：
void TestFor()
{
int array[] = { 1,2,3,4,5 };
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
array[i] *= 2;
for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); ++p)
cout << *p << endl;
}
遍历的范围是一个有限的集合，为了避免出错，在程序员使用时可以不必说明循环范围。因此在C++11中引入了基于范围的for循环 。for循环后的括号由" ："分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
上述代码可修改成下面的形式，想想打印的结果是什么？
void TestFor()
{
int array[] = { 1,2,3,4,5 };
for (auto e : array) //依次取数组中的值赋值给e，自动迭代，自动判断结束
e *= 2;
for (auto e : array)
cout << e << " ";
}
结果是：1 2 3 4 5
不是已经执行 e *= 2 了吗，为什么打印出的结果还是原数值呢。因为只是将array[0]、arrary[1] 等的值赋给了变量e，e只是它的一份拷贝，并不会修改数组本身的值。要想修改数组的值，只需将变量声明为引用类型。
4.2范围for的使用条件
①for循环迭代的范围必须是确定的
像下面代码就是有问题的，因为循环迭代的范围不确定。（形参不能是数组，传过来的是指针）
void TestFor(int a[])
{
for (auto& e : a)
e *= 2;
}
int main()
{
int arr[] = { 1,2,3 };
TestFor(arr);
return 0;
}
②迭代的对象要实现++和==的操作
5.指针空值nullptr（C++11）
请看以下代码，思考一下结果是什么
void f(int i)
{
cout << "f(int)" << endl;
}
void f(int* i)
{
cout << "f(int*)" << endl;
}
int main()
{
f(0);
f(NULL);
}
结果如下：
与你思考的结果一样吗？f(NULL)对应结果为什么不是f(int*)？
在C++98中NULL实际是一个宏，在stdio.h中可以看到以下代码
#ifndef NULL
#ifdef _cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
可以看出NULL被定义为字面常量0 ，或者被定义为无类型指针(void*)的常量。从而出现了上面的问题。
所以要想在C++中匹配第二个函数时应该将NULL强转成指针类型。
这样看来每次使用指针空值时需要强转，很不方便。在C++11中引入了一个关键字nullptr，用它来表示指针空值。
注意：
①使用nullptr表示指针空值时不需要包含头文件
②在C++11中，sizeof(nullptr) 与 sizeof((void*)0) 所占字节数相同
③为了提高代码健壮性，后续都建议使用nullptr表示指针空值