🧑‍💻第一章 初识C++🧑‍💻

前言

从本章开始，博主将持续更新C++学习经验分享，希望对看到这篇文章的你有所帮助。

C++是在C的基础之上，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式等。补充了C语言语法的不足以及对C语言设计不合理的地方进行优化

---

一、C++简介

1.1 什么是C++？

• 1979年，贝尔实验室的本贾尼等人试图分析unix内核的时候，试图将内核模块化，于是在C语言的基础上进行扩展，增加了类的机制，完成了一个可以运行的预处理程序并称之为C with classes。
• 1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言，为了表达该语言与C语言的渊源关系，命名为C++。
• 因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
  -语言的发展就像是练功打怪升级一样，也是逐步递进，由浅入深的过程。目前公司主流使用还是C++98和C++11。

1.2 C++有多重要呢？

1、语言的使用广泛度：

在TIOBE网站2022年7月编程语言流行趋势排行榜 TOP榜单可以看出，C/C++几乎一致稳居前5，不仅这个月如此，这三十年一直都在前五名之列。

2、在工作领域

1. 操作系统以及大型系统软件开发
2. 服务器端开发
3. 游戏开发
4. 嵌入式和物联网领域
5. 数字图像处理
6. 人工智能
7. 分布式应用

除了上述领域外，在：科学计算、浏览器、流媒体开发、网络软件等都是C++比较适合的场景。

二、关键字

C语言32个关键字，C++98总计63个关键字，C++11总计73个关键字

三、命名空间

3.1 为什么要有命名空间

在我们写C语言程序的时候，有时候会碰到这样的情况👇

这种情况出现的原因是 rand 既是函数又是变量名，C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决。

💡综上：使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突。

3.2 命名空间定义

• 定义命名空间，需要使用到 namespace 关键字，后面跟命名空间的名字，然后接一对 { }即可，{ }中即为命名空间的成员。
• 一个命名空间定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

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

namespace Jared
{
	int rand = 0; 					//命名空间中可以定义变量
	int Add(int left, int right)	//命名空间中可以定义函数		
	{
		return left + right;
	}
	struct Node						//命名空间中可以定义类型/结构体
	{
		struct Node* next;
		int val;
	};
}
int main()
{
	printf("%p\n", rand);			 //rand默认是去全局去找，找到是函数指针
	printf("%d\n", Jared::rand);	 //指定去Jared域去找，找到是变量rand
	cout << Jared::Add(1, 2) << endl;//调用Jared域中的Add函数，打印3
	return 0;
}

（2）命名空间可以嵌套

namespace A
{
	int a=0;
	namespace B
	{
		int c=1;
	}
}
int main()
{
	cout << A::B::c << endl; //打印1
}

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

解释说明： 一个工程中的 Test.h 和 Test.cpp 和 main.cpp 中三个A命名空间会被合并成一个命名空间，这样会方便团队协作。

2. 命名空间使用

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

int main()
{
	printf("%d\n", Jared::rand);
	return 0;
}

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

using Jared::rand;
int main()
{
	printf("%d\n", rand);
	return 0;
}

（3）使用using namespace 命名空间名称 引入

using namespce Jared;
int main()
{
	printf("%d\n", rand); //先去全局域去找，如果没有找到就去展开的Jared域去找
	Add(10, 20);
	return 0;
}

💡补充说明：

• 第三种方法看起来简单，但是标准库就全部暴露出来了，如果我们定义跟库重名的类型/对象/函数，就存在冲突问题。所以规范的工程项目中是不推荐这种方式的，日常练习可以使用。
• 建议在项目开发中使用，使用第一种和第二种方式。

四、输入和输出

使用C++打印 Hello world

#include<iostream>
// std是 C++ 标准库的命名空间名
// C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
	cout<<"Hello world!!!"<<endl;
	return 0;
}

补充说明：

• cout 是 ostream 类型的全局对象/变量， cin 是 istream 类型的全局对象。
• 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件。
• endl 是特殊的 C++符号，表示换行输出,相当于"\n" 也包含在包含< iostream >头文件中。
• std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中。
• <<是流插入运算符，>>是流提取运算符。这里主要涉及运算符重载等知识。
• 使用C++输入输出更方便，不需要像 printf/scanf 输入输出时手动控制格式。C++的输入输出可以自动识别变量类型。

int i=11; double d=11.11;
cout<<i<<d<<endl; //自动识别类型（原理：函数重占+运算符重载）

• 旧编译器(vc 6.0)中还支持 <iostream.h> 格式，后续编译器已不支持，因此推荐使用 <iostream.h> +std 的方式。

五、缺省参数

5.1 缺省参数的概念

缺省参数是声明或定义函数时，为函数的参数指定一个缺省值。

缺省参数本质上就是一个"备胎"。

void Func(int a = 10)
{
	cout << a << endl;
}
int main()
{
	Func();  // 没有传参时，使用参数的默认值，输出10
	Func(5); // 传参时，使用指定的实参，输出5
	return 0;
}

💡注意事项：

• 缺省参数不能在函数声明和定义中同时出现，一般在函数声明时给缺省参数。
• 缺省值必须是常量或者全局变量

5.2 缺省参数的分类

（1）全缺省参数

void Func(int a = 1, int b = 2, int c = 3)
{///}

💡注意事项：

• 传参时，只能从左向右开始，调用 Func(10，20）只能是传给a和b。错误示范：Func（，1，）这个在语法上是不被允许的。

（2）半缺省参数

void Func(int a, int b = 10, int c = 20)
{///}

💡注意事项：

• 半缺省参数必须从右往左连续缺省，不能间隔。错误示范： Func(int a=10, int b =, int c = 20)
• 半缺省参数的函数调用时，不能传空参数，全缺省则可以传空参数。

缺省参数作用示例：

struct Stack
{
	int* a;
	int size;
	int capacity;
};
void StackInit(struct Stack* ps, int InitCapacity = 4)
{
	ps->a = (int*)malloc(sizeof(int) * InitCapacity);
	ps->size = 0;
	ps->capacity = capacity;
}
int main()
{
	Stack st1;
	StackInit(&st1, 100);
	Stack st2;
	StackInit(&st2);
	return 0;
}

• 当我们用C语言写栈时，在StackInit中给初始化容量一个缺省值4。
• 假设我知道栈里至少要存100个数据,我们直接传100即可StackInit(&st1, 100)。
• 但像st2这种情况，我们不知道栈里可以存多少个数据，默认会开辟4个整数大小的空间，其他人使用的时候也会更加方便StackInit(&st2)。

⭐综上：缺省参数的作用就是使我们函数调用的更加灵活。

六、函数重载

6.1 函数重载概念

在汉语中经常会出现一词多义的现象，比如包袱：可以指用布包起来的包。也可以指某种负担，人们可以通过上下文来判断该词的意思。

在C++中也有类似的用法，就是函数重载。

定义：

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

6.2 函数重载分类

1. 参数类型不同

int Add(int left, int right)
{	
	return left + right;
}
double Add(double left, double right)
{
	return left + right;
}

2. 参数个数不同

void A()
{
	cout << "A()" << endl;
}
void A(int a)
{
	cout << "A(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);
	A();
	A(10);
	f(10, 'a');
	f('a', 10);
	return 0;
}

6.3 函数重载使用常见错误

1. 👇不构成函数重载，因为返回值不同时，编译器无法区分到底调用哪个函数。

short Add(int left, int right)
{
	return left + right;
}

int Add(int left, int  right)
{
	return left + right;
}

2. 👇也不构成重载，虽然两个函数的参数是缺省值和非缺省值，但是依旧不影响修饰出来的函数名，所以不能构成函数重载。

void Func(int a = 10)
{//}
void Func(int a)
{//}

6.4 为什么C++支持函数重载？

假设一个工程里面包含 fun.h、fun.c、main.c 三个文件，C/C++程序运行起来要经历的四个阶段：

1. 预处理：头文件展开、宏替换、条件编译、去掉注释，生成 fun.i 和main.i文件（fun.h文件在另外两个文件里面被展开）
2. 编译： 语法检查（语法分析、语义分析、词法分析）、符号汇总、生成汇编代码，生成fun.s 和main.s文件。
3. 汇编： 把汇编代码转换为二进制机器码，形成符号表，生成fun.o 和main.o文件。符号表里存放定义函数的地址信息
4. 链接： 合并目标文件、段表，符号表的合并和符号表的重定位，.o格式的目标文件合并到一起，生成a.out/a.exe文件。

💡解释说明：

• 在链接时，链接器看到 a.o 调用fun函数，但是没有fun函数的地址，就会到fun.o的符号表中找fun函数的地址，然后链接到一起。
• 每个编译器都有自己的函数名修饰规则，当fun函数是重载函数时，gcc的函数修饰后名字不变，而g++的函数修饰后变成_Z+函数长度+函数名+类型首字母。
• C语言没办法支持重载，因为同名函数没办法区分。
• g++函数名修饰规则，能够根据类型修饰在符号表中函数名字的特点。即使函数名相同只要参数不同，在g++中还是可以区分同名函数的重载的。

6.5 extern关键字

👆说到C、 C++编译器对函数名字修饰规则的不同。所以C++中调用C语言实现的静态库或者动态库就会出现问题，导致链接失败，在符号表中找不到对应函数的名字。

这种场景下就要使用extern "C"。在#include前加extern "C"，告诉编译器，将该头文件中的函数按照C语言规则来编译。

七、引用

7.1 引用概念

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

用法：类型& 引用变量名(对象名) = 引用实体；

👆可知，a和b共用一块内存空间。同时a的改变会影响b，b的改变也会影响a，可以说a和b是完全相同的。

7.2 引用特点

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

7.3 引用常量

const int a = 10;
//int& ra = a;		// 错，a为常量，常量只能可读，引用后就变成了可读可写。ra引用a属于权限放大，所以不行，权限不能放大，但是可以缩小
const int& ra = a;	//正确，改为可读不可写

int e = 30;
const int& f = e;	//正确，权限缩小


// int& b = 10;		// 该语句编译时会出错，10为常量
const int& b = 10;	//正确，改为可读不可写


double d = 12.34;
//int& rd = d;		// 错误，d时double类型，转换为int类型会发生隐式转换，不会改变b，但会生成临时变量，临时变量具有常性
const int& rd = d;	//正确，改为可读不可写

如果使用引用传参，函数内不改变n，尽量使用const引用传参，这样就不需要考虑权限变大变小的问题。

7.4 使用场景

• 做参数
  输出型参数、大对象传参提高效率

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 0, b = 2;
	Swap(a, b);
	cout << a << b << endl; // 2  0
	return 0;
}

• 做返回值
  输出型返回对象(调用者可以修改返回对象)、减少拷贝，提高效率

int& f()
{
	static int n = 0;
	n++;
	// ...
	return n;
}

🚨常见错误：
main 开辟栈帧调用 Add函数，Add函数开辟新的栈帧。但是出了Add函数，系统会清理栈帧将c置成随机值，所以这种程序使用引用返回本质上是不对的，结果没有保障的（虽然编译器不一定能检查出来）。

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

⭐综上：

• 出了函数作用域，返回对象就销毁了，一定不能用引用返回，一定要用传值返回int Add(int a, int b)。
• 传值返回会调用拷贝构造生成临时对象，这个临时对象保存在寄存器中用于返回，c再被析构。

7.5 传值、传引用效率比较

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

7.6 引用和指针的对比

相同点：

1. 在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间，但是引用在底层实现上实际是有空间的。
2. 从汇编实现的角度，引用底层跟指针的汇编代码是一样的。
3. 其实引用只是对指针进行了简单的封装，它的底层依然是通过指针实现的⭐。
4. 引用占用的内存和指针占用的内存长度一样，在 32 位环境下是 4 个字节，在 64 位环境下是 8 个字节。之所以不能获取引用的地址，是因为编译器进行了内部转换。

不同点：

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求。
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
4. 没有NULL引用，但有NULL指针。
5. 在sizeof 中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数。(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
7. 有多级指针，但是没有多级引用。
8. 访问实体方式不同，指针需要显式解引用，引用是由编译器自己处理。
9. 引用比指针使用起来相对更安全，指针更强大，更危险，更复杂。

八、内联函数

概念：

1. 以inline修饰的函数叫做内联函数。
2. 编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
3. 内联函数本质上是对宏函数的优化。C++中基本上不再使用宏，尽量使用const、enum、inline去替代宏。

宏
宏函数: #define ADD(a,b) ((a)+(b))
宏的优点：1、复用性变强 2、宏函数提高代码效率，减少栈帧建立
宏的缺点：1、复杂，可读性差 2、传参没有类型安全检查 3、不方便调试

普通函数：

内敛函数：
👇可以看出，内敛函数没有call Add函数

💡补充说明：

• inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
• inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小、不是递归、频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
• inline 不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

九、auto关键字(C++11)

auto会自动推导类型

	int a=10;
	auto b=a;

💡补充说明：

• 使用auto定义变量时必须对其进行初始化
• 当在同一行声明多个变量时，这些变量必须是相同的类型。 auto a = 1, b = 2;

💡 auto不能推导的场景：

1. auto不能作为函数的参数 void TestAuto(auto a)//错误
2. auto不能直接用来声明数组auto b[] = {4，5，6};

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

C++11中引入了基于范围的for循环/范围for。

格式：
for循环后的括号由冒号“ ：”分为两部分：
：前面是范围内用于迭代的变量
：后面则表示被迭代的范围。

举例：范围for，自动依次取array的数据，赋值给e ，自动迭代，自动判断结束

int array[] = { 1, 2, 3, 4, 5 };
for(auto& e : array)
	e *= 2;
for(auto e : array)
	cout << e << " "

💡补充说明：

• 与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
• for循环迭代的范围必须是确定的，对于数组而言，就是数组中第一个元素和最后一个元素的范围。

🚨常见错误：

void TestFor(int array[])
{
	for(auto& e : array)//错误
	cout<< e <<endl;
}

十一、 指针空值nullptr(C++11)

NULL本质是一个宏 #define NULL 0

有些编译器会将 NULL 定 义为((void*)0)，有些则会直接将其定义为 0，这取决于编译器如何定义 NULL。

使用时空指针时会遇到一些麻烦。所以C++11使用nullptr关键字代替NULL。

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。