C++ 和 C 语言有着紧密而特殊的关系，两者既一脉相承又各有发展。可以说 C++ 是 C 的 “超集”（功能上包含并扩展了 C），但两者定位不同：C 追求简洁高效的底层控制，C++ 则通过更多特性支持复杂系统的开发。所以先来了解一下C++到底对C改进了什么吧。

一 namespace

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

想象一下，我们进入一家公司，很多人参与同一个项目，运行程序是却出现了命名冲突的报错，多么让你恼怒。这时我们就需要使用namespace关键字了。

int rand = 10;
int main()
{
	// 编译报错：error C2365: “rand”: 重定义；以前的定义是“函数”
	printf("%d\n", rand);
	return 0;
}

这下就编译报错了，下面是namespace的使用

//命名空间定义
namespace egg
{
	//变量
	int rand;
	//函数
	int Add(int a, int b)
	{
		return a + b;
	}
	//类型
	struct node
	{
		int val;
		struct node* next;
	};
}

int main()
{
	// 这里默认是访问的是全局的rand函数指针
	printf("%p\n", rand);
	// 这里指定egg命名空间中的rand
	printf("%d\n", egg::rand);
	return 0;
}

（1）namespace的定义

格式：定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。

namespace 空间名
{
     成员变量
     成员方法
     成员类
}

namespace只能定义在全局，当然他还可以嵌套定义。

// 多文件中可以定义同名namespace，他们会默认合并到一起，就像同一个namespace一样
namespace egg
{
	namespace life
	{
		//变量
		int rand;
		//函数
		int Add(int a, int b)
		{
			return a + b;
		}
		//类型
		struct node
		{
			int val;
			struct node* next;
		};
	}

	namespace binyan
	{
		//变量
		int rand;
		//函数
		int Add(int a, int b)
		{
			return a + b;
		}
		//类型
		struct node
		{
			int val;
			struct node* next;
		};
	}
}

项目工程中多文件中定义的同名namespace会认为是一个namespace，不会冲突。就像三国杀游戏里铁索连环的使用规则。

（2）namespace的使用

#include<stdio.h>
namespace N
{
    int a = 0;
    int b = 1;
}

int main()
{
    //编译报错：errorC2065：“a”：未声明的标识符
    printf("%d\n"， a);
    return 0;
}

编译查找一个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以下面程序会编译报错。所以我们要使用命名空间中定义的变量/函数，有三种方式：
1.指定命名空间访问，项目中推荐这种方式。
2.using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。
3.展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

看一下具体代码：

// 指定命名空间访问
int main()
{
printf("%d\n", N::a);
return 0;
}
// using将命名空间中某个成员展开
using N::b;
int main()
{
printf("%d\n", N::a);
printf("%d\n", b);
return 0;
}
// 展开命名空间中全部成员
using namespce N;
int main()
{
printf("%d\n", a);
printf("%d\n", b);
return 0;
}

（3）对C++namespace的理解

1.namespace本质是定义出一个域，这个域跟全局域各自独立，不同的域可以定义同名变量。
2.C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找一个变量/函数类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。

注意：C++标准库都放在一个叫std(standard)的命名空间中

二缺省参数

（1）认识缺省参数

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

void func1(int a = 114514)
{
	cout << a << endl;
}

int main()
{
	func1();// 没有传参时，使用参数的默认值
	func1(123);// 传参时，使用指定的实参
	return 0;
}

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

// 全缺省
void Func1(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
// 半缺省
void Func2(int a, int b = 10, int c = 20)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
int main()
{
	Func1();
	Func1(1);
	Func1(1, 2);
	Func1(1, 2, 3);
	Func2(100);
	Func2(100, 200);
	Func2(100, 200, 300);
	return 0;
}

全缺省就是每个参数都给一个默认值，相反，半缺省就是只给部分参数默认值。

（2）缺省函数要注意的点

1.C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。

（这一规则主要是为了消除函数调用时的歧义，保证编译器能够正确解析参数传递的逻辑。大家当作规定就好。）

2.带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。（理由同上）

3.函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省
值。（避免默认值冲突）

// 声明
void func(int a = 10);

// 定义
void func(int a = 20) { ... } // 错误：重复指定缺省参数

三函数重载

（1）认识函数重载

C++支持在同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调用就表现出了多态行为，使用更灵活。

// 1、参数类型不同
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;
}
// 2、参数个数不同
void f()
{
cout << "f()" << endl;
}
void f(int a)
{
cout << "f(int a)" << endl;
}
// 3、参数类型顺序不同
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;
}


int main()
{
Add(10, 20);
Add(10.1, 20.2);
f();
f(10);
f(10, 'a');
f('a', 10);
return 0;
}

判断函数重载是否成立就看参数是不是完全一样。

（2）特例

// 下面两个函数构成重载
// f()但是调用时，会报错，存在歧义，编译器不知道调用谁
void f1()
{
cout << "f()" << endl;
}
void f1(int a = 10)
{
cout << "f(int a)" << endl;
}

如果函数不填参数都能运行，会有歧义。

四引用

（1）引用的概念和定义

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。（相当于一个房间又多配了一把钥匙）

格式：类型& 引用别名 = 引用对象;（人& 豹子头=林冲）

int a=0;
int& b=a;

来看看对内存的使用。

int main()
{
int a = 0;
// 引用：b和c是a的别名
int& b = a;
int& c = a;
// 也可以给别名b取别名，d相当于还是a的别名
int& d = b;
++d;
// 这里取地址我们看到是一样的
cout << &a << endl;
cout << &b << endl;
cout << &c << endl;
cout << &d << endl;
return 0;
}

发现使用的都是同一个空间。

（2）引用的特性

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

（就相当于外号，一个外号诞生的时候大概率就会有一个主人，而且一个人可以有多个外号，但一个外号往往只指向一个人）

int main()
{
int a = 10;
// 编译报错：“ra”: 必须初始化引用
//int& ra;
int& b = a;
int c = 20;
// 这里并非让b引用c，因为C++引用不能改变指向，
// 这里是一个赋值
b = c;
cout << &a << endl;
cout << &b << endl;
cout << &c << endl;
return 0;
}

（3）引用的使用

常见场景：1.函数传参      2.函数传返回值

void Swap(int& rx, int& ry)
{
int tmp = rx;
rx = ry;
ry = tmp;
}
int main()
{
int x = 0, y = 1;
cout << x <<" " << y << endl;
Swap(x, y);
cout << x << " " << y << endl;
return 0;
}

// int STTop(ST& rs)
int& STTop(ST& rs)
{
assert(rs.top > 0);
return rs.a[rs.top];
}

为什么都和函数相关呢。

（4）引用的理解

引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被
引用对象。

引用传参跟指针传参功能是类似的，引用传参相对更方便一些。

C++引用定义后不能改变指向

（总之是为了效率，还有方便）

（5）const引用

这涉及一个权限的概念，刚刚说了配钥匙的例子，我们当然不希望这把钥匙可以多打开其他的门，少打开一些门则会更安全，而文件的权限我们简单理解为可读可写。

const int a = 10;
const int& ra = a;

int main()
{
const int a = 10;
// 编译报错：error C2440: “初始化”: 无法从“const int”转换为“int &”
// 这里的引用是对a访问权限的放大
//int& ra = a;
// 这样才可以
const int& ra = a;
// 编译报错：error C3892: “ra”: 不能给常量赋值
//ra++;
// 这里的引用是对b访问权限的缩小
int b = 20;
const int& rb = b;
// 编译报错：error C3892: “rb”: 不能给常量赋值
//rb++;
return 0;
}

什么时候会遇到权限问题呢。

1.函数返回值

2.变量类型的转化

int main()
{
int a = 10;
const int& ra = 30;
// 编译报错: “初始化”: 无法从“int”转换为“int &”
// int& rb = a * 3;
const int& rb = a*3;
double d = 12.34;
// 编译报错：“初始化”: 无法从“double”转换为“int &”
// int& rd = d;
const int& rd = d;
return 0;
}

(6)const引用注意

• 可以引用一个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访
问权限在引用过程中可以缩小，但是不能放大。
• 所谓临时对象就是编译器需要一个空间暂存表达式的求值结果时临时创建的一个未命名的对象，
C++中把这个未命名对象叫做临时对象。

(7)引用与指针区别

C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。
• 语法概念上引用是一个变量的取别名不开空间，指针是存储一个变量地址，要开空间。
• 引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
• 引用在初始化时引用一个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。
• 引用可以直接访问指向对象，指针需要解引用才是访问指向对象。
• sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)
• 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全一些。

五内联函数

（1）inline关键字

用inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就需要建立栈帧了，就可以提高效率。

//非内联
int add(int a, int b)；
//内联
inline int add(int a, int b)；

（2）对C语言的改进

C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不方便调
试，C++设计了inline目的就是替代C的宏函数。

我们来实现一个宏函数看一看。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>

using namespace std;

// 实现一个ADD宏函数的常见问题
// 错误版本
//#define ADD(int a, int b) return a + b;
//#define ADD(a, b) a + b;
//#define ADD(a, b) (a + b)
#define ADD(a,b) ((a)+(b))

int main()
{
	cout << ADD(2, 3) << endl;
	cout << ADD(1, 2) << endl;
	cout << ADD(1, 2) * 5 << endl;
	//int x = 1, y = 2;
	//ADD(x & y, x | y); // -> (x&y+x|y)
	return 0;
}

 宏函数（也称为 “宏定义”，通过#define实现）是 C/C++ 等语言中预处理阶段的功能，主要作用是代码替换，宏函数在预处理阶段直接展开，没有函数调用的栈帧开销。可以通过汇编观察程序是否展开。 有call Add语句就是没有展开，没有就是展开了

来看看内联函数的汇编是不是一样：（一样没有call add语句）

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>

using namespace std;

inline int add(int a, int b)
{
	return a + b;
}

int main()
{
	cout << add(3 , 6) << endl;
	return 0;
}

再看看普通版本函数：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>

using namespace std;

int add(int a, int b)
{
	return a + b;
}

int main()
{
	cout << add(3 , 6) << endl;
	return 0;
}

(debug模式下方便调试，不展开，要自己看得设置一下（vs）)

（3）内联函数展开副作用

当函数体复杂（含循环、递归、复杂分支）、是虚函数，或编译器基于优化策略（如 Debug 模式、函数规模过大）判断不适合时，内联函数不会展开。

如果展开导致指令变多，指令膨胀了，程序占用内存会很大。

(4)注意

inline函数的定义和声明不建议分离，这样会导致链接错误。因为函数展开了，没有了函数地址。

六 nullptr

(1)对C语言的改进

nullptr是用于替换C语言当中的NULL

NULL是一个宏，是对(（void*）.....)的替换（在C语言中），对0的替换（在cpp中）。

nullptr是一个关键字，能转换成任意类型的指针，值为0