Bootstrap

C++基础知识1 入门基础

C++基础

1.C++历史

1983年，Bjarne Stroustrup在C语⾔的基础上添加了⾯向对象编程的特性，设计出了C++语⾔的雏形，此时的C++已经有了类、封装、继承等核⼼概念，为后来的⾯向对象编程奠定了基础。这⼀年该语⾔被正式命名为C++。
C++的标准化⼯作于1989年开始，并成⽴了⼀个ANSI和ISO（International StandardsOrganization）国际标准化组织的联合标准化委员会。1994年标准化委员会提出了第⼀个标准化草案。在该草案中，委员会在保持斯特劳斯特卢普最初定义的所有特征的同时，还增加了部分新特征。在完成C++标准化的第⼀个草案后不久，STL（Standard Template Library）是惠普实验室开发的⼀系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室⼯作时所开发出来的。在通过了标准化第⼀个草案之后，联合标准化委员会投票并通过了将STL包含到C++标准中的提议。STL对C++的扩展超出C++的最初定义范围。虽然在标准中增加STL是个很重要的决定，但也因此延缓了C++标准化的进程。
1997年11⽉14⽇，联合标准化委员会通过了该标准的最终草案。1998年，C++的ANSI/IS0标准被投⼊使⽤。

C++是兼容C的

2. C++版本更新

在这里插入图片描述

一般现在公司都要求掌握C++11的特性，当然部分公司可能会用到后面的一些特性。但是学习C++，我们至少掌握到C++11

3. C++参考⽂档：

https://legacy.cplusplus.com/reference/
https://zh.cppreference.com/w/cpp
https://en.cppreference.com/w/

4. C++的应用

C++的应⽤领域服务器端、游戏（引擎）、机器学习引擎、⾳视频处理、嵌⼊式软件、电信设备、⾦融
应⽤、基础库、操作系统、编译器、基础架构、基础⼯具、硬件交互等很多⽅⾯都有。

  1. ⼤型系统软件开发。如编译器、数据库、操作系统、浏览器等等
    比特就业课
  2. ⾳视频处理。常⻅的⾳视频开源库和⽅案有FFmpeg、WebRTC、Mediasoup、ijkplayer，⾳视频
  3. PC客⼾端开发。⼀般是开发Windows上的桌⾯软件，⽐如WPS之类的，技术栈的话⼀般是C++和QT
  4. QT 是⼀个跨平台的 C++图形⽤⼾界⾯（Graphical User Interface，GUI）程序。
  5. 服务端开发。各种⼤型应⽤⽹络连接的⾼并发后台服务。这块Java也⽐较多，C++主要⽤于⼀些对性能要求⽐较⾼的地⽅。如：游戏服务、流媒体服务、量化⾼频交易服务等
  6. 游戏引擎开发。很多游戏引擎就都是使⽤C++开发的，游戏开发要掌握C++基础和数据结构，学习图形学知识，掌握游戏引擎和框架，了解引擎实现，引擎源代码可以学习UE4、Cocos2d-x等开源引擎实现
  7. 嵌⼊式开发。嵌⼊式把具有计算能⼒的主控板嵌⼊到机器装置或者电⼦装置的内部，通过软件能够控制这些装置。⽐如：智能⼿环、摄像头、扫地机器⼈、智能⾳响、⻔禁系统、⻋载系统等等，粗略⼀点，嵌⼊式开发主要分为嵌⼊式应⽤和嵌⼊式驱动开发。
  8. 机器学习引擎。机器学习底层的很多算法都是⽤C++实现的，上层⽤python封装起来。如果你只想准备数据训练模型，那么学会Python基本上就够了，如果你想做机器学习系统的开发，那么需要学会C++。
  9. 测试开发/测试。每个公司研发团队，有研发就有测试，测试主要分为测试开发和功能测试，测试开发⼀般是使⽤⼀些测试⼯具(selenium、Jmeter等)，设计测试⽤例，然后写⼀些脚本进⾏⾃动化测试，性能测试等，有些还需要⾃⾏开发⼀些测试⽤具。功能测试主要是根据产品的功能，设计测试⽤例，然后⼿动的⽅式进⾏测试。

5.C++的第一个程序

#include<iostream>
using namespace std;
int main()
{
	cout << "Hello World" << endl;
	return 0;
}

C++是兼容C的因此

#include<stdio.h>
int main()
{
	printf("Hello World\n");
	return 0;
}

6. 命名空间

6.1 namespace的价值

在C/C++中，变量、函数和后⾯要学到的类都是⼤量存在的，这些变量、函数和类的名称将都存在于全局作⽤域中，可能会导致很多冲突。使⽤命名空间的⽬的是对标识符的名称进⾏本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
c语⾔项⽬类似下⾯程序这样的命名冲突是普遍存在的问题，C++引⼊namespace就是为了更好的解决这样的问题
在这里插入图片描述

我们知道头文件<stdlib.h>中声明了rand函数，因此编译器不知道用户所需要的是整形rand还是函数rand。

6.2 namespace的定义

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

定义命名空间

namespace Yusei
{
	int rand = 10;
};
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
	printf("%p\n", rand);
	printf("%d\n", Yusei::rand);
	return 0;
}

第一条printf语句打印库中rand函数的地址，第二条语句打印命名空间里的整形rand。

命名空间可以嵌套

namespace Add
{
	namespace FloatAdd
	{
		float _Add(float x, float y)
		{
			return x + y;
		}
	};
	namespace IntAdd
	{
		int _Add(int x, int y)
		{
			return x + y;
		}
	};
};

int main()
{
	cout << "FloatAdd:" << Add::FloatAdd::_Add(3.0, 5.0) << endl;
	cout << "IntAdd:" << Add::IntAdd::_Add(3, 5) << endl;
	return 0;
}

同名namespace会认为是同一个space

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
#include<assert.h>
namespace Stack
{
	typedef int HPDataType;

	typedef struct Heap
	{
		HPDataType* arr;
		int size;//有效的数据个数
		int capacity;//空间大小
	}HP;

	void HPInit(HP* php);
	void HPDestroy(HP* php);

	void HPPush(HP* php, HPDataType x);
	void HPPop(HP* php);

	HPDataType HPTop(HP* php);
	// 判空
	bool HPEmpty(HP* php);


	void Swap(int* x, int* y);
	void AdjustUp(HPDataType* arr, int child);
	void AdjustDown(HPDataType* arr, int parent, int n);
};

#include"test.h"
namespace Stack
{
	void HPInit(HP* php)
	{
		assert(php);
		php->arr = NULL;
		php->size = php->capacity = 0;
	}
	void HPDestroy(HP* php)
	{
		assert(php);
		if (php->arr)
			free(php->arr);

		php->arr = NULL;
		php->size = php->capacity = 0;
	}

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

	void AdjustUp(HPDataType* arr, int child)
	{
		int parent = (child - 1) / 2;

		while (child > 0)//不需要等于，child只要走到根节点的位置，根节点没有父节点不需要交换
		{
			//建大堆，>
			//建小堆，<
			if (arr[child] < arr[parent])
			{
				Swap(&arr[parent], &arr[child]);
				child = parent;
				parent = (child - 1) / 2;
			}
			else
			{
				break;
			}
		}

	}

	void HPPush(HP* php, HPDataType x)
	{
		assert(php);
		//判断空间是否足够
		if (php->size == php->capacity)
		{
			//扩容
			int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
			HPDataType* tmp = (HPDataType*)realloc(php->arr, newCapacity * sizeof(HPDataType));
			if (tmp == NULL)
			{
				perror("realloc fail!");
				exit(1);
			}
			php->arr = tmp;
			php->capacity = newCapacity;
		}
		php->arr[php->size] = x;

		AdjustUp(php->arr, php->size);

		++php->size;
	}

	void AdjustDown(HPDataType* arr, int parent, int n)
	{
		int child = parent * 2 + 1;//左孩子
		//while (parent < n)
		while (child < n)
		{
			//小堆：找左右孩子中找最小的
			//大堆：找左右孩子中找大的
			if (child + 1 < n && arr[child] > arr[child + 1])
			{
				child++;
			}
			if (arr[child] < arr[parent])
			{
				Swap(&arr[child], &arr[parent]);
				parent = child;
				child = parent * 2 + 1;

			}
			else
			{
				break;
			}
		}
	}

	void HPPop(HP* php)
	{
		assert(php && php->size);

		//arr[0]  arr[size-1]
		Swap(&php->arr[0], &php->arr[php->size - 1]);

		--php->size;

		AdjustDown(php->arr, 0, php->size);


	}
	// 判空
	bool HPEmpty(HP* php)
	{
		assert(php);
		return php->size == 0;
	}

	HPDataType HPTop(HP* php)
	{
		assert(php && php->size);

		return php->arr[0];
	}

};

6.3 命名空间使⽤

编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间⾥⾯去查找。所以下⾯程序会编译报错。所以我们要使⽤命名空间中定义的变量/函数，有三种⽅式：
• 指定命名空间访问，项⽬中推荐这种⽅式。
• using将命名空间中某个成员展开，项⽬中经常访问的不存在冲突的成员推荐这种⽅式。
• 展开命名空间中全部成员，项⽬不推荐，冲突⻛险很⼤，⽇常⼩练习程序为了⽅便推荐使⽤。

在这里插入图片描述

在这里插入图片描述

推荐这种部分展开的方法

在这里插入图片描述

不推荐全部展开，不过部分展开不用加前缀namespace，而部分展开不用加前缀（或许::告诉程序这是个命名空间）

在这里插入图片描述

7. 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（防止自己写的变量函数与库冲突）。
• 这⾥我们没有包含<stdio.h>，也可以使⽤printf和scanf，在包含间接包含了。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 >> a;
	cin >> b >> c;
	cout << a << endl;
	cout << b << " " << c << endl;
	return 0;
}

在这里插入图片描述

在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码
可以提⾼C++IO效率。因为C++是兼容C的，因此判断是否使用了C语言中的函数需要时间，同时输入和输出有关联。

#include<iostream>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);//关闭C++与C的兼容
cin.tie(nullptr);//让cin和cout不关联
cout.tie(nullptr);//让cin和cout不关联
return 0;
}

8. 缺省参数

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

全缺省

#include <iostream>
#include <assert.h>
using namespace std;
void Func(int a = 0,int b=1,int c=2)
{
	cout << a <<' ' << b << ' '<< c << endl;
}
int main()
{
	Func(); // 没有传参时，使⽤参数的默认值
	Func(10); // 传参时，使⽤指定的实参(部分传)
	Func(10, 11);
	Func(, 11);//error，不支持跳跃传参
	Func(10,11, 12);//全传
	return 0;
}

半缺省

传实参从左往右，定义缺省参数从右往左。
在这里插入图片描述

#include <iostream>
#include <assert.h>
#include <iostream>
#include <assert.h>
using namespace std;
void Func(int a,int b,int c=12)
{
	cout << a <<' ' << b << ' '<< c << endl;
}
int main()
{
	Func(10,11);
	return 0;
}

定义和声明分离时
缺省参数不能声明和定义同时给缺省参数，需要缺省参数时在声明里面使用

error
在这里插入图片描述
所谓声明和定义分离应该是说声明和定义在不同文件中，这里在同一个文件中了。声明在头文件中有缺省值，定义在源文件中无缺省值。声明定义在同一个文件中，任取其一有缺省值即可

只能说创造再友好的人机交互也有人不能很好的使用，这个时候缺参数不就起到作用了

9. 函数重载

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

参数类型不同

#include<iostream>
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;
}

int main()
{
	Add(3, 5);
	Add(2.7, 3.5);
	return 0;
}

调用的虽然看起来都是同一个函数但其实不是，尽管重载仍然需要针对不同的类型定义函数，但我们可以用相同的函数名表示不同的函数（这在函数的效果相同只是针对不同类型时尤为明显）

参数个数不同

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

参数类型顺序不同

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 f()
{
	cout << "f()" << endl;
}
void f(int a=10)
{
	cout << "f(int a)" << endl;
}

int main()
{
	f();
	f();
	return 0;
}

编译器无法区分你究竟想调用那个函数

10. 引⽤

10.1 引⽤的概念和定义

引⽤不是新定义⼀个变量，⽽是给已存在变量取了⼀个别名，编译器不会为引⽤变量开辟内存空间，它和它引⽤的变量共⽤同⼀块内存空间。
类型& 引⽤别名 = 引⽤对象;
C++中为了避免引⼊太多的运算符，会复⽤C语⾔的⼀些符号，⽐如前⾯的<< 和 >>，这⾥引⽤也和取地址使⽤了同⼀个符号&，⼤家注意使⽤⽅法⻆度区分就可以。

#include<iostream>
using namespace std;
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;
}

在这里插入图片描述

可能大家看了觉得有点像指针，引用就是用来辅助指针。

10.2 引⽤的特性

• 引⽤在定义时必须初始化
• ⼀个变量可以有多个引⽤（如b，c，d）
• 引⽤⼀旦引⽤⼀个实体，再不能引⽤其他实体
在这里插入图片描述

10.3 引用的使用

• 引⽤在实践中主要是于引⽤传参和引⽤做返回值中减少拷⻉提⾼效率和改变引⽤对象时同时改变被引⽤对象。
• 引⽤传参跟指针传参功能是类似的，引⽤传参相对更⽅便⼀些。
• 引⽤返回值的场景相对⽐较复杂，我在这⾥简单讲了⼀下场景
• 引⽤和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引⽤跟其他语⾔的引⽤(如Java)是有很⼤的区别的，除了⽤法，最⼤的点，C++引⽤定义后不能改变指向，
Java的引⽤可以改变指向。
• ⼀些主要⽤C代码实现版本数据结构教材中，使⽤C++引⽤替代指针传参，⽬的是简化程序，避开复杂的指针。

传参

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

我们实现初阶的数据结构也可以用这样的方式

void ListPushBack(PNode& phead, int x)
{
	PNode newnode = (PNode)malloc(sizeof(LTNode));
	newnode->val = x;
	newnode->next = NULL;
	if (phead == NULL)
	{
		phead = newnode;
	}
	else
	{
		PNode pcur = phead;
		while (pcur->next)
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;
	}
}

并没有完全取代指针，而是辅助了这一过程

引用做返回值

int* arrBackPointer(int* arr)
{
	return &arr[0];
}
int& arrBack(int* arr)
{
	return arr[0];
}
int arrBackError(int* arr)
{
	return arr[0];
}
int main()
{
	int* arr = (int*)malloc(sizeof(int) * 5);
	arr[0] = 5;
	arrBack(arr)++;
	printf("%d",arr[0]);
	(*arrBackPointer(arr))++;
	printf("%d", arr[0]);
	arrBackError(arr)++;//error
	printf("%d", arr[0]);
	return 0;
}

指针和引用都可以++，而值返回不可修改（因为是常量），而且引用比指针更好实现

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

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

#include<iostream>
using namespace std;
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;
}

在这里插入图片描述

10.5 指针和引⽤的关系

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

野引用
返回了一个垃圾值在这里插入图片描述

从底层来看引用是用指针来实现的

	int a = 10;
00802440  mov         dword ptr [a],0Ah  
	int* p = &a;
00802447  lea         eax,[a]  
0080244A  mov         dword ptr [p],eax  
	int& b = a;
0080244D  lea         eax,[a]  
00802450  mov         dword ptr [b],eax

11. inline

• ⽤inline修饰的函数叫做内联函数，编译时C++编译器会在调⽤的地⽅展开内联函数，这样调⽤内联函数就需要建⽴栈帧了，就可以提⾼效率。
• inline对于编译器⽽⾔只是⼀个建议，也就是说，你加了inline编译器也可以选择在调⽤的地⽅不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适⽤于频繁调⽤的短⼩函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。
• C语⾔实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不⽅便调
试，C++设计了inline⽬的就是替代C的宏函数。
• vs编译器 debug版本下⾯默认是不展开inline的，这样⽅便调试，debug版本想展开需要设置⼀下
以下两个地⽅。
• inline不建议声明和定义分离到两个⽂件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现报错。

想在debug下看一下可以打开项目属性-常规-调试信息程序-程序数据库
项目-属性-优化-内联函数扩展-只适用于inline

可以通过汇编观察程序是否展开
有call Add语句就是没有展开，没有就是展开了

int ret = Add(1, 2);
00441F06  mov         eax,1  
00441F0B  add         eax,2  
00441F0E  mov         dword ptr [ebp-14h],eax  
00441F11  mov         ecx,dword ptr [ebp-14h]  
00441F14  add         ecx,1  
00441F17  mov         dword ptr [ebp-14h],ecx  
00441F1A  mov         edx,dword ptr [ebp-14h]  
00441F1D  add         edx,1  
00441F20  mov         dword ptr [ebp-14h],edx  
00441F23  mov         eax,dword ptr [ebp-14h]  
00441F26  add         eax,1  
00441F29  mov         dword ptr [ebp-14h],eax  
00441F2C  mov         ecx,dword ptr [ebp-14h]  
00441F2F  mov         dword ptr [ebp-8],ecx  
00441F32  mov         edx,dword ptr [ebp-8]  
00441F35  mov         dword ptr [ret],edx

这里就直接展开了，当然即使我们改了设置。展开与否还是由编译器自身决定的。

12. nullptr

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

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

• C++中NULL可能被定义为字⾯常量0，或者C中被定义为⽆类型指针(void*)的常量。不论采取何种定义，在使⽤空值的指针时，都不可避免的会遇到⼀些⿇烦，本想通过f(NULL)调⽤指针版本的
f(int*)函数，但是由于NULL被定义成0，调⽤了f(int x)，因此与程序的初衷相悖。f((void*)NULL);
调⽤会报错。
• C++11中引⼊nullptr，nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字⾯量，它可以转换
成任意其他类型的指针类型。使⽤nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被
隐式地转换为指针类型，⽽不能被转换为整数类型。

C++不允许void*强转成其他类型，即使延续C语言对NULL的定义==#define NULL ((void *)0)==，传参时NULL也不会进行隐式转换但是可以进行强制类型转换不然malloc这类函数就用不了了（属于是不孝了），但是引进了nullptr效果又和C语言中的NULL一个效果能进行转换。

void f(int x)
{
	cout << "f(int x)" << endl;
	return;
}
void f(int*x)
{
	cout << "f(int*x)" << endl;
	return;
}
int main()
{
	f(0);
	f(NULL);
	f(nullptr);
	return 0;
}

在这里插入图片描述

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
Hadoop集群开机自启动脚本
Java数组篇[1]：数组的定义和声明
Qt Model/View理解（三）---桥梁Delegate
【C语言】实践：贪吃蛇小游戏（附源码）
Elasticsearch基础操作入门
设置实体类型中String类型的属性值为String.Empty
Vue3.0环境搭建之npm的安装
【ACM珠海分会，IEEE Fellow加盟，CPS出版】第四届管理科学和软件工程国际学术会议(ICMSSE 2024，7月19-21)
Go语言——测试与性能
IDEA的安装和使用
;