深入浅出C++ ——初识C++

---

一、C++简介

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

---

1. C++的诞生

   1979年，贝尔实验室的本贾尼等人试图分析unix内核的时候，试图将内核模块化，于是在C语言的基础上进行扩展，增加了类的机制，完成了一个可以运行的预处理程序并称之为C with classes。

   1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言，为了表达该语言与C语言的渊源关系，命名为C++。 因此，C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。 随着时间的推移，语言也在不断的发展，一段时间内C++标准委员会就会版本新的C++标准，目前公司主流使用C++98和C++11。

---

2. C++的重要性

语言的使用广泛度

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

---

工作领域

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

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

---

二、关键字

   关键字又称为保留字，是一门语言中预定义，具有特殊含义的单词。C语言有32个关键字，C++98总计63个关键字，C++11总计73个关键字。

---

三、命名空间

1. 命名空间的作用

#include
#include

int rand = 0;
int main()
{
	printf("%d", rand);
	return 0;
}

   在C语言中，会出现变量名重定义的情况，如上段代码所示，在stdlib.h库中，rand是函数名，同时又定义了一个全局变量rand，导致命名冲突。而C++使用namespace命名空间可以对标识符的名称进行本地化，以避免命名冲突。

---

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++的输入输出

C++打印helloworld

#include
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++的输入输出可以自动识别变量类型。

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

---

五、缺省参数

1. 缺省参数的概念

  缺省参数是声明或定义函数时，为函数的参数指定一个缺省值。an缺省参数本质上就是一个"备胎"。

---

案例

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

---

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)在语法上是不被允许的。另外，使用半缺省参数的函数调用时，不能传空参数，全缺省则可以传空参数。

---

3. 缺省参数的使用

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

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

   缺省参数的作用就是使函数调用的更加灵活。还要注意的是，缺省参数不能在函数声明和定义中同时出现，一般在函数声明时给缺省参数。另外，缺省值必须是常量或者全局变量。

---

六、函数重载

1. 函数重载概念

   在汉语中经常会出现一词多义的现象，比如“包袱”这个词可以指用布包起来的包，也可以指某种负担，人们可以通过上下文来判断该词的意思。在C++中也有类似的用法，就是函数重载。

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

---

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

---

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)
{//}

---

4. C++为什么能支持函数重载

C/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++中还是可以区分同名函数的重载的。

---

5. extern关键字

   因为C/C++编译器对函数名字修饰规则的不同，所以C++中调用C语言实现的静态库或者动态库就会出现问题，从而导致链接失败，也就是说在符号表中找不到对应函数的名字。这种场景下就要使用extern "C"。在#include前加extern "C"，extern{#inlucde"路径名"}告诉编译器，将该头文件中的函数按照C语言规则来编译，而C语言的程序调用C++不需要。

---

七、引用

1. 引用的概念

   引用不是新定义一个变量，而是给已存在变量取了一个别名。编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。语法结构为类型& 引用变量名(对象名) = 引用实体；

---

案例

   由上述图片可知，使用引用时，a和b共用一块内存空间，a的改变会影响b，b的改变也会影响a，可以说a和b是完全相同的。

---

2. 引用的特点

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

---

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引用传参，这样就不需要考虑权限变大变小的问题。

---

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

---

5. 引用的陷阱

   出了函数作用域，返回对象就销毁了，一定不能用引用返回，这时一定要用传值返回。传值返回会调用拷贝构造生成临时对象，这个临时对象保存在寄存器中用于返回。

---

案例

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

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

---

6. 传值、传引用效率比较

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

7. 引用和指针的对比

相同点

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

---

不同点

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

---

八、内联函数

1. 内联函数的概念

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

---

2. 内联函数替代宏函数

   宏函数形如#define ADD(a,b) ((a)+(b)) 。宏有复用性强和宏函数提高代码效率，减少栈帧建立的优点，但是宏同样存在着复杂，可读性差 传参没有类型安全检查、不方便调试的缺点，所以C++使用内联函数来替代宏。

---

3. 汇编视角下的内联函数

普通函数

---

内敛函数

---

  通过对比可以看出，内敛函数没有call Add函数

---

4. 内联函数的特点

  内联函数是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用。内联函数的优势减少了调用开销，提高程序运行效率，同时也存在这可能会使目标文件变大的缺点。
  inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议将函数规模较小、不是递归、频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

   另外inline 不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

---

九、C++11的auto关键字

   在C++11中引入auto关键字，auto会自动推导类型 形如int a=10; auto b=a; auto会自动推导b为int类型。

---

注意事项

   使用auto定义变量时必须对其进行初始化。当在同一行声明多个变量时，这些变量必须是相同的类型。 auto a = 1, b = 2; 另外，auto不能作为函数的参数 void TestAuto(auto a)//错误 并且auto不能直接用来声明数组auto b[] = {4，5，6};//错误

---

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

   C++11中引入了基于范围的for循环也称为范围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循环迭代的范围必须是确定的，对于数组而言，就是数组中第一个元素和最后一个元素的范围。

---

十一、C++11的指针空值nullptr

  有些编译器会将 NULL 定义为((void*)0)，有些则会直接将其定义为 0，#define NULL 0，这取决于编译器如何定义 NULL。所以C语言中使用时空指针时会遇到一些麻烦。所以C++11使用nullptr关键字代替NULL。

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