2019-08-21 11:05:16

docs/cpp/10.md

@@ -4,7 +4,7 @@
 
 循环用于重复执行语句块，直到满足特定条件。例如，当您显示从 1 到 100 的数字时，您可能希望将变量的值设置为 1 并将其显示 100 次，在每次循环迭代时将其值增加 1。
 
-在 C++中，我们有三种类型的基本循环：for，[而](https://beginnersbook.com/2017/08/cpp-while-loop/)和 [do-while](https://beginnersbook.com/2017/08/cpp-do-while-loop/) 。在本教程中，我们将学习如何在 C++中使用“for loop”。
+在 C++中，我们有三种类型的基本循环：`for`，[`while`](https://beginnersbook.com/2017/08/cpp-while-loop/)和[`do-while`](https://beginnersbook.com/2017/08/cpp-do-while-loop/) 。在本教程中，我们将学习如何在 C++中使用`for` 循环。
 
 #### `for`循环的语法
 
@@ -20,19 +20,19 @@ for(initialization; condition ; increment/decrement)
 当程序执行时，解释器总是跟踪将要执行的语句。我们将其称为控制流程或程序的执行流程。
 ![C++ for loop flow diagram](img/381b698f62d8866bf5d4ebd795d78400.jpg)
 
-**第一步：**在 for 循环中，初始化只发生一次，这意味着 for 循环的初始化部分只执行一次。
+**第一步：**在`for`循环中，初始化只发生一次，这意味着`for`循环的初始化部分只执行一次。
 
-**第二步：** for 循环中的条件在每次循环迭代时进行计算，如果条件为真，则 for 循环体内的语句将被执行。一旦条件返回 false，for 循环中的语句就不会执行，并且控制在 for 循环后被转移到程序中的下一个语句。
+**第二步：** `for`循环中的条件在每次循环迭代时进行计算，如果条件为真，则`for`循环体内的语句将被执行。一旦条件返回`false`，`for`循环中的语句就不会执行，并且控制在`for`循环后被转移到程序中的下一个语句。
 
-**第三步：**每次执行 for 循环体后，for 循环的递增/递减部分执行更新循环计数器。
+**第三步：**每次执行`for`循环体后，`for`循环的递增/递减部分执行更新循环计数器。
 
 **第四步：**第三步后，控制跳转到第二步，重新评估条件。
 
-> 从第二到第四的步骤重复，直到循环条件返回 false。
+> 从第二到第四的步骤重复，直到循环条件返回`false`。
 
 ## C++中的简单`for`循环示例
 
-这里，在循环初始化部分 I 中，将变量 i 的值设置为 1，条件是 i <= 6，并且在每次循环迭代中，i 的值递增 1。
+这里，在循环初始化部分中，将变量`i`的值设置为 1，条件是`i <= 6`，并且在每次循环迭代中，`i`的值递增 1。
 
 ```cpp
 #include <iostream>
@@ -63,7 +63,7 @@ Value of variable i is: 6
 
 ## C++中的无限循环
 
-当循环重复执行并且永不停止时，循环被认为是无限的。这通常是错误的。当你在 for 循环中设置条件时它永远不会返回 false，它就会变成无限循环。
+当循环重复执行并且永不停止时，循环被认为是无限的。这通常是错误的。当你在`for`循环中设置条件时它永远不会返回`false`，它就会变成无限循环。
 
 **例如：**
 
@@ -78,9 +78,9 @@ int main(){
 }
 ```
 
-这是一个无限循环，因为我们递增 i 的值，因此它总是满足条件 i&gt; = 1，条件永远不会返回 false。
+这是一个无限循环，因为我们递增`i`的值，因此它总是满足条件`i <= 1`，条件永远不会返回`false`。
 
-这是无限 for 循环的另一个例子：
+这是无限`for`循环的另一个例子：
 
 ```cpp
 // infinite loop

docs/cpp/11.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-while-loop/](https://beginnersbook.com/2017/08/cpp-while-loop/)
 
-在上一篇教程中，我们讨论了 [for loop](https://beginnersbook.com/2017/08/cpp-for-loop/) 。在本教程中，我们将讨论 while 循环。如前所述，循环用于重复执行程序语句块，直到给定的循环条件返回 false。
+在上一篇教程中，我们讨论了 [`for`循环](https://beginnersbook.com/2017/08/cpp-for-loop/) 。在本教程中，我们将讨论`while`循环。如前所述，循环用于重复执行程序语句块，直到给定的循环条件返回`false`。
 
 #### `while`循环的语法
 
@@ -15,9 +15,9 @@ while(condition)
 
 ## 循环如何工作？
 
-在 while 循环中，首先计算条件，如果它返回 true，则 while 循环中的语句执行，这会重复发生，直到条件返回 false。当 condition 返回 false 时，控制流退出循环并在 while 循环后跳转到程序中的下一个语句。
+在`while`循环中，首先计算条件，如果它返回`true`，则`while`循环中的语句执行，这会重复发生，直到条件返回`false`。当条件返回`false`时，控制流退出循环并在`while`循环后跳转到程序中的下一个语句。
 
-**注意：**使用 while 循环时要注意的重点是我们需要在 while 循环中使用递增或递减语句，以便循环变量在每次迭代时都会发生变化，并且在某些情况下返回 false。这样我们就可以结束 while 循环的执行，否则循环将无限期地执行。
+**注意：**使用`while`循环时要注意的重点是我们需要在`while`循环中使用递增或递减语句，以便循环变量在每次迭代时都会发生变化，并且在某些情况下返回`false`。这样我们就可以结束`while`循环的执行，否则循环将无限期地执行。
 
 ### `while`循环流程图
 
@@ -53,9 +53,9 @@ Value of variable i is: 6
 
 ## 无限循环
 
-永远停止的 while 循环被认为是无限循环，当我们以这样的方式给出条件以使它永远不会返回 false 时，循环变为无限并且无限地重复。
+永远停止的`while`循环被认为是无限循环，当我们以这样的方式给出条件以使它永远不会返回`false`时，循环变为无限并且无限地重复。
 **无限循环的一个例子：**
-这个循环永远不会结束，因为我递减 i 的值为 1，因此条件 i< = 6 永远不会返回 false。
+这个循环永远不会结束，因为我递减`i`的值为 1，因此条件`i <= 6`永远不会返回`false`。
 
 ```cpp
 #include <iostream>

docs/cpp/12.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-do-while-loop/](https://beginnersbook.com/2017/08/cpp-do-while-loop/)
 
-正如上一篇关于 [while 循环](https://beginnersbook.com/2017/08/cpp-while-loop/)的教程中所讨论的，循环用于重复一个语句块，直到给定的循环条件返回 false。在本教程中，我们将看到 do-while 循环。 do-while 循环类似于 while 循环，但它们之间存在差异：在 while 循环中，首先计算条件，然后执行循环体内的语句，另一方面在 do-while 循环中执行 - 首先执行，然后评估条件。
+正如上一篇关于 [`while`循环](https://beginnersbook.com/2017/08/cpp-while-loop/)的教程中所讨论的，循环用于重复一个语句块，直到给定的循环条件返回`false`。在本教程中，我们将看到`do-while`循环。`do-while`循环类似于 while 循环，但它们之间存在差异：在`while`循环中，首先计算条件，然后执行循环体内的语句，另一方面在`do-while`循环中执行 - 首先执行，然后评估条件。
 
 #### `do-while`循环的语法
 
@@ -15,7 +15,7 @@ do
 
 ## `do-while`循环如何工作？
 
-首先，循环内的语句执行，然后条件得到评估，如果条件返回 true，则控制跳转到“do”以进一步重复执行它，这会重复发生，直到条件返回 false。一旦条件返回 false，控制就会在 do-while 之后跳转到程序中的下一个语句。
+首先，循环内的语句执行，然后条件得到评估，如果条件返回`true`，则控制跳转到`do`以进一步重复执行它，这会重复发生，直到条件返回`false`。一旦条件返回`false`，控制就会在`do-while`之后跳转到程序中的下一个语句。
 ![C++ do while loop flow diagram](img/8a5f1d9785c32edcb5c78c6f602d2b04.jpg)
 
 ## C++中的`do-while`循环示例
@@ -47,7 +47,7 @@ Value of num: 6
 
 ## 示例：使用`do-while`循环显示数组元素
 
-这里我们有一个整数数组，它有四个元素。我们使用 do-while 循环显示它的元素。
+这里我们有一个整数数组，它有四个元素。我们使用`do-while`循环显示它的元素。
 
 ```cpp
 #include <iostream>

docs/cpp/13.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-continue-statement/](https://beginnersbook.com/2017/08/cpp-continue-statement/)
 
-在循环内使用 continue 语句。每当在循环内遇到 continue 语句时，控制流直接跳转到循环的开头以进行下一次迭代，跳过循环体内语句的执行以进行当前迭代。
+在循环内使用`continue`语句。每当在循环内遇到`continue`语句时，控制流直接跳转到循环的开头以进行下一次迭代，跳过循环体内语句的执行以进行当前迭代。
 
 #### `continue`语句的语法
 
@@ -12,7 +12,7 @@ continue;
 
 ## 示例：`for`循环中的`continue`语句
 
-正如你可以看到输出缺少值 3，但循环的[通过 num 值 0 到 6 进行迭代。这是因为我们在循环中设置了一个条件，这样就可以了当 num 值等于 3 时遇到语句。因此，对于此迭代，循环跳过 cout 语句并开始下一次循环迭代。](https://beginnersbook.com/2017/08/cpp-for-loop/)
+正如你可以看到输出缺少值 3，但循环迭代`num`值 0 到 6。这是因为我们在循环中设置了一个条件，这样就可以了当`num`值等于 3 时遇到语句。因此，对于此迭代，循环跳过`cout`语句并开始下一次循环迭代。
 
 ```cpp
 #include <iostream>

docs/cpp/14.md

@@ -4,9 +4,9 @@
 
 **中断语句**用于以下两种情况：
 
-a）使用 break 语句立即退出循环。每当在循环内遇到 break 语句时，控制流就会直接从循环中退出。它与 if 语句一起使用，只要在循环内部使用（参见下面的示例），以便它仅在特定条件下发生。
+a）使用`break`语句立即退出循环。每当在循环内遇到`break`语句时，控制流就会直接从循环中退出。它与`if`语句一起使用，只要在循环内部使用（参见下面的示例），以便它仅在特定条件下发生。
 
-b）用于箱体后的`switch`箱控制结构。通常，在 switch case 中的所有情况都跟一个 break 语句，以避免后续的情况（参见下面的例子）执行。无论何时在`switch-case`块中遇到，控制器都从`switch-case`体中出来。
+b）用于箱体后的`switch`箱控制结构。通常，在`switch case`中的所有情况都跟一个`break`语句，以避免后续的情况（参见下面的例子）执行。无论何时在`switch-case`块中遇到，控制器都从`switch-case`体中出来。
 
 #### `break`语句的语法
 
@@ -20,7 +20,7 @@ break;
 
 ## 示例 - 在`while`循环中使用`break`语句
 
-在下面的示例中，我们有一个从 10 到 200 运行的 while 循环，但由于我们有一个在循环计数器变量值达到 12 时遇到的 break 语句，循环终止并且控制流跳转到程序中的下一个语句之后循环体。
+在下面的示例中，我们有一个从 10 到 200 运行的`while`循环，但由于我们有一个在循环计数器变量值达到 12 时遇到的`break`语句，循环终止并且控制流跳转到程序中的下一个语句之后循环体。
 
 ```cpp
 #include <iostream>
@@ -104,7 +104,7 @@ Case 2
 Hey, I'm out of the switch case
 ```
 
-在这个例子中，我们在每个 Case 块之后都有 break 语句，这是因为如果我们没有它，那么后续的 case 块也会执行。不间断的同一程序的输出将是：
+在这个例子中，我们在每个`case`块之后都有`break`语句，这是因为如果我们没有它，那么后续的`case`块也会执行。不间断的同一程序的输出将是：
 
 ```cpp
 Case 2

docs/cpp/15.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-goto-statement/](https://beginnersbook.com/2017/08/cpp-goto-statement/)
 
-goto 语句用于将程序的控制转移到给定标签。 goto 语句的语法如下所示：
+`goto`语句用于将程序的控制转移到给定标签。` goto`语句的语法如下所示：
 
 ```cpp
 goto label_name;
@@ -21,9 +21,9 @@ label2:
 ...
 ```
 
-在程序中我们有任意数量的 goto 和 label 语句，goto 语句后跟一个标签名称，每当遇到 goto 语句时，程序的控制权就会跳转到 goto 语句中指定的标签。
+在程序中我们有任意数量的`goto`和`label`语句，`goto`语句后跟一个标签名称，每当遇到`goto`语句时，程序的控制权就会跳转到`goto`语句中指定的标签。
 
-> goto 语句几乎从不在任何开发中使用，因为它们很复杂，使得程序的可读性更低，更容易出错。代替 goto，你可以使用 [continue](https://beginnersbook.com/2017/08/cpp-continue-statement/) 和 [break 语句](https://beginnersbook.com/2017/08/cpp-break-statement/)。
+> `goto`语句几乎从不在任何开发中使用，因为它们很复杂，使得程序的可读性更低，更容易出错。代替`goto`，你可以使用[`continue`](https://beginnersbook.com/2017/08/cpp-continue-statement/)和[`break`语句](https://beginnersbook.com/2017/08/cpp-break-statement/)。
 
 ## C++中`goto`语句的示例
 

docs/cpp/17.md

@@ -63,7 +63,7 @@ int sum(int num1, int num2){
 }
 ```
 
-**函数声明：**你已经看到我用两种方式编写了相同的程序，在第一个程序中我没有任何函数声明，在第二个程序中我在程序开头有函数声明。问题是，当您在程序中的 main（）函数之前定义函数时，您不需要执行函数声明，但如果您在 main（）函数之后编写函数，就像我们在第二个程序中那样，那么您需要先声明函数，否则会出现编译错误。
+**函数声明：**你已经看到我用两种方式编写了相同的程序，在第一个程序中我没有任何函数声明，在第二个程序中我在程序开头有函数声明。问题是，当您在程序中的`main()`函数之前定义函数时，您不需要执行函数声明，但如果您在`main()`函数之后编写函数，就像我们在第二个程序中那样，那么您需要先声明函数，否则会出现编译错误。
 
 **函数声明的语法：**
 
@@ -71,7 +71,7 @@ int sum(int num1, int num2){
 return_type function_name(parameter_list);
 ```
 
-**注意：**在提供 parameter_list 时，您可以避免参数名称，就像我在上面的示例中所做的那样。我给了`int sum(int,int);`而不是`int sum(int num1,int num2);`。
+**注意：**在提供`parameter_list`时，您可以避免参数名称，就像我在上面的示例中所做的那样。我给了`int sum(int,int);`而不是`int sum(int num1,int num2);`。
 
 **函数定义：**编写函数的全部函数称为定义函数。
 **函数定义语法：**
@@ -101,11 +101,11 @@ function_name(parameters);
 
 ### 1）内置函数
 
-内置函数也称为库函数。我们不需要声明和定义这些函数，因为它们已经在 C++库中编写，例如 iostream，cmath 等。我们可以在需要时直接调用它们。
+内置函数也称为库函数。我们不需要声明和定义这些函数，因为它们已经在 C++库中编写，例如`iostream`，`cmath`等。我们可以在需要时直接调用它们。
 
 #### 示例：C++内置函数示例
 
-这里我们使用内置函数 pow（x，y），它是 x 的幂 y。此函数在`cmath`头文件中声明，因此我们使用`#include`指令将该文件包含在我们的程序中。
+这里我们使用内置函数`pow(x, y)`，它是`x`的幂`y`。此函数在`cmath`头文件中声明，因此我们使用`#include`指令将该文件包含在我们的程序中。
 
 ```cpp
 #include <iostream>

docs/cpp/18.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-default-arguments/](https://beginnersbook.com/2017/08/cpp-default-arguments/)
 
-在调用函数时不提供任何参数或仅提供少量参数时，将使用默认参数。在编译程序期间使用默认参数。例如，假设您有一个[用户定义的函数](https://beginnersbook.com/2017/08/cpp-functions/) `sum`声明如下：`int sum(int a=10, int b=20)`，现在在调用此函数时，您不提供任何参数，简称为 sum（）;那么在这种情况下结果将是 30，编译器使用函数签名中声明的默认值 10 和 20。如果你只传递一个这样的参数：sum（80）那么结果将是 100，使用传递的参数 80 作为第一个值，20 个从默认参数中获取。
+在调用函数时不提供任何参数或仅提供少量参数时，将使用默认参数。在编译程序期间使用默认参数。例如，假设您有一个[用户定义的函数](https://beginnersbook.com/2017/08/cpp-functions/) `sum`声明如下：`int sum(int a=10, int b=20)`，现在在调用此函数时，您不提供任何参数，简称为`sum()`;那么在这种情况下结果将是 30，编译器使用函数签名中声明的默认值 10 和 20。如果你只传递一个这样的参数：`sum(80)`那么结果将是 100，使用传递的参数 80 作为第一个值，20 个从默认参数中获取。
 
 ## 示例：C++中的默认参数
 
@@ -48,11 +48,11 @@ int sum(int a, int b, int c){
 
 ## 默认参数的规则
 
-正如您在上面的示例中所看到的，我在函数声明期间仅为两个参数 b 和 c 分配了默认值。您可以为所有参数或仅选定的参数指定默认值，但在仅为某些参数指定默认值时，请记住以下规则：
+正如您在上面的示例中所看到的，我在函数声明期间仅为两个参数`b`和`c`分配了默认值。您可以为所有参数或仅选定的参数指定默认值，但在仅为某些参数指定默认值时，请记住以下规则：
 
 > **如果为参数指定默认值，则后续参数必须为其分配默认值，否则将出现编译错误。**
 
-**例如：**让我们看一些有效和无效的`case`。
+**例如：**让我们看一些有效和无效的案例。
 **有效：**以下函数声明有效 -
 
 ```cpp

docs/cpp/19.md

@@ -4,7 +4,7 @@
 
 函数调用自身的过程称为递归，相应的函数称为**递归函数**。理解递归的流行示例是阶乘函数。
 
-**阶乘函数：** f（n）= n * f（n-1），基本条件：如果 n <= 1 则 f（n）= 1.不要担心我们将讨论什么是基本条件为什么它很重要
+**阶乘函数：** `f(n) = n * f(n-1)`，基本条件：如果`n <= 1`则`f(n)= 1`。不要担心我们将讨论什么是基本条件为什么它很重要
 
 在下图中。我已经证明了在函数达到基本条件之前，阶乘函数如何调用自身。
 
@@ -54,7 +54,7 @@ if (n <= 1)
         return 1;
 ```
 
-递归的目的是将问题分成较小的问题，直到达到基本条件。例如，在上述阶乘程序中，我通过调用较小的阶乘函数 f（n-1）来求解阶乘函数 f（n），这一直重复发生，直到 n 值达到基本条件（f（1）= 1）。如果未在递归函数中定义基本条件，则会出现堆栈溢出错误。
+递归的目的是将问题分成较小的问题，直到达到基本条件。例如，在上述阶乘程序中，我通过调用较小的阶乘函数`f(n-1)`来求解阶乘函数 `f(n)`，这一直重复发生，直到`n`值达到基本条件（`f(1) = 1`）。如果未在递归函数中定义基本条件，则会出现堆栈溢出错误。
 
 ## 直接递归与间接递归
 

docs/cpp/22.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-multidimensional-arrays/](https://beginnersbook.com/2017/08/cpp-multidimensional-arrays/)
 
-多维数组也称为**数组**数组。多维数组中的数据以表格形式存储，如下图所示：
+多维数组也称为**数组的**数组。多维数组中的数据以表格形式存储，如下图所示：
 ![Multidimensional Array in C++](img/703503fc6cc74e3c12ca4f3eed2fb986.jpg)
 
 **二维数组：**
@@ -11,7 +11,7 @@
 int arr[2][3];
 ```
 
-该数组总共有 2 * 3 = 6 个元素。
+该数组总共有`2 * 3 = 6`个元素。
 
 **三维数组：**
 
@@ -19,11 +19,11 @@ int arr[2][3];
 int arr[2][2][2];
 ```
 
-该数组总共有 2 * 2 * 2 = 8 个元素。
+该数组总共有`2 * 2 * 2 = 8`个元素。
 
 ## 二维数组
 
-让我们看看如何声明，初始化和访问 Two Dimensional Array 元素。
+让我们看看如何声明，初始化和访问二维数组的元素。
 
 **如何声明二维数组？**
 
@@ -144,5 +144,5 @@ int main(){
 
 看看这些相关的 C++程序：
 
-1.  [C++程序添加两个矩阵](https://beginnersbook.com/2017/08/cpp-program-to-add-two-matrices/)
-2.  [C++程序查找并打印 Matrix](https://beginnersbook.com/2017/08/cpp-program-to-find-transpose-of-matrix/) 的转置
\ No newline at end of file
+1.  [C++程序：添加两个矩阵](https://beginnersbook.com/2017/08/cpp-program-to-add-two-matrices/)
+2.  [C++程序：查找并打印矩阵](https://beginnersbook.com/2017/08/cpp-program-to-find-transpose-of-matrix/) 的转置
\ No newline at end of file

docs/cpp/23.md

@@ -10,7 +10,7 @@ function_name(array_name);
 
 ## 示例：将数组传递给函数
 
-在这个例子中，我们传递两个数组`a`& `b`到函数`sum()`。此函数添加两个数组的相应元素并显示它们。
+在这个例子中，我们传递两个数组`a`和`b`到函数`sum()`。此函数添加两个数组的相应元素并显示它们。
 
 ```cpp
 #include <iostream>

docs/cpp/24.md

@@ -2,14 +2,14 @@
 
 > 原文： [https://beginnersbook.com/2017/08/strings-in-c/](https://beginnersbook.com/2017/08/strings-in-c/)
 
-字符串是由字符组成的单词，因此它们被称为字符序列。在 C++中，我们有两种方法来创建和使用字符串：1）通过创建 char 数组并将它们视为字符串 2）通过创建`string`对象
+字符串是由字符组成的单词，因此它们被称为字符序列。在 C++中，我们有两种方法来创建和使用字符串：1）通过创建`char`数组并将它们视为字符串 2）通过创建`string`对象
 
 让我们先讨论这两种创建字符串的方法，然后我们会看到哪种方法更好，为什么。
 
 ## 1）字符数组 - 也称为 C 字符串
 
 **例 1：**
-我们在声明期间初始化了 char 数组的一个简单例子。
+我们在声明期间初始化了`char`数组的一个简单例子。
 
 ```cpp
 #include <iostream>
@@ -28,7 +28,7 @@ A Song of Ice and Fire
 ```
 
 **示例 2：将用户输入作为字符串**
-这可以被视为读取用户输入的低效方法，为什么？因为当我们使用`cin`读取用户输入字符串时，只有字符串的第一个字存储在 char 数组中而其余部分被忽略。 cin 函数将字符串中的空格视为分隔符，并忽略其后的部分。
+这可以被视为读取用户输入的低效方法，为什么？因为当我们使用`cin`读取用户输入字符串时，只有字符串的第一个字存储在`char`数组中而其余部分被忽略。`cin`函数将字符串中的空格视为分隔符，并忽略其后的部分。
 
 ```cpp
 #include <iostream>
@@ -50,9 +50,9 @@ Enter your favorite book name:The Murder of Roger Ackroyd
 You entered: The
 ```
 
-你可以看到只有“The”被捕获在书中，剩下的部分在空间被忽略之后。那怎么处理呢？那么，为此我们可以使用`cin.get`函数，它读取用户输入的完整行。
+你可以看到只有`The`被捕获在书中，剩下的部分在空间被忽略之后。那怎么处理呢？那么，为此我们可以使用`cin.get`函数，它读取用户输入的完整行。
 
-**示例 3：使用 cin.get** 正确捕获用户输入字符串的方法
+**示例 3：使用 `cin.get`** 正确捕获用户输入字符串的方法
 
 ```cpp
 #include <iostream>
@@ -77,7 +77,7 @@ You entered: The Murder of Roger Ackroyd
 
 ### 这种方法的缺点
 
-1）char 数组的大小是固定的，这意味着通过它创建的字符串的大小是固定大小的，在运行时期间不能分配更多的内存。例如，假设您已创建一个大小为 10 的字符数组，并且用户输入大小为 15 的字符串，则最后五个字符将从字符串中截断。
+1）`char`数组的大小是固定的，这意味着通过它创建的字符串的大小是固定大小的，在运行时期间不能分配更多的内存。例如，假设您已创建一个大小为 10 的字符数组，并且用户输入大小为 15 的字符串，则最后五个字符将从字符串中截断。
 另一方面，如果您创建一个更大的数组来容纳用户输入，那么如果用户输入很小并且数组比需要的大得多，则会浪费内存。
 
 2）在这种方法中，你只能使用为数组创建的内置函数，它们对字符串操作没有多大帮助。
@@ -87,7 +87,7 @@ You entered: The Murder of Roger Ackroyd
 
 ## C++中的`string`对象
 
-到目前为止我们已经看到了如何使用 char 数组处理 C++中的字符串。让我们看看在 C++中处理字符串的另一种更好的方法 - 字符串对象。
+到目前为止我们已经看到了如何使用`char`数组处理 C++中的字符串。让我们看看在 C++中处理字符串的另一种更好的方法 - 字符串对象。
 
 ```cpp
 #include<iostream>

docs/cpp/26.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-pointers/](https://beginnersbook.com/2017/08/cpp-pointers/)
 
-指针是 C++中的一个变量，它包含另一个变量的地址。它们的[数据类型](https://beginnersbook.com/2017/08/cpp-data-types/)就像变量一样，例如整数类型指针可以保存整数变量的地址，字符类型指针可以保存 char 变量的地址。
+指针是 C++中的一个变量，它包含另一个变量的地址。它们的[数据类型](https://beginnersbook.com/2017/08/cpp-data-types/)就像变量一样，例如整数类型指针可以保存整数变量的地址，字符类型指针可以保存`char`变量的地址。
 
 #### 指针的语法
 
@@ -21,7 +21,7 @@ int *p, var
 ```
 
 **赋值**
-如上所述，整数类型指针可以保存另一个 int 变量的地址。这里我们有一个整数变量 var 和指针 p 保存 var 的地址。要将变量的地址分配给指针，我们使用**&符号**（&）。
+如上所述，整数类型指针可以保存另一个`int`变量的地址。这里我们有一个整数变量`var`和指针`p`保存`var`的地址。要将变量的地址分配给指针，我们使用**`&`符号**。
 
 ```cpp
 /* This is how you assign the address of another variable
@@ -82,8 +82,8 @@ Value of var: 101
 
 ## 指针和数组
 
-在使用指针处理[数组](https://beginnersbook.com/2017/08/cpp-arrays/)时，您需要注意一些事情。关于数组的第一个也是非常重要的注意事项是数组名称单独表示数组的基地址，因此在将数组地址分配给指针时不要使用符号（&）。这样做：
-**正确：**因为 arr 代表数组的地址。
+在使用指针处理[数组](https://beginnersbook.com/2017/08/cpp-arrays/)时，您需要注意一些事情。关于数组的第一个也是非常重要的注意事项是数组名称单独表示数组的基地址，因此在将数组地址分配给指针时不要使用符号（`&`）。这样做：
+**正确：**因为`arr`代表数组的地址。
 
 ```cpp
 p = arr;
@@ -130,7 +130,7 @@ int main(){
 
 ## 如何递增指针地址和指针的值？
 
-当我们通过指针访问变量的值时，有时我们只需要增加或减少变量的值，或者我们可能需要将指针移动到下一个 int 位置（就像我们在使用数组时一样）。 [++运算符](https://beginnersbook.com/2017/08/cpp-operators/)用于此目的。我们在上面看到的++运算符的一个示例，我们使用指针通过使用++运算符递增指针值来遍历数组。让我们看几个案例。
+当我们通过指针访问变量的值时，有时我们只需要增加或减少变量的值，或者我们可能需要将指针移动到下一个`int`位置（就像我们在使用数组时一样）。 [`++`运算符](https://beginnersbook.com/2017/08/cpp-operators/)用于此目的。我们在上面看到的`++`运算符的一个示例，我们使用指针通过使用`++`运算符递增指针值来遍历数组。让我们看几个案例。
 
 ```cpp
 // Pointer moves to the next int position (as if it was an array)

docs/cpp/27.md

@@ -6,7 +6,7 @@
 
 ## C++示例：`this`指针
 
-在这里你可以看到我们有两个数据成员 num 和 ch。在成员函数 setMyValues（）中，我们有两个与数据成员名称相同的局部变量。在这种情况下，如果要将局部变量值分配给数据成员，那么除非使用`this`指针，否则您将无法执行此操作，因为除非您使用，否则编译器将不知道您指的是对象的数据成员这个指针。这是必须使用**此**指针的示例之一。
+在这里你可以看到我们有两个数据成员`num`和`ch`。在成员函数`setMyValues()`中，我们有两个与数据成员名称相同的局部变量。在这种情况下，如果要将局部变量值分配给数据成员，那么除非使用`this`指针，否则您将无法执行此操作，因为除非您使用，否则编译器将不知道您指的是对象的数据成员这个指针。这是必须使用`this`指针的示例之一。
 
 ```cpp
 #include <iostream>
@@ -42,7 +42,7 @@ A
 
 ## 示例 2：使用`this`指针进行函数链接调用
 
-使用`this`指针的另一个示例是返回当前对象的引用，以便您可以链接函数调用，这样您就可以一次调用当前对象的所有函数。在这个程序中需要注意的另一个要点是我在第二个函数中增加了对象 num 的值，你可以在输出中看到它实际上增加了我们在第一个函数调用中设置的值。这表明链接是顺序的，对对象的数据成员所做的更改将保留以进一步链接调用。
+使用`this`指针的另一个示例是返回当前对象的引用，以便您可以链接函数调用，这样您就可以一次调用当前对象的所有函数。在这个程序中需要注意的另一个要点是我在第二个函数中增加了对象`num`的值，你可以在输出中看到它实际上增加了我们在第一个函数调用中设置的值。这表明链接是顺序的，对对象的数据成员所做的更改将保留以进一步链接调用。
 
 ```cpp
 #include <iostream>

docs/cpp/29.md

@@ -10,7 +10,7 @@
 
 ### 类和对象
 
-类就像数据成员和函数的蓝图，对象是类的实例。例如，假设我们有一个类 **Car** ，它有数据成员（变量），如速度，重量，价格和功能，如 gearChange（），slowDown（），brake（）等。现在让我们说我创建了一个名为 FordFigo 的类的对象，它使用这些数据成员和函数，并为它们提供自己的值。同样，我们可以使用蓝图（类）创建任意数量的对象。
+类就像数据成员和函数的蓝图，对象是类的实例。例如，假设我们有一个类 **`Car`** ，它有数据成员（变量），如速度，重量，价格和功能，如`gearChange()`，`slowDown()`，`brake()`等。现在让我们说我创建了一个名为`FordFigo`的类的对象，它使用这些数据成员和函数，并为它们提供自己的值。同样，我们可以使用蓝图（类）创建任意数量的对象。
 
 ```cpp
 //Class name is Car
@@ -65,7 +65,7 @@ int main(void) {
 }
 ```
 
-现在这个对象 obj 可以使用 ParentClass 的属性（例如变量 var1）。
+现在这个对象`obj`可以使用`ParentClass`的属性（例如变量`var1`）。
 
 ### 多态
 

docs/cpp/30.md

@@ -110,7 +110,7 @@ Welcome to BeginnersBook
 
 带参数的构造函数称为参数化构造函数。这些类型的构造函数允许我们在创建对象时传递参数。让我们看看他们的样子：
 
-让我们说类名是 XYZ
+让我们说类名是`XYZ`
 **默认构造函数：**
 
 ```cpp

docs/cpp/31.md

@@ -13,13 +13,13 @@
 }
 ```
 
-与构造函数类似，析构函数名称应与类名完全匹配。析构函数声明应始终以波形符（〜）符号开头，如上面的语法所示。
+与构造函数类似，析构函数名称应与类名完全匹配。析构函数声明应始终以波形符（`~`）符号开头，如上面的语法所示。
 
 ## 什么时候析构函数被调用？
 
 在以下情况下，析构函数**自动调用**：
 1）程序完成执行。
-2）当包含[局部变量](https://beginnersbook.com/2017/08/cpp-variables/)的作用域（{}括号）结束时。
+2）当包含[局部变量](https://beginnersbook.com/2017/08/cpp-variables/)的作用域（`{}`括号）结束时。
 3）当你调用删除操作符时。
 
 ## 析构函数示例
@@ -62,7 +62,7 @@ Destructor is called
 
 ## 析构函数规则
 
-1）名称应以波形符号（〜）开头，并且必须与类名匹配。
+1）名称应以波形符号（`~`）开头，并且必须与类名匹配。
 2）一个类中不能有多个析构函数。
 3）与可以有参数的构造函数不同，析构函数不允许任何参数。
 4）他们没有任何返回类型，就像构造函数一样。

docs/cpp/32.md

@@ -26,7 +26,7 @@ structure_name variable_name
 Student s1, s2;
 ```
 
-然后我可以像这样访问 Student 结构的成员：
+然后我可以像这样访问`Student`结构的成员：
 
 ```cpp
 //Assigning name to first student

docs/cpp/34.md

@@ -2,16 +2,16 @@
 
 > 原文： [https://beginnersbook.com/2017/09/cpp-enumeration/](https://beginnersbook.com/2017/09/cpp-enumeration/)
 
-枚举是用户定义的数据类型，我们为变量指定一组值，变量只能从一小组可能的值中取出一个。我们使用 enum 关键字来定义枚举。
+枚举是用户定义的数据类型，我们为变量指定一组值，变量只能从一小组可能的值中取出一个。我们使用`enum`关键字来定义枚举。
 
 ```cpp
 enum direction {East, West, North, South}dir;
 ```
 
-这里枚举名称是只能取四个指定值之一的方向，声明末尾的 dir 是枚举变量。
+这里枚举名称是只能取四个指定值之一的方向，声明末尾的`dir`是枚举变量。
 
 让我们举一个简单的例子来理解这一点：
-这里我已经将值 West 分配给枚举变量 dir，当我显示 dir 的值时，它显示 1.这是因为默认情况下值从 0 开始递增，意思是东是 0，西是 1，北是 2，南是 3。
+这里我已经将值`West`分配给枚举变量`dir`，当我显示`dir`的值时，它显示 1.这是因为默认情况下值从 0 开始递增，意思是东是 0，西是 1，北是 2，南是 3。
 
 ## 简单的枚举示例
 
@@ -29,7 +29,7 @@ int main()
 
 ## 另一种声明枚举变量的方法
 
-正如我们在上面的例子中看到的，我在枚举声明中声明了枚举变量 dir，还有另一种声明枚举变量的方法。
+正如我们在上面的例子中看到的，我在枚举声明中声明了枚举变量`dir`，还有另一种声明枚举变量的方法。
 
 ```cpp
 #include <iostream>
@@ -52,9 +52,9 @@ int main(){
 ## 为什么在 C++中使用`enum`
 
 既然我们已经理解了什么是枚举以及如何在程序中使用它们，那么让我们讨论一下我们使用它们的原因：
-只有在我们期望变量具有一组可能的值时才使用枚举，例如，我们有一个保持方向的 dir 变量。由于我们有四个方向，这个变量可以取四个值中的任何一个，如果我们尝试为这个变量分配另一个随机值，它将抛出一个编译错误。这会增加编译时检查并避免通过传入无效常量而发生的错误。
+只有在我们期望变量具有一组可能的值时才使用枚举，例如，我们有一个保持方向的`dir`变量。由于我们有四个方向，这个变量可以取四个值中的任何一个，如果我们尝试为这个变量分配另一个随机值，它将抛出一个编译错误。这会增加编译时检查并避免通过传入无效常量而发生的错误。
 
-经常使用它们的另一个重要位置是[`switch-case`语句](https://beginnersbook.com/2017/08/cpp-switch-case/)，其中`case`块期望的所有值都可以在枚举中定义。这样我们就可以确保我们在 switch 括号中传递的 enum 变量没有采用它不应该接受的任何随机值。
+经常使用它们的另一个重要位置是[`switch-case`语句](https://beginnersbook.com/2017/08/cpp-switch-case/)，其中`case`块期望的所有值都可以在枚举中定义。这样我们就可以确保我们在`switch`括号中传递的`enum`变量没有采用它不应该接受的任何随机值。
 
 ## 如何更改`enum`的默认值
 

docs/cpp/35.md

@@ -2,9 +2,9 @@
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-inheritance/](https://beginnersbook.com/2017/08/cpp-inheritance/)
 
-继承是[面向对象编程系统（OOP）](https://beginnersbook.com/2017/08/cpp-oops-concepts/)的特性之一，它允许子类获取父类的属性（数据成员）和功能（成员函数）。
+继承是[面向对象编程系统（OOP）](https://beginnersbook.com/2017/08/cpp-oops-concepts/)的特性之一，它允许子类获取父类的属性（数据成员）和函数（成员函数）。
 
-**什么是儿童班？**
+**什么是子类？**
 继承另一个类的类称为子类，它也称为派生类或子类。
 **什么是父类？**
 其他类继承的类称为父类，超类或基类。
@@ -25,16 +25,16 @@ class child_class : access_modifier parent_class
 
 ## 在 C++编程中使用继承有什么好处
 
-继承的主要优点是**代码可重用性**和**可读性**。当子类继承父类的属性和功能时，我们不需要在子类中再次编写相同的代码。这使得重用代码变得更容易，使我们编写更少的代码，代码变得更具可读性。
+继承的主要优点是**代码可重用性**和**可读性**。当子类继承父类的属性和函数时，我们不需要在子类中再次编写相同的代码。这使得重用代码变得更容易，使我们编写更少的代码，代码变得更具可读性。
 
-让我们来看一个**现实生活中的例子**来理解这一点：让我们假设`Human`是一个具有高度，重量，颜色等属性的类，以及诸如吃（），睡觉（），做梦等功能（ ），工作（）等
-现在我们要创建`Male`和`Female`类，这些类是不同的，但由于男性和女性都是人类，他们共享一些共同的属性和行为（功能），所以他们可以继承 Human 类和 rest 的那些属性和功能可以单独写在它们的类中。
+让我们来看一个**现实生活中的例子**来理解这一点：让我们假设`Human`是一个具有高度，重量，颜色等属性的类，以及诸如`eat()`，`sleep()`，`dream()`，`work()`等函数。
+现在我们要创建`Male`和`Female`类，这些类是不同的，但由于男性和女性都是人类，他们共享一些共同的属性和行为（函数），所以他们可以继承`Human`类，其余的那些属性和函数可以单独写在它们的类中。
 这种方法使我们编写更少的代码，因为这两个类从基类继承了几个属性和函数，因此我们不需要重写它们。此外，这使得更容易阅读代码。
 
 ## 继承示例
 
 在我们讨论继承类型之前，让我们举个例子：
-这里我们有两个类`Teacher`和`MathTeacher`，MathTeacher 类继承了 Teacher 类，这意味着`Teacher`是一个父类，`MathTeacher`是一个儿童班。子类可以使用父类的属性`collegeName`。
+这里我们有两个类`Teacher`和`MathTeacher`，`MathTeacher`类继承了`Teacher`类，这意味着`Teacher`是一个父类，`MathTeacher`是一个子类。子类可以使用父类的属性`collegeName`。
 
 > 另一个要注意的重点是，当我们创建子类的对象时，它调用子类的构造函数，子类构造函数自动调用基类的构造函数。
 
@@ -87,7 +87,7 @@ Main Subject: Math
 ### 单继承
 
 在单继承中，一个类完全继承一个类。
-例如：假设我们有 A 级和 B 级
+例如：假设我们有`A`类和`B`类
 
 ```cpp
 B inherits A

docs/cpp/36.md

@@ -45,7 +45,7 @@ Output: 66
 
 ## 2）运行时多态
 
-函数重写是 Runtime 多态的一个例子。
+函数重写是运行时多态的一个例子。
 **函数覆盖**：当子类声明一个已存在于父类中的方法时，这称为函数覆盖，这里子类覆盖父类。
 
 在函数重写的情况下，我们有两个相同函数的定义，一个是父类，一个是子类。在**运行时**确定对函数的调用，以决定调用函数的哪个定义，这就是它被称为运行时多态的原因。

docs/cpp/38.md

@@ -73,13 +73,13 @@ Output:
 Function of Parent Class
 ```
 
-如果你想从覆盖函数调用 Overridden 函数，那么你可以这样做：
+如果你想从覆盖函数调用被覆盖的函数，那么你可以这样做：
 
 ```cpp
 parent_class_name::function_name
 ```
 
-要在上面的例子中执行此操作，我们可以在子类的 disp（）函数中编写以下语句：
+要在上面的例子中执行此操作，我们可以在子类的`disp()`函数中编写以下语句：
 
 ```cpp
 BaseClass::disp();

docs/cpp/39.md

@@ -10,7 +10,7 @@
 
 在这里看到问题。即使我们有父类指针指向子类的实例（对象），也会调用该函数的父类版本。
 
-您可能在想我为什么创建指针，我可以简单地创建子类的对象，如下所示：Dog obj;并将 Dog 实例分配给它。好吧，在这个例子中我只有一个子类，但是当我们有一个包含多个子类的大项目时，不建议单独创建子类的对象，因为它增加了复杂性并且代码容易出错。在此示例之后更加清晰。
+您可能在想我为什么创建指针，我可以简单地创建子类的对象，如下所示：`Dog obj`;并将`Dog`实例分配给它。好吧，在这个例子中我只有一个子类，但是当我们有一个包含多个子类的大项目时，不建议单独创建子类的对象，因为它增加了复杂性并且代码容易出错。在此示例之后更加清晰。
 
 ```cpp
 #include<iostream>
@@ -45,7 +45,7 @@ This is a generic Function
 
 ## 示例 2：使用虚函数
 
-在这种情况下，输出是 Woof，这是我们所期望的。在这种情况下会发生什么？由于我们将函数 animalSound（）标记为虚拟，因此在运行时解析对函数的调用，编译器在运行时确定对象的类型并调用适当的函数。
+在这种情况下，输出是`Woof`，这是我们所期望的。在这种情况下会发生什么？由于我们将函数`animalSound()`标记为虚拟，因此在运行时解析对函数的调用，编译器在运行时确定对象的类型并调用适当的函数。
 
 ```cpp
 #include<iostream>

docs/cpp/40.md

@@ -8,13 +8,13 @@
 
 为此：
 1）将所有数据成员设为私有。
-2）为每个数据成员创建公共 setter 和 getter 函数，使 set 函数设置 data 成员的值并获取函数获取 data 成员的值。
+2）为每个数据成员创建公共设置器和获取器函数，使设置函数设置数据成员的值并获取函数获取数据成员的值。
 
 让我们在一个示例程序中看到这个：
 
 ## C++中的封装示例
 
-这里我们有两个数据成员 num 和 ch，我们已将它们声明为私有，因此它们在类外无法访问，这样我们就隐藏了数据。获取和设置这些数据成员的值的唯一方法是通过公共 getter 和 setter 函数。
+这里我们有两个数据成员`num`和`ch`，我们已将它们声明为私有，因此它们在类外无法访问，这样我们就隐藏了数据。获取和设置这些数据成员的值的唯一方法是通过公共设置器和获取器函数。
 
 ```cpp
 #include<iostream>

docs/cpp/42.md

@@ -14,7 +14,7 @@ virtual void fun() = 0;
 
 让我们借助现实生活中的例子来理解这一点。让我们说我们有一个类`Animal`，动物睡眠，动物发出声音等等。现在我只考虑这两个行为并创建一个具有两个函数`sound()`和`sleeping()`的类 Animal。
 
-现在，我们知道动物的声音是不同的猫说“喵”，狗说“woof”。那么我在`Animal`类中为函数`sound()`提供了什么实现，这样做的唯一和正确的方法是使这个函数纯粹抽象，这样我就不需要在 Animal 类中给出实现但是所有继承 Animal 的类 class 必须为此函数提供实现。这样我确保所有动物都有声音，但它们有独特的声音。
+现在，我们知道动物的声音是不同的猫说“喵”，狗说“汪”。那么我在`Animal`类中为函数`sound()`提供了什么实现，这样做的唯一和正确的方法是使这个函数纯粹抽象，这样我就不需要在`Animal`类中给出实现但是所有继承`Animal`的类必须为此函数提供实现。这样我确保所有动物都有声音，但它们有独特的声音。
 
 可以在 C++程序中编写相同的示例，如下所示：
 

docs/cpp/43.md

@@ -6,7 +6,7 @@
 
 ## 将对象传递给函数
 
-可以将对象传递给函数，就像我们[将结构传递给函数](https://beginnersbook.com/2017/09/cpp-structure-and-function/)一样。在 A 类中，我们有一个函数`disp()`，我们在其中传递类`A`的对象。类似地，我们可以将另一个类的对象传递给不同类的函数。
+可以将对象传递给函数，就像我们[将结构传递给函数](https://beginnersbook.com/2017/09/cpp-structure-and-function/)一样。在`A`类中，我们有一个函数`disp()`，我们在其中传递类`A`的对象。类似地，我们可以将另一个类的对象传递给不同类的函数。
 
 ```cpp
 #include <iostream>