2019-08-14 17:53:15

docs/c-example/26.md

-# 阵列程序
+# 数组程序
\ No newline at end of file

docs/c-example/35.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2015/02/quicksort-program-in-c/](https://beginnersbook.com/2015/02/quicksort-program-in-c/)
 
-Quicksort 是一种分而治之的算法。步骤如下：1）从数组中选取一个元素，该元素称为 pivot 元素。 2）将两个数组中未排序的元素数组除以第一个子数组中小于数据透视的值，而值大于数据透视的所有元素都在第二个子数组中（相等的值可以是任意一种）。此步骤称为分区操作。 3）递归地重复步骤 2（直到子阵列被排序）到具有较小值的元素的子阵列，并且分别重复到具有较大值的元素的子阵列。我们在以下 C 程序中实现了相同的逻辑。
+Quicksort 是一种分而治之的算法。步骤如下：1）从数组中选取一个元素，该元素称为 pivot 元素。 2）将两个数组中未排序的元素数组除以第一个子数组中小于数据透视的值，而值大于数据透视的所有元素都在第二个子数组中（相等的值可以是任意一种）。此步骤称为分区操作。 3）递归地重复步骤 2（直到子数组被排序）到具有较小值的元素的子数组，并且分别重复到具有较大值的元素的子数组。我们在以下 C 程序中实现了相同的逻辑。
 
 #### C 程序 - Quicksort 算法实现
 

docs/c-example/39.md

@@ -5,7 +5,7 @@
 在本教程中，我们将编写一个 C 程序，使用指针变量逐个字符地打印 String。要了解此程序，您应该具备以下主题的基本知识：
 
 *   [C 指针](https://beginnersbook.com/2014/01/c-pointers/)
-*   [C 阵列](https://beginnersbook.com/2014/01/c-arrays-example/)
+*   [C 数组](https://beginnersbook.com/2014/01/c-arrays-example/)
 
 ## 程序使用指针打印字符串
 

docs/c-example/SUMMARY.md

@@ -22,7 +22,7 @@
     +   [C 程序在不使用函数 strlen（）的情况下查找 String 的长度](23.md)
     +   [C 程序在不使用 strcat 的情况下连接两个字符串](24.md)
     +   [C 程序使用递归来反转字符串](25.md)
-+   [阵列程序](26.md)
++   [数组程序](26.md)
     +   [C 程序按升序排列数字](27.md)
     +   [C 程序查找数组的最大元素](28.md)
     +   [C 程序使用指针，递归和扩展来查找数组元素的总和。功能](29.md)

docs/cpp/12.md

-# 使用示例在 C++中执行 do-while 循环
+# 在 C++中执行`do-while`循环
 
 > 原文： [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 循环中执行 - 首先执行，然后评估条件。
 
-#### do-while 循环的语法
+#### `do-while`循环的语法
 
 ```
 do
@@ -13,12 +13,12 @@ do
 } while(condition);
 ```
 
-## do-while 循环如何工作？
+## `do-while`循环如何工作？
 
 首先，循环内的语句执行，然后条件得到评估，如果条件返回 true，则控制跳转到“do”以进一步重复执行它，这会重复发生，直到条件返回 false。一旦条件返回 false，控制就会在 do-while 之后跳转到程序中的下一个语句。
 ![C++ do while loop flow diagram](img/8a5f1d9785c32edcb5c78c6f602d2b04.jpg)
 
-## C++中的 do-while 循环示例
+## C++中的`do-while`循环示例
 
 ```
 #include <iostream>
@@ -45,7 +45,7 @@ Value of num: 6
 
 ```
 
-## 示例：使用 do-while 循环显示数组元素
+## 示例：使用`do-while`循环显示数组元素
 
 这里我们有一个整数数组，它有四个元素。我们使用 do-while 循环显示它的元素。
 

docs/cpp/13.md

-# 使用示例在 C++中继续语句
+# C++中的`continue`语句
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-continue-statement/](https://beginnersbook.com/2017/08/cpp-continue-statement/)
 
 在循环内使用 continue 语句。每当在循环内遇到 continue 语句时，控件直接跳转到循环的开头以进行下一次迭代，跳过循环体内语句的执行以进行当前迭代。
 
-#### continue 语句的语法
+#### `continue`语句的语法
 
 ```
 continue;
 ```
 
-## 示例：在 for 循环中继续语句
+## 示例：`for`循环中的`continue`语句
 
 正如你可以看到输出缺少值 3，但循环的[通过 num 值 0 到 6 进行迭代。这是因为我们在循环中设置了一个条件，这样就可以了当 num 值等于 3 时遇到语句。因此，对于此迭代，循环跳过 cout 语句并开始下一次循环迭代。](https://beginnersbook.com/2017/08/cpp-for-loop/)
 
@@ -41,11 +41,11 @@ int main(){
 0 1 2 4 5 6
 ```
 
-## 继续声明的流程图
+## `continue`语句的流程图
 
 ![C++ continue statement](img/0eb6023039f4c9bea7a24ed0d9e861d5.jpg)
 
-## 示例：在 While 循环中使用 continue
+## 示例：在`while`循环中使用`continue`
 
 ```
 #include <iostream>
@@ -75,7 +75,7 @@ Value of j: 1
 Value of j: 0
 ```
 
-## 在 do-While 循环中继续的示例
+## `do-while`循环中`continue`的示例
 
 ```
 #include <iostream>

docs/cpp/14.md

-# 使用示例在 C++中使用 break 语句
+# 在 C++中使用`break`语句
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-break-statement/](https://beginnersbook.com/2017/08/cpp-break-statement/)
 
@@ -8,17 +8,17 @@ a）使用 break 语句立即退出循环。每当在循环内遇到 break 语
 
 b）用于箱体后的开关箱控制结构。通常，在 switch case 中的所有情况都跟一个 break 语句，以避免后续的情况（参见下面的例子）执行。无论何时在`switch-case`块中遇到，控制器都从`switch-case`体中出来。
 
-#### break 语法的语法
+#### `break`语句的语法
 
 ```
 break;
 ```
 
-## break 语句流程图
+## `break`语句流程图
 
 ![C++ break statement](img/d3819b69c1a3d4e42ba2ebd7eb6c8dfc.jpg)
 
-## 示例 - 在 while 循环中使用 break 语句
+## 示例 - 在`while`循环中使用`break`语句
 
 在下面的示例中，我们有一个从 10 到 200 运行的 while 循环，但由于我们有一个在循环计数器变量值达到 12 时遇到的 break 语句，循环终止并且控件跳转到程序中的下一个语句之后循环体。
 
@@ -48,7 +48,7 @@ Value of num is: 12
 Hey, I'm out of the loop
 ```
 
-## 示例：for 循环中的 break 语句
+## 示例：`for`循环中的`break`语句
 
 ```
 #include <iostream>
@@ -76,7 +76,7 @@ var: 197
 Hey, I'm out of the loop
 ```
 
-## 示例：Switch Case 中的 break 语句
+## 示例：`switch-case`中的`break`语句
 
 ```
 #include <iostream>

docs/cpp/15.md

-# 使用示例在 C++中转到 goto 语句
+# C++中的`goto`语句
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-goto-statement/](https://beginnersbook.com/2017/08/cpp-goto-statement/)
 
@@ -25,7 +25,7 @@ label2:
 
 > goto 语句几乎从不在任何开发中使用，因为它们很复杂，使得程序的可读性更低，更容易出错。代替 goto，你可以使用 [continue](https://beginnersbook.com/2017/08/cpp-continue-statement/) 和 [break 语句](https://beginnersbook.com/2017/08/cpp-break-statement/)。
 
-## C++中 goto 语句的示例
+## C++中`goto`语句的示例
 
 ```
 #include <iostream>

docs/cpp/16.md

-# 功能
+# 函数
\ No newline at end of file

docs/cpp/17.md

-# C++中的函数与示例
+# C++中的函数
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-functions/](https://beginnersbook.com/2017/08/cpp-functions/)
 
@@ -63,7 +63,7 @@ int sum(int num1, int num2){
 }
 ```
 
-**功能声明：**你已经看到我用两种方式编写了相同的程序，在第一个程序中我没有任何函数声明，在第二个程序中我在程序开头有函数声明。问题是，当您在程序中的 main（）函数之前定义函数时，您不需要执行函数声明，但如果您在 main（）函数之后编写函数，就像我们在第二个程序中那样，那么您需要先声明函数，否则会出现编译错误。
+**函数声明：**你已经看到我用两种方式编写了相同的程序，在第一个程序中我没有任何函数声明，在第二个程序中我在程序开头有函数声明。问题是，当您在程序中的 main（）函数之前定义函数时，您不需要执行函数声明，但如果您在 main（）函数之后编写函数，就像我们在第二个程序中那样，那么您需要先声明函数，否则会出现编译错误。
 
 **函数声明的语法：**
 
@@ -91,7 +91,7 @@ function_name(parameters);
 
 现在我们已经理解了函数的**工作，让我们看看 C++中的函数类型**
 
-## 功能类型
+## 函数类型
 
 我们在 C++中有两种类型的函数：
 ![C++ types of functions: built-in and user-defined](img/78f29a2371b2731fd049ba6271ab480a.jpg)
@@ -99,7 +99,7 @@ function_name(parameters);
 1）内置函数
 2）用户定义的函数
 
-### 1）构建它的功能
+### 1）内置函数
 
 内置函数也称为库函数。我们不需要声明和定义这些函数，因为它们已经在 C++库中编写，例如 iostream，cmath 等。我们可以在需要时直接调用它们。
 
@@ -128,7 +128,7 @@ int main(){
 32
 ```
 
-### 2）用户定义的功能
+### 2）用户定义的函数
 
 ![C++ functions](img/54490c8094bd9a1485e3b26ccf406a2a.jpg)
 我们已经看过用户定义的函数，我们在本教程开头给出的示例是用户定义函数的示例。我们在程序中声明和写入的函数是用户定义的函数。让我们看另一个用户定义函数的例子。

docs/cpp/19.md

@@ -12,7 +12,7 @@
 
 让我们用 C++程序解决问题。
 
-## C++递归示例：Factorial
+## C++递归示例：阶乘
 
 ```
 #include <iostream>

docs/cpp/22.md

@@ -32,7 +32,7 @@ int myarray[2][3];
 ```
 
 **初始化：**
-我们可以通过多种方式初始化阵列：
+我们可以通过多种方式初始化数组：
 **方法 1：**
 
 ```

docs/cpp/24.md

@@ -85,7 +85,7 @@ You entered: The Murder of Roger Ackroyd
 **这些问题的解决方案是什么？**
 我们可以使用字符串对象创建字符串。让我们看看我们如何做到这一点。
 
-## C++中的 String 对象
+## C++中的`string`对象
 
 到目前为止我们已经看到了如何使用 char 数组处理 C++中的字符串。让我们看看在 C++中处理字符串的另一种更好的方法 - 字符串对象。
 

docs/cpp/26.md

@@ -95,7 +95,7 @@ p = arr;
 p = &arr;
 ```
 
-### 示例：使用指针遍历阵列
+### 示例：使用指针遍历数组
 
 ```
 #include <iostream>

docs/cpp/27.md

-# C++'this'指针
+# C++ `this`指针
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-this-pointer/](https://beginnersbook.com/2017/08/cpp-this-pointer/)
 
 **这**指针保存当前对象的地址，简单来说，你可以说这个[指针](https://beginnersbook.com/2017/08/cpp-pointers/)指向该类的当前对象。让我们举个例子来理解这个概念。
 
-## C++示例：this 指针
+## C++示例：`this`指针
 
-在这里你可以看到我们有两个数据成员 num 和 ch。在成员函数 setMyValues（）中，我们有两个与数据成员名称相同的局部变量。在这种情况下，如果要将局部变量值分配给数据成员，那么除非使用此指针，否则您将无法执行此操作，因为除非您使用，否则编译器将不知道您指的是对象的数据成员这个指针。这是必须使用**此**指针的示例之一。
+在这里你可以看到我们有两个数据成员 num 和 ch。在成员函数 setMyValues（）中，我们有两个与数据成员名称相同的局部变量。在这种情况下，如果要将局部变量值分配给数据成员，那么除非使用`this`指针，否则您将无法执行此操作，因为除非您使用，否则编译器将不知道您指的是对象的数据成员这个指针。这是必须使用**此**指针的示例之一。
 
 ```
 #include <iostream>
@@ -40,9 +40,9 @@ int main(){
 A
 ```
 
-## 示例 2：使用此指针进行函数链接调用
+## 示例 2：使用`this`指针进行函数链接调用
 
-使用此指针的另一个示例是返回当前对象的引用，以便您可以链接函数调用，这样您就可以一次调用当前对象的所有函数。在这个程序中需要注意的另一个要点是我在第二个函数中增加了对象 num 的值，你可以在输出中看到它实际上增加了我们在第一个函数调用中设置的值。这表明链接是顺序的，对对象的数据成员所做的更改将保留以进一步链接调用。
+使用`this`指针的另一个示例是返回当前对象的引用，以便您可以链接函数调用，这样您就可以一次调用当前对象的所有函数。在这个程序中需要注意的另一个要点是我在第二个函数中增加了对象 num 的值，你可以在输出中看到它实际上增加了我们在第一个函数调用中设置的值。这表明链接是顺序的，对对象的数据成员所做的更改将保留以进一步链接调用。
 
 ```
 #include <iostream>

docs/cpp/28.md

-# 哎呀
+# OOP
\ No newline at end of file

docs/cpp/29.md

@@ -6,7 +6,7 @@
 
 ## 面向对象编程（OOP）
 
-在面向对象编程中，我们使用类和对象编写程序，利用 OOP 的特征，如**抽象**，**封装**，**继承**和**多态性**
+在面向对象编程中，我们使用类和对象编写程序，利用 OOP 的特征，如**抽象**，**封装**，**继承**和**多态**
 
 ### 类和对象
 
@@ -36,7 +36,7 @@ int main()
 }
 ```
 
-### 抽象化
+### 抽象
 
 [抽象](https://beginnersbook.com/2017/09/abstraction-in-c-with-example/)是隐藏用户不相关细节的过程。例如，当您发送短信时，您只需键入消息，选择联系人并单击发送，手机会显示消息已发送，单击发送时背景中实际发生的情况对您是隐藏的，因为它不相关给你。
 
@@ -44,7 +44,7 @@ int main()
 
 [封装](https://beginnersbook.com/2017/09/cpp-encapsulation/)是将数据和功能组合成像胶囊这样的单个单元的过程。这是为了避免从类外部访问私有数据成员。为了实现封装，我们将类的所有数据成员设为私有并创建公共函数，使用它们我们可以从这些数据成员获取值或将值设置为这些数据成员。
 
-### 遗产
+### 继承
 
 [继承](https://beginnersbook.com/2017/08/cpp-inheritance/)是一个特性，子类的对象使用该特征获取父类的属性。
 
@@ -67,12 +67,12 @@ int main(void) {
 
 现在这个对象 obj 可以使用 ParentClass 的属性（例如变量 var1）。
 
-### 多态性
+### 多态
 
-[函数重载](https://beginnersbook.com/2017/08/cpp-function-overloading/)和运算符重载是多态的例子。多态性是一种在不同情况下对象表现不同的特征。
+[函数重载](https://beginnersbook.com/2017/08/cpp-function-overloading/)和运算符重载是多态的例子。多态是一种在不同情况下对象表现不同的特征。
 在函数重载中，我们可以有多个具有相同名称但不同数量，类型或参数序列的函数。
 
-#### 多态性实例
+#### 多态实例
 
 ```
 #include <iostream>

docs/cpp/31.md

@@ -19,7 +19,7 @@
 
 在以下情况下，析构函数**自动调用**：
 1）程序完成执行。
-2）当包含[局部变量](https://beginnersbook.com/2017/08/cpp-variables/)的范围（{}括号）结束时。
+2）当包含[局部变量](https://beginnersbook.com/2017/08/cpp-variables/)的作用域（{}括号）结束时。
 3）当你调用删除操作符时。
 
 ## 析构函数示例

docs/cpp/33.md

-# C++中的结构和功能
+# C++中的结构和函数
 
 > 原文： [https://beginnersbook.com/2017/09/cpp-structure-and-function/](https://beginnersbook.com/2017/09/cpp-structure-and-function/)
 

docs/cpp/34.md

@@ -49,14 +49,14 @@ int main(){
 3
 ```
 
-## 为什么在 C++中使用 enum
+## 为什么在 C++中使用`enum`
 
 既然我们已经理解了什么是枚举以及如何在程序中使用它们，那么让我们讨论一下我们使用它们的原因：
 只有在我们期望变量具有一组可能的值时才使用枚举，例如，我们有一个保持方向的 dir 变量。由于我们有四个方向，这个变量可以取四个值中的任何一个，如果我们尝试为这个变量分配另一个随机值，它将抛出一个编译错误。这会增加编译时检查并避免通过传入无效常量而发生的错误。
 
 经常使用它们的另一个重要位置是[`switch-case`语句](https://beginnersbook.com/2017/08/cpp-switch-case/)，其中案例块期望的所有值都可以在枚举中定义。这样我们就可以确保我们在 switch 括号中传递的 enum 变量没有采用它不应该接受的任何随机值。
 
-## 如何更改 Enum 的默认值
+## 如何更改`enum`的默认值
 
 ```
 #include <iostream>

docs/cpp/36.md

-# C++中的多态性
+# C++中的多态
 
 > 原文： [https://beginnersbook.com/2017/08/cpp-polymorphism/](https://beginnersbook.com/2017/08/cpp-polymorphism/)
 
-多态性是 [OOP](https://beginnersbook.com/2017/08/cpp-oops-concepts/) 的一个特征，它允许对象在不同条件下表现不同。在 C++中，我们有两种类型的多态性：
-1）编译时间多态性 - 这也称为静态（或早期）绑定。
-2）运行时多态性 - 这也称为动态（或后期）绑定。
+多态是 [OOP](https://beginnersbook.com/2017/08/cpp-oops-concepts/) 的一个特征，它允许对象在不同条件下表现不同。在 C++中，我们有两种类型的多态：
+1）编译时多态 - 这也称为静态（或早期）绑定。
+2）运行时多态 - 这也称为动态（或后期）绑定。
 
-## 1）编译时间多态性
+## 1）编译时多态
 
 函数重载和运算符重载是编译时多态的完美例子。
 
-### 编译时间多态性示例
+### 编译时多态示例
 
 在这个例子中，我们有两个具有相同名称但参数数量不同的函数。根据我们在函数调用期间传递的参数确定要调用哪个函数，这就是为什么它被视为多态的一个例子，因为在不同的条件下输出是不同的。因为，在编译期间确定调用，这就是为什么它被称为编译时多态。
 
@@ -43,14 +43,14 @@ Output: 30
 Output: 66
 ```
 
-## 2）运行时多态性
+## 2）运行时多态
 
 函数重写是 Runtime 多态的一个例子。
 **函数覆盖**：当子类声明一个已存在于父类中的方法时，这称为函数覆盖，这里子类覆盖父类。
 
 在函数重写的情况下，我们有两个相同函数的定义，一个是父类，一个是子类。在**运行时**确定对函数的调用，以决定调用函数的哪个定义，这就是它被称为运行时多态的原因。
 
-### 运行时多态性的例子
+### 运行时多态的例子
 
 ```
 #include <iostream>

docs/cpp/38.md

-# 函数覆盖 C++
+# C++ 函数覆盖
 
 > 原文： [https://beginnersbook.com/2017/09/cpp-function-overriding/](https://beginnersbook.com/2017/09/cpp-function-overriding/)
 
-函数重写是一个允许我们在子类中具有相同功能的功能，该子类已存在于父类中。子类继承父类的数据成员和成员函数，但是当您想要覆盖子类中的功能时，您可以使用函数重写。这就像在子类中创建旧函数的新版本一样。
+函数覆盖是一个允许我们在子类中具有相同函数的函数，该子类已存在于父类中。子类继承父类的数据成员和成员函数，但是当您想要覆盖子类中的函数时，您可以使用函数覆盖。这就像在子类中创建旧函数的新版本一样。
 
-## 功能覆盖示例
+## 函数覆盖示例
 
 要覆盖函数，您必须在子类中具有相同的签名。签名是指数据类型和参数序列。这里我们在父函数中没有任何参数，所以我们没有在子函数中使用任何参数。
 
@@ -36,11 +36,11 @@ int main() {
 Function of Child Class
 ```
 
-> **注意：**在函数重写中，父类中的函数被称为重写函数，子类中的函数称为重写函数。
+> **注意：**在函数覆盖中，父类中的函数被称为覆盖函数，子类中的函数称为覆盖函数。
 
-## 如何从子类调用重写函数
+## 如何从子类调用覆盖函数
 
-正如我们在上面看到的那样，当我们调用函数（涉及重写）时，会调用子类函数（重写函数）。如果要通过使用子类的对象来调用重写的函数，该怎么办？您可以通过以父类的引用指向它的方式创建子类对象来实现。让我们举个例子来理解它。
+正如我们在上面看到的那样，当我们调用函数（涉及覆盖）时，会调用子类函数（覆盖函数）。如果要通过使用子类的对象来调用覆盖的函数，该怎么办？您可以通过以父类的引用指向它的方式创建子类对象来实现。让我们举个例子来理解它。
 
 ```
 #include <iostream>

docs/cpp/39.md

-# C++中的虚函数：运行时多态性
+# C++中的虚函数：运行时多态
 
 > 原文： [https://beginnersbook.com/2017/09/cpp-virtual-functions-runtime-polymorphism/](https://beginnersbook.com/2017/09/cpp-virtual-functions-runtime-polymorphism/)
 

docs/cpp/4.md

@@ -112,7 +112,7 @@ int main()
 ```
 
 **输出：**
-编译时间错误，因为我们试图访问其作用域之外的变量`myVar`。 `myVar`的作用域仅限于这些括号内的功能体`myFuncn()`。
+编译时错误，因为我们试图访问其作用域之外的变量`myVar`。 `myVar`的作用域仅限于这些括号内的功能体`myFuncn()`。
 
 ## 全局变量和局部变量可以在 C++中具有相同的名称吗？
 

docs/cpp/40.md

-# 用 C++封装示例
+# C++ 封装示例
 
 > 原文： [https://beginnersbook.com/2017/09/cpp-encapsulation/](https://beginnersbook.com/2017/09/cpp-encapsulation/)
 
 封装是将数据成员和函数组合在一个称为类的单个单元中的过程。这是为了防止直接访问数据，通过类的功能提供对它们的访问。它是[面向对象编程（OOP）](https://beginnersbook.com/2017/08/cpp-oops-concepts/)的流行功能之一，它有助于**数据隐藏**。
 
-## 如何在课堂上实现封装
+## 如何在类上实现封装
 
 为此：
 1）将所有数据成员设为私有。

docs/cpp/43.md

-# 从 C++中的函数传递和返回 Object
+# 从 C++中的函数传递和返回对象
 
 > 原文： [https://beginnersbook.com/2017/09/cpp-pass-and-return-object-from-a-function/](https://beginnersbook.com/2017/09/cpp-pass-and-return-object-from-a-function/)
 

docs/cpp/44.md

-# C++中的朋友类和朋友函数
+# C++中的友元类和友元函数
 
 > 原文： [https://beginnersbook.com/2017/09/friend-class-and-friend-functions/](https://beginnersbook.com/2017/09/friend-class-and-friend-functions/)
 
 我们知道一个类无法访问其他类的私有成员。类似地，不继承另一个类的类不能访问其受保护的成员。
 
-**朋友类：**
-**朋友类**是一个类，可以访问被声明为**朋友**的类的私有成员和受保护成员。当我们想要允许特定类访问类的私有成员和受保护成员时，这是必需的。
+**友元类：**
+**友元类**是一个类，可以访问被声明为**友元**的类的私有成员和受保护成员。当我们想要允许特定类访问类的私有成员和受保护成员时，这是必需的。
 
 ## 函数类示例
 
@@ -49,10 +49,10 @@ A
 ```
 
 **
-朋友功能：**
-与朋友类相似，此功能可以访问另一个类的私有和受保护成员。全局函数也可以声明为朋友，如下例所示：
+友元函数：**
+与友元类相似，此函数可以访问另一个类的私有和受保护成员。全局函数也可以声明为友元，如下例所示：
 
-## 朋友功能示例
+## 友元函数示例
 
 ```
 #include <iostream>

docs/cpp/SUMMARY.md

@@ -32,10 +32,10 @@
     +   [C++中的结构和功能](33.md)
     +   [C++中的枚举](34.md)
     +   [C++中的继承](35.md)
-    +   [C++中的多态性](36.md)
+    +   [C++中的多态](36.md)
     +   [C++中的函数重载](37.md)
     +   [函数覆盖 C++](38.md)
-    +   [C++中的虚函数：运行时多态性](39.md)
+    +   [C++中的虚函数：运行时多态](39.md)
     +   [用 C++封装示例](40.md)
     +   [C++中的抽象示例](41.md)
     +   [C++中的接口：抽象类](42.md)

docs/java-example/22.md

-# Java 阵列程序
+# Java 数组程序
\ No newline at end of file

docs/java-example/23.md

@@ -5,7 +5,7 @@
 我们将看到两个使用数组查找数字平均值的程序。 First Program 查找指定数组元素的平均值。第二个程序获取 n（元素数）的值和用户提供的数字，并使用数组查找它们的平均值。
 
 要了解这些程序，您应该具备以下 [Java 编程](https://beginnersbook.com/java-tutorial-for-beginners-with-examples/)概念的知识：
-1） [Java 阵列](https://beginnersbook.com/2013/05/java-arrays/)
+1） [Java 数组](https://beginnersbook.com/2013/05/java-arrays/)
 2） [For 循环](https://beginnersbook.com/2015/03/for-loop-in-java-with-example/)
 
 ## 示例 1：使用数组查找数字平均值的程序

docs/java-example/25.md

@@ -2,13 +2,13 @@
 
 > 原文： [https://beginnersbook.com/2017/09/java-program-to-reverse-the-array/](https://beginnersbook.com/2017/09/java-program-to-reverse-the-array/)
 
-该程序反转阵列。例如，如果用户输入数组元素为 1,2,3,4,5，那么程序将反转数组，数组元素将为 5,4,3,2,1。要理解这个程序，你应该有以下 [Java 编程](https://beginnersbook.com/java-tutorial-for-beginners-with-examples/)主题的知识：
+该程序反转数组。例如，如果用户输入数组元素为 1,2,3,4,5，那么程序将反转数组，数组元素将为 5,4,3,2,1。要理解这个程序，你应该有以下 [Java 编程](https://beginnersbook.com/java-tutorial-for-beginners-with-examples/)主题的知识：
 
 1.  [Java 中的数组](https://beginnersbook.com/2013/05/java-arrays/)
 2.  [Java For 循环](https://beginnersbook.com/2015/03/for-loop-in-java-with-example/)
 3.  [Java While 循环](https://beginnersbook.com/2015/03/while-loop-in-java-with-examples/)
 
-## 示例：用于反转阵列的程序
+## 示例：用于反转数组的程序
 
 ```java
 import java.util.Scanner;

docs/java-example/SUMMARY.md

@@ -18,7 +18,7 @@
     +   [用于对字符串执行冒泡排序的 Java 程序](19.md)
     +   [Java 程序，用于查找字符串中字符的出现](20.md)
     +   [用于计算字符串中的元音和辅音的 Java 程序](21.md)
-+   [Java 阵列程序](22.md)
++   [Java 数组程序](22.md)
     +   [Java 程序使用 Array 计算平均值](23.md)
     +   [Java 程序总结数组的元素](24.md)
     +   [Java 程序来反转数组](25.md)

docs/java/69.md

@@ -5,8 +5,8 @@
 Java 8 在 java.util 包的 Arrays 类中引入了一个新方法 parallelSort（）。引入此方法以支持数组元素的并行排序。
 并行排序算法：
 1.将给定的数组划分为子数组，将子数组进一步划分为子数组，直到子数组达到最小粒度为止。
-2.子阵列由多个线程单独排序。并行排序使用 [Fork / Join Framework](https://docs.oracle.com/javase/tutorial/essential/concurrency/forkjoin.html) 并行地对子数组进行排序。
-3.已合并的已排序子阵列。
+2.子数组由多个线程单独排序。并行排序使用 [Fork / Join Framework](https://docs.oracle.com/javase/tutorial/essential/concurrency/forkjoin.html) 并行地对子数组进行排序。
+3.已合并的已排序子数组。
 
 **并行排序的优点简单排序：**
 parallelSort（）方法使用[多线程](https://beginnersbook.com/2013/03/multithreading-in-java/)的概念，与[正常排序](https://beginnersbook.com/2014/07/how-to-sort-an-array-in-java/)相比，它更快有很多元素。

docs/kotlin/12.md

-# Kotlin 阵列
+# Kotlin 数组
 
 > 原文： [https://beginnersbook.com/2019/02/kotlin-array/](https://beginnersbook.com/2019/02/kotlin-array/)
 
 Kotlin 中的数组能够存储不同数据类型的多个值。当然，如果我们想要，我们可以限制数组保存特定数据类型的值。在本指南中，我们将讨论 Kotlin 中的数组。
 
-## Kotlin 阵列声明
+## Kotlin 数组声明
 
 包含多种不同数据类型的数组。
 

docs/kotlin/SUMMARY.md

@@ -12,7 +12,7 @@
 +   Kotlin 字符串教程
     +   [Kotlin String](11.md)
 +   Kotlin 数组教程
-    +   [Kotlin 阵列](12.md)
+    +   [Kotlin 数组](12.md)
     +   [科特林山脉](13.md)
 +   Kotlin 控制流教程
     +   [Kotlin If - Else Expression with examples](14.md)

docs/perl/10.md

@@ -6,7 +6,7 @@
 
 ## 如何定义数组？
 
-阵列以 **@** 符号为前缀。这就是你定义一个数组的方法 -
+数组以 **@** 符号为前缀。这就是你定义一个数组的方法 -
 
 ```
 @friends = ("Ajeet", "Chaitanya", "Rahul");
@@ -259,7 +259,7 @@ array now has:
 
 #### 拼接算子
 
-在上一节中，我们学习了如何在数组上执行 push，pop，shift 和 unshift 操作。但是这些运算符存在限制，它们只在数组的开头或数组的末尾执行。如果我们想在阵列中间执行操作怎么办？这就是拼接运算符进入画面的地方。
+在上一节中，我们学习了如何在数组上执行 push，pop，shift 和 unshift 操作。但是这些运算符存在限制，它们只在数组的开头或数组的末尾执行。如果我们想在数组中间执行操作怎么办？这就是拼接运算符进入画面的地方。
 
 **语法：**