前言
C++入门专栏是为了补充C的不足，并为后面学习类和对象打基础。在前面我们已经讲解了命名空间、输入输出、缺省参数、重载函数等，今天我们将完结C++的入门。
下面开始我们的学习吧！
一、引用
1、引用是什么呢？为什么C++添加了引用？
（1）引用的概念： 引用是给已存在变量取了一个别名，不是重新定义一个新变量。编译器不会为引用变量开辟内存空间，它和它引用的变量一起用同一块内存空间。（就如西游记中孙悟空，也叫齐天大圣，你不管叫他那个名字，都是代表一个人。）
（2） 在C语言中，我们要改变一个变量的值可以取一个变量的地址通过解引用来改变，但是这是一种间接的玩法。总结：简单的说就是指针是间接的，而引用相当于它的别名还是它自己，更直接，更方便了。 所以以后我们大多都是使用引用了。下面让我们详细了解引用的魅力！
2、引用的语法
引用的语法：
类型& 引用变量名(对象名) = 引用实体。
tip：
（1）引用的理解：
①C++觉得添加太多新符号不太好，所以就会在某些地方共用一些符号。例如这里的‘&’。
②‘&’这个符号用法的区分：‘&’在变量名之前，代表取地址；‘&’在类型之后代表引用（取别名）。
③引用在语法逻辑上不会开辟新空间，它和它引用的实体共用一块内存空间。
④引用就是取别名，不管怎样还是共用一块内存空间。
⑤代码示例：
//引用的理解：
#include<iostream>
using namespace std;
int main()
{
int a = 10;
//b是a的引用(别名)
int& b = a;
//打印a与b的地址
cout << &a << endl;
cout << &b << endl;
return 0;
}
运行结果：
（2）引用的特性：
①引用在定义的时候必须初始化（就如你给谁取别名，肯定是有一个明确的指向，是给谁取的）。
②一个变量可以有多个别名（就像孙悟空就有多个别名）。
③引用一旦引用了一个实体，就不能再引用其他实体了（从这里就能看出C++的革命是不彻底的，引用并没有将指针完全替代）。
④代码示例：
//引用的特性：
#include<iostream>
using namespace std;
int main()
{
int a = 10;
//①必须初始化；
//int& b;//编译报错，引用必须初始化
//②一个变量可以有多个引用
int& b = a;//b是a的引用(别名)
int& c = b;//c是b的引用(别名的别名也是可以的)
//③引用一旦引用了一个实体，就不能在引用其他实体了
int x = 9;
//int& b = x;//编译报错，"b"重定义，多次初始化
b = x;//注意这里b不是x的引用，而是x赋值给b，b仍是a的别名。
return 0;
}
（3）常引用——引用的权限
①引用过程中，权限可以平移或者缩小，但是不可以放大。
②算术转化：如果操作符的操作数类型不一致，会发生类型转化，只有类型一致，才能进行运算。
③类型转化：生成一个临时变量，临时变量具有常性，即临时变量不可改变，是常变量。图示：
④为什么类型转化会生成临时变量——因为变量a类型不会改变，所以需要生成一个中间变量来进行类型转化。
⑤当引用的实体是一个常变量的时候，我们就要使用常引用，因为权限不可以放大。
⑥常引用的应用：常引用做参数——如果函数中只是使用参数，不改变参数的值，建议使用常引用。
⑦代码示例：
//常引用——引用的权限
#include<iostream>
using namespace std;
int main()
{
//1、引用过程中，权限可以平移或者缩小
int a = 10;
int& b = a;//权限平移，a/b可读可写
//如a能++，b也可以
b++;
a++;
const int& c = a;//权限的缩小，a可读可写c可读不可写
//a能++，c不可以
a++;
//c++;//编译报错，c不能改变
//2、引用过程中，权限不可以放大
double x = 9;
//int& y = x;//因为类型不一致，x生成const int的临时变量可读不可写，而y可读可写，引用权限不可以放大，所以报错。
const int& y = x;//权限平移
return 0;
}
3、引用的应用
（1）引用做参数
引用做参数的意义：
①做输出型参数：形参的改变要影响实参。
代码示例：交换两个整数
#include<iostream>
using namespace std;
//使用引用做输出参数交换两个整数
void Swap(int& x, int& y)
{
int temp = x;
x = y;
y = temp;
}
int main()
{
int a = 3;
int b = 5;
//调用函数交换a b
Swap(a, b);
cout << "交换后：a=" << a << " b=" << b << endl;
return 0;
}
tip：在C语言的时候，我们交换两个整数，要使形参的改变影响实参，我们用的指针来实现，现在C++里面我们可以使用引用实现。
②引用做参数，减少拷贝提高了效率。（特别是对于大对象和深拷贝类对象）
代码示例：
//2.调高效率，建议大对象/深拷贝对象使用引用做参数
#include<iostream>
#include<time.h>
using namespace std;
//定义一个大结构体
struct A
{
int a[10000];
};
//定义函数：以值作为函数参数
void Func1(A a){}
//定义函数：以引用作为函数参数
void Func2(A& a){}
//定义函数：分别计算两个函数运行结束后的时间
void TestRefAndValue()
{
//struct A a;//C中定义结构体类型变量的方式，Cpp也可以这样(兼容C)
A a;//Cpp中定义类对象的方式，因为在Cpp中struct升级为类了
//以值作为函数参数
size_t begin1 = clock();//开始时间
for (size_t i = 0; i < 10000; ++i)
{
Func1(a);
}//调用10000次Func1函数
size_t end1 = clock();//结束时间
//以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 10000; ++i)
{
Func2(a);
}
size_t end2 = clock();
//分别输出两个函数运行结束后的时间
cout << "Func1(A)_time:" << end1 - begin1 << endl;
cout << "Func1(A&)_time:" << end2 - begin2 << endl;
}
int main()
{
//调用函数TestRefAndValue分别计算以值为参数和以引用为参数的运行时间
TestRefAndValue();
return 0;
}
运行结果：
（2）引用做返回值
①引用做返回值的第一个意义：减少拷贝提高效率。
代码示例：
//①减少拷贝提高效率
#include<iostream>
#include<time.h>
using namespace std;
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：局部变量传引用返回
//局部变量传引用返回
#include<iostream>
using namespace std;
int& Count()
{
int n = 0;//局部变量
n++;
//……
return n;
}
int main()
{
//ret也是n的别名
int& ret = Count();
//调用完Count直接输出ret
cout << ret << endl;
printf("sss\n");
//调用完printf，再次输出ret
cout << ret << endl;
return 0;
}
运行结果：
为什么ret的值不一样呢——因为局部变量随栈帧销毁而销毁。如果Count函数结束，栈帧不清理，那么ret的结果侥幸正确；如果Count函数结束，栈帧清理，那么ret的结果是随机值。图示：
代码示例2：静态变量传引用返回
//静态变量传引用返回
#include<iostream>
using namespace std;
int& Count()
{
static int n = 0;//静态变量
n++;
//……
return n;
}
int main()
{
//ret也是n的别名
int& ret = Count();
//调用完Count直接输出ret
cout << ret << endl;
printf("sss\n");
//调用完printf，再次输出ret
cout << ret << endl;
return 0;
}
运行结果：
为什么这里ret的值一样呢——静态变量存储在静态区，不随栈帧的销毁而销毁。
tip：谨慎用引用做返回值，出了函数作用域，对象不在了，就不能用引用返回，还在就可以用引用返回。
④引用做返回值的第二个意义：获取返回值与修改返回值。
代码示例：静态顺序表获取pos位置值与修改pos位置值
//代码示例：静态顺序表获取pos位置值与修改pos位置值
#include<iostream>
#include<assert.h>
using namespace std;
//定义静态顺序表类型
struct SeqList
{
int a[100];//顺序表大小
int size;//有效数据个数
};
//C实现——获取pos位置值
int SLGet(SeqList* ps, int pos)
{
//断言pos位置是否合理
assert(pos >= 0 && pos < 100);
//返回pos位置值
return ps->a[pos];
}
//C实现——修改pos位置值
void SLModify(SeqList* ps, int pos, int x)
{
//断言pos位置是否合理
assert(pos >= 0 && pos < 100);
//修改pos位置值
ps->a[pos] = x;
}
//C++使用引用做返回值实现——修改&获取pos位置值
int& SLAt(SeqList& ps, int pos)
{
//断言pos位置是否合理
assert(pos >= 0 && pos < 100);
//返回pos位置的别名
return ps.a[pos];
}
int main()
{
SeqList s;
//调用C的实现，来获取与修改pos位置
SLModify(&s, 1, 2);
cout << SLGet(&s, 1) << endl;
//调用C++的实现，来获取与修改pos位置
SLAt(s, 0) = 1;//修改
cout << SLAt(s, 0) << endl;//获取
return 0;
}
总结
1、引用做参数：①做输出型参数；②减少拷贝提高效率；③基本任何场景都可以用引用做参数。
2、引用做返回值：①减少拷贝提高效率；②可以读写返回值；③谨慎用引用做返回值，出了函数作用域，对象不在了，就不能用引用返回，还在就可以用引用返回。
4、引用与指针的区别
（1）语法层面： 引用不开空间，是对实体取别名；指针开空间，是存储实体地址。
代码示例：
//引用与指针的区别
#include<iostream>
using namespace std;
int main()
{
int a = 11;
//引用在语法层面：不开空间，是对a的别名
int& ra = a;
ra = 13;
//指针在语法层面：开空间，存储a的地址
int* pa = &a;
*pa = 14;
return 0;
}
F10调试观察：
（2）底层层面： 从底层汇编指令实现的角度看，引用是类似指针的方式实现的。即在底层实现上引用实际是开空间的。
汇编代码图示：
（3）引用与指针不同点总结：
①在语法层面：引用不开空间是一个实体的别名，指针开空间，存储实体的地址。
②引用在定义时必须初始化，指针没有要求。
③引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。（即引用不可以修改指向，指针可以修改指向。）
④没有NULL引用，但有NULL指针。
⑤在sizeof中含义不同：引用结果为引用类型的大小，但是指针始终是地址空间所占字节个数。
⑥引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
⑦有多级指针，但没有多级引用。
⑧访问实体方式不同，指针需要显示解引用，引用编译器自己处理。
⑨引用比指针使用起来相对更安全。（如上面第四点。）
二、内联函数
1、回顾宏函数
我们都知道调用函数需要建立栈帧是有消耗的，所以对于一些代码少且频繁调用的函数，在C语言我们使用了宏函数优化。
（1）代码示例：两数相加的宏
错误形式1：
#define Add(x,y) x+y
解读：Add(10,20) * 20，宏预编译进行替换为10 + 20 * 20，我们发现因为操作符优先级的问题，不是先加后乘。
错误形式2：
#define Add(x,y) (x+y)
解读：Add(1 | 2 , 1 & 2)，宏替换后为：（1 | 2 + 1 & 2），位操作符的优先级低于算术操作符，所以错误。
正确形式：
#define Add(x,y) ((x) + (y))
tip：宏参数的求值是在所有周围表达式的上下环境里，除非加上括号，否则邻近操作符的优先级可能会产生不可预料的后果，所以建议宏在书写的时候多写括号。（可以替换看一看。）
（2）宏的优缺点：
优点： 不需要建立栈帧，提高效率。
缺点： 因为宏在预编译阶段进行了替换，所以①不方便调试；②代码可读性差，可维护性差，容易出错；③没有类型的检查等等。
（3）宏函数有这么多缺点，我们C++祖师爷就看不下去了，所以就有了inline内联函数。
2、内联函数
（1）概念： 以inline修饰的函数叫做内联函数，编译时C++编译器会在调用函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
代码示例：
//内联函数
#include<iostream>
using namespace std;
//inline修饰的函数
inline int Add(int x, int y)
{
return x + y;
}
int main()
{
int ret = 0;
ret = Add(1, 2);
}
tip： ①内联函数弥补了宏的缺点，继承了宏的优点。内联函数可读性高，可调试，不复杂等等。②在默认的debug模式下，inline不会起作用，否则不方便调试。
（2）内联这么好能不能都写成内联呢？
答案是： 不可以，因为inline的特性不支持所有函数都写成内联。
（3）内联函数的特性：
①inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺点：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。例如Func编译后是50行指令，如果Func不是inline，调用10000次Func合计指令为：10000+50（调用即call Func(地址)，跳转到Func。）；如果Func是inline，调用10000次Func合计指令为：10000*50（假设inline只是单纯展开，实际不是）。指令越多，目标文件越大。
②inline对于编译器而言只是一个建议，最终是否成为inline，由编译器决定。一般来说，内联机制用于优化规模较小（即函数不是很长，具体没有准确的说法，取决于编译器内部实现）、流程直接（不递归）、频繁调用的函数。例如递归函数加了inline也会被编译器否决。
③inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
代码示例：
//F.h
#include<iostream>
using namespace std;
inline void f(int i);
//F.cpp
#include"F.h"
void f(int i)
{
cout << i << endl;
}
//Test.cpp
#include"F.h"
int main()
{
f(10);
return 0;
}
//链接错误：Test.obj：LNK2019：无法解析的外部符号 "void __cdecl f(int)" (? f@@YAXH@Z)，函数 _main 中引用了该符号
tip：不建议声明与定义分开，所以inline直接在.h文件中定义实现。
三、auto关键字（C++11）
1、auto简介
C++11之前： 在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量（限定变量的作用域及生命周期），但是没有人去使用，因为局部变量默认是auto修饰的。如下：
int a = 10;//自动存储类型
auto int b = 10;//自动存储类型
这样的话，auto没有用了。
C++11中： 标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
简单来说，在C++11中auto可以根据右边的表达式自动推导变量的类型
代码示例：
#include<iostream>
using namespace std;
int main()
{
auto a = 13;
auto b = 0.14;
//打印类型
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
return 0;
}
运行结果：
注意：使用auto定义变量时必须对其进行初始化，在编译阶段需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法。
2、auto的应用场景
随着程序越来越复杂，程序中用到的类型也越来越复杂。类型复杂，我们不仅容易写错还难于拼写。所以这个时候使用auto来帮我们自动推导变量的类型，就非常方便了。
代码示例：
#include<iostream>
#include<map>
int main()
{
std::map<std::string, std::string> dict;
//std::map<std::string, std::string>::iterator it = dict.begin();
//等价于
auto it = dict.begin();
return 0;
}
tip：auto在实际中最常见的优势用法就是跟C++11提供的新式for循环，还有lambda表达式等进行配合使用。
3、auto的使用细则
（1）auto与指针和引用结合使用
代码示例：
#include<iostream>
using namespace std;
int main()
{
int x = 10;
auto a = &x;
auto* b = &x;//auto*指定必须是指针类型
auto& c = x;
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
return 0;
}
运行结果：
tip:使用auto声明指针时，用auto和auto没有任何区别（auto指定必须是指针），但用auto声明引用类型时必须加&。
（2）auto在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同类型，否则编译器将报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
代码示例：
int main()
{
auto a = 1, b = 2;
auto c = 3, d = 13.14;//编译失败，因为c和d的初始化表达式类型不同
return 0;
}
4、auto不能推导的场景
（1）auto不能作为函数的参数
void TestAuto(auto a){}
此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导。
（2）auto不能直接用来声明数组
void TestAuto()
{
auto a[] = {1, 2};
}
编译失败，auto不能声明数组，因为auto类型不能出现在顶级数组类型中。
四、基于范围的for循环（C++11）
1、范围for的语法
在以前（C++98），如果要遍历一个数组，我们是按照下面的方式实现：
#include<iostream>
using namespace std;
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
//通过下标访问
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
arr[i] *= 2;
}
//通过指针访问
for (int* p = arr; p < arr + sizeof(arr) / sizeof(arr[0]); p++)
{
cout << *p << endl;
}
return 0;
}
对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还容易犯错。因此C++11中引入了基于范围的for循环。
范围for的语法格式如下：
for(auto e : array)
for循环后的括号由冒号“：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
现在我们使用范围for来遍历数组，修改数组：
#include<iostream>
using namespace std;
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
//范围for与引用结合：修改数组
for (auto& e : arr)
{
e *= 2;
}
//范围for：打印数组
for (auto e : arr)
{
cout << e << endl;
}
return 0;
}
总结：
①使用范围for遍历数组与以前相比，用起来非常方便，不易出错。所以范围for是一个语法糖。
②适用于数组，依次取数组中的数据赋值给变量e，自动迭代，自动判断结束。
③与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
2、范围for的使用条件
（1）for循环迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
错误演示：以下代码中for的范围是不确定的
void TestFor(int arr[])
{
for (auto e : arr)
{
cout << e << endl;
}
}
解读：数组传参，实际只能接收数组的首元素地址，这里我们并不知道数组的范围，所以报错。
(2)迭代的对象要实现++和==的操作。（后期讲解，大家先知道即可）
五、指针空值nullptr（C++11）
1、C++98中的指针空值
在良好的C/C++编程习惯中，声明一个变量时最好给变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。
如果一个指针没有合法的指向，我们就需要将其置为空。
代码演示：
int main()
{
int* p1 = NULL;
int* p2 = 0;
return 0;
}
为什么0也可以将指针置为空呢？
答案是：NULL实际是一个宏，在传统的C头文件（stddef.h）中，可以看到如下代码：
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
可以看到，NULL可能别被定义为字面常量0，或者被定义为无类型指针（void）的常量。
不论采用哪种定义，在使用空值的指针时，都不可避免的遇到一些麻烦，如下：
#include<iostream>
using namespace std;
//参数类型是整形
void f(int)
{
cout << "f(int)" << endl;
}
//参数类型是整形指针
void f(int*)
{
cout << "f(int*)" << endl;
}
int main()
{
//调用f函数，观察
f(0);
f(NULL);
f((int*)NULL);
return 0;
}
运行结果：
解读：
①程序的本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序初衷相孛。
②在C++98中字面常量0即可以是一个整形数字，也可以是无类型的指针（void*）常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对齐进行强转（void*）0。
③形参因为我们只是观察参数匹配规则，所以可以只写形参类型。
NULL这样太尴尬，所以C++11引入了nullptr
2、nullptr
先看一段代码示例：
#include<iostream>
using namespace std;
//参数类型是整形
void f(int)
{
cout << "f(int)" << endl;
}
//参数类型是整形指针
void f(int*)
{
cout << "f(int*)" << endl;
}
int main()
{
//调用f函数，观察
f(NULL);
f(nullptr);
return 0;
}
运行结果：
总结：
①为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。
②在使用nullptr表示空值时，不需要包含头文件，因为nullptr是C++11作为关键字引入的。
③在C++11中，sizeof（nullptr）与sizeof（（void*）0）所占字节数相同。
