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

已于 2024-08-10 10:03:23 修改
阅读量768 收藏 26
点赞数 18
文章标签： c++ 开发语言
于 2024-08-09 16:11:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yusei_0523/article/details/141056454
版权

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

在这里插入图片描述

Yusei_0523
关注
  • 18
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
C++基础知识总结入门级
05-15
"C++基础知识总结入门级"这个主题涵盖了初学者需要掌握的关键概念，让我们一一展开讨论。 首先，C++的IO系统是程序与用户交互的基础。`C++的IO.txt`可能包含关于iostream库的内容，如cin和cout用于标准输入输出，...
C语言基础知识入门大全
热门推荐
weixin_55305220的博客
05-11 59万+
C语言一经出现就以其功能丰富、表达能力强、灵活方便、应用面广等特点迅速在全世界普及和推广。C语言不但执行效率高而且可移植性好，可以用来开发应用软件、驱动、操作系统等。C语言也是其它众多高级语言的鼻祖语言，所以说学习C语言是进入编程世界的必修课！简单来说，一个C程序就是由若干和组成。就是一条预处理命令, 它的作用是通知C语言编译系统在对C程序进行正式编译之前需做一些预处理工作。就是实现代码逻辑的一个小的单元。一个C程序有且只有一个主函数，即main函数。注释是写给程序员看的，不是写给电脑看的。C语言注释方法有
C++入门基础(万字总结）（建议收藏！！！）
IamGreeHand的博客
09-22 25万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++——基础知识入门
ljinshuo的博客
10-31 8775
1.初识C++ 1.1第一个C++程序 创建新项目，选择创建C++的空项目： 选择项目名称与位置： 在源文件中添加C++文件： # include <iostream> using namespace std; int main() { cout << "hello world" << endl; system("pause"); return 0; } 1.2注释 # include <iostream> using namespac
C++入门基础知识总结（2022整理）
weixin_55305220的博客
03-23 2万+
一、C++入门基础知识之什么是C++? 1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。 PDF版、C++资料教程、C++电子书籍获取 关注微信公众号：“ C和C加加 ” 回复关键字：“ C++ ”即可领取 二、C++入门基础..
C++入门基础（万字详解！！！）
忘忧.
08-15 4万+
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
C++基础知识快速入门
weixin_46416904的博客
04-23 8747
C++基础知识，快速入门 C++简介 C++是一种静态类型、编译式的、大小写敏感的、支持过程化编程、面向对象编程和泛型编程。 C++被认为是一种中级语言，它综合了高级语言和低级语言的特点。 C++完全支持面向对象程序化设计，包括面向对象开发的四大特征：封装、抽象、继承、多态 对象 - 对象具有状态和行为。例如：一只狗的状态-颜色、名称、品种，行为-摇动、叫唤、吃。对象是类的实例。 类 - 类可以定...
C++基础入门
a577715979的博客
01-02 5494
C++入门
C++基础入门（一）
Augenstern_QXL的博客
05-25 7万+
C++基础入门 0.写在前面 本篇笔记视频讲解地址：https://www.bilibili.com/video/BV1et411b73Z?p=1 笔记配合视频效果更好 外链图片上传失败已经解决 与各位共勉 用来复习回顾使用 1 C++初识 1.1 第一个C++程序 编写一个C++程序总共分为4个步骤 创建项目 创建文件 编写代码 运行程序 1.1.1 创建项目 ​ Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开 1.1.2 创建文件 右键源文件，选择添加-&gt
C++基础入门1
怀秋秋意的博客
03-17 2286
详解c++基础入门知识，第一篇
C++基础入门.pdf
04-10
C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。 1. 创建项目...
C++入门基础知识详解
05-16
1第1章C 基础知识C 基础知识2本章要点11程序设计语言的基本概念(自学)12C 程序的基本结构13一个应用程序的开发过程14C 的词法规则15C 基本数据类型16常量与变量17运算符与表
c++基础STL入门ppt课件.ppt
11-13
这份PPT课件主要讲解C++基础知识，特别是STL（Standard Template Library）的概念和组成。下面是从这份课件中提炼出的重要知识点： 1. 抽象的重要性：抽象是计算机科学的重要进步，许多都是由于发掘了新的抽象性质...
C++入门基础知识总结
08-16
C++入门基础知识总结 C++是基于 C 语言而产生的，它既可以进行 C 语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。C++的历史版本可以追溯到1982年，...
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 190
c++ error: ‘*’ does not name a type； did you mean ‘**’?
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 325
STL中的迭代器失效（vector为例）
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 196
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C++ - 函数重载
jiaowenjie的专栏
08-06 310
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值