从C到C++

C++和C语言的关系

C++ 读作“C加加”，是“C Plus Plus”的简称。顾名思义，C++ 是在C语言的基础上增加新特性，玩出了新花样，所以叫“C Plus Plus”。

从语法上看，C语言是 C++ 的一部分，C语言代码几乎不用修改就能够以 C++ 的方式编译。

可以明确地说：学了C语言就相当于学了 C++ 的一半，从C语言转向 C++ 时，不需要再从头开始，接着C语言往下学就可以。

C++编译器

很难说 C++ 拥有独立的编译器，例如 Windows 下的微软编译器（cl.exe）、Linux 下的 GCC 编译器、Mac 下的 Clang 编译器（已经是 Xcode 默认编译器，雄心勃勃，立志超越 GCC），它们都同时支持C语言和 C++，统称为 C/C++ 编译器。对于C语言代码，它们按照C语言的方式来编译；对于 C++ 代码，就按照 C++ 的方式编译。

从表面上看，C、C++ 代码使用同一个编译器来编译，所以说“ C++ 拥有了自己的编译方式”，而不是说“C++ 拥有了独立的编译器”。

C++

C++ 是一种高级语言，它是由 Bjarne Stroustrup 于 1979 年在贝尔实验室开始设计开发的。C++ 进一步扩充和完善了 C 语言，是一种面向对象的程序设计语言。C++ 可运行于多种平台上，如 Windows、MAC 操作系统以及 UNIX 的各种版本。

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

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

C++ 是由 Bjarne Stroustrup 于 1979 年在新泽西州美利山贝尔实验室开始设计开发的。C++ 进一步扩充和完善了 C 语言，最初命名为带类的C，后来在 1983 年更名为 C++。

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

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

面向对象程序设计

C++ 完全支持面向对象的程序设计，包括面向对象开发的四大特性：

• 封装（Encapsulation）：封装是将数据和方法组合在一起，对外部隐藏实现细节，只公开对外提供的接口。这样可以提高安全性、可靠性和灵活性。

• 继承（Inheritance）：继承是从已有类中派生出新类，新类具有已有类的属性和方法，并且可以扩展或修改这些属性和方法。这样可以提高代码的复用性和可扩展性。

• 多态（Polymorphism）：多态是指同一种操作作用于不同的对象，可以有不同的解释和实现。它可以通过接口或继承实现，可以提高代码的灵活性和可读性。

• 抽象（Abstraction）：抽象是从具体的实例中提取共同的特征，形成抽象类或接口，以便于代码的复用和扩展。抽象类和接口可以让程序员专注于高层次的设计和业务逻辑，而不必关注底层的实现细节。

标准库

标准的 C++ 由三个重要部分组成：

• 核心语言，提供了所有构件块，包括变量、数据类型和常量，等等。
• C++ 标准库，提供了大量的函数，用于操作文件、字符串等。
• 标准模板库（STL），提供了大量的方法，用于操作数据结构等。

ANSI 标准

ANSI 标准是为了确保 C++ 的便携性 —— 您所编写的代码在 Mac、UNIX、Windows、Alpha 计算机上都能通过编译。

由于 ANSI 标准已稳定使用了很长的时间，所有主要的 C++ 编译器的制造商都支持 ANSI 标准。

C++的使用场景

C++ 语言在许多行业和领域都有广泛应用，包括：

• 游戏开发：C++ 是游戏开发领域中最常用的编程语言之一，因为它具有高效的性能和直接控制硬件的能力。许多主要的游戏引擎，如 Unreal Engine 和 Unity，都使用 C++ 编写。

• 嵌入式系统开发：C++ 可以在嵌入式系统中发挥重要作用，如智能手机、汽车、机器人和家电等领域。由于嵌入式系统通常具有严格的资源限制和实时要求，因此 C++ 的高效性能和内存控制功能非常有用。

• 金融领域：C++ 在金融领域中被广泛应用，如高频交易、算法交易和风险管理等领域。由于这些应用程序需要高效的性能和对硬件的直接控制，C++ 语言是一个合适的选择。

• 图形图像处理：C++ 可以用于开发图形和图像处理应用程序，如计算机视觉、计算机图形学和人工智能领域。由于这些应用程序需要高效的计算能力和对硬件的控制，因此 C++ 是一个很好的选择。

• 科学计算和数值分析：C++ 可以用于开发科学计算和数值分析应用程序，如数值模拟和高性能计算等领域。由于这些应用程序需要高效的计算能力和对硬件的直接控制，C++ 语言是一个很好的选择。

标准化

安装 GNU 的 C/C++ 编译器

在 Windows 上安装 GCC，访问 MinGW 的主页 mingw-w64.org，进入 MinGW 下载页面，下载最新版本的 MinGW 安装程序，即可。

下载好后，执行gcc -v获取gcc编译器的版本信息：

g++ 应用说明

程序 g++ 是将 gcc 默认语言设为 C++ 的一个特殊的版本，链接时它自动使用 C++ 标准库而不用 C 标准库。通过遵循源码的命名规范并指定对应库的名字，用 gcc 来编译链接 C++ 程序是可行的，如下例所示：

$ gcc main.cpp -lstdc++ -o main

下面是一个保存在文件 helloworld.cpp 中一个简单的 C++ 程序的代码：

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

最简单的编译方式：

$ g++ helloworld.cpp

由于命令行中未指定可执行程序的文件名，编译器采用默认的 a.out。程序可以这样来运行：

$ ./a.out
Hello, world!

通常我们使用 -o 选项指定可执行程序的文件名，以下实例生成一个 helloworld 的可执行文件：

$ g++ helloworld.cpp -o helloworld

执行 helloworld:

$ ./helloworld
Hello, world!

如果是多个 C++ 代码文件，如 runoob1.cpp、runoob2.cpp，编译命令如下，生成一个 runoob 可执行文件：

$ g++ runoob1.cpp runoob2.cpp -o runoob

g++ 有些系统默认是使用 C++98，可以指定使用 C++11 来编译 main.cpp 文件：

g++ -g -Wall -std=c++11 main.cpp

g++ 常用命令选项

C++ 基本语法

C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互，简要地看一下什么是类、对象，方法、即时变量。

• 对象 - 对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。
• 类 - 类可以定义为描述对象行为/状态的模板/蓝图。
• 方法 - 从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中写入逻辑、操作数据以及执行所有的动作。
• 即时变量 - 每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。

C++ 关键字

下表列出了 C++ 中的保留字。这些保留字不能作为常量名、变量名或其他标识符名称。

三字符组

三字符组就是用于表示另一个字符的三个字符序列，又称为三字符序列。三字符序列总是以两个问号开头。

三字符序列不太常见，但 C++ 标准允许把某些字符指定为三字符序列。以前为了表示键盘上没有的字符，这是必不可少的一种方法。

三字符序列可以出现在任何地方，包括字符串、字符序列、注释和预处理指令。

下面列出了最常用的三字符序列：

如果希望在源程序中有两个连续的问号，且不希望被预处理器替换，这种情况出现在字符常量、字符串字面值或者是程序注释中，可选办法是用字符串的自动连接：“…?”“?..“或者转义序列：”…??..”。

从Microsoft Visual C++ 2010版开始，该编译器默认不再自动替换三字符组。如果需要使用三字符组替换（如为了兼容古老的软件代码），需要设置编译器命令行选项/Zc:trigraphs

g++仍支持三字符组，但不再默认，但会给出编译警告。

C++ 数据类型

基本的内置类型

C++ 为程序员提供了种类丰富的内置数据类型和用户自定义的数据类型。下表列出了七种基本的 C++ 数据类型：

其实 wchar_t 是这样来的：

typedef short int wchar_t;

所以 wchar_t 实际上的空间是和 short int 一样。

一些基本类型可以使用一个或多个类型修饰符进行修饰：

• signed
• unsigned
• short
• long

下表显示了各种变量类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值。

注意：不同系统会有所差异，一字节为 8 位。

注意：默认情况下，int、short、long都是带符号的，即 signed。

注意：long int 8 个字节，int 都是 4 个字节，早期的 C 编译器定义了 long int 占用 4 个字节，int 占用 2 个字节，新版的 C/C++ 标准兼容了早期的这一设定。

下面实例会输出电脑上各种数据类型的大小：

#include<iostream>  
#include <limits>using namespace std;  int main()  
{  cout << "type: \t\t" << "************size**************"<< endl;  cout << "bool: \t\t" << "所占字节数：" << sizeof(bool);  cout << "\t最大值：" << (numeric_limits<bool>::max)();  cout << "\t\t最小值：" << (numeric_limits<bool>::min)() << endl;  cout << "char: \t\t" << "所占字节数：" << sizeof(char);  cout << "\t最大值：" << (numeric_limits<char>::max)();  cout << "\t\t最小值：" << (numeric_limits<char>::min)() << endl;  cout << "signed char: \t" << "所占字节数：" << sizeof(signed char);  cout << "\t最大值：" << (numeric_limits<signed char>::max)();  cout << "\t\t最小值：" << (numeric_limits<signed char>::min)() << endl;  cout << "unsigned char: \t" << "所占字节数：" << sizeof(unsigned char);  cout << "\t最大值：" << (numeric_limits<unsigned char>::max)();  cout << "\t\t最小值：" << (numeric_limits<unsigned char>::min)() << endl;  cout << "wchar_t: \t" << "所占字节数：" << sizeof(wchar_t);  cout << "\t最大值：" << (numeric_limits<wchar_t>::max)();  cout << "\t\t最小值：" << (numeric_limits<wchar_t>::min)() << endl;  cout << "short: \t\t" << "所占字节数：" << sizeof(short);  cout << "\t最大值：" << (numeric_limits<short>::max)();  cout << "\t\t最小值：" << (numeric_limits<short>::min)() << endl;  cout << "int: \t\t" << "所占字节数：" << sizeof(int);  cout << "\t最大值：" << (numeric_limits<int>::max)();  cout << "\t最小值：" << (numeric_limits<int>::min)() << endl;  cout << "unsigned: \t" << "所占字节数：" << sizeof(unsigned);  cout << "\t最大值：" << (numeric_limits<unsigned>::max)();  cout << "\t最小值：" << (numeric_limits<unsigned>::min)() << endl;  cout << "long: \t\t" << "所占字节数：" << sizeof(long);  cout << "\t最大值：" << (numeric_limits<long>::max)();  cout << "\t最小值：" << (numeric_limits<long>::min)() << endl;  cout << "unsigned long: \t" << "所占字节数：" << sizeof(unsigned long);  cout << "\t最大值：" << (numeric_limits<unsigned long>::max)();  cout << "\t最小值：" << (numeric_limits<unsigned long>::min)() << endl;  cout << "double: \t" << "所占字节数：" << sizeof(double);  cout << "\t最大值：" << (numeric_limits<double>::max)();  cout << "\t最小值：" << (numeric_limits<double>::min)() << endl;  cout << "long double: \t" << "所占字节数：" << sizeof(long double);  cout << "\t最大值：" << (numeric_limits<long double>::max)();  cout << "\t最小值：" << (numeric_limits<long double>::min)() << endl;  cout << "float: \t\t" << "所占字节数：" << sizeof(float);  cout << "\t最大值：" << (numeric_limits<float>::max)();  cout << "\t最小值：" << (numeric_limits<float>::min)() << endl;  cout << "size_t: \t" << "所占字节数：" << sizeof(size_t);  cout << "\t最大值：" << (numeric_limits<size_t>::max)();  cout << "\t最小值：" << (numeric_limits<size_t>::min)() << endl;  cout << "string: \t" << "所占字节数：" << sizeof(string) << endl;  // << "\t最大值：" << (numeric_limits<string>::max)() << "\t最小值：" << (numeric_limits<string>::min)() << endl;  cout << "type: \t\t" << "************size**************"<< endl;  return 0;  
}

本实例使用了 endl，这将在每一行后插入一个换行符，<< 运算符用于向屏幕传多个值，sizeof() 运算符用来获取各种数据类型的大小。

typedef 声明

可以使用 typedef 为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法：

typedef type newname; 

例如，下面的语句会告诉编译器，feet 是 int 的另一个名称：

typedef int feet;

现在，下面的声明是完全合法的，它创建了一个整型变量 distance：

feet distance;

枚举类型

枚举类型(enumeration)是C++中的一种派生数据类型，它是由用户定义的若干枚举常量的集合。

如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。所谓"枚举"是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。

创建枚举，需要使用关键字 enum。枚举类型的一般形式为：

enum 枚举名{ 标识符[=整型常数], 标识符[=整型常数], 
... 标识符[=整型常数]
} 枚举变量; 

如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始。

例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 color。最后，c 被赋值为 “blue”。

enum color { red, green, blue } c;
c = blue;

**默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。**但是，也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，green 的值为 5。

enum color { red, green=5, blue };

在这里，blue 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1，但 red 的值依然为 0。

#include <iostream>typedef enum Mode {r = 1,w = 2,rw = 3
} mode;int main() {// 习惯go语言后非常喜欢使用typedef声明别名enum Mode mode1 = r;mode mode2 = rw;std::cout << "mode1: " << mode1 << " mode2: " << mode2 << std::endl;
}

类型转换

类型转换是将一个数据类型的值转换为另一种数据类型的值。

C++ 中有四种类型转换：静态转换、动态转换、常量转换和重新解释转换。

静态转换（Static Cast）

静态转换是将一种数据类型的值强制转换为另一种数据类型的值。

静态转换通常用于比较类型相似的对象之间的转换，例如将 int 类型转换为 float 类型。

静态转换不进行任何运行时类型检查，因此可能会导致运行时错误。

int i = 10;
float f = static_cast<float>(i); // 静态将int类型转换为float类型

动态转换（Dynamic Cast）

动态转换通常用于将一个基类指针或引用转换为派生类指针或引用。动态转换在运行时进行类型检查，如果不能进行转换则返回空指针或引发异常。

class Base {};
class Derived : public Base {};
Base* ptr_base = new Derived;
Derived* ptr_derived = dynamic_cast<Derived*>(ptr_base); // 将基类指针转换为派生类指针

常量转换（Const Cast）

常量转换用于将 const 类型的对象转换为非 const 类型的对象。

常量转换只能用于转换掉 const 属性，不能改变对象的类型。

const int i = 10;
int& r = const_cast<int&>(i); // 常量转换，将const int转换为int

重新解释转换（Reinterpret Cast）

重新解释转换将一个数据类型的值重新解释为另一个数据类型的值，通常用于在不同的数据类型之间进行转换。

重新解释转换不进行任何类型检查，因此可能会导致未定义的行为。

int i = 10;
float f = reinterpret_cast<float&>(i); // 重新解释将int类型转换为float类型

C++ 变量类型

C++ 也允许定义各种其他类型的变量，比如枚举、指针、数组、引用、数据结构、类等等。

整数类型（Integer Types）：

• int：用于表示整数，通常占用4个字节。
• short：用于表示短整数，通常占用2个字节。
• long：用于表示长整数，通常占用4个字节。
• long long：用于表示更长的整数，通常占用8个字节。

浮点类型（Floating-Point Types）：

• float：用于表示单精度浮点数，通常占用4个字节。
• double：用于表示双精度浮点数，通常占用8个字节。
• long double：用于表示更高精度的浮点数，占用字节数可以根据实现而变化。

字符类型（Character Types）：

• char：用于表示字符，通常占用1个字节。
• wchar_t：用于表示宽字符，通常占用2或4个字节。
• char16_t：用于表示16位Unicode字符，占用2个字节。
• char32_t：用于表示32位Unicode字符，占用4个字节。

布尔类型（Boolean Type）：

bool：用于表示布尔值，只能取true或false。

枚举类型（Enumeration Types）：

enum：用于定义一组命名的整数常量。

指针类型（Pointer Types）：

type*：用于表示指向类型为type的对象的指针。

数组类型（Array Types）：

type[]或type[size]：用于表示具有相同类型的元素组成的数组。

结构体类型（Structure Types）：

struct：用于定义包含多个不同类型成员的结构。

类类型（Class Types）：

class：用于定义具有属性和方法的自定义类型。

共用体类型（Union Types）：

union：用于定义一种特殊的数据类型，它可以在相同的内存位置存储不同的数据类型。
在 C++ 中，类型的长度（即占用的字节数）取决于编译器和计算机架构，然而，C++ 标准规定了不同整数类型的最小范围，而不是具体的字节数，这是为了确保代码在不同的系统上都能正确运行。

请注意，以上类型的范围只是 C++ 标准规定的最小要求，实际上，许多系统上这些类型可能占用更多的字节，例如，很多现代计算机上 int 通常占用 4 字节，而 long 可能占用 8 字节。

C++ 变量作用域

一般来说有三个地方可以定义变量：

• 在函数或一个代码块内部声明的变量，称为局部变量。

• 在函数参数的定义中声明的变量，称为形式参数。

• 在所有函数外部声明的变量，称为全局变量。

作用域是程序的一个区域，变量的作用域可以分为以下几种：

• 局部作用域：在函数内部声明的变量具有局部作用域，它们只能在函数内部访问。局部变量在函数每次被调用时被创建，在函数执行完后被销毁。

• 全局作用域：在所有函数和代码块之外声明的变量具有全局作用域，它们可以被程序中的任何函数访问。全局变量在程序开始时被创建，在程序结束时被销毁。

• 块作用域：在代码块内部声明的变量具有块作用域，它们只能在代码块内部访问。块作用域变量在代码块每次被执行时被创建，在代码块执行完后被销毁。

• 类作用域：在类内部声明的变量具有类作用域，它们可以被类的所有成员函数访问。类作用域变量的生命周期与类的生命周期相同。

注意：如果在内部作用域中声明的变量与外部作用域中的变量同名，则内部作用域中的变量将覆盖外部作用域中的变量。

局部变量

在函数或一个代码块内部声明的变量，称为局部变量。它们只能被函数内部或者代码块内部的语句使用。

#include <iostream>
using namespace std;int main ()
{// 局部变量声明int a, b;int c;// 实际初始化a = 10;b = 20;c = a + b;cout << c;return 0;
}

全局变量

在所有函数外部定义的变量（通常是在程序的头部），称为全局变量。全局变量的值在程序的整个生命周期内都是有效的。

全局变量可以被任何函数访问。也就是说，全局变量一旦声明，在整个程序中都是可用的：

#include <iostream>
using namespace std;// 全局变量声明
int g = 20;int main ()
{// 局部变量声明int g = 10;cout << g;return 0;
}

在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。

当上面的代码被编译和执行时，它会产生下列结果：

10

初始化局部变量和全局变量

当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值：

块作用域

块作用域指的是在代码块内部声明的变量：

#include <iostream>int main() {int a = 10;{int a = 20;  // 块作用域变量std::cout << "块变量: " << a << std::endl;}std::cout << "外部变量: " << a << std::endl;return 0;
}

以上实例中，内部的代码块中声明了一个名为 a 的变量，它与外部作用域中的变量 a 同名。内部作用域中的变量 a 将覆盖外部作用域中的变量 a，在内部作用域中访问 a 时输出的是20，而在外部作用域中访问 a 时输出的是 10。

当上面的代码被编译和执行时，它会产生下列结果：

块变量: 20
外部变量: 10

类作用域

类作用域指的是在类内部声明的变量：

#include <iostream>class MyClass {
public:static int class_var;  // 类作用域变量
};int MyClass::class_var = 30;int main() {std::cout << "类变量: " << MyClass::class_var << std::endl;return 0;
}

以上实例中，MyClass 类中声明了一个名为 class_var 的类作用域变量。可以使用类名和作用域解析运算符 :: 来访问这个变量。

在 main() 函数中访问 class_var 时输出的是 30。

C++ 修饰符类型

C++ 允许在 char、int 和 double 数据类型前放置修饰符。

修饰符是用于改变变量类型的行为的关键字，它更能满足各种情境的需求。

下面列出了数据类型修饰符：

• signed：表示变量可以存储负数。对于整型变量来说，signed 可以省略，因为整型变量默认为有符号类型。

• unsigned：表示变量不能存储负数。对于整型变量来说，unsigned 可以将变量范围扩大一倍。

• short：表示变量的范围比 int 更小。short int 可以缩写为 short。

• long：表示变量的范围比 int 更大。long int 可以缩写为 long。

• long long：表示变量的范围比 long 更大。C++11 中新增的数据类型修饰符。

• float：表示单精度浮点数。

• double：表示双精度浮点数。

• bool：表示布尔类型，只有 true 和 false 两个值。

• char：表示字符类型。

• wchar_t：表示宽字符类型，可以存储 Unicode 字符。

修饰符 signed、unsigned、long 和 short 可应用于整型，signed 和 unsigned 可应用于字符型，long 可应用于双精度型。

这些修饰符也可以组合使用，修饰符 signed 和 unsigned 也可以作为 long 或 short 修饰符的前缀。例如：unsigned long int。

C++ 允许使用速记符号来声明无符号短整数或无符号长整数。可以不写 int，只写单词 unsigned、short 或 long，int 是隐含的。例如，下面的两个语句都声明了无符号整型变量。

signed int num1 = -10; // 定义有符号整型变量 num1，初始值为 -10
unsigned int num2 = 20; // 定义无符号整型变量 num2，初始值为 20short int num1 = 10; // 定义短整型变量 num1，初始值为 10
long int num2 = 100000; // 定义长整型变量 num2，初始值为 100000long long int num1 = 10000000000; // 定义长长整型变量 num1，初始值为 10000000000float num1 = 3.14f; // 定义单精度浮点数变量 num1，初始值为 3.14
double num2 = 2.71828; // 定义双精度浮点数变量 num2，初始值为 2.71828bool flag = true; // 定义布尔类型变量 flag，初始值为 truechar ch1 = 'a'; // 定义字符类型变量 ch1，初始值为 'a'
wchar_t ch2 = L'你'; // 定义宽字符类型变量 ch2，初始值为 '你'

为了理解 C++ 解释有符号整数和无符号整数修饰符之间的差别，运行一下下面这个短程序：

#include <iostream>
using namespace std;/* * 这个程序演示了有符号整数和无符号整数之间的差别
*/
int main()
{short int i;           // 有符号短整数short unsigned int j;  // 无符号短整数j = 50000;i = j;cout << i << " " << j;return 0;
}
当上面的程序运行时，会输出下列结果：-15536 50000

上述结果中，无符号短整数 50,000 的位模式被解释为有符号短整数 -15,536。

C++ 中的类型限定符

类型限定符提供了变量的额外信息，用于在定义变量或函数时改变它们的默认行为的关键字。

volatile 实例

volatile int num = 20; // 定义变量 num，其值可能会在未知的时间被改变

mutable 实例

class Example {
public:int get_value() const {return value_; // const 关键字表示该成员函数不会修改对象中的数据成员}void set_value(int value) const {value_ = value; // mutable 关键字允许在 const 成员函数中修改成员变量}
private:mutable int value_;
};

static 实例

void example_function() {static int count = 0; // static 关键字使变量 count 存储在程序生命周期内都存在count++;
}

register 实例

void example_function(register int num) {// register 关键字建议编译器将变量 num 存储在寄存器中// 以提高程序执行速度// 但是实际上是否会存储在寄存器中由编译器决定
}

C++ 存储类

存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C++ 程序中可用的存储类：

• auto：这是默认的存储类说明符，通常可以省略不写。auto 指定的变量具有自动存储期，即它们的生命周期仅限于定义它们的块（block）。auto 变量通常在栈上分配。

• register：用于建议编译器将变量存储在CPU寄存器中以提高访问速度。在 C++11 及以后的版本中，register 已经是一个废弃的特性，不再具有实际作用。

• static：用于定义具有静态存储期的变量或函数，它们的生命周期贯穿整个程序的运行期。在函数内部，static变量的值在函数调用之间保持不变。在文件内部或全局作用域，static变量具有内部链接，只能在定义它们的文件中访问。

• extern：用于声明具有外部链接的变量或函数，它们可以在多个文件之间共享。默认情况下，全局变量和函数具有 extern 存储类。在一个文件中使用extern声明另一个文件中定义的全局变量或函数，可以实现跨文件共享。

• mutable (C++11)：用于修饰类中的成员变量，允许在const成员函数中修改这些变量的值。通常用于缓存或计数器等需要在const上下文中修改的数据。

• thread_local (C++11)：用于定义具有线程局部存储期的变量，每个线程都有自己的独立副本。线程局部变量的生命周期与线程的生命周期相同。

从 C++ 17 开始，auto 关键字不再是 C++ 存储类说明符（只剩下用于推测类型），且 register 关键字被弃用。

从 C++11 开始，register 已经失去了原有的作用，而 mutable 和 thread_local 则是新引入的特性，用于解决特定的编程问题。

下面是一个展示不同存储类说明符的实例：

#include <iostream>// 全局变量，具有外部链接，默认存储类为extern
int globalVar;void function() {// 局部变量，具有自动存储期，默认存储类为autoauto int localVar = 10;// 静态变量，具有静态存储期，生命周期贯穿整个程序static int staticVar = 20;const int constVar = 30; // const变量默认具有static存储期// 尝试修改const变量，编译错误// constVar = 40;// mutable成员变量，可以在const成员函数中修改class MyClass {public:mutable int mutableVar;void constMemberFunc() const {mutableVar = 50; // 允许修改mutable成员变量}};// 线程局部变量，每个线程有自己的独立副本thread_local int threadVar = 60;
}int main() {extern int externalVar; // 声明具有外部链接的变量function();return 0;
}

static 存储类

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。

#include <iostream>// 函数声明 
void func(void);static int count = 10; /* 全局变量 */int main()
{while(count--){func();}return 0;
}
// 函数定义
void func( void )
{static int i = 5; // 局部静态变量i++;std::cout << "变量 i 为 " << i ;std::cout << " , 变量 count 为 " << count << std::endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

变量 i 为 6 , 变量 count 为 9
变量 i 为 7 , 变量 count 为 8
变量 i 为 8 , 变量 count 为 7
变量 i 为 9 , 变量 count 为 6
变量 i 为 10 , 变量 count 为 5
变量 i 为 11 , 变量 count 为 4
变量 i 为 12 , 变量 count 为 3
变量 i 为 13 , 变量 count 为 2
变量 i 为 14 , 变量 count 为 1
变量 i 为 15 , 变量 count 为 0

extern 存储类

extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当使用 ‘extern’ 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

当有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。

extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：

第一个文件：main.cpp

#include <iostream>int count ;
extern void write_extern();int main()
{count = 5;write_extern();
}

第二个文件：support.cpp

#include <iostream>extern int count;void write_extern(void)
{std::cout << "Count is " << count << std::endl;
}

在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.cpp 中定义的 count。现在 ，编译这两个文件，如下所示：

$ g++ main.cpp support.cpp -o write

这会产生 write 可执行程序，尝试执行 write，它会产生下列结果：

$ ./write
Count is 5

mutable 存储类

mutable 说明符仅适用于类的对象，它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。

thread_local 存储类

使用 thread_local 说明符声明的变量仅可在其创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 每个线程都有其自己的变量副本。

thread_local 说明符可以与 static 或 extern 合并。

可以将 thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义。

以下演示了可以被声明为 thread_local 的变量：

thread_local int x;  // 命名空间下的全局变量
class X
{static thread_local std::string s; // 类的static成员变量
};
static thread_local std::string X::s;  // X::s 是需要定义的void foo()
{thread_local std::vector<int> v;  // 本地变量
}

C++ 运算符

杂项运算符

下表列出了 C++ 支持的其他一些重要的运算符

C++ 中的运算符优先级

运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。

例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。

下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

C++ 函数

参数的默认值

定义一个函数时，可以为参数列表中后边的每一个参数指定默认值。当调用函数时，如果实际参数的值留空，则使用这个默认值。

这是通过在函数定义中使用赋值运算符来为参数赋值的。调用函数时，如果未传递参数的值，则会使用默认值，如果指定了值，则会忽略默认值，使用传递的值：

#include <iostream>
using namespace std;int sum(int a, int b=20)
{int result;result = a + b;return (result);
}int main ()
{// 局部变量声明int a = 100;int b = 200;int result;// 调用函数来添加值result = sum(a, b);cout << "Total value is :" << result << endl;// 再次调用函数result = sum(a);cout << "Total value is :" << result << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Total value is :300
Total value is :120

Lambda 函数与表达式

C++11 提供了对匿名函数的支持,称为 Lambda 函数(也叫 Lambda 表达式)。

Lambda 表达式把函数看作对象。Lambda 表达式可以像对象一样使用，比如可以将它们赋给变量和作为参数传递，还可以像函数一样对其求值。

Lambda 表达式本质上与函数声明非常类似。Lambda 表达式具体形式如下:

[capture](parameters)->return-type{body}

一个完整的 Lambda 表达式的组成如下：

[ capture-list ] ( params ) mutable(optional) exception(optional) attribute(optional) -> ret(optional) { body } 

1. capture-list：捕获列表。前面的例子 auto Plus = [](int a, int b) { return a + b; }; （auto表示自动推测数据类型）没有捕获任何变量。
2. params：和普通函数一样的参数。
3. mutable：只有这个 Lambda 表达式是 mutable 的才允许修改按值捕获的参数。
4. exception：异常标识。暂时不必理解。
5. attribute：属性标识。暂时不必理解。
6. ret：返回值类型，可以省略，让编译器通过 return 语句自动推导。
7. body：函数的具体逻辑。

Lambda 表达式的捕获，其实就是将局部自动变量保存到 Lambda 表达式内部（Lambda 表达式不能捕获全局变量或 static 变量）。

例如：

[](int x, int y){ return x < y ; }

如果没有返回值可以表示为：

[capture](parameters){body}

例如：

[]{ ++global_x; } 

在一个更为复杂的例子中，返回类型可以被明确的指定如下：

[](int x, int y) -> int { int z = x + y; return z + x; }

本例中，一个临时的参数 z 被创建用来存储中间结果。如同一般的函数，z 的值不会保留到下一次该不具名函数再次被调用时。

如果 lambda 函数没有传回值（例如 void），其返回类型可被完全忽略。

在Lambda表达式内可以访问当前作用域的变量，这是Lambda表达式的闭包（Closure）行为。 与JavaScript闭包不同，C++变量传递有传值和传引用的区别。可以通过前面的[]来指定：

[]      // 沒有定义任何变量。使用未定义变量会引发错误。
[x, &y] // x以传值方式传入（默认），y以引用方式传入。
[&]     // 任何被使用到的外部变量都隐式地以引用方式加以引用。
[=]     // 任何被使用到的外部变量都隐式地以传值方式加以引用。
[&, x]  // x显式地以传值方式加以引用。其余变量以引用方式加以引用。
[=, &z] // z显式地以引用方式加以引用。其余变量以传值方式加以引用。

另外有一点需要注意。对于[=]或[&]的形式，lambda 表达式可以直接使用 this 指针。但是，对于[]的形式，如果要使用 this 指针，必须显式传入：

[this]() { this->someFunc(); }();

C++ 数字

C++ 数学运算

C++ 内置了（需要引用数学头文件 <cmath>）丰富的数学函数，可对各种数字进行运算。下表列出了 C++ 中一些有用的内置的数学函数。

#include <iostream>
#include <cmath>
using namespace std;int main ()
{// 数字定义short  s = 10;int    i = -1000;long   l = 100000;float  f = 230.47;double d = 200.374;// 数学运算cout << "sin(d) :" << sin(d) << endl;cout << "abs(i)  :" << abs(i) << endl;cout << "floor(d) :" << floor(d) << endl;cout << "sqrt(f) :" << sqrt(f) << endl;cout << "pow( d, 2) :" << pow(d, 2) << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

sin(d) :-0.634939
abs(i)  :1000
floor(d) :200
sqrt(f) :15.1812
pow( d, 2 ) :40149.7

C++ 随机数

在许多情况下，需要生成随机数。关于随机数生成器，有两个相关的函数。一个是 rand()，该函数只返回一个伪随机数。生成随机数之前必须先调用 srand() 函数。

#include <iostream>
#include <ctime>
#include <cstdlib>using namespace std;int main ()
{int i,j;// 设置种子srand( (unsigned)time( NULL ) );/* 生成 10 个随机数 */for( i = 0; i < 10; i++ ){// 生成实际的随机数j= rand();cout <<"随机数： " << j << endl;}return 0;
}

上面的代码被编译和执行时，它会产生下列结果：

随机数： 1748144778
随机数： 630873888
随机数： 2134540646
随机数： 219404170
随机数： 902129458
随机数： 920445370
随机数： 1319072661
随机数： 257938873
随机数： 1256201101
随机数： 580322989

C++ 字符串

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

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

C 风格字符串

C 风格的字符串起源于 C 语言，并在 C++ 中继续得到支持。字符串实际上是使用 null 字符 \0 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。

下面的声明和初始化创建了一个 RUNOOB 字符串。由于在数组的末尾存储了空字符，所以字符数组的大小比单词 RUNOOB 的字符数多一个。

char site[7] = {'R', 'U', 'N', 'O', 'O', 'B', '\0'};
依据数组初始化规则，可以把上面的语句写成以下语句：

char site[] = "RUNOOB";

以下是 C/C++ 中定义的字符串的内存表示：

C++ 编译器会在初始化数组时，自动把 \0 放在字符串的末尾。

C++ 中有大量的函数用来操作以 null 结尾的字符串:

string str1 = "runoob";
string str2 = "google";
string str = str1 + str2;

#include <iostream>
#include <cstring>using namespace std;int main ()
{char str1[13] = "runoob";char str2[13] = "google";char str3[13];int  len ;// 复制 str1 到 str3strcpy( str3, str1);cout << "strcpy( str3, str1) : " << str3 << endl;// 连接 str1 和 str2strcat( str1, str2);cout << "strcat( str1, str2): " << str1 << endl;// 连接后，str1 的总长度len = strlen(str1);cout << "strlen(str1) : " << len << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

strcpy( str3, str1) : runoob
strcat( str1, str2): runoobgoogle
strlen(str1) : 12

C++ 中的 String 类

C++ 标准库提供了 string 类类型，支持上述所有的操作，另外还增加了其他更多的功能。

#include <iostream>
#include <string>using namespace std;int main ()
{string str1 = "runoob";string str2 = "google";string str3;int  len ;// 复制 str1 到 str3str3 = str1;cout << "str3 : " << str3 << endl;// 连接 str1 和 str2str3 = str1 + str2;cout << "str1 + str2 : " << str3 << endl;// 连接后，str3 的总长度len = str3.size();cout << "str3.size() :  " << len << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

str3 : runoob
str1 + str2 : runoobgoogle
str3.size() :  12

C++ 引用

引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

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

• 不存在空引用。引用必须连接到一块合法的内存。
• 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
• 引用必须在创建时被初始化。指针可以在任何时间被初始化。

C++ 中创建引用

#include <iostream>using namespace std;int main ()
{// 声明简单的变量int    i;double d;// 声明引用变量int&    r = i;double& s = d;i = 5;cout << "Value of i : " << i << endl;cout << "Value of i reference : " << r  << endl;d = 11.7;cout << "Value of d : " << d << endl;cout << "Value of d reference : " << s  << endl;return 0;
}

在这些声明中，& 读作引用。

当上面的代码被编译和执行时，它会产生下列结果：

Value of i : 5
Value of i reference : 5
Value of d : 11.7
Value of d reference : 11.7

C++ 把引用作为参数

#include <iostream>
using namespace std;// 函数声明
void swap(int& x, int& y);int main ()
{// 局部变量声明int a = 100;int b = 200;cout << "交换前，a 的值：" << a << endl;cout << "交换前，b 的值：" << b << endl;/* 调用函数来交换值 */swap(a, b);cout << "交换后，a 的值：" << a << endl;cout << "交换后，b 的值：" << b << endl;return 0;
}// 函数定义
void swap(int& x, int& y)
{int temp;temp = x; /* 保存地址 x 的值 */x = y;    /* 把 y 赋值给 x */y = temp; /* 把 x 赋值给 y  */return;
}

当上面的代码被编译和执行时，它会产生下列结果：

交换前，a 的值： 100
交换前，b 的值： 200
交换后，a 的值： 200
交换后，b 的值： 100

C++ 把引用作为返回值

通过使用引用来替代指针，会使 C++ 程序更容易阅读和维护。C++ 函数可以返回一个引用，方式与返回一个指针类似。

当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边。

#include <iostream>using namespace std;double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};double& setValues(int i) {  double& ref = vals[i];    return ref;   // 返回第 i 个元素的引用，ref 是一个引用变量，ref 引用 vals[i]
}// 要调用上面定义函数的主函数
int main ()
{cout << "改变前的值" << endl;for ( int i = 0; i < 5; i++ ){cout << "vals[" << i << "] = ";cout << vals[i] << endl;}setValues(1) = 20.23; // 改变第 2 个元素setValues(3) = 70.8;  // 改变第 4 个元素cout << "改变后的值" << endl;for ( int i = 0; i < 5; i++ ){cout << "vals[" << i << "] = ";cout << vals[i] << endl;}return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

改变前的值
vals[0] = 10.1
vals[1] = 12.6
vals[2] = 33.1
vals[3] = 24.1
vals[4] = 50
改变后的值
vals[0] = 10.1
vals[1] = 20.23
vals[2] = 33.1
vals[3] = 70.8
vals[4] = 50

当返回一个引用时，要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的，但是，可以返回一个对静态变量的引用。

int& func() {int q;//! return q; // 在编译时发生错误static int x;return x;     // 安全，x 在函数作用域外依然是有效的
}

以下是一个实例，演示了返回对静态变量的引用：

#include <iostream>
using namespace std;// 返回对静态变量的引用
int& getStaticRef() {static int num = 5; // 静态变量return num;
}int main() {int& ref = getStaticRef(); // 获取对静态变量的引用cout << "初始值：" << ref << endl;ref = 10; // 修改静态变量的值cout << "修改后的值：" << ref << endl;cout << "再次调用函数后的值：" << getStaticRef() << endl;return 0;
}

getStaticRef() 函数返回了对静态变量 num 的引用。输出结果为：

初始值：5
修改后的值：10
再次调用函数后的值：10

C++ 日期 & 时间

C++ 标准库没有提供所谓的日期类型。C++ 继承了 C 语言用于日期和时间操作的结构和函数。为了使用日期和时间相关的函数和结构，需要在 C++ 程序中引用 头文件。

有四个与时间相关的类型：clock_t、time_t、size_t 和 tm。类型 clock_t、size_t 和 time_t 能够把系统时间和日期表示为某种整数。

结构类型 tm 把日期和时间以 C 结构的形式保存，tm 结构的定义如下：

struct tm {int tm_sec;   // 秒，正常范围从 0 到 59，但允许至 61int tm_min;   // 分，范围从 0 到 59int tm_hour;  // 小时，范围从 0 到 23int tm_mday;  // 一月中的第几天，范围从 1 到 31int tm_mon;   // 月，范围从 0 到 11int tm_year;  // 自 1900 年起的年数int tm_wday;  // 一周中的第几天，范围从 0 到 6，从星期日算起int tm_yday;  // 一年中的第几天，范围从 0 到 365，从 1 月 1 日算起int tm_isdst; // 夏令时
};

下面是 C/C++ 中关于日期和时间的重要函数：

当前日期和时间

下面的实例获取当前系统的日期和时间，包括本地时间和协调世界时（UTC）。

#include <iostream>
#include <ctime>using namespace std;int main( )
{// 基于当前系统的当前日期/时间time_t now = time(0);// 把 now 转换为字符串形式char* dt = ctime(&now);cout << "本地日期和时间：" << dt << endl;// 把 now 转换为 tm 结构tm *gmtm = gmtime(&now);dt = asctime(gmtm);cout << "UTC 日期和时间："<< dt << endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

本地日期和时间：Sat Jan  8 20:07:41 2011UTC 日期和时间：Sun Jan  9 03:07:41 2011

使用结构 tm 格式化时间

tm 结构在 C/C++ 中处理日期和时间相关的操作时，显得尤为重要。tm 结构以 C 结构的形式保存日期和时间。大多数与时间相关的函数都使用了 tm 结构。下面的实例使用了 tm 结构和各种与日期和时间相关的函数。

#include <iostream>
#include <ctime>using namespace std;int main( )
{// 基于当前系统的当前日期/时间time_t now = time(0);cout << "1970 到目前经过秒数:" << now << endl;tm *ltm = localtime(&now);// 输出 tm 结构的各个组成部分cout << "年: "<< 1900 + ltm->tm_year << endl;cout << "月: "<< 1 + ltm->tm_mon<< endl;cout << "日: "<<  ltm->tm_mday << endl;cout << "时间: "<< ltm->tm_hour << ":";cout << ltm->tm_min << ":";cout << ltm->tm_sec << endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

1970 到目前时间:1503564157
年: 2017
月: 8
日: 24
时间: 16:42:37

C++ 基本的输入输出

C++ 的 I/O 发生在流中，流是字节序列。如果字节流是从设备（如键盘、磁盘驱动器、网络连接等）流向内存，这叫做输入操作。如果字节流是从内存流向设备（如显示屏、打印机、磁盘驱动器、网络连接等），这叫做输出操作。

I/O 库头文件

下列的头文件在 C++ 编程中很重要。

标准输出流（cout）

预定义的对象 cout 是 iostream 类的一个实例。cout 对象"连接"到标准输出设备，通常是显示屏。cout 是与流插入运算符 << 结合使用的，如下所示：

#include <iostream>using namespace std;int main( )
{char str[] = "Hello C++";cout << "Value of str is : " << str << endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

Value of str is : Hello C++

C++ 编译器根据要输出变量的数据类型，选择合适的流插入运算符来显示值。<< 运算符被重载来输出内置类型（整型、浮点型、double 型、字符串和指针）的数据项。

流插入运算符 << 在一个语句中可以多次使用，如上面实例中所示，endl 用于在行末添加一个换行符。

标准输入流（cin）

预定义的对象 cin 是 iostream 类的一个实例。cin 对象附属到标准输入设备，通常是键盘。cin 是与流提取运算符 >> 结合使用的，如下所示：

#include <iostream>using namespace std;int main( )
{char name[50];cout << "请输入您的名称： ";cin >> name;cout << "您的名称是： " << name << endl;}

当上面的代码被编译和执行时，它会提示用户输入名称。当用户输入一个值，并按回车键，就会看到下列结果：

请输入您的名称： cplusplus
您的名称是： cplusplus

C++ 编译器根据要输入值的数据类型，选择合适的流提取运算符来提取值，并把它存储在给定的变量中。

流提取运算符 >> 在一个语句中可以多次使用，如果要求输入多个数据，可以使用如下语句：

cin >> name >> age;

这相当于下面两个语句：

cin >> name;
cin >> age;

标准错误流（cerr）

预定义的对象 cerr 是 iostream 类的一个实例。cerr 对象附属到标准输出设备，通常也是显示屏，但是 cerr 对象是非缓冲的，且每个流插入到 cerr 都会立即输出。

cerr 也是与流插入运算符 << 结合使用的，如下所示：

#include <iostream>using namespace std;int main( )
{char str[] = "Unable to read....";cerr << "Error message : " << str << endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

Error message : Unable to read....

标准日志流（clog）

预定义的对象 clog 是 iostream 类的一个实例。clog 对象附属到标准输出设备，通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲区，直到缓冲填满或者缓冲区刷新时才会输出。

clog 也是与流插入运算符 << 结合使用的，如下所示：

#include <iostream>using namespace std;int main( )
{char str[] = "Unable to read....";clog << "Error message : " << str << endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

Error message : Unable to read....

通过这些小实例，无法区分 cout、cerr 和 clog 的差异，但在编写和执行大型程序时，它们之间的差异就变得非常明显。所以良好的编程实践告诉我们，使用 cerr 流来显示错误消息，而其他的日志消息则使用 clog 流来输出。

C++ vector 容器

C++ 中的 vector 是一种序列容器，它允许程序在运行时动态地插入和删除元素。

vector 是基于数组的数据结构，但它可以自动管理内存，这意味着你不需要手动分配和释放内存。

与 C++ 数组相比，vector 具有更多的灵活性和功能，使其成为 C++ 中常用的数据结构之一。

vector 是 C++ 标准模板库（STL）的一部分，提供了灵活的接口和高效的操作。

基本特性:

• 动态大小：vector 的大小可以根据需要自动增长和缩小。
• 连续存储：vector 中的元素在内存中是连续存储的，这使得访问元素非常快速。
• 可迭代：vector 可以被迭代，你可以使用循环（如 for 循环）来访问它的元素。
• 元素类型：vector 可以存储任何类型的元素，包括内置类型、对象、指针等。

使用场景：

• 当你需要一个可以动态增长和缩小的数组时。
• 当你需要频繁地在序列的末尾添加或移除元素时。
• 当你需要一个可以高效随机访问元素的容器时。

要使用 vector，首先需要包含 头文件：

#include <vector>

创建 Vector

创建一个 vector 可以像创建其他变量一样简单：

std::vector<int> myVector; // 创建一个存储整数的空 vector

这将创建一个空的整数向量,也可以在创建时指定初始大小和初始值：

std::vector<int> myVector(5); // 创建一个包含 5 个整数的 vector，每个值都为默认值（0）
std::vector<int> myVector(5, 10); // 创建一个包含 5 个整数的 vector，每个值都为 10

或：

std::vector<int> vec; // 默认初始化一个空的 vector
std::vector<int> vec2 = {1, 2, 3, 4}; // 初始化一个包含元素的 vector

添加元素

可以使用 push_back 方法向 vector 中添加元素：

myVector.push_back(7); // 将整数 7 添加到 vector 的末尾

访问元素

可以使用下标操作符 [] 或 at() 方法访问 vector 中的元素：

int x = myVector[0]; // 获取第一个元素
int y = myVector.at(1); // 获取第二个元素

获取大小

可以使用 size() 方法获取 vector 中元素的数量：

int size = myVector.size(); // 获取 vector 中的元素数量

迭代访问

可以使用迭代器遍历 vector 中的元素：

for (auto it = myVector.begin(); it != myVector.end(); ++it) {std::cout << *it << " ";
}

或者使用范围循环：

for (int element : myVector) {std::cout << element << " ";
}

删除元素

可以使用 erase() 方法删除 vector 中的元素：

myVector.erase(myVector.begin() + 2); // 删除第三个元素

清空 Vector

可以使用 clear() 方法清空 vector 中的所有元素：

myVector.clear(); // 清空 vector

以下是一个完整的使用实例，包括创建 vector、添加元素、访问元素以及输出结果的代码：

#include <iostream>
#include <vector>int main() {// 创建一个空的整数向量std::vector<int> myVector;// 添加元素到向量中myVector.push_back(3);myVector.push_back(7);myVector.push_back(11);myVector.push_back(5);// 访问向量中的元素并输出std::cout << "Elements in the vector: ";for (int element : myVector) {std::cout << element << " ";}std::cout << std::endl;// 访问向量中的第一个元素并输出std::cout << "First element: " << myVector[0] << std::endl;// 访问向量中的第二个元素并输出std::cout << "Second element: " << myVector.at(1) << std::endl;// 获取向量的大小并输出std::cout << "Size of the vector: " << myVector.size() << std::endl;// 删除向量中的第三个元素myVector.erase(myVector.begin() + 2);// 输出删除元素后的向量std::cout << "Elements in the vector after erasing: ";for (int element : myVector) {std::cout << element << " ";}std::cout << std::endl;// 清空向量并输出myVector.clear();std::cout << "Size of the vector after clearing: " << myVector.size() << std::endl;return 0;
}

以上代码创建了一个整数向量，向其中添加了几个元素，然后输出了向量的内容、元素的访问、向量的大小等信息，接着删除了向量中的第三个元素，并输出删除元素后的向量。最后清空了向量，并输出清空后的向量大小。

输出结果为：

Elements in the vector: 3 7 11 5 
First element: 3
Second element: 7
Size of the vector: 4
Elements in the vector after erasing: 3 7 5 
Size of the vector after clearing: 0

C++ for 循环

基于范围的for循环(C++11)，for 语句允许简单的范围迭代：

int my_array[5] = {1, 2, 3, 4, 5};
// 每个数组元素乘于 2
for (int &x : my_array)
{x *= 2;cout << x << endl;  
}
// auto 类型也是 C++11 新标准中的，用来自动获取变量的类型
for (auto &x : my_array) {x *= 2;cout << x << endl;  
}

上面for述句的第一部分定义被用来做范围迭代的变量，就像被声明在一般for循环的变量一样，其作用域仅只于循环的范围。而在":"之后的第二区块，代表将被迭代的范围。

#include<iostream>  
#include<string>  
#include<cctype>  
using namespace std;  int main()  
{  string str("some string");  // range for 语句  for(auto &c : str)  {  c = toupper(c);  }  cout << str << endl;  return 0;  
}

上面的程序使用Range for语句遍历一个字符串，并将所有字符全部变为大写，然后输出结果为：

SOME STRING

C++ 类 & 对象

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

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

类用于指定对象的形式，是一种用户自定义的数据类型，它是一种封装了数据和函数的组合。类中的数据称为成员变量，函数称为成员函数。类可以被看作是一种模板，可以用来创建具有相同属性和行为的多个对象。

C++ 类定义

定义一个类需要使用关键字 class，然后指定类的名称，并类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数。

定义一个类，本质上是定义一个数据类型的蓝图，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。

以下实例使用关键字 class 定义 Box 数据类型，包含了三个成员变量 length、breadth 和 height：

class Box
{public:double length;   // 盒子的长度double breadth;  // 盒子的宽度double height;   // 盒子的高度
};

关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。也可以指定类的成员为 private 或 protected。

定义 C++ 对象

类提供了对象的蓝图，所以基本上，对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。下面的语句声明了类 Box 的两个对象：

Box Box1;          // 声明 Box1，类型为 Box
Box Box2;          // 声明 Box2，类型为 Box

对象 Box1 和 Box2 都有它们各自的数据成员。

访问数据成员

类的对象的公共数据成员可以使用直接成员访问运算符.来访问。

#include <iostream>using namespace std;class Box
{public:double length;   // 长度double breadth;  // 宽度double height;   // 高度// 成员函数声明double get(void);void set( double len, double bre, double hei );
};
// 成员函数定义
double Box::get(void)
{return length * breadth * height;
}void Box::set( double len, double bre, double hei)
{length = len;breadth = bre;height = hei;
}
int main( )
{Box Box1;        // 声明 Box1，类型为 BoxBox Box2;        // 声明 Box2，类型为 BoxBox Box3;        // 声明 Box3，类型为 Boxdouble volume = 0.0;     // 用于存储体积// box 1 详述Box1.height = 5.0; Box1.length = 6.0; Box1.breadth = 7.0;// box 2 详述Box2.height = 10.0;Box2.length = 12.0;Box2.breadth = 13.0;// box 1 的体积volume = Box1.height * Box1.length * Box1.breadth;cout << "Box1 的体积：" << volume <<endl;// box 2 的体积volume = Box2.height * Box2.length * Box2.breadth;cout << "Box2 的体积：" << volume <<endl;// box 3 详述Box3.set(16.0, 8.0, 12.0); volume = Box3.get(); cout << "Box3 的体积：" << volume <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Box1 的体积：210
Box2 的体积：1560
Box3 的体积：1536

需要注意的是，私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问。

类 & 对象详解

C++ 类成员函数

类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。

成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。所以可以按照如下方式定义 getVolume() 函数：

class Box
{public:double length;      // 长度double breadth;     // 宽度double height;      // 高度double getVolume(void){return length * breadth * height;}
};

也可以在类的外部使用范围解析运算符 :: 定义该函数，如下所示：

double Box::getVolume(void)
{return length * breadth * height;
}

在 :: 运算符之前必须使用类名。调用成员函数是在对象上使用点运算符（.），这样它就能操作与该对象相关的数据，如下所示：

Box myBox;          // 创建一个对象myBox.getVolume();  // 调用该对象的成员函数

C++ 类访问修饰符

数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问修饰符。

一个类可以有多个 public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。

class Base {public:// 公有成员protected:// 受保护成员private:// 私有成员};

公有（public）成员

公有成员在程序中类的外部是可访问的。可以不使用任何成员函数来设置和获取公有变量的值，如下所示：

#include <iostream>using namespace std;class Line
{public:double length;void setLength( double len );double getLength( void );
};// 成员函数定义
double Line::getLength(void)
{return length ;
}void Line::setLength( double len )
{length = len;
}// 程序的主函数
int main( )
{Line line;// 设置长度line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl;// 不使用成员函数设置长度line.length = 10.0; // OK: 因为 length 是公有的cout << "Length of line : " << line.length <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Length of line : 6
Length of line : 10

私有（private）成员

私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。

默认情况下，类的所有成员都是私有的。

class Box
{double width;public:double length;void setWidth( double wid );double getWidth( void );
};

实际操作中，一般会在私有区域定义数据，在公有区域定义相关的函数，以便在类的外部也可以调用这些函数，

#include <iostream>using namespace std;class Box
{public:double length;void setWidth( double wid );double getWidth( void );private:double width;
};// 成员函数定义
double Box::getWidth(void)
{return width ;
}void Box::setWidth( double wid )
{width = wid;
}// 程序的主函数
int main( )
{Box box;// 不使用成员函数设置长度box.length = 10.0; // OK: 因为 length 是公有的cout << "Length of box : " << box.length <<endl;// 不使用成员函数设置宽度// box.width = 10.0; // Error: 因为 width 是私有的box.setWidth(10.0);  // 使用成员函数设置宽度cout << "Width of box : " << box.getWidth() <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Length of box : 10
Width of box : 10

protected（受保护）成员

protected（受保护）成员变量或函数与私有成员十分相似，但有一点不同，protected（受保护）成员在派生类（即子类）中是可访问的。

#include <iostream>
using namespace std;class Box
{protected:double width;
};class SmallBox:Box // SmallBox 是派生类
{public:void setSmallWidth( double wid );double getSmallWidth( void );
};// 子类的成员函数
double SmallBox::getSmallWidth(void)
{return width ;
}void SmallBox::setSmallWidth( double wid )
{width = wid;
}// 程序的主函数
int main( )
{SmallBox box;// 使用成员函数设置宽度box.setSmallWidth(5.0);cout << "Width of box : "<< box.getSmallWidth() << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Width of box : 5

继承中的特点

有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。

1. public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private

2. protected 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private

3. private 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：private, private, private

但无论哪种继承方式，下面两点都没有改变：

1. private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；

2. rotected 成员可以被派生类访问。

public 继承

#include<iostream>
#include<assert.h>
using namespace std;class A{
public:int a;A(){a1 = 1;a2 = 2;a3 = 3;a = 4;}void fun(){cout << a << endl;    //正确cout << a1 << endl;   //正确cout << a2 << endl;   //正确cout << a3 << endl;   //正确}
public:int a1;
protected:int a2;
private:int a3;
};
class B : public A{
public:int a;B(int i){A();a = i;}void fun(){cout << a << endl;       //正确，public成员cout << a1 << endl;       //正确，基类的public成员，在派生类中仍是public成员。cout << a2 << endl;       //正确，基类的protected成员，在派生类中仍是protected可以被派生类访问。cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。}
};
int main(){B b(10);cout << b.a << endl;cout << b.a1 << endl;   //正确cout << b.a2 << endl;   //错误，类外不能访问protected成员cout << b.a3 << endl;   //错误，类外不能访问private成员system("pause");return 0;
}

protected 继承

#include<iostream>
#include<assert.h>
using namespace std;
class A{
public:int a;A(){a1 = 1;a2 = 2;a3 = 3;a = 4;}void fun(){cout << a << endl;    //正确cout << a1 << endl;   //正确cout << a2 << endl;   //正确cout << a3 << endl;   //正确}
public:int a1;
protected:int a2;
private:int a3;
};
class B : protected A{
public:int a;B(int i){A();a = i;}void fun(){cout << a << endl;       //正确，public成员。cout << a1 << endl;       //正确，基类的public成员，在派生类中变成了protected，可以被派生类访问。cout << a2 << endl;       //正确，基类的protected成员，在派生类中还是protected，可以被派生类访问。cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。}
};
int main(){B b(10);cout << b.a << endl;       //正确。public成员cout << b.a1 << endl;      //错误，protected成员不能在类外访问。cout << b.a2 << endl;      //错误，protected成员不能在类外访问。cout << b.a3 << endl;      //错误，private成员不能在类外访问。system("pause");return 0;
}

private 继承

#include<iostream>
#include<assert.h>
using namespace std;
class A{
public:int a;A(){a1 = 1;a2 = 2;a3 = 3;a = 4;}void fun(){cout << a << endl;    //正确cout << a1 << endl;   //正确cout << a2 << endl;   //正确cout << a3 << endl;   //正确}
public:int a1;
protected:int a2;
private:int a3;
};
class B : private A{
public:int a;B(int i){A();a = i;}void fun(){cout << a << endl;       //正确，public成员。cout << a1 << endl;       //正确，基类public成员,在派生类中变成了private,可以被派生类访问。cout << a2 << endl;       //正确，基类的protected成员，在派生类中变成了private,可以被派生类访问。cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。}
};
int main(){B b(10);cout << b.a << endl;       //正确。public成员cout << b.a1 << endl;      //错误，private成员不能在类外访问。cout << b.a2 << endl;      //错误, private成员不能在类外访问。cout << b.a3 << endl;      //错误，private成员不能在类外访问。system("pause");return 0;
}

C++ 类构造函数 & 析构函数

类的构造函数

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

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。

#include <iostream>using namespace std;class Line
{public:void setLength( double len );double getLength( void );Line();  // 这是构造函数private:double length;
};// 成员函数定义，包括构造函数
Line::Line(void)
{cout << "Object is being created" << endl;
}void Line::setLength( double len )
{length = len;
}double Line::getLength( void )
{return length;
}
// 程序的主函数
int main( )
{Line line;// 设置长度line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Object is being created
Length of line : 6

默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示：

#include <iostream>using namespace std;class Line
{public:void setLength( double len );double getLength( void );Line(double len);  // 这是构造函数private:double length;
};// 成员函数定义，包括构造函数
Line::Line( double len)
{cout << "Object is being created, length = " << len << endl;length = len;
}void Line::setLength( double len )
{length = len;
}double Line::getLength( void )
{return length;
}
// 程序的主函数
int main( )
{Line line(10.0);// 获取默认设置的长度cout << "Length of line : " << line.getLength() <<endl;// 再次设置长度line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Object is being created, length = 10
Length of line : 10
Length of line : 6

使用初始化列表来初始化字段：

Line::Line( double len): length(len)
{cout << "Object is being created, length = " << len << endl;
}

上面的语法等同于如下语法：

Line::Line( double len)
{length = len;cout << "Object is being created, length = " << len << endl;
}

假设有一个类 C，具有多个字段 X、Y、Z 等需要进行初始化，同理地，您可以使用上面的语法，只需要在不同的字段使用逗号进行分隔，如下所示：

C::C( double a, double b, double c): X(a), Y(b), Z(c)
{....
}

类的析构函数

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

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

#include <iostream>using namespace std;class Line
{public:void setLength( double len );double getLength( void );Line();   // 这是构造函数声明~Line();  // 这是析构函数声明private:double length;
};// 成员函数定义，包括构造函数
Line::Line(void)
{cout << "Object is being created" << endl;
}
Line::~Line(void)
{cout << "Object is being deleted" << endl;
}void Line::setLength( double len )
{length = len;
}double Line::getLength( void )
{return length;
}
// 程序的主函数
int main( )
{Line line;// 设置长度line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Object is being created
Length of line : 6
Object is being deleted

C++ 拷贝构造函数

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

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

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

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

如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下：

classname (const classname &obj) {// 构造函数的主体
}

在这里，obj 是一个对象引用，该对象是用于初始化另一个对象的。

#include <iostream>using namespace std;class Line
{public:int getLength( void );Line( int len );             // 简单的构造函数Line( const Line &obj);      // 拷贝构造函数~Line();                     // 析构函数private:int *ptr;
};// 成员函数定义，包括构造函数
Line::Line(int len)
{cout << "调用构造函数" << endl;// 为指针分配内存ptr = new int;*ptr = len;
}Line::Line(const Line &obj)
{cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;ptr = new int;*ptr = *obj.ptr; // 拷贝值
}Line::~Line(void)
{cout << "释放内存" << endl;delete ptr;
}
int Line::getLength( void )
{return *ptr;
}void display(Line obj)
{cout << "line 大小 : " << obj.getLength() <<endl;
}// 程序的主函数
int main( )
{Line line(10);display(line);return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

调用构造函数
调用拷贝构造函数并为指针 ptr 分配内存
line 大小 : 10
释放内存
释放内存

通过使用已有的同类型的对象来初始化新创建的对象：

#include <iostream>using namespace std;class Line
{public:int getLength( void );Line( int len );             // 简单的构造函数Line( const Line &obj);      // 拷贝构造函数~Line();                     // 析构函数private:int *ptr;
};// 成员函数定义，包括构造函数
Line::Line(int len)
{cout << "调用构造函数" << endl;// 为指针分配内存ptr = new int;*ptr = len;
}Line::Line(const Line &obj)
{cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;ptr = new int;*ptr = *obj.ptr; // 拷贝值
}Line::~Line(void)
{cout << "释放内存" << endl;delete ptr;
}
int Line::getLength( void )
{return *ptr;
}void display(Line obj)
{cout << "line 大小 : " << obj.getLength() <<endl;
}// 程序的主函数
int main( )
{Line line1(10);Line line2 = line1; // 这里也调用了拷贝构造函数display(line1);display(line2);return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

调用构造函数
调用拷贝构造函数并为指针 ptr 分配内存
调用拷贝构造函数并为指针 ptr 分配内存
line 大小 : 10
释放内存
调用拷贝构造函数并为指针 ptr 分配内存
line 大小 : 10
释放内存
释放内存
释放内存

C++ 友元函数

类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

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

如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend，如下所示：

class Box
{double width;
public:double length;friend void printWidth( Box box );void setWidth( double wid );
};

声明类 ClassTwo 的所有成员函数作为类 ClassOne 的友元，需要在类 ClassOne 的定义中放置如下声明：

friend class ClassTwo;

实例：

#include <iostream>using namespace std;class Box
{double width;
public:friend void printWidth( Box box );void setWidth( double wid );
};// 成员函数定义
void Box::setWidth( double wid )
{width = wid;
}// 请注意：printWidth() 不是任何类的成员函数
void printWidth( Box box )
{/* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */cout << "Width of box : " << box.width <<endl;
}// 程序的主函数
int main( )
{Box box;// 使用成员函数设置宽度box.setWidth(10.0);// 使用友元函数输出宽度printWidth( box );return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Width of box : 10

添加友元类的使用：

#include <iostream>using namespace std;class Box
{double width;
public:friend void printWidth(Box box);friend class BigBox;void setWidth(double wid);
};class BigBox
{
public :void Print(int width, Box &box){// BigBox是Box的友元类，它可以直接访问Box类的任何成员box.setWidth(width);cout << "Width of box : " << box.width << endl;}
};// 成员函数定义
void Box::setWidth(double wid)
{width = wid;
}// 请注意：printWidth() 不是任何类的成员函数
void printWidth(Box box)
{/* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */cout << "Width of box : " << box.width << endl;
}// 程序的主函数
int main()
{Box box;BigBox big;// 使用成员函数设置宽度box.setWidth(10.0);// 使用友元函数输出宽度printWidth(box);// 使用友元类中的方法设置宽度big.Print(20, box);getchar();return 0;
}

C++ 内联函数

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

对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。

如果想把一个函数定义为内联函数，则需要在函数名前面放置关键字 inline，在调用函数之前需要对函数进行定义。如果已定义的函数多于一行，编译器会忽略 inline 限定符。

在类定义中的定义的函数都是内联函数，即使没有使用 inline 说明符。

内联函数inline：引入内联函数的目的是为了解决程序中函数调用的效率问题，程序在编译器编译的时候，编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换，而对于其他的函数，都是在运行时候才被替代。这其实就是个空间代价换时间的i节省。所以内联函数一般都是1-5行的小函数。在使用内联函数时要留神：

1. 在内联函数内不允许使用循环语句和开关语句；
2. 内联函数的定义必须出现在内联函数第一次调用之前；
3. 类结构中所在的类说明内部定义的函数是内联函数。

C++ this 指针

在 C++ 中，this 指针是一个特殊的指针，它指向当前对象的实例。

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

this是一个隐藏的指针，可以在类的成员函数中使用，它可以用来指向调用对象。

当一个对象的成员函数被调用时，编译器会隐式地传递该对象的地址作为 this 指针。

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

#include <iostream>class MyClass {
private:int value;public:void setValue(int value) {this->value = value;}void printValue() {std::cout << "Value: " << this->value << std::endl;}
};int main() {MyClass obj;obj.setValue(42);obj.printValue();return 0;
}

以上代码执行输出结果为：

Value: 42

C++ 指向类的指针

一个指向 C++ 类的指针与指向结构的指针类似，访问指向类的指针的成员，需要使用成员访问运算符 ->，就像访问指向结构的指针一样。

#include <iostream>class MyClass {
public:int data;void display() {std::cout << "Data: " << data << std::endl;}
};int main() {// 创建类对象MyClass obj;obj.data = 42;// 声明和初始化指向类的指针MyClass *ptr = &obj;// 通过指针访问成员变量std::cout << "Data via pointer: " << ptr->data << std::endl;// 通过指针调用成员函数ptr->display();return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Data via pointer: 42
Data: 42

指向类的指针还可以用于动态分配内存，创建类的对象：

#include <iostream>class MyClass {
public:int data;void display() {std::cout << "Data: " << data << std::endl;}
};int main() {// 动态分配内存创建类对象MyClass *ptr = new MyClass;ptr->data = 42;// 通过指针调用成员函数ptr->display();// 释放动态分配的内存delete ptr;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Data: 42

指向类的指针可以作为函数参数传递：

#include <iostream>class MyClass {
public:int data;void display() {std::cout << "Data: " << data << std::endl;}
};// 函数接受指向类的指针作为参数
void processObject(MyClass *ptr) {ptr->display();
}int main() {MyClass obj;obj.data = 42;// 将指向类的指针传递给函数processObject(&obj);return 0;
}

C++ 类的静态成员

可以使用 static 关键字来把类成员定义为静态的。当声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。

静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句，在创建第一个对象时，所有的静态数据都会被初始化为零。不能把静态成员的初始化放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化，如下面的实例所示。

#include <iostream>using namespace std;class Box
{public:static int objectCount;// 构造函数定义Box(double l=2.0, double b=2.0, double h=2.0){cout <<"Constructor called." << endl;length = l;breadth = b;height = h;// 每次创建对象时增加 1objectCount++;}double Volume(){return length * breadth * height;}private:double length;     // 长度double breadth;    // 宽度double height;     // 高度
};// 初始化类 Box 的静态成员
int Box::objectCount = 0;int main(void)
{Box Box1(3.3, 1.2, 1.5);    // 声明 box1Box Box2(8.5, 6.0, 2.0);    // 声明 box2// 输出对象的总数cout << "Total objects: " << Box::objectCount << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Constructor called.
Constructor called.
Total objects: 2

如果把函数成员声明为静态的，就可以把函数与类的任何特定对象独立开来。静态成员函数即使在类对象不存在的情况下也能被调用，静态函数只要使用类名加范围解析运算符 :: 就可以访问。

静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。

静态成员函数有一个类范围，他们不能访问类的 this 指针。您可以使用静态成员函数来判断类的某些对象是否已被创建。

静态成员函数与普通成员函数的区别：

• 静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。
• 普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针。

#include <iostream>using namespace std;class Box
{public:static int objectCount;// 构造函数定义Box(double l=2.0, double b=2.0, double h=2.0){cout <<"Constructor called." << endl;length = l;breadth = b;height = h;// 每次创建对象时增加 1objectCount++;}double Volume(){return length * breadth * height;}static int getCount(){return objectCount;}private:double length;     // 长度double breadth;    // 宽度double height;     // 高度
};// 初始化类 Box 的静态成员
int Box::objectCount = 0;int main(void)
{// 在创建对象之前输出对象的总数cout << "Inital Stage Count: " << Box::getCount() << endl;Box Box1(3.3, 1.2, 1.5);    // 声明 box1Box Box2(8.5, 6.0, 2.0);    // 声明 box2// 在创建对象之后输出对象的总数cout << "Final Stage Count: " << Box::getCount() << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Inital Stage Count: 0
Constructor called.
Constructor called.
Final Stage Count: 2

C++ 继承

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。

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

// 基类
class Animal {// eat() 函数// sleep() 函数
};//派生类
class Dog : public Animal {// bark() 函数
};

基类 & 派生类

一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

class derived-class: access-specifier base-class

其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。

假设有一个基类 Shape，Rectangle 是它的派生类，如下所示：

#include <iostream>using namespace std;// 基类
class Shape 
{public:void setWidth(int w){width = w;}void setHeight(int h){height = h;}protected:int width;int height;
};// 派生类
class Rectangle: public Shape
{public:int getArea(){ return (width * height); }
};int main(void)
{Rectangle Rect;Rect.setWidth(5);Rect.setHeight(7);// 输出对象的面积cout << "Total area: " << Rect.getArea() << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Total area: 35

访问控制和继承

派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。

一个派生类继承了所有的基类方法，但下列情况除外：

• 基类的构造函数、析构函数和拷贝构造函数。
• 基类的重载运算符。
• 基类的友元函数。

继承类型

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。

几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

• 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
• 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
• 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

多继承

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

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

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

访问修饰符继承方式是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔，

#include <iostream>using namespace std;// 基类 Shape
class Shape 
{public:void setWidth(int w){width = w;}void setHeight(int h){height = h;}protected:int width;int height;
};// 基类 PaintCost
class PaintCost 
{public:int getCost(int area){return area * 70;}
};// 派生类
class Rectangle: public Shape, public PaintCost
{public:int getArea(){ return (width * height); }
};int main(void)
{Rectangle Rect;int area;Rect.setWidth(5);Rect.setHeight(7);area = Rect.getArea();// 输出对象的面积cout << "Total area: " << Rect.getArea() << endl;// 输出总花费cout << "Total paint cost: $" << Rect.getCost(area) << endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Total area: 35
Total paint cost: $2450

C++ 重载运算符和重载函数

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。

重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。

当调用一个重载函数或重载运算符时，编译器通过把所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。

C++ 中的函数重载

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

#include <iostream>
using namespace std;class printData
{public:void print(int i) {cout << "整数为: " << i << endl;}void print(double  f) {cout << "浮点数为: " << f << endl;}void print(char c[]) {cout << "字符串为: " << c << endl;}
};int main(void)
{printData pd;// 输出整数pd.print(5);// 输出浮点数pd.print(500.263);// 输出字符串char c[] = "Hello C++";pd.print(c);return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

整数为: 5
浮点数为: 500.263
字符串为: Hello C++

C++ 中的运算符重载

重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。

Box operator+(const Box&);

声明加法运算符用于把两个 Box 对象相加，返回最终的 Box 对象。大多数的重载运算符可被定义为普通的非成员函数或者被定义为类成员函数。如果定义上面的函数为类的非成员函数，那么需要为每次操作传递两个参数，如下所示：

Box operator+(const Box&, const Box&);

实例：

#include <iostream>
using namespace std;class Box
{public:double getVolume(void){return length * breadth * height;}void setLength( double len ){length = len;}void setBreadth( double bre ){breadth = bre;}void setHeight( double hei ){height = hei;}// 重载 + 运算符，用于把两个 Box 对象相加Box operator+(const Box& b){Box box;box.length = this->length + b.length;box.breadth = this->breadth + b.breadth;box.height = this->height + b.height;return box;}private:double length;      // 长度double breadth;     // 宽度double height;      // 高度
};
// 程序的主函数
int main( )
{Box Box1;                // 声明 Box1，类型为 BoxBox Box2;                // 声明 Box2，类型为 BoxBox Box3;                // 声明 Box3，类型为 Boxdouble volume = 0.0;     // 把体积存储在该变量中// Box1 详述Box1.setLength(6.0); Box1.setBreadth(7.0); Box1.setHeight(5.0);// Box2 详述Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0);// Box1 的体积volume = Box1.getVolume();cout << "Volume of Box1 : " << volume <<endl;// Box2 的体积volume = Box2.getVolume();cout << "Volume of Box2 : " << volume <<endl;// 把两个对象相加，得到 Box3Box3 = Box1 + Box2;// Box3 的体积volume = Box3.getVolume();cout << "Volume of Box3 : " << volume <<endl;return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

可重载运算符/不可重载运算符

下面是可重载的运算符列表：

下面是不可重载的运算符列表：

1. .：成员访问运算符
2. .*, ->*：成员指针访问运算符
3. ::：域运算符
4. sizeof：长度运算符
5. ?:：条件运算符
6. #： 预处理符号