C++ Cheat Sheet 速查表

语法

#include <iostream>
using namespace std;

int main() {
    cout << "Hello World!";
    return 0;
}

在编写 C++ 代码时，请务必在每行末尾添加分号以指定该行的结束。你还必须添加结束括号来结束主函数，否则在编译代码时会出现错误。

• 第1行： #include <iostream> 指定了 头文件库，它帮助你处理输入和输出对象，如 cout。头文件用于为 C++ 程序添加特定功能。
• 第2行： using namespace std 允许你使用标准库中的对象和变量名称。
• 第3行： 空行。C++ 忽略代码中的空格。
• 第4行： int main()，这是一个函数。大括号 {} 内的任何代码都会被执行。
• 第5行： cout 是一个对象，与插入操作符 (<<) 一起使用来打印输出文本。
• 第6行： return 0 用于结束主函数。

注释

在 C++ 中，编译器会忽略注释后的文本。C++ 支持两种不同类型的注释：

//: 指定单行注释。

/* ….*/: 指定多行注释。

数据类型

数据类型指定数据变量的类型。编译器根据数据类型分配内存。以下是 C++ 的数据类型：

• 内置或原始数据类型： 预定义的数据类型，可以直接使用，包括整数、字符、布尔、浮点、双精度浮点、无值或 void 以及宽字符。
• 派生数据类型： 从原始数据类型派生：函数、数组、指针和引用。
• 用户定义数据类型： 由用户定义：类、结构、联合、枚举和类型定义（Typedef）。

变量

变量存储数据值。C++ 支持各种类型的变量，如 int、double、string、char 和 float。

例如：

int num = 12; // 整数
string name = "Unity Buddy"; // 字符串（文本）
char ch = 'U'; // 字符
float fl = 5.99; // 浮点数

变量名可以使用字母、数字和下划线。然而，变量不能以数字或下划线字符‘_’开头。相反，它们以字母开头，后跟数字或下划线字符。此外，你不能使用关键字作为变量名。

变量作用域

在 C++ 中，你可以在程序的三个部分中声明变量，也称为变量的作用域：

1. 局部变量

这些变量在函数或代码块中声明。它们的作用域仅限于该函数或代码块，不能被该块外的任何语句访问。

例如：

#include <iostream>
using namespace std;

int main () {
    // 局部变量:
    int a, b;
    int c;

    // 初始化
    a = 10;
    b = 20;
    c = a + b;

    cout << c;

    return 0;
}

2. 全局变量

全局变量可由程序的任何函数、方法或块访问。通常，它定义在所有函数之外。全局变量的值在整个程序中是相同的。

例如：

#include <iostream>
using namespace std;

// 全局变量:
int g;

int main () {
    // 局部变量:
    int a, b;

    // 初始化
    a = 10;
    b = 20;
    g = a + b;

    cout << g;

    return 0;
}

数据类型修饰符

数据类型修饰符用于修改数据类型的最大数据长度。下表将帮助你理解内置数据类型与修饰符结合时的大小和范围。C++ 中有四种不同类型的修饰符，即 signed、unsigned、short 和 long。

数据类型	大小（字节）	范围
short int	2	-32,768 to 32,767
unsigned short int	2	0 to 65,535
unsigned int	4	0 to 4,294,967,295
int	4	-2,147,483,648 to 2,147,483,647
long int	4	-2,147,483,648 to 2,147,483,647
unsigned long int	4	0 to 4,294,967,295
long long int	8	-(2^63) to (2^63)-1
unsigned long long int	8	0 to 18,446,744,073,709,551,615
signed char	1	-128 to 127
unsigned char	1	0 to 255
float	4
double	8
long double	12
wchar_t	2 或 4	1 宽字符

字面值

C++ 中的字面值是用于表示固定值的数据。你可以直接在代码中使用它们。

例如，1、2.5、“s”等。

C++ 中有不同类型的字面值，解释如下：

1. 整数字面值

整数字面值是数字，不包含任何小数或指数部分。

例如：

十进制（基数 10）：0、-9、22 等。

八进制（基数 8）：021、077、033 等。

十六进制（基数 16）：0x7f、0x2a、0x521 等。

2. 浮点字面值

这些是包含小数部分或指数部分的数字字面值。

例如：(-2.0、0.8589、-0.26E-5)。

3. 字符字面值

这些是用单引号括起来的单个字符。

例如：‘a’、‘F’、‘2’等。

4. 转义序列

你可以在 C++ 中使用转义序列来表示具有特殊含义的字符。

例如：

转义序列	字符
\b	退格
\f	换页
\n	换行
\r	回车
\t	水平制表符
\v	垂直制表符
\	反斜杠
’	单引号
"	双引号
?	问号
\0	空字符

5. 字符串字面值

这是用双引号括起来的字符序列。

例如：

“good”	字符串常量
“”	空字符串常量
" "	包含六个空格的字符串常量
“x”	包含单个字符的字符串常量
“Earth is round\n”	打印带有换行符的字符串

常量

要创建一个不希望改变值的变量，可以使用“const”关键字。

例如：

const int LIGHT_SPEED = 2997928;
LIGHT_SPEED = 2500; // 不能更改值

数学函数

C++ 提供了多种函数，允许你执行数学任务。下表突出了 C++ 中所有基本的数学函数：

函数	描述
abs(x)	返回 x 的绝对值
acos(x)	返回 x 的反余弦值
asin(x)	返回 x 的反正弦值
atan(x)	返回 x 的反正切值
cbrt(x)	返回 x 的立方根
ceil(x)	返回向上舍入到最近整数的 x 的值
cos(x)	返回 x 的余弦值
cosh(x)	返回 x 的双曲余弦值
exp(x)	返回 e^x 的值
expm1(x)	返回 e^x - 1
fabs(x)	返回浮点数 x 的绝对值
fdim(x, y)	返回 x 和 y 之间的正差
floor(x)	返回向下舍入到最近整数的 x 的值
hypot(x, y)	返回 sqrt(x^2 + y^2)，没有中间溢出或下溢
fma(x, y, z)	返回 x*y+z，不丢失精度
fmax(x, y)	返回浮点数 x 和 y 中的最大值
fmin(x, y)	返回浮点数 x 和 y 中的最小值
fmod(x, y)	返回 x/y 的浮点余数
pow(x, y)	返回 x 的 y 次幂
sin(x)	返回 x 的正弦值（x 为弧度）
sinh(x)	返回双曲正弦值
tan(x)	返回角度的正切值
tanh(x)	返回双曲正切值

用户输入

C++ 支持使用“cout”和“cin”分别显示输出和接收用户输入。cout 使用插入运算符 (<<)，而 cin 使用 (>>)。

例如：

int x; // 声明变量
cout << "Type a number: "; // 输入任意数字并按回车键
cin >> x; // 从键盘获取用户输入
cout << "Your number is: " << x; // 显示输入的值

字符串

字符串是用双引号括起来的字符集合或序列。

例如：

string str = "Hello";

要在代码中使用字符串，必须使用以下代码行包含字符串库：

#include <string>

然后，C++ 允许你执行各种函数来操作字符串。下表描述了函数名称及其描述：

函数	描述
int compare(const string& str)	比较两个字符串对象
int length()	查找字符串的长度
void swap(string& str)	交换两个字符串对象的值
string substr(int pos, int n)	创建一个新字符串对象，包含 n 个字符
int size()	返回字符串的字节长度
void resize(int n)	将字符串的长度调整为最多 n 个字符
string& replace(int pos, int len, string& str)	替换从位置 pos 开始并跨越 len 个字符的字符串部分
string& append(const string& str)	在另一个字符串对象的末尾添加一个新字符
char& at(int pos)	访问指定位置 pos 的单个字符
int find(string& str, int pos, int n)	查找参数中指定的字符串
int find_first_of(string& str, int pos, int n)	查找指定序列的第一个出现
int find_first_not_of(string& str, int pos, int n )	查找字符串中第一个不匹配任何指定字符的字符
int find_last_of(string& str, int pos, int n)	查找指定序列的最后一个字符
int find_last_not_of(string& str, int pos)	查找最后一个不匹配指定序列的字符
string& insert()	在由位置 pos 指示的字符之前插入新字符
int max_size()	查找字符串的最大长度
void push_back(char ch)	在字符串末尾添加新字符 ch
void pop_back()	移除字符串的最后一个字符
string& assign()	为字符串分配新值
int copy(string& str)	将字符串内容复制到另一个字符串
void clear()	从字符串中移除所有元素
const_reverse_iterator crbegin()	指向字符串的最后一个字符
const_char* data()	将字符串的字符复制到数组
bool empty()	检查字符串是否为空
string& erase()	删除指定的字符
char& front()	返回第一个字符的引用
string& operator+=()	在字符串末尾追加一个新字符
string& operator=()	为字符串分配新值
char operator	检索指定位置 pos 的字符
int rfind()	查找字符串的最后一次出现
iterator end()	引用字符串的最后一个字符
reverse_iterator rend()	指向字符串的第一个字符
void shrink_to_fit()	减少容量并使其等于字符串的大小
char* c_str()	返回指向包含以 null 结尾的字符序列的数组的指针
void reserve(inr len)	请求更改容量
allocator_type get_allocator();	返回与字符串关联的分配对象

运算符

C++ 支持不同类型的运算符，以向代码添加逻辑并对变量及其相应值执行操作。以下是 C++ 运算符类型：

1. 算术运算符

你可以使用算术运算符执行常见的数学运算。

运算符	名称	示例
+	加法	x + y
-	减法	x - y
*	乘法	x * y
/	除法	x / y
%	取余	x % y
++	自增	++x
–	自减	–x

2. 赋值运算符

你可以使用赋值运算符为变量赋值。

运算符	示例	描述	等同于
=	x = 5	为变量赋值	x = 5
+=	x += 3	将值 3 添加到 x 的值	x = x + 3
-=	x -= 3	将值 3 从 x 的值中减去	x = x - 3
*=	x *= 3	将值 3 与 x 的值相乘	x = x * 3
/=	x /= 3	将 x 的值除以 3	x = x / 3
%=	x %= 3	返回 x 除以 3 的余数	x = x % 3
&=	x &= 3	x = x & 3
|=	x |= 3	x = x | 3
^=	x ^= 3	x = x ^ 3
>>=	x >>= 3	x = x >> 3
<<=	x <<= 3	x = x << 3

3. 比较运算符

你可以使用这些运算符比较两个值，以返回 true 或 false。它将返回 true 如果两个值匹配，否则返回 false。

运算符	名称	示例
==	等于	x == y
!=	不等于	x != y
>	大于	x > y
<	小于	x < y
>=	大于等于	x >= y
<=	小于等于	x <= y

4. 逻辑运算符

这些运算符决定变量之间的逻辑。

运算符	名称	描述	示例
&&	逻辑与	如果两个语句都为真，则返回 true	x < 5 && x < 10
||	逻辑或	如果其中一个语句为真，则返回 true	x < 5 || x < 4
!	逻辑非	反转结果，如果结果为真，则返回 false	!(x < 5 && x < 10)

决策语句

C++ 中的决策语句决定程序执行的流程。在这里，程序员指定多个条件。如果条件成立，则执行该块中的语句。否则，执行其他块中的语句。

C++ 有各种决策指令：

• If 语句
• if…else 语句
• Switch 语句
• 嵌套 if 语句
• 嵌套 switch 语句
• 三元运算符

1. If 语句

这是最基本的决策语句类型。它指示编译器仅在条件成立时执行代码

块。

语法：

if (expression) {
    // 代码
}

示例：

#include <iostream>
using namespace std;

int main () {
    int b = 10;
    if( b < 20 ) {
        cout << "b is less than 20;" << endl;
    }
    cout << "value of a is : " << b << endl;

    return 0;
}

2. If…Else 语句

这是‘if’语句的扩展。它指示编译器仅在指定条件为真时执行‘if’块。否则，它执行‘else’块。

语法：

if (expression) {
    // 代码
} else {
    // 代码
}

示例：

#include <iostream>
using namespace std;

int main () {
    int b = 10;
    if( b < 20 ) {
        cout << "b is less than 20;" << endl;
    }
    cout << "value of a is : " << b << endl;

    return 0;
}

3. Switch 语句

当你需要对各种值执行条件时，可以使用 switch 语句。

语法：

switch(expression) {
    case constant-expression :
        statement(s);
        break; // 可选
    case constant-expression :
        statement(s);
        break; // 可选

    default : // 可选
        statement(s);
}

示例：

#include <iostream>
using namespace std;

int main () {
    // 局部变量声明:
    char grade = 'D';

    switch(grade) {
        case 'A' :
            cout << "Outstanding!" << endl;
            break;
        case 'B' :
        case 'C' :
            cout << "Well done" << endl;
            break;
        case 'D' :
            cout << "Pass" << endl;
            break;
        case 'F' :
            cout << "Try again" << endl;
            break;
        default :
            cout << "Invalid grade" << endl;
    }
    cout << "Your grade is " << grade << endl;

    return 0;
}

4. 嵌套 If 语句

这是一个“if”语句在另一个“if”语句中。需要基于另一个条件的结果来判断特定条件时，可以使用这种语句。

语法：

if( boolean_expression 1) {
    // 当布尔表达式 1 为真时执行
    if(boolean_expression 2) {
        // 当布尔表达式 2 为真时执行
    }
}

示例：

#include <iostream>
using namespace std;

int main () {
    // 局部变量声明:
    int x = 100;
    int y = 200;

    if( x == 100 ) {
        if( y == 200 ) {
            cout << "Value of x is 100 and y is 200" << endl;
        }
    }
    cout << "Exact value of x is : " << x << endl;
    cout << "Exact value of y is : " << y << endl;

    return 0;
}

5. 嵌套 Switch 语句

你可以在一个 switch 语句中包含另一个 switch 语句。

语法：

switch(ch1) {
    case 'A':
        cout << "This A is part of outer switch";
        switch(ch2) {
            case 'A':
                cout << "This A is part of inner switch";
                break;
            case 'B': 
                // ...
        }
        break;
    case 'B': 
        // ...
}

示例：

#include <iostream>
using namespace std;

int main () {
    int x = 100;
    int y = 200;

    switch(x) {
        case 100:
            cout << "This is part of outer switch" << endl;
            switch(y) {
                case 200:
                    cout << "This is part of inner switch" << endl;
            }
    }
    cout << "Exact value of x is : " << x << endl;
    cout << "Exact value of y is : " << y << endl;

    return 0;
}

6. 三元运算符

Exp1 ? Exp2 : Exp3;

首先，评估表达式 Exp1。如果为真，则评估 Exp2，并成为整个‘?’表达式的值。如果 Exp1 为假，则评估 Exp3，并且其值成为表达式的值。

循环

循环用于基于评估条件的结果，执行特定次数的一组命令。C++ 包括以下循环：

• While 循环
• Do-while 循环
• For 循环
• Break 语句
• Continue 语句

1. While 循环

只要指定条件为真，循环将继续。

while (condition) {
    // 代码
}

2. Do-While 循环

当条件变为假时，do-while 循环停止执行。然而，while 和 do-while 循环之间的唯一区别在于，do-while 循环在执行循环后测试条件。因此，循环至少执行一次。

do {
    // 代码
} while (condition);

3. For 循环

你可以使用 for 循环多次执行代码块。这个循环运行代码块，直到其中指定的条件为假。

for (int a=0; i< count; i++) {
    // 代码
}

4. Break 语句

这用于打断代码流，使剩余代码不被执行。这会将你带出循环。

例如：

for (int i = 0; i < 10; i++) {
    if (i == 4) {
        break;
    }
    cout << i << "\n";
}

5. Continue 语句

此语句将中断代码流并将你带到条件的评估处。随后，它重新开始代码执行。

例如：

for (int i = 0; i < 10; i++) {
    if (i == 4) {
        continue;
    }
    cout << i << "\n";
}

数组

数组是派生数据类型，存储相同类型的多个数据项于连续的内存位置中。

例如：

string vehicles [4]; // 声明数组以存储最多 4 个变量。
string vehicles[4]= {"car", "scooter", "cycle", "bike"}; // 初始化数组

1. 访问数组值

需要使用索引号访问存储在数组中的元素。

string vehicles[4]= {"car", "scooter", "cycle", "bike"};
cout << vehicles [0];

2. 更改数组元素

可以使用索引号更改存储在数组中的元素。

string vehicles[4]= {"car", "scooter", "cycle", "bike"};
vehicles [0]= "airplane";
cout << vehicles[0];

函数

函数是一组用于执行特定任务的指令。每个 C++ 程序中常见的函数是 main() 函数。你甚至可以将复杂代码分解为多个小函数并分别执行它们。

为此，你需要声明、定义和调用该函数。C++ 有几个内置函数，可以直接在任何程序中调用。

定义函数

以下是 C++ 中定义函数的语法：

return_type function_name( parameter list ) {
    // 函数体
}

其中：

• return_type 指定该函数返回值的类型。
• function_name 指定函数名称，并且需要唯一。
• parameter list 允许你将多个值传递给函数及其数据类型。
• 函数体 指定完成任务的一组指令。

例如：

int max(int num1, int num2) { 
    // 声明函数 max
    int result;

    if (num1 > num2)
        result = num1;
    else
        result = num2;

    return result;
}

调用函数

你必须在程序中需要的地方调用函数。

例如：

#include <iostream>
using namespace std;

// 函数声明
int max(int num1, int num2);

int main () {
    int a = 100;
    int b = 200;
    int ret;

    ret = max(a, b);
    cout << "Max value is : " << ret << endl;

    return 0;
}

函数参数

你可以通过三种方式传递参数：

• 值传递： 将参数的实际值传递到函数的形式参数中。它不会对函数内的参数做任何更改，也不会影响参数。
• 指针传递： 可以将参数地址复制到形式参数中。这里，地址访问调用中使用的实际参数。这意味着对参数所做的更改会影响参数。
• 引用传递： 可以将参数引用复制到形式参数中。引用访问调用

中使用的实际参数。这意味着对参数所做的更改会影响参数。

存储类

存储类定义变量和函数的可见性。C++ 支持各种存储类，如 auto、register、extern、static 和 mutable。

1. Auto 存储类

默认情况下，C++ 为所有变量使用此存储类。

例如：

{
    int var;
    auto int var1;
}

你只能在函数内使用“auto”来定义局部变量。

2. Register 存储类

此存储类定义在寄存器中而不是在 RAM 中存储的局部变量。当你希望频繁访问变量（如计数器）时，这很有用。变量的大小最大等于寄存器的大小。

例如：

{
    register int miles;
}

3. Static 存储类

静态存储类告诉编译器在整个程序中维护局部变量，而无需在其作用域内创建和销毁它们。定义变量为 static 意味着它将在函数调用之间保持其值。

全局变量是静态的，这意味着它们的作用域将限制在其声明的文件中。如果将类的数据成员指定为 static，它将只创建该成员的一个副本，供其类的所有对象共享。

例如：

#include <iostream>

// 函数声明
void func1(void);

static int count = 10; /* 全局变量 */

main() {
    while(count--) {
        func();
    }

    return 0;
}

// 函数定义
void func1( void ) {
    static int i = 5; // 局部静态变量
    i++;
    std::cout << "i is " << i ;
    std::cout << " and count is " << count << std::endl;
}

Extern 存储类

extern 存储类提供全局变量的引用，并使其对所有程序文件可见。当你将变量指定为‘extern’时，不能对变量进行初始化，因为它将变量名指向先前定义的存储位置。

在多文件情况下，如果你定义了一个全局变量或函数，还需要在其他文件中使用，extern 将在另一个文件中提供定义变量或函数的引用。必须在需要在两个或多个文件之间共享相同的全局变量或函数时使用 extern 修饰符。

例如：

程序 1

#include <iostream>
int count ;
extern void write_extern();

main() {
    count = 5;
    write_extern();
}

程序 2

#include <iostream>

extern int count;

void write_extern(void) {
    std::cout << "Count is " << count << std::endl;
}

Mutable 存储类

如果希望对象成员覆盖成员函数，可以使用此存储类。也就是说，一个 mutable 成员可以由 const 成员函数修改。

结构

结构允许你定义不同类型的数据项。要使用结构，必须定义它并访问其结构成员。

以下是创建结构的语法：

struct [结构标签] {
    成员定义;
    成员定义;
    ...
    成员定义;
} [一个或多个结构变量];

例如，我们要创建一本书的结构，包括标题、作者、主题和书籍编号，如下所示：

struct Books {
    char title[50];
    char author[50];
    char subject[100];
    int book_id;
} book;

必须使用成员访问运算符 (.) 访问结构成员。这是结构变量名与我们希望访问的结构成员之间的点。

访问结构成员

#include <iostream>
#include <cstring>

using namespace std;

struct Books {
    char title[50];
    char author[50];
    char subject[100];
    int book_id;
};

int main() {
    struct Books Book1; // 声明 Book1 类型为 Books
    struct Books Book2; // 声明 Book2 类型为 Books

    // 书籍 1 规格
    strcpy( Book1.title, "Learn C++ Programming");
    strcpy( Book1.author, "Chand Miyan");
    strcpy( Book1.subject, "C++ Programming");
    Book1.book_id = 6495407;

    // 书籍 2 规格
    strcpy( Book2.title, "Telecom Billing");
    strcpy( Book2.author, "Yakit Singha");
    strcpy( Book2.subject, "Telecom");
    Book2.book_id = 6495700;

    // 打印 Book1 信息
    cout << "Book 1 title : " << Book1.title <<endl;
    cout << "Book 1 author : " << Book1.author <<endl;
    cout << "Book 1 subject : " << Book1.subject <<endl;
    cout << "Book 1 id : " << Book1.book_id <<endl;

    // 打印 Book2 信息
    cout << "Book 2 title : " << Book2.title <<endl;
    cout << "Book 2 author : " << Book2.author <<endl;
    cout << "Book 2 subject : " << Book2.subject <<endl;
    cout << "Book 2 id : " << Book2.book_id <<endl;

    return 0;
}

引用

当你将变量声明为引用时，它充当现有变量的替代。你需要用“&”指定引用变量，如下所示：

string food = "Pizza";
string &meal = food; // food 的引用

指针

C++ 中的指针是存储另一个变量内存地址的变量。与常规变量类似，指针也有数据类型。我们使用‘*’来声明 C++ 中的指针。

例如：

string food = "Pizza"; // 字符串变量

cout << food; // 输出 food 的值 (Pizza)
cout << &food; // 输出 food 的内存地址 (0x6dfed4)

类和对象

C++ 是一种面向对象编程语言，具有类和对象。类是用户定义的数据类型，可以用于将数据成员和成员函数绑定在一起。可以通过创建该类的实例来访问它们。

创建类

以下是如何在 C++ 中创建类：

class MyClass { // 类
public: // 访问说明符 - 对所有人可访问
    int myNum; // 属性 (int 变量)
    string myString; // 属性 (字符串变量)
};

创建对象

对象作为类的实例，允许你访问其成员、函数和变量。必须使用点 (.) 运算符，如下所示：

class MyClass {
public:
    int myNum;
    string myString;
};

int main() {
    MyClass myObj; // 创建 MyClass 的对象

    myObj.myNum = 15;
    myObj.myString = "Some text";

    // 打印属性值
    cout << myObj.myNum << "\n";
    cout << myObj.myString;
    return 0;
}

创建多个对象

以下是如何创建同一类的多个对象的示例：

class Car {
public:
    string brand;
};

int main() {
    // 创建 Car 对象
    Car carObj1;
    carObj1.brand = "BMW";

    // 创建另一个 Car 对象
    Car carObj2;
    carObj2.brand = "Ford";
    // 打印属性值
    cout << carObj1.brand "\n";
    cout << carObj2.brand "\n";
    return 0;
}

类方法

方法类似于类中定义的函数。C++ 有两种类型的方法：类内和类外方法。

类内方法

class MyClass {
public:
    void myMethod() { // 类内方法/函数
        cout << "Hello World!";
    }
};

int main() {
    MyClass myObj; // 创建 MyClass 的对象
    myObj.myMethod(); // 调用方法
    return 0;
}

类外方法

class MyClass {
public:
    void myMethod(); // 方法声明
};

// 类外方法/函数定义
void MyClass::myMethod() {
    cout << "Hello World!";
}

int main() {
    MyClass myObj; // 创建对象
    myObj.myMethod(); // 调用方法
    return 0;
}

构造函数

构造函数是在创建对象时自动调用的方法。它的名称与类名相同，并且没有数据类型。

例如：

class Fir_Class {
public:
    Fir_Class() { // 构造函数
        cout << "Hello World!";
    }
};

int main() {
    Fir_Class myObj; // 调用构造函数
    return 0;
}

访问说明符

访问说明符定义类成员和变量的访问权限。C++ 支持三种类型的访问说明符：

• Public： 类成员和变量可从类外部访问。
• Private： 类成员和变量只能在类内部访问，不能在类外部访问。
• Protected： 类成员和变量只能在其子类中访问。

封装

封装帮助你将敏感数据隐藏起来。这里，我们使用 private 访问说明符声明变量和方法。如果你希望其他人能够读取或修改这些变量和方法，必须使用 public 的 get 和 set 方法。

例如：

#include <iostream>
using namespace std;

class Employee {
private:
    int name;

public:
    // Setter
    void setName(int n) {
        name = s;
    }
    // Getter
    int getName() {
        return name;
    }
};

int main() {
    Employee myObj;
    myObj.setName("Bob");
    cout << myObj.getName();
    return 0;
}

继承

C++ 支持继承，允许你将一个类的成员和变量继承给另一个类。继承的类是子类，另一个是父类。你必须使用 (😃 符号来继承：

// 父类
class Vehicle {
public:
    string brand = "Ford";
    void sound() {
        cout << "honk \n" ;
    }
};

// 子类
class Car: public Vehicle {
public:
    string model = "Mustang";
};

int main() {
    Car myCar;
    myCar.sound();
    cout << myCar.brand + " " + myCar.model;
    return 0;
}

多态

多态指定“多种形式”。这是一个单一消息以多种形式显示的能力，并且发生在你有多个子类和一个基类时。

例如：

// 父类
class Animal {
public:
    void sound() {
        cout << "The animal makes a sound \n" ;
    }
};

// 子类
class Pig : public Animal {
public:
    void sound() {
        cout << "The pig says: wee wee \n" ;
    }
};

// 派生类
class Dog : public Animal {
public:
    void sound() {
        cout << "The dog says: bow wow \n" ;
    }
};

int main() {
    Animal ani;
    Pig myPig;
    Dog myDog;

    ani.sound();
    myPig.sound();
    myDog.sound();
    return 0;
}

文件处理

你可以使用 fstream 库来处理文件。fstream 库包括 <iostream> 和 <fstream> 头文件。

#include <iostream>

#include <fstream>

ofstream： 创建和写入文件。

ifstream： 从指定文件读取。

fstream： 以上两者的组合。

创建和写入

#include <iostream>
#include <fstream>
using namespace std;

int main() {
    // 创建并打开文本文件
    ofstream MyFile("filename.txt");

    // 写入文件
    MyFile << "content";

    // 关闭文件
    MyFile.close();
}

读取

// 文本字符串以输出文本文件
string myText;

// 从文本文件中读取
ifstream MyReadFile("filename.txt");

// 按行读取文件
while (getline (MyReadFile, myText)) {
    // 从文件输出文本
    cout << myText;
}

// 关闭文件
MyReadFile.close();

异常处理

在编译和运行时，你可能会遇到错误。C++ 允许你使用异常处理来处理和捕获这些错误。以下是异常处理的语法，包括 try-catch 块：

try {
    // 尝试代码块
    throw exception; // 出现问题时抛出异常
}
catch () {
    // 处理错误的代码块
}

例如：

try {
    int age = 10;
    if (age >= 20) {
        cout << "you are old enough.";
    } else {
        throw 505;
    }
}
catch (int num) {
    cout << "Access denied \n";
    cout << "Error number: " << num;
}

预处理器

以下是 C++ 中一些内置预处理器，用于实现各种功能。

#include <stdio.h> // 插入标准头文件

#include "myfile.h" // 插入当前目录中的文件

#define X some text // 将 X 替换为 some text

#define F(a,b) a+b // 将 F(1,2) 替换为 1+2

#define X \

some text // 多行定义

#undef X // 删除定义

#if defined(X) // 条件编译 (#ifdef X)

#else // 可选 (#ifndef X 或 #if !defined(X))

#endif // 在 #if, #ifdef 之后必需

动态内存管理

#include <memory> // 包含内存（std 命名空间）
shared_ptr<int> x; // 指向堆上整数的空 shared_ptr。使用引用计数清理对象。
x = make_shared<int>(12); // 在堆上分配值 12
shared_ptr<int> y = x; // 复制 shared_ptr，隐式更改引用计数为 2。
cout << *y; // 解引用 y 以打印 '12'
if (y.get() == x.get()) { // 原始指针（这里 x == y）
    cout << "Same";
}
y.reset(); // 消除一个对象所有者
if (y.get() != x.get()) {
    cout << "Different";
}
if (y == nullptr) { // 可以与 nullptr 比较（这里返回 true）
    cout << "Empty";
}
y = make_shared<int>(15); // 分配新值
cout << *y; // 解引用 x 以打印 '15'
cout << *x; // 解引用 x 以打印 '12'
weak_ptr<int> w; // 创建空弱指针
w = y; // w 对 y 有弱引用。
if (shared_ptr<int> s = w.lock()) { // 必须复制到 shared_ptr 才能使用
    cout << *s;
}
unique_ptr<int> z; // 创建空唯一指针
unique_ptr<int> q;
z = make_unique<int>(16); // 在堆上分配 int (16)。只允许一个引用。
q = move(z); // 将引用从 z 移动到 q。
if (z == nullptr){
    cout << "Z null";
}
cout << *q;
shared_ptr<B> r;
r = dynamic_pointer_cast<B>(t); // 将 t 转换为 shared_ptr<B>

浮点数学

必须包含“cmath”库才能对浮点数执行任务。

#include <cmath> // 包含 cmath（std 命名空间）

sin(x); cos(x); tan(x); // 可以执行三角函数，x（double）为弧度

asin(x); acos(x); atan(x); // 反函数

atan2(y, x); // atan(y/x)

sinh(x); cosh(x); tanh(x); // 双曲正弦、余弦、正切函数

exp(x); log(x); log10(x); // e 的 x 次方，自然对数，常用对数

pow(x, y); sqrt(x); // x 的 y 次方，平方根

ceil(x); floor(x); // 向上或向下舍入（作为 double）

fabs(x); fmod(x, y); // 绝对值，x 模 y

iostream.h 和 iostream

#include <iostream> // 包含 iostream（std 命名空间）

cin >> x >> y; // 从标准输入读取单词 x 和 y（任何类型）

cout << "x=" << 3 << endl; // 向标准输出写入行

cerr << x << y << flush; // 向标准错误输出写入并刷新

c = cin.get(); // c = getchar();

cin.get(c); // 读取字符

cin.getline(s, n, '\n'); // 将行读取到 char s[n]，直到 '\n'（默认）

if (cin) // 状态良好（不是 EOF）？

// 读取/写入任何类型 T：

istream& operator>>(istream& i, T& x) {i >> ...; x=...; return i;}

ostream& operator<<(ostream& o, const T& x) {return o << ...;}