Update: enhance documentation on const qualifiers, overload resolution, and value categories

Author: dynilath

src/zh/03-types/cv-qualifiers.md

@@ -63,6 +63,16 @@ const auto f = e; // f 的类型是 const int
 因为 `const` 带来的不能被修改的性质，类型有 `const` 限定的对象往往被称为常量。相对地，没有被 `const` 限定的对象往往被称为变量。但技术性地说，`const` 限定的对象也是变量，只是不能被修改。当看到一个对象声明为 `const int a = 1;` 时，我们可以说 `a` 是一个常量，也可以说 `a` 是一个变量，或者说 `a` 是一个常变量，这都是正确的，这些说法并不冲突。
 :::
 
+### 在函数参数中使用 const 限定符
+
+在函数参数中使用的 `const` 限定符会被忽略。例如：
+```cpp
+void func(const int a);
+void func(int a); // 两个函数是等价的
+```
+
+注意这仅是指最外层的 `const` 限定符。对于复合类型而言，需要注意观察 `const` 限定符的位置。在介绍复合类型时，会对此详细讨论。
+
 ## volatile 限定符
 
 对于 `volatile` 限定的类型的对象，编译器认为其值可能在任何时候被修改。具体而言，类型有 `volatile` 限定的对象的读写都被视作有副作用（普通的对象只有写视为副作用），因此当访问 `volatile` 限定的对象值时，程序总是会从对象的内存位置得到值，而不能简化。

src/zh/03-types/overload.md

@@ -77,19 +77,138 @@ void some_function(){
 }
 ```
 
-此时，即使 `make_some_value` 的返回类型发生了变化，`some_function` 中，（至少这里写出的部分）完全不需要进行任何修改。这样，代码的维护成本就大大降低了。
+假如此时 `make_some_value` 的返回类型发生了变化，`some_function` 中，这段代码
+```cpp
+auto temp_value = sqrt(value);
+```
+会变成
+```cpp
+auto temp_value = sqrt(value); // 是的，对于程序员写下的代码来说，完全没有变化
+```
+于是，上面写出来的部分完全不需要进行任何修改。这样，代码的维护成本就大大降低了。
+
+## 重载决议
 
-## 算数类型的重载
+重载决议是编译器在多个候选函数中选择最合适版本的过程。这个过程分为三个阶段：
 
-::: important TODO: 补充内容
+- **候选函数收集**：查找与被调用函数同名且在作用域内的所有函数声明
+- **可行函数筛选**：排除参数数量不匹配或无法隐式转换参数类型的候选
+- **最佳匹配选择**：根据优先级确定最优匹配
+
+### 候选函数收集
+
+简单来说，候选函数是指与被调用函数同名，并且在相同作用域内的所有函数声明。例如：
+
+```cpp
+void foo(int a);
+void foo(int a, int b);
+void foo(double a);
+
+namespace example {
+void foo(int a);
+void foo(int a, int b);
+void foo(double a);
+}
+
+foo(1); // 候选函数集合为 {foo(int), foo(int, int), foo(double)}
+example::foo(2); // 候选函数集合为 {example::foo(int), example::foo(int, int), example::foo(double)}
+```
+
+这里调用 `foo(1)` 时，会在全局作用域中查找 `foo` 函数，而调用 `example::foo(2)` 时，会在 `example` 命名空间中查找 `foo` 函数。
+
+这里要考虑[`using` 声明](../02-program-structure/scope.md#using-声明)和[`using` 指令](../02-program-structure/scope.md#using-namespace-指令) 的影响。
+
+对于 `using` 声明，它将接下来的名称替换为一个限定的名称，例如：
+
+```cpp
+void foo(int a);
+
+namespace example { 
+void foo(int a);
+}
+
+int main() {
+    using example::foo;
+    foo(1); // 候选函数集合为 {example::foo(int)}，而不包括 {foo(int)}
+}
+```
+
+对于 `using` 指令，它将整个命名空间的名称引入当前作用域，例如：
+
+```cpp
+void foo(int a);
+
+namespace example {
+void foo(int a);
+}
+
+int main() {
+    using namespace example;
+    foo(1); // 候选函数集合为 {foo(int), example::foo(int)}，这里会因为无法决定用哪个而报错
+}
+```
+
+::: info using namespace std;
+在 C++ 中，有一个特殊的命名空间 `std`，其中包含了大量的标准库函数和对象。
+在一些快速开发测试的情况，程序员不会定义很多函数，而倾向于直接使用标准库。这时候就会 `using namespace std;` 语句，将 `std` 命名空间中的所有名称引入当前作用域，省去每次都写 `std::` 的麻烦。
+但是，对于较大的项目而言，这样会把大量的名称引入当前作用域，可能会导致名称冲突。
 :::
 
-## 涉及 `const` 和 `volatile` 的重载
+### 可行函数筛选
 
-::: important TODO: 补充内容
+在候选函数集合中，会排除那些参数数量不匹配，或者参数无法转换过去的函数。例如：
+
+```cpp
+void foo(int a, int b);
+void foo(int a);
+
+foo(1); 
+// 候选函数集合为 {foo(int), foo(int, int)}
+// 其中，foo(int, int) 无法匹配参数 1，不是可行函数，因此调用 foo(int)
+```
+
+### 最佳匹配选择
+
+在可行函数集合中，会根据参数的类型和优先级选择最佳匹配的函数。例如：
+
+```cpp
+void foo(int a);
+void foo(double a);
+
+foo(1); // 调用 foo(int)
+```
+
+这里简单概括一下最佳匹配的规则：
+- 如果有类型完全匹配的函数，选择这个函数
+- 否则，选择最接近的类型
+
+如果此时无法判断调用哪个函数，编译器会报错。例如：
+
+```cpp
+void foo(bool a);
+void foo(short a);
+
+foo(1); // [!code error] // 无法判断调用哪个函数
+```
+
+::: info 浮点与整数
+C++ 中常常被认为比较糟糕的一点是，浮点数和整数之间是可转换的。例如：
+
+```cpp
+int a = 1.1; // a 的值是 1，浮点转换到整数，截断小数部分
+```
+
+只有上述这种情况，问题看起来并不大，但当我们考虑函数重载时：
+
+```cpp
+void foo(int a);
+void foo(float a);
+
+foo(1.1); // [!code error] // 无法判断调用哪个函数
+```
 :::
 
-## 左值引用和右值引用的重载
+### 左值引用和右值引用的重载
 
 ::: important TODO: 补充内容
 :::
@@ -99,7 +218,7 @@ void some_function(){
 ::: important TODO: 润色与细化描述
 :::
 
-在声明函数类型时，并不能推导出函数调用类型为何，因此在声明函数类型时，必须显式指定参数类型，而不能使用 `auto`。例如：
+在声明函数类型时，并不能推导出函数参数类型为何，因此在声明函数类型时，必须显式指定参数类型，而不能使用 `auto`。例如：
 ```cpp
 using binary_int_func = int(auto, auto); // [!code error] // 错误，auto 不能用在这里
 ```

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

@@ -268,6 +268,22 @@ set_a_to(a); // a 是左值，也可以传入
 
 这个 `set_a_to` 函数当然也可以使用 `int` 类型作为参数，但当类型更为复杂，构造参数的成本也不得不被考虑时，常量左值引用的作用就会凸显出来。
 
+## 常量左值引用的语法结构
+
+前面我们介绍了 `const int&` 这种形式的常量左值引用。考虑引用的语法形式 `type_name &`，所以这里引用指代的类型是 `const int` 而不是 `int`。换句话说，`const` 限定的是 `int` 类型，而非 `int &` 这个引用类型。
+
+在[const限定](../cv-qualifiers.md)一章中，我们提到限定符的顺序是可以交换的，`const int` 和 `int const` 是等价的。因此，`const int&` 和 `int const&` 是等价的。
+
+但需要注意，C++ 规定，引用类型本身是不能被限定的，因此 `int& const` 是错误的写法。
+
+此外，使用别名处理时，添加在引用类型上的限定符会被忽略，例如：
+```cpp
+using int_ref = int&;
+using const_int_ref = const int_ref; // const_int_ref 是 int& 类型，而非 const int&
+
+int a = 1;
+const int_ref ref = a; // ref 是 int& 类型
+```
 
 ## 悬垂引用
 

src/zh/03-types/value-category.md

@@ -1,5 +1,5 @@
 ---
-title: 3.4 值类别
+title: 3.4 值类别（不是类型）
 ---
 
 **值类别**（value category）在 C++ 是一个用来描述表达式性质的概念。注意，值类别并不是表达式的类型，放在类型一章的此处，是因为这个概念对于对接下来类型的理解是必要的。