C++应用笔记

一、简介 1、C++简介

C++融合了 3 种不同的编程传统：C语言代表的过程性传统、C++在C语言基础上添加的类代表的面向对象语言的传统以及C++模板支持的通用编程传统。

一般来说，计算机语言要处理两个概念，即数据和算法。

数据是程序使用和处理的信息，算法是程序使用的方法。

C语言是一种过程性语言，更强调算法，它具有结构化编程的特性，其试图使问题满足语言的过程性方法。

为了更好地解决大型程序设计问题，其采用了自顶向下的设计原则，将大型程序分解为小型的、易于编写的程序单元（称为函数）来表示各个任务模块，尽管如此，在编写大型程序时仍面临很大的挑战。

在C++中，类是一种规范，它描述了这种新型数据格式，对象是根据这种规范构造的特定数据结构。

为了应付C语言所面临的挑战，OOP(Object-Oriented Programming)提供了一种试图让语言来满足问题要求的一种新方法，其理念是设计与问题的本质特性相对应的数据格式。

OOP程序设计方法首先设计类，它准确地描述了程序要处理的信息，这种技术涉及到许多新概念，如对象、类、封装、继承、多态等。

C++通用编程(generic programming)是C++支持的另一种编程模式，与OOP的目标相同，即：创建独立于类型的代码(通用)，使重用代码和抽象通用概念的技术更简单。

C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。

C++ 被认为是一种中级语言，它综合了高级语言和低级语言的特点。

C++ 是由 Bjarne Stroustrup 于 1979 年在新泽西州美利山贝尔实验室开始设计开发的。

C++ 进一步扩充和完善了 C 语言，最初命名为带类的C，后来在 1983 年更名为 C++。

C++ 是 C 的一个超集，事实上，任何合法的 C 程序都是合法的 C++ 程序。

**注意：**使用静态类型的编程语言是在编译时执行类型检查，而不是在运行时执行类型检查。

二、开发环境

在 Linux 下进行测试，具体使用工具如下：

编辑	VSCode
编译	g++
调试	GDB
编译控制	makefile

三、 C++基础 1、标识符

C++ 标识符是用来标识变量、函数、类、模块，或任何其他用户自定义项目的名称。

一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。

2、关键字

关键字：

替代关键字：

注：以上图片在 C++11 标准中摘取。

3、数据类型 1、整型

类型	含义	最小尺寸
char	字符类型	8bit
wchar_t	宽字符	16bit
char16_t	Unicode字符	16bit
char32_t	Unicode字符	32bit
short	短整型	16bit
int	整型	16bit
long	长整型	32bit
long long	长长整型	64bit
unsigned	无符号	-
signed	有符号	-

2、浮点型

类型	含义	最小尺寸
float	单精度浮点型	6位有效数字
double	双精度浮点型	10位有效数字

3、布尔型

类型	含义	最小尺寸
bool	布尔类型	未定义，只有true和false两个值

4、空类型

类型	含义	最小尺寸
void	空类型	-

5、指针类型 4、变量

变量其实只不过是程序可 *** 作的存储区的名称。

C++ 中每个变量都有指定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。

变量的名称可以由字母、数字和下划线字符组成。

它必须以字母或下划线开头。

大写字母和小写字母是不同的，因为 C++ 是大小写敏感的。

5、常量

常量是固定值，在程序执行期间不会改变。

这些固定的值，又叫做字面量。

常量可以是任何的基本数据类型，可分为整型数字、浮点数字、字符、字符串和布尔值。

常量就像是常规的变量，只不过常量的值在定义后不能进行修改。

6、运算符

7、结构 1、顺序

自上而下，依次执行。

2、循环

多次执行同一块代码。

循环结构相关关键字：

类型	含义
while	当给定条件为真时，重复语句或语句组。 它会在执行循环主体之前测试条件。
for	多次执行一个语句序列，简化管理循环变量的代码。
do	常和 while 配合，形式为 do {语句;}while(……)；
break	跳出当前循环。
continue	跳出本次循环。

3、选择

根据给定的条件是否成立来决定程序的执行流程。

类型	含义
if	if 后跟一个表达式，如果为真，则执行。
else	和 if 配合，如果if 后表达式为假，则执行。
switch	switch 和 case 配合，根据 switch 的值选择执行的 case。
case	switch 和 case 配合，根据 switch 的值选择执行的 case。
goto	将控制转移到被标记的语句。

8、函数

函数是一组一起执行一个任务的语句。

函数声明告诉编译器函数的名称、返回类型和参数。

函数定义提供了函数的实际主体。

1、函数定义

在 C++ 中，函数由一个函数头和一个函数主体组成。

下面列出一个函数的所有组成部分：

• 返回类型：一个函数可以返回一个值。
  

  
  

• 函数名称：这是函数的实际名称。
  

  
  

• 参数：参数就像是占位符。
  

  
  

  当函数被调用时，您向参数传递一个值，这个值被称为实际参数。
  

  
  

  参数列表包括函数参数的类型、顺序、数量。
  

  
  

  参数是可选的，也就是说，函数可能不包含参数。
  

  
  

• 函数主体：函数主体包含一组定义函数执行任务的语句。
  

  
  

2、函数声明

函数声明会告诉编译器函数名称及如何调用函数。

函数的实际主体可以单独定义。

3、函数调用

当程序调用函数时，程序控制权会转移给被调用的函数。

被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给调用程序。

4、函数参数

如果函数要使用参数，则必须声明接受参数值的变量。

这些变量称为函数的形式参数。

形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。

当调用函数时，有两种向函数传递参数的方式：

调用类型	描述
传值调用	该方法把参数的实际值复制给函数的形式参数。 在这种情况下，修改函数内的形式参数对实际参数没有影响。
指针调用	该方法把参数的地址复制给形式参数。 在函数内，该地址用于访问调用中要用到的实际参数。 这意味着，修改形式参数会影响实际参数。
引用调用	该方法把参数的引用复制给形式参数。 在函数内，该引用用于访问调用中要用到的实际参数。 这意味着，修改形式参数会影响实际参数。

5、参数默认值

当您定义一个函数，您可以为参数列表中后边的每一个参数指定默认值。

当调用函数时，如果实际参数的值留空，则使用这个默认值。

6、参数占位符

占位参数只有参数类型声明，而没有参数名声明。

一般情况下，在函数体内部⽆无法使⽤用占位参数。

占位符参数一般用于程序扩展和对C代码的兼容。

9、数组

数组是用来存储相同类型的变量的顺序集合。

所有的数组都是由连续的内存位置组成。

10、字符串

C++ 提供了以下两种类型的字符串表示形式：

• C 风格字符串
• C++ 引入的 string 类类型

1、C 风格字符串

C 风格的字符串起源于 C 语言，并在 C++ 中继续得到支持。

字符串实际上是使用 null 字符终止的一维字符数组。

因此，一个以 null 结尾的字符串，包含了组成字符串的字符。

2、C++ 中的 String 类

C++ 标准库提供了 string 类用于处理字符串。

11、指针 1、指针基本概念

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。

就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。

所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。

不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

2、指针使用

使用指针时会频繁进行以下几个 *** 作：

• 定义一个指针变量
• 把变量地址赋值给指针
• 访问指针变量中可用地址的值。
  

  
  

3、指针详解

在 C++ 中，有很多指针相关的概念，这些概念都很简单，但是都很重要。

下面列出了 C++ 程序员必须清楚的一些与指针相关的重要概念：

概念	描述
C++ null指针	C++ 支持空指针。 一般赋值为 nullptr。
C++指针的算术运算	可以对指针进行四种算术运算：++、–、+、-。
C++指针 vs 数组	指针和数组之间有着密切的关系。
C++指针数组	可以定义用来存储指针的数组。
C++指向指针的指针	C++ 允许指向指针的指针。
C++传递指针给函数	通过引用或地址传递参数，使传递的参数在调用函数中被改变。
C++从函数返回指针	C++ 允许函数返回指针到局部变量、静态变量和动态内存分配。

12、引用 1、引用概念

引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。

一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

2、引用 vs 指针

引用很容易与指针混淆，它们之间有三个主要的不同：

• 不存在空引用。
  

  
  

  引用必须连接到一块合法的内存。
  

  
  

• 一旦引用被初始化为一个对象，就不能被指向到另一个对象。
  

  
  

  指针可以在任何时候指向到另一个对象。
  

  
  

• 引用必须在创建时被初始化。
  

  
  

  指针可以在任何时间被初始化。
  

  
  

3、引用使用

引用通常用于函数参数列表和函数返回值，详细内容见下：

概念	描述
引用作为函数参数	C++ 支持把引用作为参数传给函数，这比传一般的参数更安全。
引用作为函数返回值	可以从 C++ 函数中返回引用，就像返回其他数据类型一样。

13、日期和时间

C++ 标准库没有提供所谓的日期类型。

C++ 继承了 C 语言用于日期和时间 *** 作的结构和函数。

为了使用日期和时间相关的函数和结构，需要在 C++ 程序中引用 头文件。

14、结构

结构体是一个自定义的数据类型，可以容纳许多不同的数据。

声明结构体的方式和声明类的方式大致相同，其区别如下：

• 使用关键字 struct 而不是关键字 class。
  

  
  

• 尽管结构体可以包含成员函数，但它们很少这样做。
  

  
  

  所以，通常情况下结构体声明只会声明成员变量。
  

  
  

• 结构体声明通常不包括 public 或 private 的访问修饰符。
  

  
  

• 类成员默认情况是 private ，而结构体的成员则默认是 public。
  

  
  

  程序员通常希望它们保持公开，只需使用默认值即可。
  

  
  

四、C++面向对象 1、类和对象 1、基本概念

C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。

类是 C++ 的核心特性，通常被称为用户定义的类型。

类用于指定对象的形式，它包含了数据和用于处理数据的方法。

类中的数据和方法称为类的成员。

函数在一个类被称为类的成员。

2、类定义

定义一个类，本质上是定义一个数据类型的蓝图。

这实际上并没有定义任何数据，但它定义了类的名称意味着什么，也就是说，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些 *** 作。

类定义是以关键字 class 开头，后跟类的名称。

类的主体是包含在一对花括号中。

类定义后必须跟着一个分号或一个声明列表。

3、访问控制权限

访问属性	属性	对象内部	对象外部
public	公有	可访问	可访问
protected	保护	可访问	不可访问
private	私有	可访问	不可访问

4、成员变量

类的成员变量和普通变量一样，也有数据类型和名称，占用固定长度的内存。

但是，在定义类的时候不能对成员变量赋值，因为类只是一种数据类型或者说是一种模板，本身不占用内存空间，而变量的值则需要内存来存储。

5、成员函数

类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。

类成员函数是类的一个成员，它可以 *** 作类的任意对象，可以访问对象中的所有成员。

6、构造函数

类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。

构造函数可用于为某些成员变量设置初始值。

7、析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。

析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

8、拷贝构造

拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。

拷贝构造函数通常用于：

• 通过使用另一个同类型的对象来初始化新创建的对象。
  

  
  

• 复制对象把它作为参数传递给函数。
  

  
  

• 复制对象，并从函数返回这个对象。
  

  
  

如果在类中没有定义拷贝构造函数，编译器会自行定义一个。

9、友元

类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。

尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。

10、内联函数

如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。

11、this 指针

在 C++ 中，每一个对象都能通过 this 指针来访问自己的地址。

this 指针是所有成员函数的隐含参数。

因此，在成员函数内部，它可以用来指向调用对象。

友元函数没有 this 指针，因为友元不是类的成员。

只有成员函数才有 this 指针。

12、静态成员

我们可以使用 static 关键字来把类成员定义为静态的。

当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。

静态成员在类的所有对象中是共享的。

如果不存在其他的初始化语句，在创建第一个对象时，所有的静态数据都会被初始化为零。

我们不能把静态成员放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化。

2、继承 1、概述

面向对象程序设计中最重要的一个概念是继承。

继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。

这样做，也达到了重用代码功能和提高执行时间的效果。

当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。

这个已有的类称为基类，新建的类称为派生类。

继承代表了 is a 关系。

2、语法

class derived-class: access-specifier base-class

• access-specifier（访问修饰符）：public、protected 和 private。
  

  
  

  如果未使用，则默认 private。
  

  
  

• base-class（基类）
• derived-class（派生类）

3、访问控制

基类成员权限	public继承方式	protected继承方式	private继承方式
public	public	protected	private
protected	protected	protected	private
private	不能访问	不能访问	不能访问

4、多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

3、函数重载

在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。

4、运算符重载

重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。

与其他函数一样，重载运算符有一个返回类型和一个参数列表。

1、可重载运算符

+	-	*****	/	%	^
&	|	~	!	,	=
<	>	<=	>=	++	–
<<	>>	==	!=	&&	||
+=	-=	/=	%=	^=	&=
|=	*=	<<=	>>=	[]	()
->	->*	new	new []	delete	delete []

2、不可重载运算符

::	.*	.	?:

5、多态 1、概述

多态按字面的意思就是多种形态。

当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。

C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

2、虚函数

虚函数 是在基类中使用关键字 virtual 声明的函数。

在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种 *** 作被称为动态链接，或后期绑定。

3、纯虚函数

您可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

6、抽象 1、概述

数据抽象是指，只向外界提供关键信息，并隐藏其后台的实现细节，即只表现必要的信息而不呈现细节。

数据抽象是一种依赖于接口和实现分离的编程（设计）技术。

针对 C++ 编程而言，C++ 类为数据抽象提供了可能。

它们向外界提供了大量用于 *** 作对象数据的公共方法，也就是说，外界实际上并不清楚类的内部实现。

2、数据抽象的好处

数据抽象有两个重要的优势：

• 类的内部受到保护，不会因无意的用户级错误导致对象状态受损。
  

  
  

• 类实现可能随着时间的推移而发生变化，以便应对不断变化的需求，或者应对那些要求不改变用户级代码的错误报告。
  

  
  

3、设计策略

抽象把代码分离为接口和实现。

所以在设计组件时，必须保持接口独立于实现，这样，如果改变底层实现，接口也将保持不变。

在这种情况下，不管任何程序使用接口，接口都不会受到影响，只需要将最新的实现重新编译即可。

7、封装 1、概述

所有的 C++ 程序都有以下两个基本要素：

• 程序语句（代码）：这是程序中执行动作的部分，它们被称为函数。
  

  
  

• 程序数据：数据是程序的信息，会受到程序函数的影响。
  

  
  

封装是面向对象编程中的把数据和 *** 作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。

数据封装引申出了另一个重要的 OOP 概念，即数据隐藏。

数据封装是一种把数据和 *** 作数据的函数捆绑在一起的机制，数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制。

C++ 通过创建类来支持封装。

2、设计策略

通常情况下，我们都会设置类成员状态为私有（private），除非我们真的需要将其暴露，这样才能保证良好的封装性。

这通常应用于数据成员，但它同样适用于所有成员，包括虚函数。

8、接口（抽象类） 1、概述

接口描述了类的行为和功能，而不需要完成类的特定实现。

C++ 接口是使用抽象类来实现的，抽象类与数据抽象互不混淆，数据抽象是一个把实现细节与相关的数据分离开的概念。

如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。

纯虚函数是通过在声明中使用 “= 0” 来指定的。

设计抽象类（通常称为 ABC）的目的，是为了给其他类提供一个可以继承的适当的基类。

抽象类不能被用于实例化对象，它只能作为接口使用。

因此，如果一个 ABC 的子类需要被实例化，则必须实现每个虚函数，这也意味着 C++ 支持使用 ABC 声明接口。

2、设计策略

面向对象的系统可能会使用一个抽象基类为所有的外部应用程序提供一个适当的、通用的、标准化的接口。

然后，派生类通过继承抽象基类，就把所有类似的 *** 作都继承下来。

外部应用程序提供的功能（即公有函数）在抽象基类中是以纯虚函数的形式存在的。

这些纯虚函数在相应的派生类中被实现。

这个架构也使得新的应用程序可以很容易地被添加到系统中，即使是在系统被定义之后依然可以如此。

五、C++高级 1、文件和流

C++ 中使用标准库 fstream 从文件读取流和向文件写入流。

它定义了三个新的数据类型：

数据类型	描述
ofstream	该数据类型表示输出文件流，用于创建文件并向文件写入信息。
ifstream	该数据类型表示输入文件流，用于从文件读取信息。
fstream	该数据类型通常表示文件流，且同时具有 ofstream 和 ifstream 两种功能，这意味着它可以创建文件，向文件写入信息，从文件读取信息。

要在 C++ 中进行文件处理，必须在 C++ 源代码文件中包含头文件 和 。

2、异常处理 1、基本思想

C++之父 Bjarne Stroustrup 在《The C++ Programming Language》中讲到：一个库的作者可以检测出发生了运行时错误，但一般不知道怎样去处理它们（因为和用户具体的应用有关）；另一方面，库的用户知道怎样处理这些错误，但却无法检查它们何时发生（如果能检测，就可以再用户的代码里处理了，不用留给库去发现）。

Bjarne Stroustrup说：提供异常的基本目的就是为了处理上面的问题。

基本思想是：让一个函数在发现了自己无法处理的错误时抛出（throw）一个异常，然后它的（直接或者间接）调用者能够处理这个问题。

2、概述

异常是程序在执行期间产生的问题。

C++ 异常是指在程序运行时发生的特殊情况，比如尝试除以零的 *** 作。

异常提供了一种转移程序控制权的方式。

C++ 异常处理涉及到三个关键字：try、catch、throw。

• throw: 当问题出现时，程序会抛出一个异常。
  

  
  

  这是通过使用 throw 关键字来完成的。
  

  
  

• catch: 在您想要处理问题的地方，通过异常处理程序捕获异常。
  

  
  

  catch 关键字用于捕获异常。
  

  
  

• try: try 块中的代码标识将被激活的特定异常。
  

  
  

  它后面通常跟着一个或多个 catch 块。
  

  
  

如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。

try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。

使用 try/catch 语句的语法如下所示：

try
{
   // 保护代码
}catch( ExceptionName e1 )
{
   // catch 块
}catch( ExceptionName e2 )
{
   // catch 块
}catch( ExceptionName eN )
{
   // catch 块
}

如果 try 块在不同的情境下会抛出不同的异常，这个时候可以尝试罗列多个 catch 语句，用于捕获不同类型的异常。

3、抛出异常

您可以使用 throw 语句在代码块中的任何地方抛出异常。

throw 语句的 *** 作数可以是任意的表达式，表达式的结果的类型决定了抛出的异常的类型。

4、捕获异常

catch 块跟在 try 块后面，用于捕获异常。

您可以指定想要捕捉的异常类型，这是由 catch 关键字后的括号内的异常声明决定的。

try
{
   // 保护代码
}catch( ExceptionName e )
{
  // 处理 ExceptionName 异常的代码
}

5、C++标准异常

6、定义新异常

可以通过继承和重载 exception 类来定义新的异常。

3、动态内存

C++ 程序中的内存分为两个部分：

• 栈：在函数内部声明的所有变量都将占用栈内存。
  

  
  

• 堆：这是程序中未使用的内存，在程序运行时可用于动态分配内存。
  

  
  

很多时候，您无法提前预知需要多少内存来存储某个定义变量中的特定信息，所需内存的大小需要在运行时才能确定。

在 C++ 中，您可以使用特殊的运算符为给定类型的变量在运行时分配堆内的内存，这会返回所分配的空间地址。

这种运算符即 new 运算符。

如果您不需要动态分配内存，可以使用 delete 运算符，删除之前由 new 运算符分配的内存。

4、命名空间 1、概述

一个中大型软件往往由多名程序员共同开发，会使用大量的变量和函数，不可避免地会出现变量或函数的命名冲突。

为了解决合作开发时的命名冲突问题，C++ 引入了命名空间（Namespace）的概念。

2、定义命名空间

命名空间的定义使用关键字 namespace，后跟命名空间的名称，如下所示：

namespace namespace_name {
   // 代码声明
}

为了调用带有命名空间的函数或变量，需要在前面加上命名空间的名称，如下所示：

name::code;  // code 可以是变量或函数

3、using 指令

您可以使用 using namespace 指令，这样在使用命名空间时就可以不用在前面加上命名空间的名称。

这个指令会告诉编译器，后续的代码将使用指定的命名空间中的名称。

4、不连续的命名空间

命名空间可以定义在几个不同的部分中，因此命名空间是由几个单独定义的部分组成的。

一个命名空间的各个组成部分可以分散在多个文件中。

所以，如果命名空间中的某个组成部分需要请求定义在另一个文件中的名称，则仍然需要声明该名称。

下面的命名空间定义可以是定义一个新的命名空间，也可以是为已有的命名空间增加新的元素：

namespace namespace_name {
   // 代码声明
}

5、嵌套的命名空间

命名空间可以嵌套，您可以在一个命名空间中定义另一个命名空间，如下所示：

namespace namespace_name1 {
   // 代码声明
   namespace namespace_name2 {
      // 代码声明
   }
}

5、模板 1、概述

模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。

模板是创建泛型类或函数的蓝图或公式。

库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。

每个容器都有一个单一的定义，比如 向量，我们可以定义许多不同类型的向量，比如 vector 或 vector 。

2、函数模板

模板函数定义的一般形式如下所示：

template <typename type> ret-type func-name(parameter list)
{
   // 函数的主体
}  
template <class 类型参数1，class 类型参数2,……>
返回值类型 模板名 (形参表) {
	函数体
};

3、类模板

泛型类声明的一般形式如下所示：

template <class type> class class-name {
.
.
.
}
template <类型参数表>
class 类模板名{
    成员函数和成员变量
};

6、预处理器 1、概述

预处理器是一些指令，指示编译器在实际编译之前所需完成的预处理。

所有的预处理器指令都是以井号（#）开头，只有空格字符可以出现在预处理指令之前。

预处理指令不是 C++ 语句，所以它们不会以分号（;）结尾。

2、#define 预处理

#define 预处理指令用于创建符号常量。

该符号常量通常称为宏，指令的一般形式是：

#define macro-name replacement-text 

3、宏函数

您可以使用 #define 来定义一个带有参数的宏，如下示例所示：

#define MIN(a,b) (((a)<(b)) ? a : b)

4、条件编译

有几个指令可以用来有选择地对部分程序源代码进行编译。

这个过程被称为条件编译。

5、C++中预定义宏

宏	描述
LINE	这会在程序编译时包含当前行号。
FILE	这会在程序编译时包含当前文件名。
DATE	这会包含一个形式为 month/day/year 的字符串，它表示把源文件转换为目标代码的日期。
TIME	这会包含一个形式为 hour:minute:second 的字符串，它表示程序被编译的时间。

7、信号处理

信号由 *** 作系统提供接口。

8、多线程

多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。

在一般情况下，有两种类型的多任务处理：基于进程和基于线程。

基于进程的多任务处理处理的是程序的并发执行。

基于线程的多任务处理的是同一程序的片段的并发执行。

多线程程序包含可以同时运行的两个或多个部分。

这样的程序中的每个部分称为一个线程，每个线程定义了一个单独的执行路径。

C++ 不包含多线程应用程序的任何内置支持。

相反，它完全依赖于 *** 作系统来提供此功能。

9、web编程 10、MySQL编程 11、OpenSSL编程 1、SSL网络通信 2、HTTPS通信

六、C++资源库 1、STL

C++ STL（标准模板库）是一套功能强大的 C++ 模板类，提供了通用的模板类和函数，这些模板类和函数可以实现多种流行和常用的算法和数据结构，如向量、链表、队列、栈。

C++ 标准模板库的核心包括以下三个组件：

组件	描述
容器（Containers）	容器是用来管理某一类对象的集合。 C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。
算法（Algorithms）	算法作用于容器。 它们提供了执行各种 *** 作的方式，包括对容器内容执行初始化、排序、搜索和转换等 *** 作。
迭代器（iterators）	迭代器用于遍历对象集合的元素。 这些集合可能是容器，也可能是容器的子集。

这三个组件都带有丰富的预定义函数，帮助我们通过简单的方式处理复杂的任务。

2、标准库 1、概述

C++ 标准库可以分为两部分：

• 标准函数库： 这个库是由通用的、独立的、不属于任何类的函数组成的。
  

  
  

  函数库继承自 C 语言。
  

  
  

• 面向对象类库： 这个库是类及其相关函数的集合。
  

  
  

C++ 标准库包含了所有的 C 标准库，为了支持类型安全，做了一定的添加和修改。

2、标准函数库

标准函数库分为以下几类：

• 输入/输出 I/O
• 字符串和字符处理
• 数学
• 时间、日期和本地化
• 动态分配
• 其他
• 宽字符函数

3、面向对象类库

标准的 C++ 面向对象类库定义了大量支持一些常见 *** 作的类，比如输入/输出 I/O、字符串处理、数值处理。

面向对象类库包含以下内容：

• 标准的 C++ I/O 类
• String 类
• 数值类
• STL 容器类
• STL 算法
• STL 函数对象
• STL 迭代器
• STL 分配器
• 本地化库
• 异常处理类
• 杂项支持库

七、资源

• http://www.hal9k.com/cug/ - C 和 C++ 的用户团体提供了免费的涵盖各种编程领域 C++ 项目的源代码，包括 AI、动画、编译器、数据库、调试、加密、游戏、图形、GUI、语言工具、系统编程等。