Update: improve discription

Author: dynilath

src/zh/02-program-structure/function.md

@@ -171,6 +171,12 @@ int sqrt_x2 = sqrt(x2);
 //... 依此类推
 ```
 
+::: info 形式参数与实际参数
+在描述函数调用的时候，例如 `int sqrt_x2 = sqrt(x2);` ，人并不喜欢称呼 `sqrt(x2)` 中的 `x2` 叫什么“函数调用表达式的直接子表达式”。它被用来初始化函数的参数，所以干脆直接就叫做“参数”。
+
+称 `x2` 为“参数”当然是没有错的，但是，这样就会带来一个混淆——`int sqrt(int x)` 中的 `x` 也叫“参数”，并且显然不是一个东西，在这个函数调用中，`x` 是从 `x2` 初始化而来的另一个对象。为了避免这种混淆，我们通常称呼 `int sqrt(int x)` 中的 `x` 为“形式参数”，称呼 `sqrt(x2)` 中的 `x2` 为“实际参数”。或者更简略的称呼为“形参”和“实参”。当然，在没有混淆的语境中，称呼 `x2` 为“参数”更符合人的直觉。
+:::
+
 ::: info 省略标识符的参数
 在参数列表中，如果省略了标识符，那么这个参数是一个匿名参数，这样的参数在函数体中是无法访问的。例如：
 ```cpp
@@ -183,7 +189,6 @@ int f(int) {
 ```cpp
 int a = f(42);
 ```
-这种形式的使用方式我们会在后面的章节中介绍。
 :::
 
 ## 无返回值函数

src/zh/03-types/reference-type/function-ref.md

@@ -94,5 +94,67 @@ int add(int,int); // 函数声明，为了简便起见，省略了函数体
 
 ## 在返回值中使用函数引用
 
-::: important TODO: 补充内容
-:::
+函数引用也可以作为函数的返回值，例如：
+```cpp
+using binary_int_func = int(int, int);
+
+binary_int_func& get_add() {
+    return add;
+}
+
+auto& add_ref = get_add(); // add_ref 是 add 函数的引用
+int result = add_ref(1, 2); // 调用 add 函数
+```
+
+在这里，`get_add` 函数返回了 `add` 函数的引用，然后我们可以通过 `add_ref` 来调用 `add` 函数。
+
+当然，`get_add` 可以调用再紧跟调用，不需要额外的变量：
+```cpp
+int result = get_add()(1, 2); // 调用 add 函数
+```
+
+结合之前提到[switch 语句](../../02-program-structure/statements.md#switch-语句)的例子，我们可以把 `get_add` 函数进一步扩展：
+```cpp
+using binary_int_func = int(int, int);
+
+int add(int a, int b) {
+    return a + b;
+}
+
+int sub(int a, int b) {
+    return a - b;
+}
+
+int mul(int a, int b) {
+    return a * b;
+}
+
+int div(int a, int b) {
+    return a / b;
+}
+
+int no_such_operator(int a, int b) {
+    return 0;
+}
+
+binary_int_func& get_func(char op) {
+    switch (op) {
+        case '+':
+            return add;
+        case '-':
+            return sub;
+        case '*':
+            return mul;
+        case '/':
+            return div;
+        default:
+            return no_such_operator;
+    }
+}
+```
+
+这样，我们就可以通过 `get_func` 来获取不同的函数引用，然后调用这些函数。例如：
+
+```cpp
+int result = get_func('+')(1, 2); // 调用 add 函数
+```

src/zh/03-types/reference-type/object-ref.md

@@ -96,7 +96,7 @@ int a = 1;
 auto& ref = a; // ref 是 int& 类型
 ```
 
-### 函数参数中的左值引用
+### 在函数参数中使用左值引用
 
 可以在函数参数中使用左值引用，来修改作为参数传入的对象：
 ```cpp
@@ -130,7 +130,7 @@ safe_divide(a, b, c); // c 的值变为 5
 但是，在工程中，我们一般不希望函数修改传入的参数，因此这种传出参数的方式在使用时应充分注释，或遵循一定的代码规范，以免造成误解。
 :::
 
-### 函数返回值中的左值引用
+### 在函数返回值中使用左值引用
 
 可以在返回值中使用左值引用，例如：
 ```cpp
@@ -196,7 +196,7 @@ auto&& ref2 = 1; // ref2 是 int&& 类型
 
 这一原理及其应用会在后面的章节中详细介绍。
 
-### 函数参数中的右值引用
+### 在函数参数中使用右值引用
 
 类似于左值引用，右值引用也可以用在函数参数中，例如：
 ```cpp
@@ -217,6 +217,10 @@ set_a_to(a + 1); // a + 1 是纯右值表达式
 set_a_to(a); // [!code error] // 错误，a 是左值表达式
 ```
 
+### 在函数返回值中使用右值引用
+
+::: important TODO 补充内容
+:::
 
 ## 常量左值引用
 

src/zh/03-types/type-intro.md

@@ -89,20 +89,20 @@ auto a = 42;
 auto b = a;
 ```
 
-此外，`auto`也可以用于函数参数和返回值的类型推导：
+此外，`auto`也可以用于函数返回值的类型推导：
 
 ```cpp
-auto sqrt(auto x) {
-    auto a = x;
-    while (a * a > x) {
-        a = (a + x / a) / 2;
-    }
-    return a;
+int x = 0;
+
+auto doubled_x() {
+    x *= 2;
+    return x;
 }
 
-// 由于 42 是 int 类型，x 的类型也是 int
-// 因此 foo 返回值的类型推导为 int，a 的类型也是 int
-auto a = foo(42); 
+// 由于 x 是 int 类型
+// 因此 doubled_x 的返回值类型是 int
+// 因此 a 的类型是 int
+auto a = doubled_x(); 
 ```
 
 对于目前的内容而言，读者可能会觉得 `auto` 的使用并不是很有必要，甚至会觉得 `auto` 的使用会使代码变得不够清晰。但是在后面的章节中，我们会逐渐看到 `auto` 的使用能够让复杂的程序变得简洁明了且更易维护。