2019-08-22 11:19:48

docs/c/11.md

@@ -118,7 +118,7 @@ int main()
 
 ```
 
-Output:
+输出：
 
 ```c
 0, 0

docs/c/12.md

@@ -148,7 +148,7 @@ int main()
 }
 ```
 
-Output:
+输出：
 
 ```c
 1 1

docs/c/13.md

@@ -64,7 +64,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 Out of loop
@@ -85,7 +85,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 while vs do-while

docs/c/15.md

@@ -71,7 +71,7 @@ int main()
 
 ```
 
-**Output:**
+**输出：**
 
 ```c
 var: 100

docs/c/16.md

@@ -75,7 +75,7 @@ int main()
 
 ```
 
-Output:
+输出：
 
 ```c
 10 9 8 6 5 4 3 2 1 0
@@ -105,7 +105,7 @@ int main()
 
 ```
 
-Output:
+输出：
 
 ```c
 0 1 2 3 4 5 6 8 9

docs/c/20.md

@@ -154,7 +154,7 @@ int main()
 
 ```
 
-Output:
+输出：
 
 ```c
 1600101376 1600101392 1600101408 1600101424 1600101440

docs/c/21.md

@@ -39,7 +39,7 @@ val[6]: value is 77 and address is 1423453256
 
 ```
 
-> 请注意，每个元素之间存在 4 个字节的差异，因为这是整数的大小。这意味着所有元素都存储在内存中连续的连续内存位置。（参见下图）
+> 请注意，每个元素之间存在 4 个字节的差异，因为这是整数的大小。这意味着所有元素都存储在内存中的连续位置。（参见下图）
 
 ![Pointer-to-array](img/a1e69ea934a5994aef225afc2fb15d9b.jpg)
 
@@ -90,7 +90,7 @@ val[6]: value is 77 and address is 0x7fff51472c48
 ```
 
 **注意事项：**
-1）使用带数组的指针时，指针的数据类型必须与数组的数据类型匹配。
+1）使用数组和指针时，指针的数据类型必须与数组的数据类型匹配。
 2）你也可以使用数组名来初始化指针，如下所示：
 
 ```c
@@ -106,6 +106,7 @@ val==&val[0];
 3）在循环中，对指针变量执行递增操作（`p++`）以获取下一个位置（下一个元素的位置），此算法对于所有类型的数组都是相同的（对于所有数据类型`double`，`char`，`int`等）即使每种数据类型消耗的字节不同。
 
 **指针逻辑**
+
 你必须已经理解了上面代码中的逻辑，所以现在是时候玩几个指针算术和表达式了。
 
 ```c

docs/c/22.md

@@ -2,13 +2,13 @@
 
 > 原文： [https://beginnersbook.com/2014/01/c-passing-array-to-function-example/](https://beginnersbook.com/2014/01/c-passing-array-to-function-example/)
 
-就像变量一样，数组也可以作为参数传递给函数。在本指南中，我们将学习如何使用按值调用和通过引用方法调用将数组传递给函数。
+就像变量一样，数组也可以作为参数传递给函数。在本指南中，我们将学习如何使用按值调用和按引用调用方法将数组传递给函数。
 
 > 要理解本指南，您应该具有以下 [C 编程](https://beginnersbook.com/2014/01/c-tutorial-for-beginners-with-examples/)主题的知识：
 > 
 > 1.  [C - 数组](https://beginnersbook.com/2014/01/c-arrays-example/)
-> 2.  [C](https://beginnersbook.com/2014/01/c-function-call-by-value-example/) 中的值调用函数
-> 3.  [C](https://beginnersbook.com/2014/01/c-function-call-by-reference-example/) 中的参考函数调用
+> 2.  [C 中的按值函数调用](https://beginnersbook.com/2014/01/c-function-call-by-value-example/)
+> 3.  [C 中的按引用函数调用](https://beginnersbook.com/2014/01/c-function-call-by-reference-example/)
 
 ## 使用按值调用方法将数组传递给函数
 
@@ -40,9 +40,9 @@ int main()
 a b c d e f g h i j
 ```
 
-## 使用引用调用将数组传递给函数
+## 使用按引用调用将数组传递给函数
 
-当我们在调用函数时传递数组的地址然后通过引用调用函数调用。当我们传递一个地址作为参数时，函数声明应该有一个[指针](https://beginnersbook.com/2014/01/c-pointers/)作为接收传递地址的参数。
+当我们在调用函数的同时传递数组的地址，然后这就是按引用函数调用。当我们传递一个地址作为参数时，函数声明应该有一个[指针](https://beginnersbook.com/2014/01/c-pointers/)作为接收传递地址的参数。
 
 ```c
 #include <stdio.h>
@@ -73,7 +73,7 @@ int main()
 
 ### 如何将整个数组作为参数传递给函数？
 
-在上面的例子中，我们在 C 中使用[`for`循环逐个传递每个数组元素的地址。但是，您也可以将整个数组传递给这样的函数：](https://beginnersbook.com/2014/01/c-for-loop/)
+在上面的例子中，我们在 C 中使用[`for`循环](https://beginnersbook.com/2014/01/c-for-loop/)逐个传递每个数组元素的地址。但是，您也可以将整个数组传递给这样的函数：
 
 > 注意：数组名称本身是该数组的第一个元素的地址。例如，如果数组名称为`arr`，则可以说`arr`等同于`&arr[0]` 。
 

docs/c/24.md

@@ -4,29 +4,31 @@
 
 **字符串是一个字符数组**。在本指南中，我们将学习如何声明字符串，如何在 C 编程中使用字符串以及如何使用预定义的字符串处理函数。
 
-我们将看到如何比较两个字符串，连接字符串，将一个字符串复制到另一个字符串&执行各种字符串操作操作。我们可以使用`string.h`头文件的预定义函数执行此类操作。要使用这些字符串函数，必须在 C 程序中包含`string.h`文件。
+我们将看到如何比较两个字符串，连接字符串，将一个字符串复制到另一个字符串，以及执行各种字符串操作。我们可以使用`string.h`头文件的预定义函数执行此类操作。要使用这些字符串函数，必须在 C 程序中包含`string.h`文件。
 
 ## 字符串声明
 
 ![string declaration in C](img/b7071677a40bf87380964f6dca0b919b.jpg)
+
 **方法 1：**
 
 ```c
 char address[]={'T', 'E', 'X', 'A', 'S', '\0'};
 ```
 
-**方法 2：上面的字符串也可以定义为** -
+**方法 2：上面的字符串也可以定义为：**
 
 ```c
 char address[]="TEXAS";
 ```
 
-在上面的声明中，NULL 字符（`\0`）将自动插入字符串的末尾。
+在上面的声明中，空字符（`\0`）将自动插入字符串的末尾。
+
+**什么是空字符`\0`？**
 
-**什么是 NULL 字符`\0`？**
 `'\0'`表示字符串的结尾。它也被称为字符串结尾或空字符。
 
-## C 编程中的字符串 I/O.
+## C 编程中的字符串 I/O
 
 ![C String-IO](img/56572ec8c165dd235997e32d03c11a76.jpg)
 
@@ -99,8 +101,7 @@ int main()
 size_t strlen(const char *str)
 ```
 
-**`size_t`** 表示无符号短
-它返回字符串的长度而不包括结束字符**（终止字符`\0`）**。
+**`size_t`** 表示无符号短整数，它返回字符串的长度而不包括结束字符**（终止字符`\0`）**。
 
 **`strlen`的例子：**
 
@@ -115,28 +116,27 @@ int main()
 }
 ```
 
-Output:
+输出：
 
 ```c
 Length of string str1: 13
 ```
 
 **`strlen` vs `sizeof`**
-`strlen`返回存储在数组中的字符串的长度，但`sizeof`返回分配给数组的总分配大小。因此，如果我再次考虑上述示例，则以下语句将返回以下值。
 
-`strlen(str1)`返回值 13。
-`sizeof(str1)`将返回值 20，因为数组大小为 20（请参阅`main`函数中的第一个语句）。
+`strlen`返回存储在数组中的字符串的长度，但`sizeof`返回分配给数组的总大小。因此，如果我再次考虑上述示例，则以下语句将返回以下值。
+
+`strlen(str1)`返回值 13。`sizeof(str1)`将返回值 20，因为数组大小为 20（请参阅`main`函数中的第一个语句）。
 
 ### C 字符串函数 - `strnlen`
 
-Syntax:
+语法：
 
 ```c
 size_t strnlen(const char *str, size_t maxlen)
 ```
 
-`size_t`表示无符号短
-如果字符串小于为`maxlen`指定的值（最大长度），则返回字符串的长度，否则返回`maxlen`值。
+`size_t`表示无符号短整数。如果字符串小于为`maxlen`指定的值（最大长度），则返回字符串的长度，否则返回`maxlen`值。
 
 **`strnlen`的例子：**
 
@@ -153,8 +153,11 @@ int main()
 ```
 
 输出：
-当`maxlen`为`30:13`时字符串`str1`的长度
-当`maxlen`为`10:10`时字符串`str1`的长度
+
+```c
+Length of string str1 when maxlen is 30: 13
+Length of string str1 when maxlen is 10: 10
+```
 
 您是否注意到第二个`printf`语句的输出，即使字符串长度为 13，它只返回 10，因为`maxlen`为 10。
 
@@ -166,8 +169,9 @@ int strcmp(const char *str1, const char *str2)
 
 它比较两个字符串并返回一个整数值。如果两个字符串相同（相等），则此函数将返回 0，否则它可能会根据比较返回负值或正值。
 
-**如果`string1<string2`或者`string1`是`string2`**的子字符串，然后它会产生负值。如果`string1>string2`然后它将返回正值。
-**如果`string1 == string2`** ，那么当你将此函数用于比较字符串时，你会得到 0（零）。
+**如果`string1<string2`或者`string1`是`string2`**的子字符串，它会产生负值。如果`string1>string2`它将返回正值。
+
+**如果`string1 == string2`** ，那么当你将此函数用于比较字符串时，你会得到 0。
 
 **`strcmp`示例：**
 
@@ -201,8 +205,7 @@ string 1 and 2 are different
 int strncmp(const char *str1, const char *str2, size_t n)
 ```
 
-`size_t`用于未分配的短
-它比较字符串直到`n`个字符，或者换句话说，它比较两个字符串的前`n`个字符。
+`size_t`用于无符号短整数。它比较字符串直到`n`个字符，或者换句话说，它比较两个字符串的前`n`个字符。
 
 **`strncmp`示例：**
 
@@ -225,7 +228,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 string1 and string 2 are equal
@@ -254,7 +257,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 Output string after concatenation: HelloWorld
@@ -283,7 +286,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 Concatenation using strncat: HelloWor
@@ -313,7 +316,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 String s1 is: string 2: I’m gonna copied into s1
@@ -326,9 +329,11 @@ String s1 is: string 2: I’m gonna copied into s1
 char *strncpy(char *str1, char *str2, size_t n)
 ```
 
-`size_t`是未分配的`short`，`n`是数字。
+`size_t`是无符号`short`，`n`是数字。
+
 **情况 1：**如果`str2`的长度`>n`然后它只是将`str2`的前`n`个字符复制到`str1`中。
-**情况 2：**如果`str2`的长度`<n`。然后它将`str2`的所有字符复制到`str1`中，并附加几个终结符字符（`\0`）以累积`str1`的长度使其成为`n`。
+
+**情况 2：**如果`str2`的长度`<n`。然后它将`str2`的所有字符复制到`str1`中，并附加几个终结符字符（`\0`）以填充`str1`的长度使其成为`n`。
 
 **`strncpy`的例子：**
 
@@ -346,7 +351,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 String s1 is: string 2: I’m
@@ -358,7 +363,7 @@ String s1 is: string 2: I’m
 char *strchr(char *str, int ch)
 ```
 
-它在字符串`str`中搜索字符`ch`（您可能想知道在上面的定义中我已经将`ch`的数据类型赋予了`int`，不要担心我没有犯任何错误它应该只是`int`。事情是当我们给任何在使用`strchr`时，它会在内部转换为整数以便更好地搜索。
+它在字符串`str`中搜索字符`ch`（您可能想知道在上面的定义中我已经将`ch`的数据类型赋予了`int`，不要担心我没有犯任何错误它应该只是`int`。事情是当我们将任何值给`strchr`时，它会在内部转换为整数以便更好地搜索。
 
 **`strchr`的例子：**
 
@@ -373,7 +378,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 f function strchr
@@ -400,7 +405,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 function strchr
@@ -429,7 +434,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 Output string is: BeginnersBook.COM

docs/c/26.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2014/01/c-functions-examples/](https://beginnersbook.com/2014/01/c-functions-examples/)
 
-函数是执行特定任务的语句块。假设您正在使用 C 语言构建应用，并且在某个程序中，您需要多次执行相同的任务。在这种情况下，您有两种选择 -
+函数是执行特定任务的语句块。假设您正在使用 C 语言构建应用，并且在某个程序中，您需要多次执行相同的任务。在这种情况下，您有两种选择：
 
 a）每次要执行任务时都使用相同的语句集
 b）创建一个执行该任务的函数，并在每次需要执行该任务时调用它。
@@ -13,16 +13,20 @@ b）创建一个执行该任务的函数，并在每次需要执行该任务时
 
 1）**预定义的标准库函数** - 如`puts()`，`gets()`，`printf()`，`scanf()`等 - 这些函数已经在头文件中有定义（`.h`文件如`stdio.h`），所以我们只要在需要使用它们时调用它们。
 
-2）**用户定义函数 -** 我们在程序中创建的函数称为用户定义函数。
+2）**用户定义函数** - 我们在程序中创建的函数称为用户定义函数。
 
-在本指南中，我们将学习如何创建用户定义的函数以及如何在 C 编程中使用它们
+在本指南中，我们将学习如何创建用户定义的函数以及如何在 C 编程中使用它们。
 
 ## 为什么我们需要 C 中的函数
 
-由于以下原因使用函数 -
+由于以下原因使用函数：
+
 a）提高代码的可读性。
+
 b）提高代码的可重用性，可以在任何程序中使用相同的函数，而不是从头开始编写相同的代码。
+
 c）如果使用函数，代码的调试会更容易，因为错误很容易被跟踪。
+
 d）减少代码的大小，重复的语句集被函数调用替换。
 
 ### 函数的语法
@@ -34,31 +38,33 @@ return_type function_name (argument list)
 }
 ```
 
-**`return_type`：**返回类型可以是任何数据类型，如`int`，`double`，`char`，`void`，`short`等。一旦你完成下面的例子，不要担心你会更好地理解这些术语。
+**`return_type`**：返回类型可以是任何数据类型，如`int`，`double`，`char`，`void`，`short`等。一旦你完成下面的例子，不要担心你会更好地理解这些术语。
+
+**`function_name`**：它可以是任何东西，但建议为函数设置一个有意义的名称，这样只要看到它的名字就可以很容易地理解函数的用途。
+
+**参数列表**：参数列表包含变量名称及其数据类型。这些参数是函数的一种输入。例如 - 用于相加两个整数变量的函数将具有两个整数参数。
 
-**`function_name`：**它可以是任何东西，但建议为函数设置一个有意义的名称，这样只要看到它的名字就可以很容易地理解函数的用途。
+**代码块**：C 语句集，只要对函数进行调用，就会执行。
 
-**参数列表：**参数列表包含变量名称及其数据类型。这些参数是函数的一种输入。例如 - 用于添加两个整数变量的函数将具有两个整数参数。
+**您觉得上述术语令人困惑吗？ - 不要担心，在你学会了所有这些之前我不会结束本指南 :)**
 
-**代码块：** C 语句集，只要对函数进行调用，就会执行。
+让我们举一个例子 - 假设你想创建一个函数来相加两个整数变量。
 
-**您觉得上述条款令人困惑吗？ - 不要担心，在你学会了所有这些之前我不会结束本指南:)**
-让我们举一个例子 - 假设你想创建一个函数来添加两个整数变量。
+**让我们分解问题，以便它易于理解：**
 
-**让我们分解问题，以便它易于理解 -**
-函数将添加两个数字，因此它应该有一些有意义的名称，如`sum`，`addition`等。例如，让我们取名为这个函数。
+函数将添加两个数字，因此它应该有一些有意义的名称，如`sum`，`addition`等。例如，让我们为这个函数取名。
 
 ```c
 return_type addition(argument list)
 ```
 
-这个函数添加了两个整数变量，这意味着我需要两个整数变量作为输入，让我们在函数签名中提供两个整数参数。函数签名是 -
+这个函数相加了两个整数变量，这意味着我需要两个整数变量作为输入，让我们在函数签名中提供两个整数参数。函数签名是：
 
 ```c
 return_type addition(int num1, int num2)
 ```
 
-两个整数之和的结果仅为整数。因此函数应该返回一个整数值 - **我得到了我的返回类型** - 它将是整数 -
+两个整数之和的结果仅为整数。因此函数应该返回一个整数值 - **我得到了我的返回类型** - 它将是整数：
 
 ```c
 int addition(int num1, int num2);
@@ -68,7 +74,7 @@ int addition(int num1, int num2);
 
 ### 如何在 C 中调用函数？
 
-考虑以下 C 程序
+考虑以下 C 程序：
 
 #### 示例 1：创建用户定义的函数`addition()`
 
@@ -99,7 +105,7 @@ int main()
       * returned value of this function.
       */
      int res = addition(var1, var2);
-     printf ("Output: %d", res);
+     printf ("输出： %d", res);
 
      return 0;
 }
@@ -111,7 +117,7 @@ int main()
 ```c
 Enter number 1: 100
 Enter number 2: 120
-Output: 220
+输出： 220
 ```
 
 #### 示例 2：创建一个不返回任何内容的`void`用户定义函数
@@ -138,7 +144,7 @@ int main()
 
 ```
 
-Output:
+输出：
 
 ```c
 Hi
@@ -147,17 +153,22 @@ How are you?
 ```
 
 **有关 C 中函数的注意事项：**
+
 1）C 程序中的`main()`也是一个函数。
+
 2）每个 C 程序必须至少有一个函数，即`main()`。
+
 3）函数数量没有限制; C 程序可以具有任意数量的函数。
+
 4）一个函数可以调用自身，它被称为“**递归**”。我已经为它写了一份单独的指南。
 
 **C 函数必须记住的术语**
-**返回类型：**返回值的数据类型。它也可以是无效的，在这种情况下，函数不返回任何值。
 
-注意：例如，如果函数返回类型是 **`char`，**那么函数应该返回`char`类型的值，并且在调用此函数时`main()`函数应该有一个`char`数据类型的变量来存储返回的值。
+**返回类型**：返回值的数据类型。它也可以是`void`的，在这种情况下，函数不返回任何值。
+
+注意：例如，如果函数返回类型是 **`char`**，那么函数应该返回`char`类型的值，并且在调用此函数时`main()`函数应该有一个`char`数据类型的变量来存储返回的值。
 
-结构看起来像 -
+结构看起来像：
 
 ```c
 char abc(char ch1, char ch2)
@@ -178,6 +189,6 @@ int main()
 
 #### 关于 C 中函数的更多主题
 
-1） [**函数 - 按值调用方法**](https://beginnersbook.com/2014/01/c-function-call-by-value-example/) - 在按值调用方法中，实际参数被复制到形式参数，因此函数对参数执行的任何操作都不会影响实际参数。
+1） [**函数 - 按值调用方法**](https://beginnersbook.com/2014/01/c-function-call-by-value-example/) - 在按值调用方法中，实际参数被复制到形式参数，因此函数对形式参数执行的任何操作都不会影响实际参数。
 
-2） [**函数 - 通过引用方法调用**](https://beginnersbook.com/2014/01/c-function-call-by-reference-example/) - 与按值调用不同，在此方法中，实际参数（或参数）的地址被传递给形式参数，这意味着执行的任何操作形式参数会影响实际参数的值。
\ No newline at end of file
+2） [**函数 - 按引用调用方法**](https://beginnersbook.com/2014/01/c-function-call-by-reference-example/) - 与按值调用不同，在此方法中，实际参数的地址被传递给形式参数，这意味着对形式参数执行的任何操作会影响实际参数的值。
\ No newline at end of file

docs/c/27.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://beginnersbook.com/2014/01/c-function-call-by-value-example/](https://beginnersbook.com/2014/01/c-function-call-by-value-example/)
 
-按值调用函数是在 C 编程中调用函数的默认方式。在我们按值讨论函数调用之前，让我们在解释这个时理解我们将使用的术语：
+按值调用函数是在 C 编程中调用函数的默认方式。在我们按值讨论函数调用之前，让我们理解在解释这个时我们将使用的术语：
 
 **实际参数：**函数调用中出现的参数。
 **形式参数：**函数声明中出现的参数。
@@ -28,13 +28,15 @@ int main(
 }
 ```
 
-在上面的例子中，变量`a`和`b`是形式参数（或形式参数）。变量`var1`和`var2`是实际参数（或实际参数）。实际参数也可以是值。像`sum(10,20)`一样，这里 10 和 20 是实际参数。
+在上面的例子中，变量`a`和`b`是形式参数。变量`var1`和`var2`是实际参数。实际参数也可以是值。像`sum(10,20)`一样，这里 10 和 20 是实际参数。
 
-在本指南中，我们将按值讨论**函数调用。如果您想通过引用方法读取调用，请参考本指南：[函数调用参考](https://beginnersbook.com/2014/01/c-function-call-by-reference-example/)。**
+在本指南中，我们将讨论**按值函数调用**。如果您想阅读按引用调用方法，请参考本指南：[按引用函数调用](https://beginnersbook.com/2014/01/c-function-call-by-reference-example/)。
 
 让我们回到原点。
-**什么是函数调用值？**
-当我们在调用函数时传递实际参数时，这称为函数调用值。在这种情况下，实际参数的值被复制到形式参数。因此，对形式参数执行的操作不反映在实际参数中。
+
+**什么是按值函数调用？**
+
+当我们在调用函数的同时传递实际参数，这称为按值函数调用。在这种情况下，实际参数的值被复制到形式参数。因此，对形式参数执行的操作不反映在实际参数中。
 
 ## 函数按值调用的示例
 
@@ -68,9 +70,10 @@ num2 value is: 21
 ```
 
 **说明**
-我们在调用方法时传递变量 num1，但由于我们使用 call by value 方法调用函数，因此只将 num1 的值复制到形式参数 var。因此，对 var 的更改不会反映在 num1 中。
 
-## 示例 2：使用函数按值调用交换数字
+我们在调用方法时传递变量`num1`，但由于我们使用按值调用方法调用函数，因此只将`num1`的值复制到形式参数`var`。因此，对`var`的更改不会反映在`num1`中。
+
+## 示例 2：使用按值函数调用交换数字
 
 ```c
 #include <stdio.h>
@@ -107,4 +110,5 @@ After swapping: 35, 45
 ```
 
 **为什么变量在交换后仍保持不变？**
+
 原因相同 - 函数由`num1`和`num2`的值调用。实际上`var1`和`var2`实际上是交换的（不是`num1`和`num2`）。在按值调用时，实际参数只是复制到形式参数中。
\ No newline at end of file

docs/c/28.md

-# C 编程中的函数按引用调用
+# C 编程中的按引用函数调用
 
 > 原文： [https://beginnersbook.com/2014/01/c-function-call-by-reference-example/](https://beginnersbook.com/2014/01/c-function-call-by-reference-example/)
 
-在我们通过引用讨论函数调用之前，让我们理解我们将在解释这个时使用的术语：
+在我们讨论按引用函数调用之前，让我们理解我们将在解释这个时使用的术语：
+
 **实际参数**：函数调用中出现的参数。
+
 **形式参数**：函数声明中出现的参数。
+
 例如：我们有这样的函数声明：
 
 ```c
@@ -21,14 +24,15 @@ or
 int s = sum(n1, n2); //Here n1 and n2 are actual parameters
 ```
 
-在本指南中，我们将通过引用方法讨论函数调用。如果要读取值调用方法，请参考本指南：[函数调用值](https://beginnersbook.com/2014/01/c-function-call-by-value-example/)。
+在本指南中，我们将讨论按引用函数调用方法。如果要阅读按值调用方法，请参考本指南：[按值函数调用](https://beginnersbook.com/2014/01/c-function-call-by-value-example/)。
 
 让我们回到原点。
-**
-什么是函数调用参考？**
-当我们通过传递实际参数的地址来调用函数时，这种调用函数的方式称为引用调用。在通过引用调用时，对形式参数执行的操作会影响实际参数的值，因为对值执行的所有操作都存储在实际参数的地址中。它可能听起来很混乱，但下面的例子将清除你的怀疑。
 
-## 函数按引用调用的示例
+**什么是按引用函数调用？**
+
+当我们通过传递实际参数的地址来调用函数时，这种调用函数的方式称为按引用调用。在按引用调用时，对形式参数执行的操作会影响实际参数的值，因为对值执行的所有操作都存储在实际参数的地址中。它可能听起来很混乱，但下面的例子将清除你的怀疑。
+
+## 按引用函数调用的示例
 
 让我们举一个简单的例子。阅读以下程序中的注释。
 
@@ -63,9 +67,9 @@ int main()
 Value of num is: 21
 ```
 
-## 示例 2：按引用调用函数 - 交换数字
+## 示例 2：按引用函数调用 - 交换数字
 
-这里我们使用引用调用来交换数字。正如您所看到的，在调用`swapnum()`函数后，变量的值已经更改，因为交换发生在变量`num1`和`num2`的地址上。
+这里我们使用按引用调用来交换数字。正如您所看到的，在调用`swapnum()`函数后，变量的值已经更改，因为交换发生在变量`num1`和`num2`的地址上。
 
 ```c
 #include 
@@ -94,7 +98,7 @@ int main( )
 
 ```
 
-**Output:**
+**输出：**
 
 ```c
 Before swapping:

docs/c/30.md

@@ -31,7 +31,7 @@ struct struct_name {
 struct  struct_name  var_name;
 ```
 
-要么
+或者：
 
 ```c
 struct struct_name {
@@ -50,23 +50,24 @@ var_name.member2_name;
 …
 ```
 
-### 如何为结构成员复制？
+### 如何为结构成员赋值？
 
 有三种方法可以做到这一点。
+
 1）使用点（`.`）运算符
 
 ```c
 var_name.memeber_name = value;
 ```
 
-2）在一个声明中分配的所有成员
+2）在一个声明中赋值所有成员
 
 ```c
 struct struct_name var_name = 
 {value for memeber1, value for memeber2 …so on for all the members}
 ```
 
-3）**指定的初始值设定项** - 我们将在本文末尾讨论这个问题。
+3）**指定初始值设定项** - 我们将在本文末尾讨论这个问题。
 
 ### C 中的结构示例
 
@@ -106,13 +107,14 @@ Student Id is: 1234
 Student Age is: 30
 ```
 
-## C：中的嵌套结构：另一个结构中的结构
+## C 中的嵌套结构：另一个结构中的结构
 
 您可以在另一个结构中使用结构，这是相当可能的。正如我上面所解释的，一旦你声明了一个结构， **`struct struct_name`** 就像一个新的数据类型，所以你可以把它包含在另一个结构中，就像其他数据成员的数据类型一样。听起来很混乱？别担心。以下示例将清除您的疑问。
 
 ### C 编程中嵌套结构的例子
 
 假设我们有两个这样的结构：
+
 **结构 1：`stu_address`**
 
 ```c
@@ -155,7 +157,8 @@ mydata.stuAddress.state = "UP"; //Nested struct assignment
 #### 如何访问嵌套结构成员？
 
 使用`.`运算符链。
-假设你想从嵌套结构中单独显示城市 -
+
+假设你想从嵌套结构中单独显示城市：
 
 ```c
 printf("%s",  mydata.stuAddress.city);
@@ -165,7 +168,7 @@ printf("%s",  mydata.stuAddress.city);
 
 `typedef`使代码简短并提高了可读性。在上面的讨论中，我们已经看到，每次使用结构时我们都必须使用冗长的语法，这会使代码混乱，冗长，复杂且可读性降低。这个问题的简单解决方案是使用`typedef`。它就像`struct`的别名。
 
-**没有 typedef 的代码**
+**没有`typedef`的代码**
 
 ```c
 struct home_address {
@@ -198,7 +201,7 @@ var.town = "Agra";
 
 ## 指定初始值设定项以设置结构成员的值
 
-我们已经学会了两种设置`struct`成员值的方法，还有另一种方法可以使用指定的初始化器来完成相同的操作。当我们只分配结构的少数成员时，这很有用。在以下示例中，结构变量`s2`只有一个成员赋值。
+我们已经学会了两种设置`struct`成员值的方法，还有另一种方法可以使用指定的初始化器来完成相同的操作。当我们只赋值结构的少数成员时，这很有用。在以下示例中，结构变量`s2`只有一个赋值的成员。
 
 ```c
 #include <stdio.h>
@@ -219,7 +222,7 @@ int main()
 
 ```
 
-Output:
+输出：
 
 ```c
 num1: 11, num2: 22

docs/c/32.md

@@ -150,7 +150,7 @@ int main()
 
 ```
 
-Output:
+输出：
 
 ```c
 Value of variable var is: 10
@@ -215,7 +215,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 Address of var is: 0x7fff5d027c58

docs/c/35.md

@@ -73,7 +73,7 @@ int main( )
 
 ```
 
-**Output:**
+**输出：**
 
 ```c
 Before swapping:

docs/c/43.md

@@ -69,7 +69,7 @@ int main () {
 }
 ```
 
-Output:
+输出：
 
 ```c
 String after concatenation: This is my initial string, add this

docs/c/47.md

@@ -91,7 +91,7 @@ int main () {
 }
 ```
 
-Output:
+输出：
 
 ```c
 ASCII value of first unmatched character of str1 is greater than str2

docs/c/49.md

@@ -70,7 +70,7 @@ int main () {
 }
 ```
 
-Output:
+输出：
 
 ```c
 Return value of function: Apple

docs/c/8.md

@@ -133,7 +133,7 @@ int main()
 
 ```
 
-Output:
+输出：
 
 ```c
 Input the value of var1:12
@@ -203,7 +203,7 @@ int main()
 
 ```
 
-Output:
+输出：
 
 ```c
 Input the value of var1:12

docs/c/9.md

@@ -129,7 +129,7 @@ int main()
 }
 ```
 
-**Output:**
+**输出：**
 
 ```c
 Case 2