初识C++ - 悦读

C++的起源可以追溯到1979年，当时Bjarne Stroustrup（本贾尼·斯特劳斯特卢普，名字翻译可能因地区而异）在贝尔实验室从事计算机科学和软件工程的研究工作。面对项目中复杂的软件开发任务，特别是模拟和操作系统的开发工作，他感受到了现有语言（如C语言）在表达能力、可维护性和可扩展性方面的不足。
在随后的几年中，C++在学术界和工业界的应用逐渐增多。一些大学和研究所开始将C++作为教学和研究的首选语言，而一些公司也开始在产品开发中尝试使用C++。这一时期，C++的标准库和模板等特性也得到了进一步的完善和发展。
在随后的几年中，C++在学术界和工业界的应用逐渐增多。一些大学和研究所开始将C++作为教学和研究的首选语言，而一些公司也开始在产品开发中尝试使用C++。这一时期，C++的标准库和模板等特性也得到了进一步的完善和发展。
C++的标准化工作于1989年开始，并成立了一个ANSI（American National Standards Institute）和ISO（International Standards Organization）国际标准化组织的联合标准化委员会。这个委员会致力于制定C++语言的标准，以确保其跨平台、跨编译器的兼容性和一致性。
1994年，标准化委员会提出了第一个标准化草案。在该草案中，委员会在保持斯特劳斯特卢普最初定义的所有特征的同时，还增加了部分新特征。这些新特征的加入，使得C++语言更加完善、更加灵活。
在完成C++标准化的第一个草案后不久，STL（Standard Template Library）被提出并加入到C++标准中。STL是由惠普实验室的Alexander Stepanov、Meng Lee和David R Musser开发的一系列软件的统称。STL为C++提供了丰富的模板类和函数，使得程序员可以更加高效地进行编程和算法实现。
虽然将STL包含到C++标准中是个很重要的决定，但也因此延缓了C++标准化的进程。然而，这一决定最终证明是正确的，STL的加入极大地提升了C++的实用性和表达能力。
1997年11月14日，联合标准化委员会通过了C++标准的最终草案。1998年，C++的ANSI/ISO标准正式投入使用。这一标准的发布标志着C++语言已经成为了一种成熟、稳定、功能强大的编程语言。

2. C++在工作领域中的应用

C++的应用领域极为广泛，涵盖了服务器端、游戏（引擎）、机器学习引擎、音视频处理、嵌入式软件、电信设备、金融应用、基础库、操作系统、编译器、基础架构、基础工具以及硬件交互等多个方面。

大型系统软件开发。如编译器、数据库、操作系统、浏览器等等
音视频处理。常见的音视频开源库和方案有FFmpeg、WebRTC、Mediasoup、ijkplayer，⾳视频开发最主要的技术栈就是C++。
PC客户端开发主要是针对Windows等操作系统上的桌面软件进行开发，例如WPS等应用。在技术栈方面，C++和QT是常用的组合。QT是一个跨平台的C++图形用户界面（Graphical User Interface，GUI）程序开发框架，使得开发者能够利用C++编写出可在不同平台上运行的桌面应用程序。
服务端开发主要涉及各种大型应用网络连接的高并发后台服务。虽然Java在这一领域也有广泛应用，但C++主要用于一些对性能要求比较高的场合。例如，游戏服务、流媒体服务以及量化高频交易服务等，都倾向于使用C++来开发，以满足其高性能需求。
游戏引擎开发多使用C++，要求开发者掌握C++基础和数据结构，学习图形学知识，并熟悉游戏引擎与框架。为了深入理解引擎实现，可以学习如UE4、Cocos2d-x等开源引擎的源代码。
嵌入式开发是将具有计算能力的主控板嵌入到机器装置或电子装置的内部，通过软件控制这些装置。例如：智能手环、摄像头、扫地机器人、智能音响、门禁系统、车载系统等。粗略来说，嵌入式开发主要分为嵌入式应用和嵌入式驱动开发。
机器学习引擎。机器学习底层的很多算法都是用C++实现的，上层用python封装起来。如果你只想准备数据训练模型，那么学会Python基本上就够了，如果你想做机器学习系统的开发，那么需要学会C++。
测试开发/测试。每个公司研发团队，有研发就有测试，测试主要分为测试开发和功能测试，测试开发一般是使用一些测试⼯具(selenium、Jmeter等)，设计测试用例，然后写一些脚本进行自动化测试，性能测试等，有些还需要自行开发一些测试用具。功能测试主要是根据产品的功能，设计测试用例，然后手动的方式进行测试。

3. 第一个C++程序

C++兼容C语言绝大多数的语法，所以C语言实现的hello world依旧可以运行。在C++中需要把定义文件代码后缀改为.cpp。VS编译器看到是.cpp就会调用C++编译器编译，Linux下要用g++编译，不再是gcc。

3.1 梦开始的地方：打印hello world

#include <stdio.h>

int main()
{
 printf("hello world\n");
 return 0;
}

当然C++有一套自己的输入输出，严格说C++版本的hello world应该是这样写的。

//这⾥的std cout等我们都看不懂，没关系，下⾯我们会依次讲解
#include<iostream>
using namespace std;

int main()
{
	cout << "hello world\n" << endl;
	return 0;
}

4. 命名空间

4.1 namespace的价值

在C/C++中，变量、函数和后续要学到的类都是大量存在的，它们的名称都将存在于全局作用域中，这可能导致许多冲突。使用命名空间的目的是对标识符的名称进行本地化，从而避免命名冲突或名字污染。namespace关键字的引入正是为了解决这类问题（主要还是解决命名冲突的问题）。

C语言项目中类似下面程序这样的命名冲突是普遍存在的问题，C++引入namespace就是为了更好地解决这样的问题。

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

因为在<stdlib.h>这个头文件中，rand是已经定义好的函数，所以当我们打印rand时，编译器会报错（重复定义）。为了解决这样的问题C++就引入了namespace。

4.2 namespace的定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。
namespace本质是定义出一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以下面的rand不在冲突了。
C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找一个变量/函数/ 类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期（全局）。
namespace只能定义在全局，当然他还可以嵌套定义。
项目工程中多文件中定义的同名namespace会认为是一个namespace，不会冲突。
C++标准库都放在一个叫std(standard)的命名空间中。

#include <stdio.h>

#include <stdlib.h>

// 1. 正常的命名空间定义 

// bit是命名空间的名字，⼀般开发中是⽤项⽬名字做命名空间名。 

// 我们上课⽤的是bit，⼤家下去以后⾃⼰练习可以考虑⽤⾃⼰名字缩写，如张三：zs 

namespace bit
{
 // 命名空间中可以定义变量/函数/类型 
 int rand = 10;
 int Add(int left, int right)
 {
     return left + right;
 }

 struct Node
 {
     struct Node* next;
     int val;
 };
}

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

由于main函数中没有rand，所以我们会在全局域中搜索，而rand在头文件<stdlib.h>中就已经被定义为函数了，头文件在预处理阶段就会被展开，所以我们一开始访问的是全局的rand函数指针
用命名空间名字配上::就可以到指定域中查找（如果找不到也不会再其他域中查找）

printf("%d\n", a)默认访问的是局部的a，想要用全局的a就要在a前面加上::

编译器默认查找

当前局部域
全局域
到展开的命名空间中找

在不同于中我们可以定义同名的变量/函数/类型

命名空间三种访问方法

指定访问（使用命名空间的名字搭配::）例如：bit::
到展开的命名空间域中查找。例如：using namespace bit
指定展开某一个。例如：using bit:: x; x是命名空间中的变量x

命名空间还可以嵌套

//命名空间嵌套
namespace bit
{
	namespace pg
	{
		int rand = 1;
		int Add(int left, int right)
		{
			return left + right;
		}
	}
	namespace hg
	{
		int rand = 2;
		int Add(int left, int right)
		{
			return (left + right) * 10;
		}
	}
}

int main()
{
	printf("%d\n", bit::pg::rand);
	printf("%d\n", bit::hg::rand);
	printf("%d\n", bit::pg::Add(1, 2));
	printf("%d\n", bit::hg::Add(1, 2));
	return 0;
}

运行结果：

多文件中可以定义同名namespace，他们会默认合并到一起，就像同一个namespace一样。

#pragma once
//Stack.h
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

namespace bit
{
	#define N 10000
	typedef int STDataType;
	typedef struct Stack
	{
		STDataType* a;
		int top;
		int capacity;
	}ST;

	static int x = 0;
	static int y = 0;

	// 缺省参数在声明给
	void STInit(ST* ps, int n = 4);
	void STDestroy(ST* ps);

	// 栈顶
	void STPush(ST* ps, STDataType x);
	void STPop(ST* ps);
	STDataType STTop(ST* ps);
	int STSize(ST* ps);
	bool STEmpty(ST* ps);
}

#include"Stack.h"
//Stack.cpp
namespace bit
{
	// 缺省参数不能声明和定义同时给
	void STInit(ST* ps, int n)
	{
		assert(ps);

		ps->a = (STDataType*)malloc(n * sizeof(STDataType));
		ps->top = 0;
		ps->capacity = n;
	}

	void STDestroy(ST* ps)
	{
		assert(ps);

		free(ps->a);
		ps->a = NULL;
		ps->top = ps->capacity = 0;
	}

	// 栈顶
	void STPush(ST* ps, STDataType x)
	{
		assert(ps);

		// 满了， 扩容
		if (ps->top == ps->capacity)
		{
			printf("扩容\n");
			int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
			STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
		ps->a[ps->top] = x;
		ps->top++;
	}

	void STPop(ST* ps)
	{
		assert(ps);
		assert(!STEmpty(ps));
		ps->top--;
	}

	STDataType STTop(ST* ps)
	{
		assert(ps);
		assert(!STEmpty(ps));
		return ps->a[ps->top - 1];
	}

	int STSize(ST* ps)
	{
		assert(ps);
		return ps->top;
	}

	bool STEmpty(ST* ps)
	{
		assert(ps);
		return ps->top == 0;
	}
}

//Test.cpp
int main()
{
	bit::ST st1;
	STInit(&st1);
	STPush(&st1, 1);
	STPush(&st1, 2);
	printf("%d\n", sizeof(st1));
	bit::ST st2;
	printf("%d\n", sizeof(st2));
	bit::STInit(&st2);
	bit::STPush(&st2, 1);
	bit::STPush(&st2, 2);
	return 0;
}

运行结果：

4.3 命名空间的使用

编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以下面程序会编译报错。所以我们要使用命名空间中定义的变量/函数，有三种方式：

指定命名空间访问，项目中推荐这种方式。
using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。
展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

#include<stdio.h>

namespace bit
{
	int a = 0;
	int b = 1;
}

int main()
{
	// 编译报错：error C2065: “a”: 未声明的标识符 
    //不展开bit，默认是不会到bit域中查找的
	printf("%d\n", a);
	return 0;
}

namespace N
{
    int a = 10;
    int b = 20;
}
// using将命名空间中某个成员展开
using N::a;

int main()
{
	printf("%d\n", N::a);
    //这里也可以不指定直接输出a
   	printf("%d\n", a); 
	return 0;
}

运行结果：

namespace N
{
	int a = 10;
	int b = 20;
}

using N::b;
int main()
{
	printf("%d\n", N::a);
	printf("%d\n", b);
	return 0;
}

运行结果：

5. C++输入&输出

<iostream>是 Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。
std::cin是istream类的对象，它主要面向窄字符（narrow characters(of type char)）的标准输入流。
std::cout是ostream类的对象，它主要面向窄字符的标准输出流。
std::endl是一个函数，流插入输出时，相当于插入一个换行字符加刷新缓冲区。
<<是流插入运算符，>>是流提取运算符。（C语言还用这两个运算符做位运算左移/右移）
使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动指定格式，C++的输入输出可以自动识别变量类型(本质是通过函数重载实现的，这个以后会讲到)，其实最重要的是 C++的流能更好的支持自定义类型对象的输入输出。
IO流涉及类和对象，运算符重载、继承等很多面向对象的知识，这些知识我们还没有讲解，所以这里我们只能简单认识一下C++ IO流的用法，后面我们会有专门的一个章节来细节IO流库。
cout/cin/endl等都属于C++标准库，C++标准库都放在一个叫std(standard)的命名空间中，所以要通过命名空间的使用方式去用他们。
一般日常练习中我们可以using namespace std，实际项目开发中不建议using namespace std。
这里我们没有包含，也可以使用printf和scanf，在包含<iostream>间接包含了。vs系列译器是这样的，其他编译器可能会报错。

int main()
{
	int a = 0;
	double b = 0.1;
	char c = 'x';
	cout << a << " " << b << " " << c << endl;
	std::cout << a << " " << b << " " << c << std::endl;
	/
	scanf("%d%lf", &a, &b);
	printf("%d %lf\n", a, b);
	//cin和cout可以自动识别变量类型
	cin >> a;
	cin >> b >> c;
	cout << a << endl;
	cout << b << " " << c << endl;
}

运行结果：

6. 缺省参数

缺省参数是在声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有为某个参数指定实参则采用该形参的缺省值；如果指定了实参，则使用指定的实参。缺省参数可以分为全缺省和半缺省参数。（有些地方把缺省参数也叫默认参数）
全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

//全缺省
void Func1(int a = 10, int b = 20, int c = 30)
{
	cout << a << " " << b << " " << c << endl;
}
//半缺省
void Func2(int a, int b = 10, int c = 40)
{
	cout << a << " " << b << " " << c << endl;
}

int main()
{
	Func1();
	Func1(1,2,3);
	Func2(1);
	Func2(1, 2, 3);
	return 0;
}

运行结果：

7. 函数重载

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

不同作用域可以同名，同一作用域也可以同名，但要满足重载规则。

#include<iostream>
using namespace std;

// 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;
}

返回值不同不能作为重载条件，因为调用时也无法区分

// 返回值不同不能作为重载条件，因为调⽤时也⽆法区分 

void fxx()
{}

int fxx()
{
 return 0;
}

有些函数即使构成了重载，运行的时候也有可能报错

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

void f1(int a = 10)
{
	cout << "f(int a)" << endl;
}

int main()
{
	f1();
	f1(10);
	return 0;
}

运行结果：

因为全缺省实参是可以不用传值的，所以f1()就不知道调用那个函数，调用61行的可以，66行的也行，有歧义。

那为什么C++支持重载，C语言不支持？
C语言没办法支持重载是因函数名没法区分，而C++是通过函数修饰规则来区分，只要参数、类型不同则修饰出来的名字就不一样，则支持重载。

8. 引用

8.1 引用的概念的定义

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。比如：水浒传中李逵，宋江叫"铁牛"，江湖上人称"黑旋风"；林冲，外号豹子头；

类型& 引用别名 = 引用对象;

C++中为了避免引⼊太多的运算符，会复用C语言的一些符号，不如前面的>，这里引用也和取地址使用了同用个符号&，大家注意使用方法角度区分就可以。（吐槽一下，这个问题其实挺坑的，个人觉得用更多符号反而更好，不容易混淆）

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

	return 0;
}

运行结果：

8.2 引用的特性

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

int main()
{
	int a = 10;
	//引用的时候必须要进行初始化，否则会报错
	//int& ra;错误案例
	int& b = a;
	int c = 20;
	//这里并非是让b引用c,因为b是a的别名，不能再被修改了
	//这里b = c是赋值操作
	b = c;
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	return 0;
}

8.3 引用的使用

引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。
引用传参跟指针传参功能是类似的，引用传参相对更方便一些。
引用返回值的场景相对⽐较复杂，我们在这里简单讲了一下场景，还有一些内容后续类和对象章节中会继续深入讲解。
引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他语言的引用(如Java)是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向， Java的引用可以改变指向。
一些主要用C代码实现版本数据结构教材中，使用C++引用替代指针传参，目的是简化程序，避开复杂的指针，但是很多同学没学过引用，导致⼀头雾水。

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int x = 0;
	int y = 1;
	cout << x << " " << y << endl;
	Swap(x, y);
	cout << x << " " << y << endl;
	return 0;
}

用引用传参使用栈

#include <iostream>
#include <assert.h>
#include <stdlib.h>
using namespace std;
typedef int STDataType;

typedef struct Stack

{
	STDataType* a;
	int top;
	int capacity;
}ST;

void STInit(ST& rs, int n = 4)
{
	rs.a = (STDataType*)malloc(n * sizeof(STDataType));
	rs.top = 0;
	rs.capacity = n;
}

// 栈顶 
void STPush(ST& rs, STDataType x)
{
	// 满了， 扩容 
	if (rs.top == rs.capacity)
	{
		printf("扩容\n");
		int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
		STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity *

			sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		rs.a = tmp;
		rs.capacity = newcapacity;
	}
	rs.a[rs.top] = x;
	rs.top++;
}


int& STTop(ST& rs)
{
	assert(rs.top > 0);
	//返回类型是int&
	//所以引用的那块空间就是栈顶最上面的元素空间
	return rs.a[rs.top-1];
}

int main()
{
	// 调⽤全局的 
	ST st1;
	STInit(st1);
	STPush(st1, 1);
	STPush(st1, 2);
	cout << STTop(st1) << endl;
	//因为返回类型是引用
	//所以STTop(st1) += 10;就能改变栈顶元素
	STTop(st1) += 10;
	cout << STTop(st1) << endl;
	return 0;
}

运行结果：

8.4 const引用

可以引用⼀个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。
不需要注意的是类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样一些场景下a*3的和结果保存在一个临时对象中， int& rd = d 也是类似，在类型转换中会产生临时对象存储中间值，rb和rd引用的都是临时对象，而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要用常引用才可以。
所谓临时对象就是编译器需要一个空间暂存表达式的求值结果时临时创建的一个未命名的对象， C++中把这个未命名对象叫做临时对象。

#include <iostream>
using namespace std;

int main()
{
	//可以权限的平移
	int x = 0;
	int& y = x;

	//可以，权限变小了
	const int& z = x;
	//z++; // 不行z是常量，不能被修改
	y++;

	//原本是只读的，但是赋给n就变成可读可写的
	//权限变大了，所以不可以
	const int m = 0;
	// int& n = m;
	//可以，权限的平移
	const int& n = m;

	//赋值操作，可以
	int p = m;


	const int* p1 = &m;
	// p1++;  const修饰的是*p1，所以p1可以++，*p1不可以修改空间里面的内容
	// int* p2 = p1;权限放大不可以
	const int* p2 = p1;


	int* p3 = &x;
	const int* p4 = p3;

	return 0;
}

8.5 指针和引用的关系

C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。

语法概念上引用是⼀个变量的取别名不开空间，指针是存储一个变量地址，要开空间。
引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
引用在初始化时引用一个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。
引用可以直接访问指向对象，指针需要解引用才是访问指向对象。
sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)
指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全一些。
引用表面好像是传值，其本质也是传地址，只是这个工作由编译器来做

上面是课件上的说法，下面是我总结的

引用和指针的不同点

引用概念上定义一个变量的别名，指针存储一个变量的地址
引用在定义时必须初始化，指针没有要求
引用在初始化时引用一个实体后，就不能在引用其他实体，而指针可在任何时候指向任何一个同类型实体
没有空引用，但有NULL指针
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
有多级指针，但没有多级引用

9. inline

用inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就需要建立栈帧了，就可以提高效率。
inline对于编译器而言只是一个建议，也就是说，你加了inline编译器也可以选择在调用的地方不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适⽤于频繁调用的短小函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。
C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不方便调试，C++设计了inline目的就是替代C的宏函数。
vs编译器debug版本下面默认是不展开inline的，这样方便调试，debug版本想展开需要设一下以下两个地方。
inline不建议声明和定义分离到两个文件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现报错。报错的原因是定义的时候会把函数展开，那就是函数没有地址了，所以声明的时候地址是无效的，比如0x00，所以链接的时候头文件的Add是不能在test.cpp中找到函数，所以会报错

#include <iostream>
using namespace std;

inline int Add(int x, int y)
{
	int ret = x + y;
	ret += 1;
	ret += 1;
	ret += 1;
	return ret;
}

int main()
{
	// 可以通过汇编观察程序是否展开 
	// 有call Add语句就是没有展开，没有就是展开了 
	int n = 10;
	int ret = Add(1, 2);
	cout << Add(1, 2) * 5 << endl;
	return 0;
}