C++ 编程语言快速参考笔记

蘭雅

C++ 是一种通用语言和 C 语言扩展。作为当今市场上[最受欢迎的编程语言之一，C++ 是有抱负的开发人员的热门学习选择。程序员参加课程并尝试项目来提高他们的知识。

但是，你在工作时是否曾渴望一份 C++ 快速参考？如果你能更高效地完成 C++ 工作会怎么样？这份 C++ 速查表是一个很好的参考，可以帮助你更顺利地工作。

我们精心挑选了出色的 C++ 语法备忘单或 C++ 命令备忘单，帮助您提高或完善您的技能。

这份 C++ 编程速查表也是[面试准备的良好资源准备好快速解决 C++ 项目了吗？让我们开始吧！

C++ 速查表

句法

让我们从语法开始我们的 C++ 参考表。

#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，结束main函数。

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

**//：**指定单行注释。

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

数据类型

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

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

变量

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

例如：

int num = 12; // Integer
string name = "Unity Buddy"; // String(text)
char ch = 'U'; //character
float fl = 5.99; // Floating point number

变量名可以使用字母、数字和下划线。但是，变量不能以数字或下划线“”字符开头。相反，它们必须以字母开头，后跟数字或下划线“”字符。此外，变量名不能使用关键字。

变量范围

在 C++ 中，你可以在程序的三个部分内声明变量，这也称为变量的范围：

1.局部变量

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

例如：

#include <iostream>
using namespace std;

int main () {
// Local variable:
int a, b;
int c;

// initialization
a = 10;
b = 20;
c = a + b;

cout << c;

return 0;
}

2.全局变量

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

例如：

#include <iostream>
using namespace std;

// Global variable:
int g;

int main () {
// Local variable:
int a, b;

// initialization
a = 10;
b = 20;
g = a + b;

cout << g;

return 0;
}

建议课程

开始 C++ 编程 - 从初学者到进阶者

数据类型修饰符

数据类型修饰符用于修改数据类型的最大数据长度。下表将帮助您了解内置数据类型与修饰符结合使用时的大小和范围。C++ 中有四种不同类型的修饰符，分别是有符号、无符号、短整型和长整型。

数据类型	C++ 类型	大小（以字节为单位）	范围
短整型	`short`	2	-32,768 至 32,767
无符号短整型	`unsigned short`	2	0 至 65,535
无符号整数	`unsigned int`	4	0 至 4,294,967,295
整数	`int`	4	-2,147,483,648 至 2,147,483,647
长整型	`long`	4	-2,147,483,648 至 2,147,483,647
无符号长整型	`unsigned long`	4	0 至 4,294,967,295
长整型	`long long`	8	- (2⁶³) 到 (2⁶³)-1
无符号长整型	`unsigned long long`	8	0 至 18,446,744,073,709,551,615
有符号字符	`signed char`	1	-128 至 127
无符号字符	`unsigned char`	1	0 至 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++ 中使用转义序列来表示在 C++ 中具有特殊含义的不可输入字符。

例如：

转义序列	人物
\b	退格键
\f	换页
\n	换行符
\r	返回
\t	水平标签
\v	垂直标签
\\	反斜杠
\'	单引号
\"	双引号
\?	问号
\0	空字符

5. 字符串文字

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

例如：

“好的”

字符串常量

“”

空字符串常量

“ “

六个空格的字符串常量

“x”

具有单个字符的字符串常量

“地球是圆的\n”

打印带有换行符的字符串

常量

要创建不想更改其值的变量，可以使用“const”关键字。

例如：

constint LIGHT_SPEED = 2997928;
LIGHT_SPEED = 2500// cannot change the value

数学函数

C++ 提供了几个函数，可让您执行数学任务。下表列出了 C++ 中可用的所有基本数学函数：数学函数

功能	描述
fabs(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)	返回 Ex 的值
expm1(x)	返回 ex - 1
fabs(x)	返回浮点数 x 的绝对值
fdim(x, y)	返回 x 和 y 之间的正差
floor(x)	返回 x 向下舍入到其最接近的整数的值
hypot(x, y)	返回 sqrt(x² + y²)，无中间溢出或下溢
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; // declaring a variable
cout << "Type a number: "; // Type any number and hit enter
cin >> x; // Get user input from the keyboard
cout << "Your number is: " << x; // Display the value

字符串

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

例如：

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, const string& str)	替换字符串中从字符位置 pos 开始并跨越 len 个字符的部分
string& append(const string& str)	在另一个字符串对象的末尾添加一个新字符
char& at(int pos)	访问指定位置 pos 处的单个字符
int find(const string& str, int pos, int n)	查找参数中指定的字符串
int find_first_of(const string& str, int pos, int n)	查找指定序列的第一次出现
int find_first_not_of(const string& str, int pos, int n)	在字符串中搜索第一个与字符串中指定的任何字符不匹配的字符
int find_last_of(const string& str, int pos, int n)	在字符串中搜索指定序列的最后一个字符
int find_last_not_of(const string& str, int pos)	搜索与指定序列不匹配的最后一个字符
string& insert(int pos, const string& str)	在位置 pos 指示的字符前插入一个新字符
int max_size()	查找字符串的最大长度
void push_back(char ch)	在字符串末尾添加新字符 ch
void pop_back()	删除字符串的最后一个字符
string& assign(const string& str)	为字符串分配新值
int copy(string& str)	将字符串的内容复制到另一个字符串中
void clear()	删除字符串中的所有元素
const_reverse_iterator crbegin()	指向字符串的最后一个字符
const char* data()	将字符串的字符复制到数组中
bool empty()	检查字符串是否为空
string& erase(int pos, int len)	删除指定的字符
char& front()	返回第一个字符的引用
string& operator+= (const string& str)	在字符串末尾附加一个新字符
string& operator= (const string& str)	为字符串分配一个新值
char operator[](int pos)	检索指定位置 pos 处的字符
int rfind(const string& str)	搜索字符串的最后一次出现
iterator end()	指向字符串的最后一个字符
reverse_iterator rend()	指向字符串的第一个字符
void shrink_to_fit()	减少容量并使其等于字符串的大小
char* c_str()	返回指向包含以空字符结尾的字符序列的数组的指针
void reserve(int 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	它将从 x 的值中减去值 3。	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.比较运算符

您可以使用这些运算符比较两个值以返回真值或假值。如果两个值匹配，则返回真值；如果不匹配，则返回假值。

运算符	描述	表达式
==	等于	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)
{ //code}

例子：

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

例子：

#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; //optional
case constant-expression :
statement(s);
break; //optional

default : //Optional
statement(s);
}

例子：

#include <iostream>
using namespace std;

int main () {
// local variable declaration:
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) {
// Executes when the boolean expression 1 is true
if(boolean_expression 2) {
// Executes when the boolean expression 2 is true
}
}

例子：

#include <iostream>
using namespace std;

int main () {
// local variable declaration:
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) {
case100:
cout << "This is part of outer switch" << endl;
switch(y) {
case200:
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.三元运算符

实验1？实验2：实验3；

首先，对表达式 Exp1 求值。如果为真，则对 Exp2 求值，并将其作为整个 '?' 表达式的值。如果 Exp1 为假，则对 Exp3 求值，并将其值作为表达式的值。

循环

循环用于根据评估条件的结果执行特定次数的特定命令集。C++ 包括以下循环

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

1. While 循环

循环将持续，直到指定条件为真。

while (condition)
{code}

2. Do-While 循环

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

do
{
Code
}
while (condition)

3. For 循环

您可以使用 for 循环多次执行代码块。此循环将运行该块，直到其中指定的条件为 false。

for (int a=0; i< count; i++)
{
Code
}

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]; //declaring array to store up to 4 variables.
string vehicles[4]= {"car", "scooter", "cycle", "bike"}; //initializing the array

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 ) {
body of the function
}

在哪里：

return_type指定该函数返回的值的类型。
function_name指定函数的名称，需要唯一。
参数列表允许您向函数传递多个值及其数据类型。
函数主体指定了完成任务的一组指令。

例如：

int max(int num1, int num2) { // declaring the function max
int result;

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

return result;
}

调用函数

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

例如：

#include <iostream>
using namespace std;

// function declaration
intmax(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. 自动存储类

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

例如：

{
int var;
autoint var1;
}

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

2. 注册存储类

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

例如：

{
registerint miles;
}

3.静态存储类

静态存储类指示编译器在整个程序中维护局部变量，而无需在进入和超出范围时创建和销毁它们。将变量定义为静态意味着它将在函数调用之间保持其值。

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

例如：

#include <iostream>

// Function declaration
voidfunc1(void);

staticint count = 10; /* Global variable */

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

return 0;
}

// Function definition
voidfunc1( void ) {
staticint i = 5; // local static variable
i++;
std::cout << "i is " << i ;
std::cout << " and count is " << count << std::endl;
}

外部存储类

extern 存储类提供全局变量的引用，并使其对所有程序文件可见。当您将变量指定为“extern”时，该变量无法初始化，因为它将变量名称指向先前已定义的存储位置。

如果您在多个文件中定义了全局变量或函数，并且该变量或函数也在其他文件中使用，则 extern 将在另一个文件中提供对已定义变量或函数的引用。当您必须在两个或多个文件之间共享相同的全局变量或函数时，必须使用 extern 修饰符。

例如：

计划 1

#include <iostream>
int count ;
externvoidwrite_extern();

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

计划 2

#include <iostream>

externint count;

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

可变存储类

如果希望对象成员覆盖成员函数，则可以使用此存储类。也就是说，可变成员可以通过 const 成员函数进行修改。

结构

结构允许您定义非相似数据类型的数据项。要使用结构，您必须定义它并访问其结构成员。

以下是创建结构的语法：

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

例如，我们要创建一个由标题、作者、主题和book_id组成的书籍结构，如下所示：

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

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

访问结构成员

#include <iostream>
#include <cstring>

using namespace std;

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

int main() {
structBooksBook1; // Declare Book1 of type Book
structBooksBook2; // Declare Book2 of type Book

// book 1 specification
strcpy( Book1.title, "Learn C++ Programming");
strcpy( Book1.author, "Chand Miyan");
strcpy( Book1.subject, "C++ Programming");
Book1.book_id = 6495407;

// book 2 specification
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Yakit Singha");
strcpy( Book2.subject, "Telecom");
Book2.book_id = 6495700;

// Print Book1 info
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;

// Print Book2 info
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; // reference to food

指针

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

例如：

string food = "Pizza"; // string variable

cout << food; // Outputs the value of food (Pizza)
cout << &food; // Outputs the memory address of food (0x6dfed4)

类和对象

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

创建一个类

以下是在 C++ 中创建类的方法：

classMyClass { // The class
public: // Access specifier- accessible to everyone
int myNum; // Attribute (int variable)
string myString; // Attribute (string variable)
};

创建一个对象

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

classMyClass {
public:
int myNum;
string myString;
};

int main() {
MyClass myObj; // Creating an object of MyClass

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

// Print attribute values
cout << myObj.myNum << "\n";
cout << myObj.myString;
return 0;
}

创建多个对象

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

classCar {
public:
string brand;
};

int main() {
// Create an object of Car
Car carObj1;
carObj1.brand = "BMW";

// Create another object of Car
Car carObj2;
carObj2.brand = "Ford";
// Print attribute values
cout << carObj1.brand "\n";
cout << carObj2.brand "\n";
return 0;
}

类方法

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

类内部方法

classMyClass {
public:
voidmyMethod() { // Method/function inside the class
cout << "Hello World!";
}
};

int main() {
MyClass myObj; // Create an object of MyClass
myObj.myMethod(); // Call the method
return 0;
}

类外方法

classMyClass {
public:
voidmyMethod(); // Method declaration
};

// Method/function definition outside the class
void MyClass::myMethod() {
cout << "Hello World!";
}

int main() {
MyClass myObj; // object creation
myObj.myMethod(); // Call the method
return 0;
}

构造函数

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

例如：

classFir_Class {
public:
Fir_Class() { // Constructor
cout << "Hello World!";
}
};

int main() {
Fir_Class myObj; // call the constructor
return 0;
}

访问说明符

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

**公共：**类成员和变量可以从类外部访问。
**私有：**类成员和变量只能在类内部访问，不能在类外部访问。
**受保护：**类成员和变量只能在其子类中访问。

封装

封装可帮助您向用户隐藏敏感数据。在这里，我们使用私有访问说明符来声明变量和方法。如果您想允许其他人读取或修改这些变量和方法，则必须使用公共 get 和 set 方法。

例如：

#include <iostream>
using namespace std;

classEmployee {
private:
int name;

public:
// Setter
voidsetName(int n) {
name= s;
}
// Getter
intgetName() {
return name;
}
};

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

继承

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

// Parent class
classVehicle {
public:
string brand = "Ford";
voidsound() {
cout << "honk \n" ;
}
};

// Child class
classCar: public Vehicle {
public:
string model = "Mustang";
};

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

多态性

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

例如：

// Parent class
classAnimal {
public:
voidsound() {
cout << "The animal makes a sound \n" ;
}
};

// Child class
classPig : public Animal {
public:
voidsound() {
cout << "The pig says: wee wee \n" ;
}
};

// Derived class
classDog : public Animal {
public:
voidsound() {
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> 头文件组成。

#包括 <iostream>

#包括 <fstream>

**ofstream：**创建并写入文件。

**ifstream：**从指定文件读取。

**fstream：**以上两者的结合。

写文件

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

int main() {
// Create and open a text file
ofstream MyFile("filename.txt");

// Write to the file
MyFile << "content";

// Close the file
MyFile.close();
}

读文件

// text string to output the text file
string myText;

// Read from the text file
ifstream MyReadFile("filename.txt");

// for reading the file line by line
while (getline (MyReadFile, myText)) {
// Output the text from the file
cout << myText;
}

// Close the file
MyReadFile.close();

异常处理

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

try {
// Block of code to try
throw exception; // Throw an exception when a problem arise
}
catch () {
// Block of code to handle errors
}

例如：

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

预处理器

以下是 C++ 中可用于各种功能的内置预处理器。

#include <stdio.h> // Insert standard header file

#include "myfile.h" // Insert file in current directory

#define X some text // Replace X with some text

#define F(a,b) a+b // Replace F(1,2) with 1+2

#define X \

 some text // Multiline definition

#undef X // Remove definition

#if defined(X) // Conditional compilation (#ifdef X)

#else // Optional (#ifndef X or #if !defined(X))

#endif // Required after #if, #ifdef

动态内存管理

#include <memory> // Include memory (std namespace)
shared_ptr<int> x; // Empty shared_ptr to a integer on heap. Uses reference counting for cleaning up objects.
x = make_shared<int>(12); // Allocate value 12 on heap
shared_ptr<int> y = x; // Copy shared_ptr, implicit changes reference count to 2.
cout << *y; // Dereference y to print '12'
if (y.get() == x.get()) { // Raw pointers (here x == y)
cout << "Same";
}
y.reset(); // Eliminate one owner of object
if (y.get() != x.get()) {
cout << "Different";
}
if (y == nullptr) { // Can compare against nullptr (here returns true)
cout << "Empty";
}
y = make_shared<int>(15); // Assign new value
cout << *y; // Dereference x to print '15'
cout << *x; // Dereference x to print '12'
weak_ptr<int> w; // Create empty weak pointer
w = y; // w has weak reference to y.
if (shared_ptr<int> s = w.lock()) { // Has to be copied into a shared_ptr before usage
cout << *s;
}
unique_ptr<int> z; // Create empty unique pointers
unique_ptr<int> q;
z = make_unique<int>(16); // Allocate int (16) on heap. Only one reference allowed.
q = move(z); // Move reference from z to q.
if (z == nullptr){
cout << "Z null";
}
cout << *q;
shared_ptr<B> r;
r = dynamic_pointer_cast<B>(t); // Converts t to a shared_ptr<B>

浮点数学

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

#include <cmath> // Include cmath (std namespace)。
的一切。``
sin(x); cos(x); tan(x); // you can perform Trig functions, x (double) is in radians

asin(x); acos(x); atan(x); // Inverses

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

sinh(x); cosh(x); tanh(x); // Hyperbolic sin, cos, tan functions

exp(x); log(x); log10(x); // e to the x, log base e, log base 10

pow(x, y); sqrt(x); // x to the y, square root

ceil(x); floor(x); // Round up or down (as a double)

fabs(x); fmod(x, y); // Absolute value, x mod y

iostream.h 和 iostream

#include <iostream> // Include iostream (std namespace)

cin >> x >> y; // Read words x and y (any type) from standard input

cout << "x=" << 3 << endl; // Write line to stdout

cerr << x << y << flush; // Write to stderr and flush

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

cin.get(c); // Read char

cin.getline(s, n, '\n'); // Read line into char s[n] to '\n' (default)

if (cin) // Good state (not EOF)?

// To read/write any type T:

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

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

结论

我们已经读完了 C++ 参考备忘单。恭喜！

在本 C++ 参考资料中，我们几乎涵盖了初学者在开始职业生涯或准备即将到来的面试时需要了解的所有 C++ 方面。这份面向初学者的 C++ 备忘单是一份极好的资源，您可以在开发应用程序时或参加面试之前查看。

我们希望这个 C++ 参考能够帮助您深入了解有关 C++ 的一切。