认识C++

C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机， 20世纪80年代， 计算机界提出了OOP(object oriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生。
1982年，本贾尼·斯特劳斯特卢普(Bjarne Stroustrup)博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

1979年，贝尔实验室的本贾尼等人试图分析unix内核的时候，试图将内核模块化，于是在C语言的基础上进行扩展，增加了类的机制，完成了一个可以运行的预处理程序，称之为C with classes。随着时代的发展，C++已经产生很多版本，但是现在主流使用的还是C++98和C++11，C++的历史版本如下：

阶段	内容
C++1.0	添加虚函数概念，函数和运算符重载，引用、常量等
C++2.0	更加完善支持面向对象，新增保护成员、多重继承、对象的初始化、抽象类、静 态成员以及const成员函数
C++3.0	进一步完善，引入模板，解决多重继承产生的二义性问题和相应构造和析构的处 理
C++98	C++标准第一个版本，绝大多数编译器都支持，得到了国际标准化组织(ISO)和美 国标准化协会认可，以模板方式重写C++标准库，引入了STL(标准模板库)
C++03	C++标准第二个版本，语言特性无大改变，主要：修订错误、减少多异性
C++05	C++标准委员会发布了一份计数报告(Technical Report，TR1)，正式更名 C++0x，即：计划在本世纪第一个10年的某个时间发布
C++11	增加了许多特性，使得C++更像一种新语言，比如：正则表达式、基于范围for循 环、auto关键字、新容器、列表初始化、标准线程库等
C++14	对C++11的扩展，主要是修复C++11中漏洞以及改进，比如：泛型的lambda表 达式，auto的返回值类型推导，二进制字面常量等
C++17	在C++11上做了一些小幅改进，增加了19个新特性，比如：static_assert()的文 本信息可选，Fold表达式用于可变的模板，if和switch语句中的初始化器等
C++20	自C++11以来最大的发行版，引入了许多新的特性，比如：模块(Modules)、协 程(Coroutines)、范围(Ranges)、概念(Constraints)等重大特性，还有对已有 特性的更新：比如Lambda支持模板、范围for支持初始化等
C++23	制定ing

C++关键字

C++(C++98)总计63个关键字，C语言32个关键字。C++的关键字中也包含C语言的32个关键字。

asm	do	if	return	try	continue
auto	double	inline	short	typedef	for
bool	dynamic_cast	int	signed	typeid	public
break	else	long	sizeof	typename	throw
case	enum	mutable	static	union	wchar_t
catch	explicit	namespace	static_cast	unsigned	default
char	export	new	struct	using	friend
class	extern	operator	switch	virtual	register
**const **	false	private	template	void	true
const_cast	float	protected	this	volatile	while
delete	goto	reinterpret_cast

命名空间

在C语言中，定义一个int类型的变量rand，只包含头文件<stdio.h>时程序可以正常运行，代码如下：输出结果为10，无报错。

#include <stdio.h>
int rand = 10;
int main()
{
	printf("%d ", rand);//输出结果为10
	return 0;
}

但是包含头文件<stdlib.h>之后，程序会出现如下报错信息：

为什么不包含头文件<stdlib.h>之前能正常运行，而包含之后就不能正常运行了？因为在头文件<stdlib.h>中，rand是作为一个函数存在的，不能够被定义为变量。

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

命名空间定义

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

namespace nmz { 	//nmz就是命名空间的名字
	int a = 0; //成员变量
	char c = 0;
}

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

namespace nmz { 	//nmz就是命名空间的名字
	int a = 0; //成员变量
	char c ='#';
	struct Node { //自定义类型
		int val;
		struct Node* next;
	};
	int Add(int x, int y)//定义函数
	{
		return x + y;
	}
}

2.命名空间可以嵌套

namespace n {     //n是命名空间名字
	int a = 0;
	int b = 0;
	namespace m {  //命名空间嵌套，m是被嵌套的命名空间
		int c = 1;
		int d = 1;
		int Add(int x, int y)
		{
			return x + y;
		}
	}
}

嵌套的命名空间在使用时只需要指定对应的命名空间，如使用上面的Add函数

int main()
{
	int ret = n::m::Add(1,2);//指定命名空间 输出结果为3
	return 0;
}

3.同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。

namespace nmz {
	int a;
	int b;
}
//具有相同的命名空间
namespace nmz {
	int Add(int x, int y)
	{
		return x + y;
	}
}

名称相同的命名空间，编译器会合并到一起。

namespace nmz {  //合并到同一个命名空间
	int a = 0;
	int b = 0;
	int Add(int x, int y)
	{
		return x + y;
	}
}

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

命名空间使用

当定义了如下的命名空间，怎么使用里面的变量和函数呢？

namespace nmz { 	//nmz就是命名空间的名字
	int a = 0; //成员变量
	char c ='#';
	struct Node { //自定义类型
		int val;
		struct Node* next;
	};
	int Add(int x, int y)//定义函数
	{
		return x + y;
	}
}

1.加命名空间名称及作用域限定符

::域作用限定符，作用是去指定的作用域中查找。

int main()
{
    struct nmz::Node node1;//使用结构体定义变量时指定命名空间,要写在结构体标签前
	printf("%d ", nmz::a);//::域作用限定符，去指定的域中查找
	return 0;
}

2.使用using将命名空间中某个成员引入

using nmz::a;	
int main()
{
	printf("%d ", a);	
	return 0;
}

3.全局展开命名空间（使用using namespace+命名空间名称）

using namespace nmz;
int main()
{
	printf("%d ", a);	
	return 0;
}

在项目开发中不推荐使用全局展开命名空间。

输入和输出

C语言中输入用函数scanf，输出用函数printf，它们包含在头文件<stdio.h>中。在C++中通常用cin标准输入和cout标准输出，使用时必须包含头文件，且需要展开相应的命名空间。

#include <iostream>
//在项目开发中，通常使用std::cout和std::cin，避免全局展开造成命名冲突
//在日常练习中，可以全局展开std命名空间
using namespace std;
int main()
{
	int a = 10;
	char ch = 'a';
    
	//	C语言方式:需要控制输入输出格式
	scanf("%c%d",&ch, &a); //输入 n 10
	printf("%d ", a);  
	printf("%c\n", ch);
    //输出10 n
    
	//C++:不需要控制输入输出格式
	cin >> a; //输入10
	cin >> ch; //输入n
	cout << a <<" "<< ch << endl;  
    //输出10 n
	return 0;
}

注意：

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

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

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

4.使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式；C++的输入输出可以自动识别变量类型。因为C++兼容C语言，所以在C++开发中根据实际情况选择合适的输入输出方式。

5.cout和cin分别是ostream和istream类型的对象，>>和<<涉及运算符重载。

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

缺省参数

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

#include <iostream>
int Add(int x = 10,int y = 20)//全缺省参数
{
	return x + y;
}
int main()
{
	int ret1 = Add();//不传参时，默认使用缺省值
	int ret2 = Add(20, 30);//传入实参时，使用传入的实参值
	printf("%d\n", ret1);//输出结果为30
	printf("%d\n", ret2);//输出结果为50
	return 0;
}

缺省参数可以分为全缺省参数和半缺省参数。

全缺省参数：函数中每个形参都有默认的缺省值。

int Add(int x = 10,int y = 20)//全缺省参数即函数中每个参数都有默认的缺省值
{
	return x + y;
}
int main()
{
    int ret1 = Add(,5);//error,使用的时候不能跳着使用
    //正确使用如下
    int ret2 = Add();//不传参  输出结果30
    int ret3 = Add(20);//传一个参数，传给第一个形参  输出结果40
    int ret4 = Add(5,6);//都传参 输出结果11
    return 0;
}

半缺省参数：函数中部分形参没有缺省值，缺省值必须从右向左给出

int Add(int x = 5,int y)//error，缺省值必须从右向左给出
int Add(int x,int y = 20)//半缺省参数
{
	return x + y;
}
int main()
{
    int ret3 = Add();//error，函数中第一个形参没有缺省值，必须传入
	//正确使用如下    
    int ret1 = Add(5);//传给第一个参数
    int ret2 = Add(5,10);//两个参数都传参
}

注意：

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

2.缺省参数不能在函数声明和定义中同时出现，在函数声明和定义同时存在的情况下，要在声明中给缺省值，定义中不要给缺省值。

//声明和定义同时存在时，要在声明中给缺省值，定义中不能给缺省值，因为当声明和定义中的缺省值不同时编译器无法确定到底该用哪个缺省值

//声明
int Add(int x = 20, int y = 10);

//定义
int Add(int x, int y)
{
	return x + y;
}

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

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

函数重载

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

1.参数个数不同

#include <iostream>
using namespace std;
//不要给缺省值，否则编译器不能判断使用哪个函数
int Add(int x, int y)//2个int类型的参数
{
	return x + y;
}
int Add(int x, int y,int z)//3个int类型的参数
{
	return x + y + z;
}
int main()
{
    Add(1,2);
    Add(2,3,4);
    return 0;
}

2.参数类型不同

#include <iostream>
using namespace std;
//参数类型不同，函数的返回值类型和函数重载无关
int Add(int x, int y)//2个int类型的参数
{
	return x + y;
}
double Add(double dx, double dy)//2个double类型的参数
{
	return dx + dy;
}
int main()
{
	Add(1, 2);
	Add(1.1,2.2);
	return 0;
}

3.参数类型顺序不同

#include <iostream>
using namespace std;
//参数类型顺序不同
void func(int x, double y)//int double类型
{
	cout << "void func(int x, double y)" << endl;
}
void func(double y,int x)//double int类型
{
	cout << "void func(double y,int x)" << endl;
}
int main()
{
	func(1,2.2);
	func(1.1, 2);
	return 0;
}

函数重载实现原理

C++中之所以能够实现函数重载，是因为C++编译器对函数名进行了修饰。

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。

在编译阶段会分别对每个源文件的全局变量和函数名进行汇总；

在汇编阶段会给每个源文件汇总出来的符号分配一个地址（若符号只是一个声明，则给其分配一个无意义的地址），然后分别生成一个符号表。下图为main.c和Add.c汇编之后形成的符号表：在main.c中Add函数和func函数都是声明，分配一个无意义的地址。

在链接时会将每个源文件的符号表进行合并，若不同源文件的符号表中出现了相同的符号，则取合法的地址为合并后的地址（重定位指的就是有相同符号名的时候找一个有效的地址）。

在C语言中，汇编阶段进行符号汇总时，一个函数汇总后的符号就是其函数名，所以当汇总时发现有多个函数名相同时，编译器便会报错。而C++在进行符号汇总时，C++有自己的函数名修饰规则，汇总出的符号不再单单是函数的函数名，而是通过其参数的类型、个数、参数类型不同顺序等信息汇总出 一个符号，这样一来，就算是函数名相同的函数，只要其参数的类型、参数的个数或者参数的顺序不同，那么汇总出来的函数名也就不同了。

注：不同编译器下，对函数名的修饰不同，但其原理类似。

下面为在Linux环境下分别使用C语言编译器和C++编译器分别演示：

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

结论：在Linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。

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

结论：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。

g++下函数命名修饰规则：g++的函数修饰后完成函数名变为【_Z+函数长度+函数名+类型首字母】。

通过以上讲解明白了C语言之所以不支持函数重载，是因为同名函数没办法区分；而C++是通过函数修饰规则来区分，只要参数个数、参数类型和参数类型顺序不同，修饰出来的名字就不一样，就支持了重载。

如果两个函数的函数名和参数是一样的，返回值不同是不能构成重载的，因为调用时两者的函数符号相同，编译器没办法区分。

extern “C”

有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern C，意思是告诉编译器，将该函数按照C语言规则来编译。

例：

extern "C" int Add(int a, int b);
int main()
{
	Add(1, 2);
	return 0;
}

注意：之所以能够按照C的风格来编译，是因为在函数前加“extern C”后，该函数便不能支持重载了。

引用

引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

引用格式为：类型& 引用变量名(对象名) = 引用实体，引用类型必须和引用实体是同种类型的。

int main()
{
    int a = 10;
    double& c = a;//error,引用类型必须和引用实体是同种类型的
	int& b = a;//b是a的别名，a是引用实体
	cout << a << " " << b << endl; //输出10 10
    
	cin >> a;//输入20
	cout << a << " " << b << endl; //输出20 20
    //a和b共用一块内存空间，a的值改变也会改变b的值，同样b的值改变也会影响a的值
    
    cin >> b;//输入30
	cout << a << " " << b << endl; //输出30 30
    return 0;
}

引用特性

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

int a = 10;
int* p = &a;
int*& pi = p;//也可以用来给指针取别名，pi就是指针p的引用，都是int* 类型
int& b = a;//true
int& c;// error

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

int a = 10;
int& b = a;
int& c = a;
int& d = b;//引用变量也可以是引用实体

3.引用一旦引用一个实体，再不能引用其他实体

int a = 10;
int b = 20;
int& c = a;
int& c = d;//error c重定义
c = b;//就是将b的值给c，并不是引用b

常引用

• 指针和引用在赋值或者初始化时权限可以缩小，但是不能放大。

const int a = 20;
int& b = a;//error,a的值不能改变，这里就属于权限的放大

const int& c = a;//true,权限的平移

int d = 20;
const int q = d;//权限的缩小

const int* p1 = NULL;
int*& p2 = p1;//error,权限的放大

const int*& p3 = p1;//true,权限的平移

int* e = NULL;
const int* pe = e;//权限的缩小

• 在使用引用接收函数返回值时，要使用const属性，因为临时变量也是常变量，所以要在前面加上const。

int Count()
{
	int n = 1;
	n++;
	return n;
}
int main()
{
	const int& ret = Count();//使用const引用接收
	return 0;
}

• 类型转换时也会产生临时变量，所以此时使用引用也要加const。

int a = 10;
double& d1 = a;//error
const double& d2 = a;//true

扩展：const关键字位置不同，修饰的变量不同

• int* const p1：指针常量，指针的指向不能发生改变，但是指针指向的内容可以改变；

int a = 10;
int b = 20;
int* const p1 = &a;
p1 = &b; //false
*p1 = b; //true

• const int* p2：常量指针，指针指向的内容不能改变，但是指针的指向可以改变；
• int const* p3：指针指向的内容不能改变，但是指针的指向可以改变；

这两个的const虽然位置不同，但是作用相同（指针指向的内容不能改变，但是指针的指向可以改变）。

int a = 10;
int b = 20;
const int* p2 = &a;
p1 = &b; //true
*p1 = b; //false

引用作用

1.使用引用做参数（输出型参数）。形参是实参的别名，两者共用同一块内存空间所以形参的改变影响实参。

#include <iostream>
using namespace std;
void Swap(int& x, int& y)//使用引用做参数，形参的改变影响实参
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 10;
	int b = 20;
	cout << a << " " << b << endl;//输出10 20
	Swap(a, b);
	cout << a << " " << b << endl;//输出20 10
}

使用引用做参数时，表面是传值，其实本质也是传地址，只不过是由编译器完成传地址的工作。

2.引用做返回值。

如下程序是我们之前常用的直接返回int类型，程序中main函数调用Count函数计算n值之后返回n，在main函数中使用ret变量接收。

int Count()
{
	int n = 0;
	n++;
	return n;
}
int main()
{
	int ret = Count();
	return 0;
}

如下图，函数建立栈帧并且调用，Count函数返回的时候并不是用n做返回值，因为n是局部变量出作用域就销毁了，所以通常会把n的值给一个临时变量去做表达式的返回值给ret。如果临时变量小（4个字节或者8个字节）就使用寄存器，如果临时变量大就在上一层函数栈帧中建立一个临时变量（本程序是在main函数中）；在Count函数销毁之前就把n的值保存在临时变量中然后将临时变量中的值给ret。这个程序中没有优化的空间。

下面的程序和上面程序类似，不过这个程序中n是静态变量。

int Count()
{
	static int n = 0;
	n++;
	return n;
}
int main()
{
	int ret = Count();
	return 0;
}

n是静态变量，但是不管是静态变量还是局部变量都要使用临时变量充当返回值，这个程序和上面的程序这种使用临时变量返回的场景叫做传值返回。

但是这种场景有优化的空间，可以使用引用做返回值。

程序如下：

int& Count()
{
	static int n = 0;
	n++;
	return n;
}
int main()
{
	int ret = Count();
	return 0;
}

我们可以认为返回值是n的别名，没有临时变量相当于用n直接返回。

引用返回作用

• 减少拷贝（减少返回值拷贝到临时变量）

• 调用者可以修改返回对象，程序如下：

int arr[6] = { 0 };
int& post(int i)
{
	return arr[i];
}
int main()
{
	int n = 6;
	for (int i = 0; i < 6; i++)
	{
		printf("%d  ", arr[i]);
	}
    //输出结果 0 0 0 0 0 0
	printf("\n");
	for (int i = 0; i < 6; i++)
	{
		post(i) = 2 * i;
	}
	for (int i = 0; i < 6; i++)
	{
		printf("%d  ", arr[i]);
	}
    //输出结果 0 2 4 6 8 10
}

下面程序会出现输出结果不正确的现象，原因是变量c是一个局部变量，出了Add函数这个作用域就销毁了，引用对象就不存在了，可能导致错误。

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << "Add(1,2) is " << ret << endl; //Add(1,2) is 7
	cout << "Add(1,2) is " << ret << endl; //Add(1,2) is 2070579496
	return 0;
}

总结：如果函数返回时，出了函数作用域返回对象还在（还没还给操作系统），则可以使用引用返回；如果出了作用域返回对象已经还给操作系统（即出了作用域返回值销毁），则必须使用传值返回，如果此时使用传引用返回，结果是未定义的（不确定结果）。

传值、传引用效率比较

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

指针和引用的区别

• 在语法概念上引用就是一个别名，没有独立的空间，和其引用实体共用同一块空间。

int main()
{
	int a = 10;
	int& b = a;

	cout << "&a:" << &a << endl;
	cout << "&b:" << &b << endl;
	return 0;
}

输出结果a的地址和b的地址相同：

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

int main()
{
	int a = 10;

	int& ra = a;
	ra = 20;	

	int* pa = &a;
	*pa = 20;

	return 0;
}

通过程序中的汇编代码，我们可以看到引用的底层实现也是类似于指针存地址的方式实现。

引用和指针的区别：

1.引用概念上定义一个变量的别名，指针存储一个变量地址；

2.引用在定义时必须初始化，指针没有要求；

int a = 10;

int& b = a;//引用定义时必须初始化
int& c;//error

//指针定义时没有要求必须初始化
int* pa; //true
int* pb = &a;//true

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

4.没有NULL引用，但有NULL指针；

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

6.引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小；

7.有多级指针，但是没有多级引用；

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

9.引用比指针使用起来相对更安全。

内联函数

内联函数概念

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

如下图，当我们调用普通函数时，汇编代码中call Add就是调用函数，要建立对应的栈帧。

我们再通过将Add函数前增加inline关键字将其修改为内联函数观察是否还会调用（内联在默认debug下不会起作用，要在release模式或者debug配置下才可以使用）

1.在release模式下查看编译器生成的汇编代码中是否还存在call Add（VS2022）

2.在debug模式下，需要对编译器进行设置，否则不会展开，因为debug模式下，编译器默认不会对代码进行优化，设置方式（VS2022）如下：

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用，汇编代码中并没有call Add。

内联函数特性

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

2.inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，如果定义为inline的函数体内有递归等，编译器会忽略inline特性。

3.inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

扩展：

在C++中推荐用const和enum替代宏常量，inline替代宏函数。

宏的优势：

1.宏常量可以提高代码复用性；

2.提高性能。

宏缺点：

1.不能调试；

2.没有类型安全的检查；

3.宏在有些场景下面非常复杂，如当要求实现一个ADD宏函数时：

//#define ADD(x,y)  ((x) + (y))
#define ADD(x,y)  x + y
int main()
{
	int ret1 = ADD(1, 2); 
	int ret2 = ADD(1, 3) * 3; //想要的结果为12
	int ret3 = ADD(1 | 4, 3 & 5); //想要的结果为 6 
	
	cout << ret1 << endl; //输出结果为 3
	cout << ret2 << endl; //输出结果为 10
	cout << ret3 << endl; //输出结果为 5
	return 0;
}

如果在定义宏函数时，不将其参数()起来，最后计算出来的结果可能不是我们想要的。

auto关键字(C++11)

auto简介

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它。

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

#include <iostream>
using namespace std;
float func()
{
	return 6.66;
}
int main()
{
	int a = 10;
	auto b = a;
	auto c = 'c';
	auto f = func();
	
    //typeid(变量名).name()是用来查看变量的类型的函数
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(f).name() << endl;
    
    //auto e;//无法通过编译，使用auto定义变量时必须对其进行初始化
	return 0;
}

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

auto的使用

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

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&。如果不加&则是创建一个新的和=有右边相同类型的普通变量。

int main()
{
	int a = 10;
	auto b1 = &a;//自动推导出b1的类型为int*
	auto*& b2 = b1;//自动推导出b2的类型为int*
	auto& c = a;//自动推导出c的类型为int

	cout << typeid(a).name() << endl;//输出int
	cout << typeid(b1).name() << endl;//输出int*
	cout << typeid(b2).name() << endl;//输出int*
	cout << typeid(c).name() << endl;//输出int

	return 0;
}

• 在同一行定义多个变量

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

int main()
{
	auto a1 = 3, a2 = 4;

	//auto根据第一个类型推导出来为int，所以这一行的默认类型就是int
	//b1和b2的初始化表达类型不同，所以报错
	auto b1 = 5, b2 = 3.14;//error
    return 0;
}

auto不能推导的场景

• auto不能作为函数的参数

此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导。

void func(auto x)
{}

• auto不能直接用来声明数组

int main()
{
	int arr1[] = { 1,2,3 };
	auto arr2[] = { 4，5，6 };//error
	return 0;
}

扩展：

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

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

范围for的语法

在C++11之前我们要遍历一个数组，往往使用的是下面的程序：

int main()
{
	int a[] = { 1,2,3,4,5,6,7 };
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		cout << a[i] << " ";
	}
}

对于一个有范围的集合，我们使用上面的方法不太方便，所以C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

int main()
{
	int a[] = { 1, 2, 3, 4, 5, 6, 7 };
	for (auto e : a)
	{
		cout << e << " ";
	}
	//输出结果为1 2 3 4 5 6 7
	cout << endl;
	//我们还可以使用引用和范围for结合改变数组
	for (auto& e : a)
	{
		e *= 2;
		cout << e << " ";
	}
	//输出结果为2 4 6 8 10 12 14
}

注意：范围for与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

范围for的使用条件

• for循环迭代的范围必须是确定的

对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

下面代码是错误的，因为for循环的范围是不确定的。

void func(int arr[])
{
	for (auto e : arr) //error,数组传参时传过去的是地址
	{
		cout << e << " ";
	}
}
int main()
{
	int a[] = { 1, 2, 3, 4, 5, 6, 7 };
	func(a);
}

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

指针空值nullptr(C++11)

C++98中的指针空值

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现错误。对于未初始化的指针我们通常使用下面的方式进行初始化：

int* p1 = NULL;
int* p2 = 0;

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

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

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

void func(int)
{
	cout << "func(int)" << endl;
}
void func(int*)
{
	cout << "func(int*)" << endl;
}
int main()
{
	f(0); //输出结果为func(int)
	f(NULL);//输出结果为func(int)
	f((int*)NULL);//输出结果为func(int*)
	return 0;
}

func(NULL)本意是调用func(int*)函数，但是由于NULL被定义为0，所以实际调用的时候调用的是func(int)。

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

C++11中的指针空值

针对上述所存在的问题，C++11中引入了关键字nullptr。

注意：

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

• 在C++11中，sizeof(nullptr)与sizeof((void*)0)所占的字节数相同（32位下4个字节，64位下8个字节）；

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