2020-07-07 21:39:41

docs/cpp/10.md

@@ -8,9 +8,9 @@
 
 例如，根据学生获得的分数分配成绩（A，B，C）。
 
-*   如果百分比高于 **90** ，则将等级**分配为 A**
-*   如果百分比高于 **75** ，则指定等级 **B**
-*   如果百分比高于 **65** ，请指定等级 **C**
+*   如果百分比高于 **90**，则将等级**分配为 A**
+*   如果百分比高于 **75**，则指定等级 **B**
+*   如果百分比高于 **65**，请指定等级 **C**
 
 * * *
 
@@ -150,7 +150,7 @@ int main() {
 }
 ```
 
-**Output 1**
+**输出 1**
 
 ```cpp
 Enter an integer: 4
@@ -162,7 +162,7 @@ This line is always printed.
 
 在这里，我们输入`4`。 因此，条件为`true`。 因此，将执行`if`主体内部的语句。
 
-**Output 2**
+**输出 2**
 
 ```cpp
 Enter an integer: -4
@@ -234,7 +234,7 @@ else {
 }
 ```
 
-**Output 1**
+**输出 1**
 
 ```cpp
 Enter an integer: 1
@@ -242,7 +242,7 @@ You entered a positive integer: 1.
 This line is always printed.
 ```
 
-**Output 2**
+**输出 2**
 
 ```cpp
 Enter an integer: -2
@@ -325,7 +325,7 @@ int main() {
 }
 ```
 
-**Output 1**
+**输出 1**
 
 ```cpp
 Enter an integer: 34
@@ -333,7 +333,7 @@ The number is even.
 This line is always printed.
 ```
 
-**Output 2**
+**输出 2**
 
 ```cpp
 Enter an integer: 35
@@ -341,7 +341,7 @@ The number is odd.
 This line is always printed.
 ```
 
-**Output 3**
+**输出 3**
 
 ```cpp
 Enter an integer: 0

docs/cpp/12.md

@@ -10,7 +10,7 @@
 
 那只是一个简单的例子； 通过有效利用循环，我们可以在程序中实现更高的效率和复杂性。
 
-C++ 中有 **3** 类型的循环。
+C++ 中有 **3** 种循环。
 
 1.  `for`循环
 2.  `while`循环

docs/cpp/17.md

@@ -16,7 +16,7 @@
 有两种功能：
 
 1.  **标准库函数**：在 C++ 中预定义
-2.  **用户定义的功能**：由用户创建
+2.  **用户定义的函数**：由用户创建
 
 在本教程中，我们将主要关注用户定义的函数。
 

docs/cpp/21.md

@@ -182,7 +182,7 @@ int main()
 
 在第二个函数调用期间，没有创建新的变量`var`。 将相同的`var`加 1，然后显示在屏幕上。
 
-**如果未将`var`指定为静态变量**，则输出上述程序
+**如果未将`var`指定为静态变量**，则上述程序输出：
 
 ```cpp
 1

docs/cpp/3.md

@@ -20,7 +20,7 @@ int age = 14;
 
 在下一个教程中，我们将详细了解所有数据类型。
 
-变量的值可以更改，因此名称为**变量**。
+变量的值可以更改，因此称为**变量**。
 
 ```cpp
 int age = 14;   // age is 14

docs/cpp/30.md

@@ -45,7 +45,7 @@ int foo;
 
 `int`指定变量`foo`仅可容纳整数元素。 同样，结构定义仅指定结构变量在定义时所具有的属性。
 
-**注意**：请记住以分号**（;）结尾的声明**
+**注意**：请记住以分号（`;`）结尾的声明
 
 * * *
 

docs/cpp/31.md

@@ -139,6 +139,6 @@ void displayData(Person p)
 p = getData(p); 
 ```
 
-**注意**：如果两个结构变量的类型相同，则可以使用赋值运算符 **=** 将结构变量的所有成员的值分配给另一个结构。 您无需手动分配每个成员。
+**注意**：如果两个结构变量的类型相同，则可以使用赋值运算符`=`将结构变量的所有成员的值分配给另一个结构。 您无需手动分配每个成员。
 
 然后将结构变量`p`传递给`displayData()`函数，该函数显示信息。
\ No newline at end of file

docs/cpp/32.md

@@ -74,7 +74,7 @@ Distance = 4 feet 3.5 inches
 
 **注意**：由于指针`ptr`指向此程序中的变量`d`，因此`(*ptr).inch`和`d.inch`是完全相同的单元格。 同样，`(*ptr).feet`和`d.feet`是完全相同的单元格。
 
-使用指针访问成员函数的语法很丑陋，还有更常见的替代符号**->** 。
+使用指针访问成员函数的语法很丑陋，还有更常见的替代符号`->`。
 
 ```cpp
 ptr->feet is same as (*ptr).feet

docs/cpp/33.md

@@ -4,7 +4,7 @@
 
 #### 在本文中，您将学习使用枚举（`enum`）。 此外，您还将学习 C++ 编程中通常使用枚举的地方。
 
-枚举是用户定义的数据类型，由整数常量组成。 要定义枚举，使用关键字**枚举**。
+枚举是用户定义的数据类型，由整数常量组成。 要定义枚举，使用关键字`enum`。
 
 ```cpp
 enum season { spring, summer, autumn, winter };
@@ -38,9 +38,9 @@ enum boolean { false, true };
 enum boolean check;
 ```
 
-在此，创建类型为 **`enum boolean`** 的变量`check`。
+在此，创建类型为`enum boolean`的变量`check`。
 
-这是使用不同语法声明相同`检查`变量的另一种方法。
+这是使用不同语法声明相同`check`变量的另一种方法。
 
 ```cpp
 enum boolean 

docs/cpp/40.md

@@ -47,7 +47,7 @@ int main()
 
 **注意**：您的系统上可能不会得到相同的结果。
 
-开头的 **0x** 表示地址为十六进制格式。
+开头的`0x`表示地址为十六进制格式。
 
 请注意，第一个地址与第二个地址相差 4 个字节，第二个地址与第三个地址相差 4 个字节。
 
@@ -74,9 +74,9 @@ int* p;
 
 上面的语句定义了一个指针变量`p`。 它保存内存地址
 
-星号是解引用运算符，表示**指向** **的指针。**
+星号是解引用运算符，表示**指向`p`的指针**。
 
-此处，指针`p`是指向`int`的**指针，即它指向内存地址中的整数值。**
+此处，指针`p`是指向`int`的**指针**，即它指向内存地址中的整数值。
 
 * * *
 
@@ -86,9 +86,9 @@ int* p;
 
 要获取存储在内存地址中的值，我们使用解引用运算符（`*`）。
 
-**例如**：如果`num`变量存储在内存地址`0x123`中，并且它包含值 **5** 。
+**例如**：如果`num`变量存储在内存地址`0x123`中，并且它包含值 **5**。
 
-**引用（`&`）**运算符给出值`0x123`，而**取消引用（`*`）**运算符给出值 **5** 。
+**引用（`&`）**运算符给出值`0x123`，而**取消引用（`*`）**运算符给出值 **5**。
 
 **注意**：在 C++ 指针的声明中使用的（`*`）符号不是取消引用指针。 只是创建指针的类似符号。
 
@@ -96,7 +96,7 @@ int* p;
 
 ## 示例 2：C++ 指针
 
-**C++ 程序演示指针的工作。**
+**演示指针的工作的 C++ 程序。**
 
 ```cpp
 #include <iostream>

docs/cpp/42.md

@@ -57,7 +57,7 @@ b = 1
 
 在`main()`中，定义了两个整数变量`a`和`b`。 这些整数通过引用传递给函数`swap()`。
 
-编译器可以识别出此引用是通过引用传递的，因为函数定义为`void swap(int& n1, int& n2)`（请在数据类型后注意 **&** 符号）。
+编译器可以识别出此引用是通过引用传递的，因为函数定义为`void swap(int& n1, int& n2)`（请在数据类型后注意`&`符号）。
 
 在`swap()`函数中仅接收变量`a`和`b`的引用（地址），并且在变量的原始地址中进行交换。
 
@@ -118,4 +118,4 @@ void swap(int* n1, int* n2) {
 
 `*n1`和`*n2`分别给出存储在地址`n1`和`n2`中的值。
 
-由于`n1`包含`和`的地址，因此对`*n1`执行的任何操作也会更改`main()`函数中的`和`的值。 类似地，`b`将具有与`*n2`相同的值。
\ No newline at end of file
+由于`n1`包含`a`的地址，因此对`*n1`执行的任何操作也会更改`main()`函数中的`a`的值。 类似地，`b`将具有与`*n2`相同的值。
\ No newline at end of file

docs/cpp/43.md

@@ -97,7 +97,7 @@ ptr = new float[num];
 delete [] ptr;
 ```
 
-方括号 **[]** 表示数组已删除。 如果您需要删除单个对象，则无需使用方括号。
+方括号`[]`表示数组已删除。 如果您需要删除单个对象，则无需使用方括号。
 
 ```cpp
 delete ptr;

docs/cpp/45.md

@@ -34,7 +34,7 @@
 
 这使您的代码更简洁，易于理解和可扩展。
 
-**重要的是要记住**：在处理继承时，每个派生类都应满足**“不是”** 基类的条件。 在上面的示例中，数学老师**是**人，足球先生**是**人。 您不能拥有：商人**是**企业。
+**重要的是要记住**：在处理继承时，每个派生类都应满足“**是**”基类的条件。 在上面的示例中，数学老师**是**人，足球先生**是**人。 您不能拥有：商人**是**企业。
 
 * * *
 
@@ -58,11 +58,11 @@ class Footballer : public Person
 
 ```
 
-在以上示例中，类别`人员`是基类，类别`MathsTeacher`和`Footballer`是从*人员*派生的。
+在以上示例中，类别`Person`是基类，类别`MathsTeacher`和`Footballer`是从`Person`派生的。
 
 派生的类与类的声明一起显示，后跟冒号，关键字`public`和派生该类的基类的名称。
 
-由于`MathsTeacher`和`Footballer`源自`Person`，因此可以从中访问`人员`的所有数据成员和成员功能。
+由于`MathsTeacher`和`Footballer`源自`Person`，因此可以从中访问`Person`的所有数据成员和成员功能。
 
 * * *
 

docs/cpp/46.md

@@ -22,7 +22,7 @@ class derived : access_specifier base
 
 ```
 
-**注意**：可以使用`public`，`受保护的`或`私有`关键字代替上述中使用的`access_specifier`术语 码。
+**注意**：可以使用`public`，`protected`或`private`关键字代替上述中使用的`access_specifier`术语。
 
 ## C++ 中的公共继承，保护继承和私有继承的示例
 

docs/cpp/49.md

@@ -16,7 +16,7 @@ OOP 的重要概念之一是数据隐藏，即[非成员函数](/cpp-programming
 
 如果将函数定义为友元函数，则可以使用[函数](/cpp-programming/function "C++ functions")访问类的私有数据和受保护数据。
 
-编译器通过使用关键字**友元**知道给定的函数是友元函数。
+编译器通过使用关键字`friend`知道给定的函数是友元函数。
 
 为了访问数据，应该在类的主体内部（可以在类内部的任何地方，无论是私有的还是公共的部分），从关键字`friend`开始声明友元函数。
 

docs/cpp/51.md

@@ -10,16 +10,16 @@
 
 模板的概念可以两种不同的方式使用：
 
-*   功能模板
+*   函数模板
 *   类模板
 
 * * *
 
-## 功能模板
+## 函数模板
 
-功能模板的工作方式与普通[功能](/cpp-programming/function "C++ functions")类似，但有一个按键差异。
+函数模板的工作方式与普通[功能](/cpp-programming/function "C++ functions")类似，但有一个按键差异。
 
-单个功能模板可以一次处理不同的数据类型，但是单个普通功能只能处理一组数据类型。
+单个函数模板可以一次处理不同的数据类型，但是单个普通功能只能处理一组数据类型。
 
 通常，如果需要对两种或更多种类型的数据执行相同的操作，则可以使用函数重载来创建具有所需函数声明的两个函数。
 
@@ -27,19 +27,19 @@
 
 * * *
 
-### 如何声明功能模板？
+### 如何声明函数模板？
 
-功能模板以关键字**模板**开头，后跟`**< >**`内的模板参数，然后是函数声明。
+函数模板以关键字`template`开头，后跟`< >`内的模板参数，然后是函数声明。
 
 ```cpp
-**template** <**class** T>
+template <class T>
 T someFunction(T arg)
 {
    ... .. ...
 }
 ```
 
-在上面的代码中，`T`是接受不同数据类型（`int`，`float`）的模板参数，而**类**是关键字。
+在上面的代码中，`T`是接受不同数据类型（`int`，`float`）的模板参数，而`class`是关键字。
 
 您也可以使用关键字`typename`代替上面示例中的类。
 
@@ -47,9 +47,9 @@ T someFunction(T arg)
 
 * * *
 
-### 示例 1：查找最大数量的功能模板
+### 示例 1：查找最大数量的函数模板
 
-**程序使用功能模板显示两个数字中最大的一个。**
+**使用函数模板显示两个数字中最大的一个的程序。**
 
 ```cpp
 // If two characters are passed to function template, character with larger ASCII value is displayed.
@@ -119,9 +119,9 @@ z has larger ASCII value.
 
 * * *
 
-### 示例 2：使用功能模板交换数据
+### 示例 2：使用函数模板交换数据
 
-**程序使用功能模板交换数据。**
+**使用函数模板交换数据的程序。**
 
 ```cpp
 #include <iostream>
@@ -189,7 +189,7 @@ c2 = a
 
 ## 类模板
 
-与功能模板一样，您也可以为通用类操作创建类模板。
+与函数模板一样，您也可以为通用类操作创建类模板。
 
 有时，您需要一个适用于所有类的类实现，只是所使用的数据类型不同。
 
@@ -204,7 +204,7 @@ c2 = a
 ### 如何声明一个类模板？
 
 ```cpp
-**template** <**class** T>
+template <class T>
 class className
 {
    ... .. ...

docs/cpp/53.md

@@ -40,7 +40,7 @@ Hello World!
     在 C++ 中，以`//`开头的任何行都是注释。 注释供阅读代码的人员使用，以更好地理解程序的功能。 C++ 编译器完全忽略了它。
 2.  `#include <iostream>`
 
-    `#include`是预处理程序指令，用于在程序中包含文件。 上面的代码包括 **iostream** 文件的内容。
+    `#include`是预处理程序指令，用于在程序中包含文件。 上面的代码包括`iostream`文件的内容。
 
     这使我们可以在程序中使用`cout`在屏幕上打印输出。
 
@@ -54,17 +54,17 @@ Hello World!
 
     `std::cout`打印引号内的内容。 必须在其后跟`<<`，然后是格式字符串。 在我们的示例中，`"Hello World!"`是格式字符串。
 
-    **注意**：，`;`用于指示语句的结尾。
+    **注意**：`;`用于指示语句的结尾。
 5.  `return 0;`
 
-    语句是程序的**“退出状态”** 。 简单来说，程序以该语句结束。
+    该语句是程序的“**退出状态**”。 简单来说，程序以该语句结束。
 
 * * *
 
 ## 带走的东西
 
 *   我们使用`std:cout`以便在屏幕上打印输出。
-*   如果要使用`std::cout`，则必须包含 **iostream** 。
+*   如果要使用`std::cout`，则必须包含`iostream`。
 *   代码的执行从`main()`函数开始。 此功能是强制性的。 这是不执行任何操作的有效 C++ 程序。
 
 ```cpp

docs/cpp/55.md

@@ -73,7 +73,7 @@ int main()
 1 2 3 4 5
 ```
 
-**Source Code**
+**源代码**
 
 ```cpp
 #include <iostream>
@@ -110,7 +110,7 @@ D D D D
 E E E E E
 ```
 
-**Source Code**
+**源代码**
 
 ```cpp
 #include <iostream>
@@ -151,7 +151,7 @@ int main()
 *
 ```
 
-**Source Code**
+**源代码**
 
 ```cpp
 #include <iostream>
@@ -189,7 +189,7 @@ int main()
 1
 ```
 
-**Source Code**
+**源代码**
 
 ```cpp
 #include <iostream>
@@ -229,7 +229,7 @@ int main()
 * * * * * * * * *
 ```
 
-**Source Code**
+**源代码**
 
 ```cpp
 #include <iostream>
@@ -272,7 +272,7 @@ int main()
 5 6 7 8 9 8 7 6 5
 ```
 
-**Source Code**
+**源代码**
 
 ```cpp
 #include <iostream>
@@ -327,7 +327,7 @@ int main()
         *
 ```
 
-**Source Code**
+**源代码**
 
 ```cpp
 #include <iostream>
@@ -371,7 +371,7 @@ int main()
  1  5   10   10  5   1 
 ```
 
-**Source Code**
+**源代码**
 
 ```cpp
 #include <iostream>
@@ -416,7 +416,7 @@ int main()
 7 8 9 10
 ```
 
-**Source Code**
+**源代码**
 
 ```cpp
 #include <iostream>

docs/cpp/67.md

@@ -47,6 +47,6 @@ Sum = 1275
 
 该程序假定用户始终输入正数。
 
-如果用户输入负数，则显示 **Sum = 0** 并终止程序。
+如果用户输入负数，则显示`Sum = 0`并终止程序。
 
 该程序也可以使用递归来完成。 查看本文，了解[使用递归](/cpp-programming/examples/natural-number-sum-recursion "C++ find sum of natural numbers using recursion")计算自然数之和。
\ No newline at end of file

docs/cpp/7.md

@@ -76,7 +76,7 @@ a % b = 1
 
 在这里，运算符`+`，`-`和`*`分别计算了我们可能期望的加，减和乘。
 
-**/除法运算符**
+**除法运算符**
 
 注意我们程序中的操作`(a / b)`。`/`运算符是除法运算符。
 
@@ -94,7 +94,7 @@ In C++,
 
 **模运算符**
 
-模运算符`%`计算余数。 当`a = 9`除以`b = 4`时，其余为 **1** 。
+模运算符`%`计算余数。 当`a = 9`除以`b = 4`时，余数为 **1**。
 
 **注意**：`%`运算符只能与整数一起使用。
 
@@ -102,7 +102,7 @@ In C++,
 
 ### 增减运算符
 
-C++ 还提供了递增和递减运算符：分别为`++`和`--`。`++`将操作数的值增加 **1** ，而`--`将其减少值 **1** 。
+C++ 还提供了递增和递减运算符：分别为`++`和`--`。`++`将操作数的值增加 **1**，而`--`将其减少值 **1**。
 
 例如，
 
@@ -113,7 +113,7 @@ int num = 5;
 ++num; 
 ```
 
-在此，`num`的值从其初始值 **5** 增加到 **6** 。
+在此，`num`的值从其初始值 **5** 增加到 **6**。
 
 ### 示例 2：递增和递减运算符
 
@@ -220,15 +220,15 @@ a > b;
 
 在此，`>`是关系运算符。 它检查`a`是否大于`b`。
 
-如果关系为**为真**，则返回 **1** ，而如果关系为**为假**，则返回 **0** 。
+如果关系为**为真**，则返回 **1**，而如果关系为**为假**，则返回 **0**。
 
 | Operator | 含义 | Example |
-| `==` | 等于 | `3 == 5`给了我们**错误** |
-| `!=` | 不等于 | `3 != 5`给了我们**真实的** |
-| `>` | 比...更棒 | `3 > 5`给了我们**错误** |
-| `<` | 少于 | `3 < 5`给了我们**真实的** |
-| `>=` | 大于或等于 | `3 >= 5`给我们**假** |
-| `<=` | 小于或等于 | `3 <= 5`给了我们**真实的** |
+| `==` | 等于 | `3 == 5`给了我们`false` |
+| `!=` | 不等于 | `3 != 5`给了我们`true` |
+| `>` | 比...更棒 | `3 > 5`给了我们`false` |
+| `<` | 少于 | `3 < 5`给了我们`true` |
+| `>=` | 大于或等于 | `3 >= 5`给我们`false` |
+| `<=` | 小于或等于 | `3 <= 5`给了我们`true` |
 
 ### 示例 4：关系运算符
 
@@ -281,7 +281,7 @@ int main() {
 
 ## 4\. C++ 逻辑运算符
 
-逻辑运算符用于检查表达式是 **true** 还是 **false** 。 如果表达式为**为真**，则返回 **1** ，而如果表达式为**为假**，则返回 **0** 。
+逻辑运算符用于检查表达式是`true`还是`false`。 如果表达式为`true`，则返回 **1**，而如果表达式为`false`，则返回 **0**。
 
 | Operator | Example | Meaning |
 | --- | --- | --- |
@@ -359,16 +359,16 @@ int main() {
 !(5 == 5) is 0 
 ```
 
-**逻辑操作程序**的说明
+**逻辑运算符**的说明
 
-*   `(3 != 5) && (3 < 5)`的值为 **1** ，因为两个操作数`(3 != 5)`和`(3 < 5)`均为 **1** （是）。
-*   `(3 == 5) && (3 < 5)`的值为 **0** ，因为操作数`(3 == 5)`为 **0** （否）。
-*   `(3 == 5) && (3 > 5)`的值为 **0** ，因为两个操作数`(3 == 5)`和`(3 > 5)`均为 **0** （否）。
-*   `(3 != 5) || (3 < 5)`的值为 **1** ，因为两个操作数`(3 != 5)`和`(3 < 5)`均为 **1** （是）。
-*   `(3 != 5) || (3 > 5)`的值为 **1** ，因为操作数`(3 != 5)`为 **1** （是）。
-*   `(3 == 5) || (3 > 5)`的值为 **0** ，因为两个操作数`(3 == 5)`和`(3 > 5)`均为 **0** （否）。
-*   `!(5 == 2)`的值为 **1** ，因为操作数`(5 == 2)`为 **0** （否）。
-*   `!(5 == 5)`的值为 **0** ，因为操作数`(5 == 5)`为 **1** （是）。
+*   `(3 != 5) && (3 < 5)`的值为 **1**，因为两个操作数`(3 != 5)`和`(3 < 5)`均为 **1**（`true`）。
+*   `(3 == 5) && (3 < 5)`的值为 **0**，因为操作数`(3 == 5)`为 **0** （`false`）。
+*   `(3 == 5) && (3 > 5)`的值为 **0**，因为两个操作数`(3 == 5)`和`(3 > 5)`均为 **0**（`false`）。
+*   `(3 != 5) || (3 < 5)`的值为 **1**，因为两个操作数`(3 != 5)`和`(3 < 5)`均为 **1**（`true`）。
+*   `(3 != 5) || (3 > 5)`的值为 **1**，因为操作数`(3 != 5)`为 **1**（`true`）。
+*   `(3 == 5) || (3 > 5)`的值为 **0**，因为两个操作数`(3 == 5)`和`(3 > 5)`均为 **0**（`false`）。
+*   `!(5 == 2)`的值为 **1**，因为操作数`(5 == 2)`为 **0**（`false`）。
+*   `!(5 == 5)`的值为 **0**，因为操作数`(5 == 5)`为 **1**（`true`）。
 
 * * *