【C++】C++入门

1.C++的由来

C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机， 20世纪80年代， 计算机界提出了OOP(object oriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生。 1982年，贝尔实验室的Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++，Bjarne Stroustrup因此也被尊称为C++之父。因此C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象程序设计。C++是在C的基础之上，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式等。熟悉C语言之后，对C++学习有一定的帮助。

快来拜见祖师爷啦！！！😄😄😄

​ C++之父 :本贾尼·斯特劳斯特卢普

2.C++关键字(C++98)

C++总计63个关键字，C语言32个关键字

下面我们只是看一下C++有多少关键字，不对关键字进行具体的讲解，后面我们学到以后再细讲。

2.1. 命名空间

这里我们补充一点知识

大家看别人写的C++代码中，在一开始会包这个头文件：

#include
1

这个头文件等价于我们在C语言学习到的#include，它是用来跟我们的控制台输入和输出的，这里简要提一下，重点在后面。除了上面这个头文件，还有这样一行代码：

using namespace std;
1

namespace就是我们要接触C++的第一个关键字，它就是**命名空间**。

• 命名空间的作用：

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

2.1.1.C语言的命名冲突

在正式了解C++的命名空间，让我回顾一下C语言的命名冲突问题

#include 
#include 
int rand = 10;

int main()
{
 printf("%d\n", rand);
 return 0;
}
1
2
3
4
5
6
7
8
9

如上的代码中，我们定义了全局变量rand，但是要知道C语言存在一个库函数正是rand（随机数种子），在头文件#include

。这里很明显发生命名冲突了，我们定义的全局变量rand和库里的rand函数冲突。想要解决此问题也非常简单，修改变量名就可以了，确实可以，但并不是长久之计，万一你不小心在程序中定义了多个与库函数冲突的函数，难道你要一个一个修改吗，这就充分体现了C语言的命名冲突。

C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决。

2.1.2.命名空间定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{} 中即为命名空间的成员。

同一个作用域不能出现两个相同变量，此时的rand被限制在N1的命名空间域里了，跟其它东西进行了隔离。所以在stdlib.h头文件展开时并不会发生命名冲突。此时rand的打印均是库函数里rand的地址，rand是一个函数指针，打印的就是地址。

命名空间有三大特性：

1.命名空间可以定义变量，函数，类型

//命名空间不影响变量的生命周期，只是限定域，编译查找规则
namespace bit //bit为命名空间的名称
{
	int rand = 11;//变量
	int x = 0;
	int Add(int left, int right) //函数
	{
		return left + right;
	}
	struct Node // 类型
	{
		struct Node* cur;
		int val;
	};
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.命名空间可以嵌套

namespace N1
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace N2
	{
		int c;
		int d;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个。

//test.h
namespace N1
{
	int Mul(int left, int right)
	{
		return left * right;
	}
}
1
2
3
4
5
6
7
8

2.2.命名空间使用

我们都知道在C语言中存在局部优先原则，如下：

int a = 0; // 全局变量
int main()
{
   int a = 1; //局部变量
   printf("%d\n", a);// 1
   return 0;
}    
1
2
3
4
5
6
7

我们都知道打印结果是1，但是如果我们非要打印全局域的全局变量a呢?这里引出我们域作用限定符(:😃，我们修改一下程序，看看结果如何？

这里我们说明一下，加上了(:😃，此时访问的a，就是全局域，这里的(::)是全局域的原因是::的前面是空白的话，那么访问的就是全局域的变量。但是如果在::的前面加上命名空间，就可以访问命名空间域里的数据，这样看，::就是命名空间的一种使用方式。这里我们可以把命名空间看作一堵墙，使用::就是把这堵墙开一个门。

比如这里我们定义了如下的命名空间：

namespace bit
{
   	int rand = 0;
   	char c = 'a';
}
1
2
3
4
5

我们该如何访问命名空间里的内容呢？

这里给出三种方法：

1.使用作用域限定符::

int main()
{
   printf("%d\n", bit::rand);
   printf("%d\n",bit::c);
   return 0;
}
1
2
3
4
5
6

为了防止定义多个命名空间的变量或类型重复，我们可以定义多个命名空间来避免。

namespace bit //bit为命名空间的名称
{
	int rand = 11;//变量
	int x = 0;
	int Add(int left, int right) //函数
	{
		return left + right;
	}
	struct Node // 类型
	{
		struct Node* cur;
		int val;
	};
}
//避免命名冲突
namespace byte
{
	struct Node
	{
		struct Node* cur;
		struct Node* prev;
		int val;
	};
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

当我们需要访问节点的内容时，如下：

int main()
{
   struct bit::Node node;
   struct byte::Node dnode;
}
1
2
3
4
5

另外，关于命名空间的嵌套，如下：

namespace N1
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace N2
	{
		int c;
		int d;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

那如何访问N2呢?如下：

main()
{
	N2::c = 2; //false
	N1::N2::c = 2;//true
	printf("%d\n", N1::N2::c);
   printf("%d\n",N1::N2::Sub(3, 1));
	return 0;
}
1
2
3
4
5
6
7
8

但是上述的方式嵌套的比较麻烦，可不可以省略一些呢？比如不写N1::，这里我们引出命名空间的第二种访问方法：

2.使用using namespace 命名空间全部展开

using namespace N1;
1

这句话的意思时把N1这个命名空间定义的内容从命名空间中放出来，我们就可以访问：

int main()
{
   N2::c = 4;
   printf("%d\n", N2::c);
   printf("%d\n", N2::Sub(3, 1));
}
1
2
3
4
5
6

当然，其实我们还可以再拆一层，如下：

using namespace N1;
using namespace N2;
int main()
{
   c = 6;
   printf("%d\n", Sub(3, 1));
}
1
2
3
4
5
6
7

注意：展开时要注意N1，N2的的顺序不能颠倒，这种访问方式是可以达到简化效果的，但是也会存在一定的风险：命名空间全部释放又重新回到命名冲突。

所以针对某些特定情况会出现命名冲突问题的，需要单独讨论：

所以，其实全部展开并不好，我们需要根据需要去展开，用什么展开什么，引出第三种使用方法：

3.使用using将命名空间部分展开

namespace N1
{
   	int rand = 10;
   	int a = 0;
}
using N1::a;
int main()
{
   	a++;
   	printf("%d\n", a);
   	N1::rand++;
   	printf("%d\n", N1::rand);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

我们来看一下C++标准库命名空间：

#include 

using namespace std; // std是封装C++库的命名空间
int main()
{
	cout << "hello world!" << endl;//打印"hello world!"
	return 0;
}
1
2
3
4
5
6
7
8

但是如果省略了这行代码：

using namespace std;
1

想要打印”hello world!“就必须这么更改程序：

#include 

int main()
{
   std::cout << "hello world!" << std::endl;//打印"hello world!"
	return 0;
}
1
2
3
4
5
6
7

其实也可以这么做：

#include 
using std::cout;
int main()
{
  cout << "hello world!" << std::endl;//打印"hello world!"
}
1
2
3
4
5
6

std命名空间的使用惯例：

std是C++标准库的命名空间，如何展开std使用更合理呢？

1. 在日常练习中，建议直接using namespace std即可，这样就很方便。

2. using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 +using std::cout展开常用的库对象/类型等方式。这就充分运用到了命名空间，希望大家能活学活用。

3.C++输入&输出

在C语言中，我们都清楚输入用scanf，输出用printf，但是在C++中，不仅可以使用C语言的输入输出，而且还有自己独有的输入函数cin， 输出函数cout。

这里我们以一个经典函数举例：

#include 

using namespace std; // std是封装C++库的命名空间
int main()
{
	cout << "hello world!" << endl;//打印"hello world!"
	return 0;
}
1
2
3
4
5
6
7
8

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件 以及按命名空间使用方法使用std。

2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。

3. <<是流插入运算符，>>是流提取运算符。

4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。 C++的输入输出可以自动识别变量类型。

5. 实际上cout和cin分别是ostream和istrea 类型的对象，>>和<<也涉及运算符重载等知识， 这些知识我们我们后续才会学习，所以我们这里只是简单学习他们的使用。后面我们再深入学习。

6.endl是换行符，等价于C语言的’\n’。

注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应 头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间， 规定C++头文件不带.h；旧编译器(VC 6.0)中还支持格式，后续编译器已不支持，因此推荐使用**+std**的方式。

4.缺省参数

4.1.缺省参数概念

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该 数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

void Func(int a = 0)
{
	cout<<a<<endl;
}

int main()
{
    Func(); // 没有传参时，使用参的默认值
   Func(10); // 传参时，使用指定的实参
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11

我们看上述代码，我们得知，如果你不传参数，那我就使用缺省参数，函数默认的参数值，这里是0。如果你传了参数，那就用你传参时传过来的实参。

4.2.缺省参数分类

全缺省参数

void Func(int a = 10, int b = 20, int c = 30)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
}
1
2
3
4
5
6

我们看上述代码，我们这个缺省参数有3个，那么我在调用函数的时候，就有4种调用方式。

int main()
{
	Func();
	Func(1);
	Func(1, 2);
	Func(1, 2, 3);
	//Func(1, , 3);//false
}
1
2
3
4
5
6
7
8

注意：在传参数时，要按照顺序来传，不能说我第一个还没传就先传第二个，如上面最后一个。

半缺省参数

//半缺省/部分缺省 -- 只能从左往右缺省
void Fun3(int a, int b = 20, int c = 30)
{
	cout << " a = " << a;
	cout << " b = " << b;
	cout << " c = " << c << endl;
}
1
2
3
4
5
6
7

上述代码就已经很明确了，我在调用函数时，传的参数至少是一个，有以下三种调用方式：

int main()
{
	Func3(1);
	Func3(1, 2);
	Func3(1, 2, 3);
	return 0;
}
1
2
3
4
5
6
7

注意：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给

//错误示范
void Fun3(int a = 10, int b = 20, int c)
{
	cout << " a = " << a;
	cout << " b = " << b;
	cout << " c = " << c << endl;
}
1
2
3
4
5
6
7

2. 缺省参数不能在函数声明和定义中同时出现

假如我们在Stack.h文件中声明了函数：

并且我们在Stack.cpp文件中定义了函数：

我们在test.cpp中编译：

很明显，编译错误！！！

注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。

总结：

1.缺省参数不能在定义和声明中同时出现，防止出现不同的赋值导致错误

2. 缺省值必须是常量或者全局变量。

3. C语言不支持（编译器不支持）

5.函数重载

自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词的含义，即该词被重载了。

比如：以前有一个笑话，我国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个是男足。前者是"谁也赢不了！“，后者是"谁也赢不了！”

5.1.函数重载概念

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

• 参数类型不同

#include
using namespace std;

//参数类型不同构成函数重载
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}
double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 参数个数不同

//参数个数不同构成函数重载
void f()
{
	cout << "f()" << endl;
}
void f(int a)

{
	cout << "f(int a)" << endl;
}
1
2
3
4
5
6
7
8
9
10

• 顺序不同

//参数类型顺序不同构成函数重载
void f(int a, char b)
{
	cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
	cout << "f(char b, int a)" << endl;
}
1
2
3
4
5
6
7
8
9

5.2.函数重载的原理 (重要)

我们在学习C语言【C】程序环境和预处理 的时候知道了一个程序要运行起来，需要经历预处理、编译、汇编、链接四个阶段；其中编译阶段会进行符号汇总，汇编阶段会生成符号表，而链接阶段则会对符号表进行合并与重定位，其中符号表会将每一个变量都关联上一个地址，但这个地址是否有效需要在链接阶段进行符号表的合并与重定位是时才能检查出来。

而对于上述过程中生成符号表这一阶段，C编译器与C++编译器所进行的操作是不同的 – C语言编译器会直接用变函数名作为符号表中的符号，而不会对函数名进行修饰；而C++编译器则是会对函数名进行修饰，用修饰后的名称来构成符号表。

注：由于Windows下vs的修饰规则过于复杂，而Linux下g++的修饰规则简单易懂，下面我们使 用了g++演示了这个修饰后的名字。

采用C语言编译器编译后结果：

采用C++编译器编译后结果：

经过对比后我们发现：在linux下，采用gcc (C语言编译器) 编译完成后，函数名字的修饰没有发生改变；而采用g++ (C++编译器) 编译完成后，函数名字的修饰发生改变，函数名由 前缀_Z+函数长度 +函数名+类型首字母 组成，即编译器将函数参数类型信息添加到了修改后的名字中。

通过上面这个实例就理解了：C语言没办法支持重载是因为同名函数没办法区分；而C++是通过函数修饰规则来区分，只要参数类型不同，修饰出来的名字就不一样，所以就支持重载。

同样，我们也理解了函数的返回值不同以及同类型参数的顺序不同是不构成重载的，因为C++编译器没办法区分；但其实即使是C++编译器把函数的返回值类型也加入了函数修饰规则，也仅仅是让它在语法层面是构成了重载而已，在实际使用中也是不构成重载的，因为函数传参时并不会传递函数的返回值类型，那么对于返回值不同，其他各方面都相同的函数而言，操作系统就不知道应该将参数传递给哪个函数，即在传递参数时出现了二义性，这时候编译也是会报错的。

注：对C/C++函数调用约定和名字修饰规则感兴趣的同学可以拓展学习一下下面这篇文章，里面有对vs下函数名修饰规则的讲解：C/C++ 函数调用约定 。

6.内联函数

6.1.内联函数的概念

在 函数栈帧的创建和销毁 一节中我们知道：一个函数在开始调用时会建立函数栈帧，结束调用时会销毁函数栈帧，而函数栈帧的建立与销毁是有空间和时间上的开销的；

那么，对于功能简单、调用次数非常多的函数来说，每次调用都重新开辟栈帧势必就会造成效率的降低；比如 hoare 法的快速排序中，我们仅仅是每次单趟排序都会调用很多次 Swap 函数，更别说单趟排序也会被递归调用很多次，而 Swap 函数本身的功能恰好十分简单，那么该如何来对其进行优化呢？

在C语言中，我们使用宏函数来解决这个问题：我们直接将 Swap 函数写成宏函数，这样使得程序在预处理阶段直接将 Swap 函数替换成相应的代码，从而不再建立函数栈帧。

void Swap(int* x, int* y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}
1
2
3
4
5
6

宏函数：

#define SWAP(x, y) {int tmp = x; x = y; y = tmp;}
1

• 既然用宏就可以解决，C++为何引出inline?

使用宏确实可以帮助我们避免调用栈帧继而不会造成效率损失，但是宏的写法上欠妥，我们需要注意结尾不能加分号，要注意优先级带来的问题而频繁加括号……C++为了填补宏书写规则麻烦的坑，专门设计了一个更为方便的内联函数（inline）。以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。综上，结论如下：

1. 解决宏函数比较难写，容易写错的问题
2. 解决宏不支持调试
3. 不支持类型安全的检查等问题

• 内联函数（inline）如何使用？

只需要在函数前面加上inline即可：

inline int Add(int x, int y)
{
    return x + y;
}
1
2
3
4

此时我们再调用函数就不会再建立栈帧了，函数直接会在调用的地方展开。

内联函数（inline）如何支持调试的呢？
我们需要查看其反汇编，查看方式：

在release模式下，查看编译器生成的汇编代码中是否存在call Add

在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2013的设置方式)

执行完上述指令后 ，我们在debug版的编译器就设置好了，再来看下其反汇编：

普通函数的汇编代码

内联函数的汇编代码

综上：

inline的好处如下：

1. debug支持调试
2. 不易写错，就是普通函数的写法

6.2.内联函数的特性

特性1：

inline 对于编译器而言只是一个建议 (类似于C语言的 register 关键字)，不同编译器关于 inline 的实现机制可能不同，一般建议将具有如下特点的函数采用 inline 修饰：

• 函数规模较小 (即函数不是很长，具体没有准确的说法，取决于编译器内部实现)；
• 不是递归；
• 频繁调用；

下图为 《C++prime》第五版对于 inline 的建议：

我们可以简单写一个函数来验证内联函数的这个特性：

//把Add的内部逻辑复杂化
inline int Add(int x, int y)
{
	int ret = x + y;
	ret += x + y;
	ret = x + y;
	ret /= x + y;
	ret = x + y;
	ret = x + y;
	ret *= x + y;
	ret = x + y;
	ret = x + y;
	ret -= x + y;
	ret = x + y;
	ret += x + y;
	return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

我们可以看到，当我们将 Add 函数的内部逻辑复杂化之后，尽管我们使用了 inline 关键字修饰 Add 函数，但是 Add 函数并没有被展开，而是和正常函数一样调用、建立栈帧。

特性2

inline 是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段会用函数体替换函数调用；这样做的优势是减少了栈帧建立的开销，提高了程序运行效率；缺陷是可能会使目标文件变大。

需要注意的是，这里的空间指并不是指程序运行时占用的内存空间，而是指经过编译链接后得到的可执行程序 (.exe/.o文件) 所占用的空间；对于可执行程序变大的原因，我们以下面这个例子为例：

假设一个Func函数的汇编指令有30条，且这个函数要被重复调用1W次；那么对于普通Func函数来说：我们每次调用Func都要转换出一条 call 汇编代码，调用1W次就有1W条汇编指令；但是Func函数本身只会在函数定义处被转换为汇编代码；所以普通Func函数经过编译之后的汇编指令一共有 1W+30 条；而对于 inline 函数来说，由于 inline 函数会在所有调用的地方展开，也就是说，每调用一次Func函数，就会转换成30条对应的汇编代码；所以 inline Func函数经过编译之后的汇编指令一共有 30W 条；

而汇编指令的增多可能会导致我们编写的静态库/动态库增大，也有可能导致编写的 .exe 增大；这其实就是所谓的 “代码膨胀”，这也在一定程度上解释了为什么当内联函数过长时编译器不进行展开。
特性3

inline 不建议声明和定义分离，分离会导致链接错误，具体原因如下：

在 程序环境和预处理 中我们知道：程序在编译阶段进行符号汇总，汇编阶段生成符号表，链接阶段进行符号表的合并和重定位；

对于定义在本文件内的函数来说，编译器在汇编阶段会直接调用该函数，在调用过程中会生成对应的符号表，且此符号表中的地址一定是有效的，所以程序不会进行后续的链接操作；

而对于定义在其他文件中的函数，编译器会先在本文件内寻找该函数的声明，且声明生成的符号表中的地址是无效的；此时编译器会继续后续的链接操作；

链接过程中符号表的合并会将汇编阶段生成的所有符号表合并到一起，合并的意思是如果两个符号表中的函数名相同，那么编译器会选取与有效地址相关联的符号表，丢弃掉另一个与无效地址关联的；这样同时具有声明和定义的函数经过链接就只有一个符号表了；

而如果一个函数只有声明，而没有定义的话，那么它经过符号表的合并之后关联的仍然是一个无效地址，则在进行符号表的重定位时就会发生链接性错误；如果符号表中关联的是一个有效地址，重定位时编译器就会根据这个地址来调用函数，这样就可以实现跨文件调用函数；

对于 inline 函数来说，如果我们将函数的定义和声明分离，那么函数的声明在汇编阶段会生成一个符号表，里面关联的是一个无效的地址；但是由于 inline 函数是直接展开的，所以函数定义部分在汇编阶段并不会生成符号表；这时候就出现了上面的问题，程序经过符号表的合并之后 inline 函数仍然关联一个无效地址，会在重定位的时候发生链接性错误。如下：

图中，我们将 inline 函数的定义放在 Add.h 中，将其实现放在 Add.cpp 中，然后在 test.cpp 中包含 Add.h，这样经过预处理之后，test.cpp 中就包含了 inline 函数的声明；那么经过汇编，Add.cpp 中的 Add 函数由于是内联函数，会直接展开，所以不会生成符号表；

而在 test.cpp 中，经过汇编，Add 函数的声明会生成一个符号表，且符号表中的地址是无效的；而在链接阶段，Add 声明对应的符号表又不能匹配到有效的地址 (因为 test.cpp 中并没有生成 Add 函数的符号表)，所以重定位时发生链接型错误 (LNK 错误)；

正确的使用方法如下：如果有 .h 文件，将 inline 函数的定义直接放在 .h 文件中；如果没有 .h 文件，就直接放在本文件内部；

【经典面试题】

• 问题1：宏的优缺点？

优点：

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

缺点：

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

• 问题2：C++有哪些技术代替宏？

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

7.auto关键字(C++11)

7.1.类型别名思考

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

• 类型难于拼写；

• 含义不明确导致容易出错；

例如下面 m 和 it 变量的类型：

#include 
#include 
int main()
{
	std::map<std::string, std::string> m{ { "apple", "苹果" }, { "orange","橙子" },{"pear","梨"} };
	std::map<std::string, std::string>::iterator it = m.begin();
	while (it != m.end())
	{
		//....
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

std::map::iterator 是一个类型，但是该类型太长了，特别容易写错；可能聪明的同学可能已经想到：我们可以通过 typedef 给类型取别名，比如：

#include 
#include 
typedef std::map<std::string, std::string> Map;
int main()
{
	Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
	{
		//....
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

使用typedef给类型取别名确实可以简化代码，但是 typedef 有时会遇到新的难题：

比如我有一个程序：

typedef char* pc;
int main()
{
    //能否编译成功？
    const pc p1;
    cosnt pc* p2;
    return 0;
}
1
2
3
4
5
6
7
8

在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的类型。然而有时候要做到这点并非那么容易，因此C++11给auto赋予了新的含义。

7.2.auto 的概念

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它；因为当函数调用结束后，函数的栈帧会被销毁，那么存在于函数栈帧中的局部变量自然也会被销毁，这就使得 auto 修饰失去了意义；

而在C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

简单来说：先前定义变量要在变量前指定类型，使用auto可以不指定类型，让右边赋的值进行推导，如示例：

int a = 10;
auto b = a;
auto c = 'a';
1
2
3

这里a的类型是整型，那么自动推出b的类型为int，而’a’为char类型，自然c就是char类型。

• 补充：这里补充一个知识点：typeid().name：它是专门用来输出一个变量的类型，返回的是一个字符串。

代码如下：

int TestAuto()
{
	return 10;
}
int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = TestAuto();
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

7.3.auto 的使用细则

1. auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

int main()
{
	int x = 10;
	auto a = &x;
	auto* b = &x;
	auto& c = x;
	cout << typeid(a).name() << endl; // int*
	cout << typeid(b).name() << endl; // int*
	cout << typeid(c).name() << endl; // int
	*a = 20;
	*b = 30;
	c = 40;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 在同一行定义多个变量

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

void TestAuto()
{
	auto a = 1, b = 2;
	auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}
1
2
3
4
5

7.4.auto不能推导的场景

1. auto不能作为函数的参数，因为不是所有的参数都有初始化表达式，因此编译器可能无法推导出a的实际类型，所以直接规定auto不能作为函数形参：

2. auto不能直接用来声明数组：数组需要根据元素类型及个数来开辟空间，而数组名代表指针，因此 auto 无法推导：

3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法；

4. auto在实际中最常见的优势用法就是跟C++11提供的新式for循环，还有lambda表达式等进行配合使用;

8.基于范围的 for 循环 (C++11)

8.1.范围 for 的用法

在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 i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
	for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); ++p)
		cout << *p << endl;
}
1
2
3
4
5
6
7
8
9

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

因此，在C++中，我们可以这样使用它：

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
		array[i] *= 2;
	for (auto e : array)
		cout << e << " "; // 2 4 6 8 10
}
1
2
3
4
5
6
7
8

此段代码就是范围for，它可以自动遍历，它会依次取数组中的数据赋值给e，自动判断结束。怎么样？是不是用起来特别舒服，这种小语法，叫做语法糖，用起来很爽！！！

• 现在我们想对数组进行修改，使数组中每一个数字除以2，该怎么做呢？是如下这样嘛？

为什么按照图示的修改并没有起到作用呢？注意看范围for的规则，依次取数组中的数据赋值给e，这也就说明了e是数组中每个值的拷贝，e的改变不会影响数组。此时也就需要我们用到引用了 ，当我们给其取别名时，e的修改就会影响到原数组。

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
		array[i] *= 2;
	for (auto e : array)
		cout << e << " "; // 2 4 6 8 10
	cout << endl;
	for (auto& e : array)
		e /= 2;
	for (auto e : array)
		cout << e << " "; //1 2 3 4 5
}
1
2
3
4
5
6
7
8
9
10
11
12
13

注意：

1. 范围for里的auto也可以写成int，不过最好还是写成auto，毕竟auto可以自动推出数组的类型嘛，不用auto还要自己手动设置。把e改成其它的变量也是可以的，不强求。

2. 与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

8.2.范围 for 的使用条件

范围 for 的使用有如下条件限制：

1. for循环迭代的范围必须是确定的：对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供 begin 和 end 的方法，begin 和 end 就是 for 循环迭代的范围；比如下面代码的范围就是不确定的：

void TestFor(int array[])
{
    for(auto& e : array)
        cout<< e <<endl;
}
1
2
3
4
5

用范围for必须是数组名，C语言有规定参数传递的过程中不能是数组，这里的形参是指针，自然不能用范围for的规则了。

2. 迭代的对象要实现++和==的操作；(关于迭代器我们以后会学习，现在大家了解一下就可以了)

9.指针空值 nullptr (C++11)

在C语言中，通常我们在定义一个指针变量的时候会将其初始化为 NULL，避免后面对其错误使用造成野指针越界访问问题；其实这里的 NULL 是C语言中定义的一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif
1
2
3
4
5
6
7

我们可以看到，对于C语言来说，NULL 其实是数字0被强转为指针类型，相当于0处的地址；而对于C++来说，NULL 则被直接解释为数字0；虽然 0 和 (void*)0 二者在数值上相同，但是他们的类型是不相同的，一个是整形，另一个是指针；这就导致使用时会出现一些问题，比如下面这个例子：

void f(int)
{
	cout << "f(int)" << endl;
}

void f(int*)
{
	cout << "f(int*)" << endl;
}

int main()
{
	f(0);
	f(NULL);
	f((int*)NULL);
	f(nullptr);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

程序本意是想通过 f(NULL) 调用指针版本的 f(int*) 函数，但是由于NULL被定义成0，因此与程序的初衷相悖；

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

为了解决这个问题，C++11中专门为空指针设计了一个关键字 – nullptr，用来弥补C++98中空指针NULL存在的缺陷。(可以认为，nullptr 就是 (void*)0 )

nullptr 注意事项:

• 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入 的；

• 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同；

• 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr.