作者：M81（zzhx2006@outlook.com）

题库版本：v20250809

资源链接：点击此处下载。含有：

• Anki 备份文件 (amateur_radio_class_b_exam_question_bank.apkg)：可在 Anki 中直接导入，内置一个品相稍差的选择题模板，可按需替换调整；
• 2025 年 B 类考试题库 txt 版 (amateur_radio_class_b_exam_question_bank.txt)：从官方 pdf 题库中直接提取；
• 2025 年 B 类考试题库 csv 版 (amateur_radio_class_b_exam_question_bank.csv)：遵循标准 csv 格式，从 txt 版处理得到；

三者皆不含图片。图片题仅数道，建议单独学习。

使用时既可以直接导入 Anki 备份文件版，也可以按需自行从 txt 或 csv 定制化。

合理安排每天学习和复习的卡片数量，最短 4 天即可拿下。

祝考试通过！73～

本文2026-01-29首发于M81's Website，最后修改于2026-01-29

作者：M81（zzhx2006@outlook.com）

本文主要记录在 Arch Linux 上使用 GCC 15.2.1 编译器编译包含 import std; 的 C++23 标准模块（std module）代码时，如何让 Clangd 正常工作——即 import std; 不再被标记为红色波浪线提示“Module ‘std’ not found”，并且能够正常提供其中符号的悬停（Hover）提示。

使用的工具版本如下：

 - GCC: 15.2.1
 - Clangd: 22.0.0git def8ecbda9f146d5ba5bbc8c92f7d5ccd242ad2b
 - VS Code: 1.106.1
 - VS Code 中的 Clangd 插件: 0.2.0
 - Bear: 3.1.6

如你所见，Clangd 官方目前最新的稳定版本是 21.1.6，但本次实验需自行从 Git 仓库编译开发中的 22.0.0 版本。实测表明，21.x 版本容易出现部分源代码文件中的符号无法正常解析的问题。

VS Code 的 C++ 插件使用的是 Clangd（LLVM）。Microsoft 官方的 C/C++ 插件表现如何，可自行尝试。

首先，我们创建一个最小可行项目。运行以下命令：

cp /usr/include/c++/15.2.1/bits/std.cc .
cp /usr/include/c++/15.2.1/bits/std.compat.cc .

将系统中 GCC 提供的两个用于 C++23 标准模块的关键文件复制到当前目录。

接着新建一个 main.cpp 文件，内容如下：

import std;
import std.compat;

int main()
{
    std::cout << "Hello C++23 Std Module in GCC!\n";
}

并编写对应的 Makefile：

CXX := /usr/bin/g++
CXXFLAGS := -std=c++26 -fmodules

STDCC := std.cc
STDCOMPATCC := std.compat.cc

main: gcm.cache/std.gcm gcm.cache/std.compat.gcm main.cpp
	$(CXX) $(CXXFLAGS)    -o main           main.cpp

gcm.cache/std.gcm: $(STDCC)
	$(CXX) $(CXXFLAGS) -c -o std.o          $(STDCC)

gcm.cache/std.compat.gcm: $(STDCOMPATCC)
	$(CXX) $(CXXFLAGS) -c -o std.compat.o   $(STDCOMPATCC)

.PHONY: clean

clean:
	rm -rf .cache gcm.cache main *.o compile_commands.json

下一步，使用 Bear 生成 compile_commands.json，同时尝试编译，运行：

bear -- make

这会在当前目录下生成 compile_commands.json 文件，该文件将被 Clangd 识别并使用。同时会编译源文件。正常情况下应无报错，当前目录下会生成 std.o、std.compat.o、main 和 gcm.cache/ 目录。Make 实际执行了以下命令：

/usr/bin/g++ -std=c++26 -fmodules -c -o std.o          std.cc
/usr/bin/g++ -std=c++26 -fmodules -c -o std.compat.o   std.compat.cc
/usr/bin/g++ -std=c++26 -fmodules    -o main           main.cpp

接着，新建 .clangd 配置文件，内容如下：

If:
    PathMatch: [.*\.h, .*\.cpp]
CompileFlags:
    Add: [-std=c++26, -fmodules, -Xclang, -fbuiltin-headers-in-system-modules]
    Compiler: g++

在 VS Code 中按 Ctrl+, 打开设置，搜索 “clangd”，找到 “Clangd: Arguments” 选项，添加以下两条参数：

--enable-config
--experimental-modules-support

如果你确实自行编译了 Clangd 22.0.0，可能还需要修改 “Clangd: Path” 设置，将其指向你编译出的 Clangd 可执行文件路径。

此时，用 VS Code 打开 main.cpp，应该会看到 import std; 下的红色波浪线已经消失，将光标悬停在 cout 上时，也能正常显示悬停提示框。

以下是一些可能出现的常见问题：

1. 请确保 compile_commands.json 中包含正确的内容，而不是只有 []。这可以通过执行 make clean; make 来解决。
2. 请确保确实将系统目录中的 std.cc 和 std.compat.cc 这两个文件复制到了当前目录中，而不是在 Makefile 中直接引用系统路径下的文件，否则可能导致 Clangd 解析失败。
3. 请确保 Clangd 能读取到的 .clangd 配置文件中，CompileFlags 已正确添加了 -fmodules、-Xclang 和 -fbuiltin-headers-in-system-modules 这几个选项，特别是最后一个。否则可能在 Clangd 日志中看到与 inttypes.h 相关的报错。
4. 请确保在 VS Code 的 Clangd 插件设置中已添加 --experimental-modules-support 参数，否则 Clangd 可能在多次重启失败后自动停止运行。

希望这篇文章对你有所帮助！如果你仍有疑问，欢迎通过电子邮件等方式与我分享你的实验经历。

本文2025-11-22首发于M81's Website，最后修改于2025-11-22

作者：M81（zzhx2006@outlook.com）

以下内容是《ISO/IEC 14882:2024》[7.2.1] Value category [basic.lval] 部分的中文翻译。标准文件可从此仓库下载。

          expression         
           /     \           
          /       \          
     glvalue      rvalue     
      /    \      /   \      
     /      \    /     \     
 lvalue     xvalue    prvalue

• glvalue（泛左值）是一个表达式，其求值结果决定了某个对象或函数的身份（identity）。
• prvalue（纯右值）是一个表达式，其求值用于初始化一个对象、或在特定上下文中计算某个运算符的操作数，或者是一个类型为 cv void 的表达式。

• xvalue（亡值）是一个 glvalue，它表示一个其资源可以被重用的对象（通常是因为该对象即将结束其生命周期）。
• lvalue（左值）是一个不是 xvalue 的 glvalue。
• rvalue（右值）是一个 prvalue 或者 xvalue。

每一条表达式恰好属于本分类体系中以下三种基本类别之一：lvalue、xvalue 或 prvalue。这种表达式的属性被称为它的值类别（value category）。

注 1： 第 [7.6] 节中对每一个内建运算符的讨论，都指明了该运算符所产生的结果的值类别，以及它所期望的操作数的值类别。例如，内建的赋值运算符要求其左侧操作数为 lvalue，右侧操作数为 prvalue，并产生一个 lvalue 类型的结果。用户定义的运算符本质上是函数，其所接受的操作数和所产生的结果的值类别由其参数类型与返回类型决定。

注 2： 历史上，lvalue 和 rvalue 这两个术语来源于它们通常出现在赋值表达式的左边或右边（尽管这一规则在现代语言规范中已不再普遍适用）；glvalue 是 “广义的” lvalue，prvalue 是 “纯正的” rvalue，而 xvalue 是 “将亡的” lvalue。尽管这些术语中包含 “值（value）”，但它们实际上是对表达式的分类，而非对实际数据值的描述。

注 3： 一个表达式是 xvalue（将亡值），如果它满足以下任一条件：

• 它是一个可移动的合格 id 表达式（id-expression）（参见 [7.5.5.2] 节）；
• 它是调用一个返回类型为对象类型的右值引用（rvalue reference）的函数所得到的结果，无论该函数调用是显式的还是隐式的（参见 [7.6.1.3] 节）；
• 它是一个到对象类型的右值引用的显式类型转换（cast）的结果（参见 [7.6.1.4]、[7.6.1.7]、[7.6.1.9]、[7.6.1.10]、[7.6.1.11]、[7.6.3] 节）；
• 它是一个使用 xvalue 类型数组操作数进行下标访问（subscripting）所得的结果（参见 [7.6.1.2] 节）；
• 它是一个类成员访问表达式，用于指代一个非静态数据成员，且该成员的类型不是引用类型，同时其对象表达式（object expression）本身是一个 xvalue（参见 [7.6.1.5] 节）；
• 它是一个指向成员的 .* 操作符表达式，其中第一个操作数是 xvalue，第二个操作数是指向数据成员的指针（pointer to data member）（参见 [7.6.4] 节）。

一般而言，此规则的效果是：命名的右值引用（named rvalue references）被视为左值（lvalues），而未命名的右值引用到对象（unnamed rvalue references to objects）被视为将亡值（xvalues）；对于右值引用到函数（rvalue references to functions），无论是否命名，均被视为左值（lvalues）。

举例：

struct A
{
    int m;
};
A &&operator+(A, A);
A &&f();
A a;
A &&ar = static_cast<A &&>(a);

表达式 f()、f().m、static_cast<A&&>(a) 和 a + a 是 xvalue。表达式 ar 是一个 lvalue。

一个 glvalue（“广义左值”）的结果是该表达式所表示的实体（entity）。一个 prvalue（“纯右值”）的结果是该表达式在其求值上下文中所存储的值；类型为 cv void 的 prvalue 没有结果。一个结果为值 V 的 prvalue 有时被称为 “拥有” 或 “命名” 该值 V。prvalue 的结果对象（result object）是指由该 prvalue 初始化的对象；如果某个非被丢弃的 prvalue 被用于计算某个内建运算符的操作数，或者其类型为 cv void，则它没有结果对象。

注 4： 除非该纯右值（prvalue）是 decltype-specifier 的操作数，否则类型为类类型或数组类型的纯右值总是具有一个结果对象（result object）。对于类型不是 cv void 的被丢弃纯右值（discarded prvalue），会物化一个临时对象（temporary object）；参见 [7.2.3]。

注 5： 试图将右值引用绑定到左值（lvalue）的情形不属于此类上下文；参见 [9.4.4]。

注 6： 因为当非类类型的表达式被转换为纯右值时，其类型中的 cv 限定符会被移除，例如，类型为 const int 的左值可以在需要类型为 int 的纯右值的上下文中使用。

注 7： 不存在作为纯右值的位域（bit-field）；如果一个位域被转换为纯右值（参见 [7.3.2]），则会创建一个其位域类型的纯右值，该纯右值随后可能进行整数提升（integer promotion）（参见 [7.3.7]）。

每当一个纯右值（prvalue）作为某个操作符的操作数出现，而该操作符期望的是一个广义左值（glvalue）时，则会应用临时对象物化转换（见 [7.3.5]）将该表达式转换为一个亡值（xvalue）。

在第 [9.4.4] 节关于引用初始化的讨论以及第 [6.7.7] 节关于临时对象的内容中，描述了左值和右值在其他重要上下文中的行为。

除非另有说明（见 [9.2.9.5]），一个纯右值的类型应当始终是完整类型（complete type）或 void 类型；如果其类型是一个类类型，或者是一个（可能是多维的）类类型的数组，则该类不得为抽象类（见 [11.7.4]）。广义左值（glvalue）不得具有 cv 限定的 void 类型。

注 8： 广义左值可以具有完整的或不完整的非 void 类型。类类型和数组类型的纯右值可以具有 cv 限定类型；其他类型的纯右值总是具有非 cv 限定类型。参见 [7.2.2]。

一个左值是可修改的，除非其类型是 const 限定的，或者是一个函数类型。

注 9： 若程序试图通过一个不可修改的左值或通过一个右值来修改一个对象，则该程序格式错误（ill-formed）（见 [7.6.19]、[7.6.1.6]、[7.6.2.3]）。

若一程序试图通过一个泛左值（glvalue）访问某一对象的存储值，而该泛左值的类型与下列类型之一不相似（not similar，见 [7.3.6]），则行为未定义（undefined behavior）：

• 该对象的动态类型（dynamic type）；
• 与该对象的动态类型相对应的有符号或无符号类型；
• char、unsigned char 或 std::byte 类型。

若一程序对某一联合体（union）类型 U 的默认生成的拷贝 / 移动构造函数或拷贝 / 移动赋值运算符进行调用时，使用了一个泛左值实参，而该实参并不表示在其生存期内的一个 cv U 类型的对象，则行为未定义。

注 10： 在 C 语言中，可以通过例如赋值操作来访问整个结构体类型的对象。相比之下，C++ 中并不存在通过类类型的左值来访问类类型对象的概念。

本文2025-06-05首发于M81's Website，最后修改于2025-06-05

作者：M81（zzhx2006@outlook.com）

1. socket()

int socket(int 协议族, int 套接字类型, int 协议);

📖 解释：创建一个新的套接字，返回一个文件描述符用于后续网络通信.

第 1 个参数 🔑：协议族，指定通信协议类型.

• 示例：AF_INET（IPv4协议）、AF_INET6（IPv6协议）、AF_UNIX（本地进程间通信）.

第 2 个参数 🔑：套接字类型，指定通信语义.

• 示例：SOCK_STREAM（TCP流式套接字）、SOCK_DGRAM（UDP数据报套接字）.

第 3 个参数 🔑：具体协议，通常为0（使用默认协议）.

• 示例：若类型是SOCK_STREAM，则默认协议是IPPROTO_TCP；若类型是SOCK_DGRAM，默认协议是IPPROTO_UDP.

返回值 📤：

• ✅ 成功时：返回非负整数（套接字文件描述符）.

• ❎ 失败时：返回-1，并设置errno（如EACCES权限不足、EINVAL参数无效）.

2. bind()

int bind(int 套接字描述符, const struct sockaddr *地址, socklen_t 地址长度);

📖 解释：将套接字与特定IP地址和端口绑定.

第 1 个参数 🔑：套接字描述符（通过socket()创建的文件描述符）.

第 2 个参数 🔑：地址（指向sockaddr结构的指针），包含IP和端口.

• 示例：struct sockaddr_in server_addr（IPv4地址结构），需填充sin_family（AF_INET）、sin_port（htons(8080)）、sin_addr（INADDR_ANY 表示监听所有接口）.

第 3 个参数 🔑：地址长度（地址结构的大小）.

• 示例：sizeof(struct sockaddr_in).

返回值 📤：

• ✅ 成功时：返回0.

• ❎ 失败时：返回-1（如端口已被占用，errno=EADDRINUSE）.

3. listen()

int listen(int 套接字描述符, int 积压连接数);

📖 解释：将套接字设为监听模式，等待客户端连接请求.

第 1 个参数 🔑：套接字描述符（已绑定的套接字）.

第 2 个参数 🔑：积压连接数（等待队列的最大长度）.

• 示例：5（表示最多允许5个未处理的连接请求）.

返回值 📤：

• ✅ 成功时：返回0.

• ❎ 失败时：返回-1（如套接字未绑定，errno=EINVAL）.

4. accept()

int accept(int 监听套接字描述符, struct sockaddr *客户端地址, socklen_t *客户端地址长度);

📖 解释：接受客户端的连接请求，返回新的套接字用于通信.

第 1 个参数 🔑：监听套接字描述符（通过listen()设置的套接字）.

第 2 个参数 🔑：客户端地址（输出参数，保存客户端地址信息）.

• 示例：struct sockaddr_in client_addr，调用后填充客户端IP和端口.

第 3 个参数 🔑：客户端地址长度（输入输出参数，传入地址结构大小，返回实际大小）.

• 示例：socklen_t len = sizeof(client_addr);

返回值 📤：

• ✅ 成功时：返回新的套接字描述符（用于与客户端通信）.

• ❎ 失败时：返回-1（如系统资源不足，errno=ENOMEM）.

5. connect()

int connect(int 套接字描述符, const struct sockaddr *服务器地址, socklen_t 地址长度);

📖 解释：客户端主动连接服务器.

第 1 个参数 🔑：套接字描述符（客户端通过socket()创建的套接字）.

第 2 个参数 🔑：服务器地址（服务器的IP和端口）.

• 示例：struct sockaddr_in server_addr，填充sin_family=AF_INET、sin_port=htons(80)、sin_addr.s_addr=inet_addr("192.168.1.1").

第 3 个参数 🔑：地址长度（地址结构的大小）.

• 示例：sizeof(struct sockaddr_in).

返回值 📤：

• ✅ 成功时：返回0.

• ❎ 失败时：返回-1（如服务器不可达，errno=ECONNREFUSED）.

6. send()

ssize_t send(int 套接字描述符, const void *缓冲区, size_t 长度, int 标志);

📖 解释：通过TCP套接字发送数据.

第 1 个参数 🔑：套接字描述符（已连接的套接字）.

第 2 个参数 🔑：缓冲区（发送数据的内存地址）.

• 示例：char *msg = "Hello";

第 3 个参数 🔑：长度（要发送的字节数）.

• 示例：strlen(msg).

第 4 个参数 🔑：标志（控制行为，通常为0）.

• 示例：0（默认阻塞发送）.

返回值 📤：

• ✅ 成功时：返回实际发送的字节数.

• ❎ 失败时：返回-1（如连接断开，errno=EPIPE）.

7. recv()

ssize_t recv(int 套接字描述符, void *缓冲区, size_t 长度, int 标志);

📖 解释：通过TCP套接字接收数据.

第 1 个参数 🔑：套接字描述符（已连接的套接字）.

第 2 个参数 🔑：缓冲区（接收数据的内存地址）.

• 示例：char buffer[1024];

第 3 个参数 🔑：长度（缓冲区最大容量）.

• 示例：sizeof(buffer).

第 4 个参数 🔑：标志（控制行为，通常为0）.

• 示例：0（默认阻塞接收，直到有数据到达）.

返回值 📤：

• ✅ 成功时：返回实际接收的字节数（若返回0，表示对端关闭连接）.

• ❎ 失败时：返回-1（如套接字无效，errno=ENOTCONN）.

8. sendto()

ssize_t sendto(int 套接字描述符, const void *缓冲区, size_t 长度, int 标志, const struct sockaddr *目标地址, socklen_t 地址长度);

📖 解释：通过UDP套接字发送数据到指定地址.

第 1 个参数 🔑：套接字描述符（UDP套接字）.

第 2 个参数 🔑：缓冲区（发送数据的内存地址）.

• 示例：char *msg = "UDP Message";

第 3 个参数 🔑：长度（发送数据的字节数）.

• 示例：strlen(msg).

第 4 个参数 🔑：标志（通常为0）.

第 5 个参数 🔑：目标地址（目标IP和端口）.

• 示例：struct sockaddr_in server_addr，填充服务器信息.

第 6 个参数 🔑：地址长度（目标地址结构的大小）.

• 示例：sizeof(struct sockaddr_in).

返回值 📤：

• ✅ 成功时：返回实际发送的字节数.

• ❎ 失败时：返回-1（如网络不可达，errno=ENETUNREACH）.

9. recvfrom()

ssize_t recvfrom(int 套接字描述符, void *缓冲区, size_t 缓冲区长度, int 标志, struct sockaddr *源地址, socklen_t *地址长度);

📖 解释：从套接字接收数据，支持获取发送方地址信息（常用于UDP）.

第 1 个参数 🔑：套接字描述符（已绑定的UDP或TCP套接字）.

第 2 个参数 🔑：接收缓冲区指针（存储接收到的数据）.

第 3 个参数 🔑：缓冲区最大容量（字节）.

第 4 个参数 🔑：接收标志（如MSG_PEEK预览数据、MSG_WAITALL等待完整数据）.

第 5 个参数 🔑：源地址（输出参数，保存发送方地址信息）.

第 6 个参数 🔑：地址长度（输入输出参数，传入地址结构大小，返回实际地址长度）.

返回值 📤：

• ✅ 成功时：返回实际接收的字节数.

• ❎ 失败时：返回-1（如缓冲区不足，errno=EINVAL）.

10. sendmsg()

ssize_t sendmsg(int 套接字描述符, const struct msghdr *消息结构, int 标志);

📖 解释：发送复杂消息（支持多缓冲区和辅助数据，如文件描述符传递）.

第 1 个参数 🔑：套接字描述符（已连接的TCP或绑定的UDP套接字）.

第 2 个参数 🔑：消息结构指针（包含数据缓冲区、地址、控制信息）.

第 3 个参数 🔑：发送标志（如MSG_DONTWAIT非阻塞发送）.

返回值 📤：

• ✅ 成功时：返回实际发送的字节数.

• ❎ 失败时：返回-1（如无效参数，errno=EINVAL）.

11. recvmsg()

ssize_t recvmsg(int 套接字描述符, struct msghdr *消息结构, int 标志);

📖 解释：接收复杂消息（支持多缓冲区和辅助数据）.

第 1 个参数 🔑：套接字描述符.

第 2 个参数 🔑：消息结构指针（输出参数，存储接收的数据和控制信息）.

第 3 个参数 🔑：接收标志（如MSG_TRUNC返回完整数据长度即使截断）.

返回值 📤：

• ✅ 成功时：返回实际接收的字节数.

• ❎ 失败时：返回-1（如套接字未连接，errno=ENOTCONN）.

12. close()

int close(int 文件描述符);

📖 解释：关闭套接字描述符，释放资源.

第 1 个参数 🔑：要关闭的套接字描述符.

返回值 📤：

• ✅ 成功时：返回0.

• ❎ 失败时：返回-1（如无效描述符，errno=EBADF）.

13. shutdown()

int shutdown(int 套接字描述符, int 关闭方式);

📖 解释：关闭套接字的读/写通道或全部通道.

第 1 个参数 🔑：套接字描述符.

第 2 个参数 🔑：关闭方式（SHUT_RD停读，SHUT_WR停写，SHUT_RDWR全停）.

返回值 📤：

• ✅ 成功时：返回0.

• ❎ 失败时：返回-1（如无效方式，errno=EINVAL）.

14. setsockopt()

int setsockopt(int 套接字描述符, int 协议层, int 选项名, const void *选项值, socklen_t 选项长度);

📖 解释：设置套接字选项（如超时、重用地址）.

第 1 个参数 🔑：套接字描述符.

第 2 个参数 🔑：协议层（如SOL_SOCKET通用选项，IPPROTO_TCP TCP选项）.

第 3 个参数 🔑：选项名（如SO_REUSEADDR地址重用，SO_RCVTIMEO接收超时）.

第 4 个参数 🔑：选项值指针（如int reuse = 1）.

第 5 个参数 🔑：选项值长度（如sizeof(reuse)）.

返回值 📤：

• ✅ 成功时：返回0.

• ❎ 失败时：返回-1（如无效选项，errno=ENOPROTOOPT）.

15. getsockopt()

int getsockopt(int 套接字描述符, int 协议层, int 选项名, void *选项值, socklen_t *选项长度);

📖 解释：获取套接字选项的当前值.

第 1 个参数 🔑：套接字描述符.

第 2 个参数 🔑：协议层（同setsockopt）.

第 3 个参数 🔑：选项名（如SO_ERROR获取错误状态）.

第 4 个参数 🔑：选项值指针（输出参数，存储选项值）.

第 5 个参数 🔑：选项长度（输入输出参数，传入指针大小，返回实际大小）.

返回值 📤：

• ✅ 成功时：返回0.

• ❎ 失败时：返回-1（如无效选项，errno=ENOPROTOOPT）.

16. getsockname()

int getsockname(int 套接字描述符, struct sockaddr *地址, socklen_t *地址长度);

📖 解释：获取套接字绑定的本地地址.

第 1 个参数 🔑：套接字描述符.

第 2 个参数 🔑：地址结构指针（输出参数，保存本地IP和端口）.

第 3 个参数 🔑：地址长度（输入输出参数，传入结构大小，返回实际大小）.

返回值 📤：

• ✅ 成功时：返回0.

• ❎ 失败时：返回-1（如未绑定地址，errno=EINVAL）.

17. getpeername()

int getpeername(int 套接字描述符, struct sockaddr *地址结构, socklen_t *地址长度);

📖 解释：获取已连接套接字对端的地址信息.

第 1 个参数 🔑：已连接的套接字描述符（如accept返回的描述符）.

第 2 个参数 🔑：地址结构（输出参数，保存对端IP和端口）.

• 示例：struct sockaddr_in peer_addr;

第 3 个参数 🔑：地址长度（输入输出参数，传入结构大小，返回实际大小）.

• 示例：socklen_t len = sizeof(peer_addr);

返回值 📤：

• ✅ 成功时：返回0.

• ❎ 失败时：返回-1（如未连接套接字，errno=ENOTCONN）.

18. ioctl()

int ioctl(int 文件描述符, unsigned long 请求码, ... /* 参数 */);

📖 解释：对文件描述符执行设备输入/输出操作（常用于设置套接字选项）.

第 1 个参数 🔑：文件描述符（如套接字描述符）.

第 2 个参数 🔑：请求码（指定操作类型，如FIONBIO设置非阻塞模式）.

第 3 个参数 🔑：可变参数（根据请求码传入参数，如int *非阻塞标志）.

• 示例：

  
  int flags = 1;
  
  ioctl(sockfd, FIONBIO, &flags); // 设置非阻塞
  

返回值 📤：

• ✅ 成功时：返回0.

• ❎ 失败时：返回-1（如无效请求码，errno=EINVAL）.

19. fcntl()

int fcntl(int 文件描述符, int 命令, ... /* 可选参数 */);

📖 解释：对文件描述符执行控制操作（如设置非阻塞模式）.

第 1 个参数 🔑：文件描述符（如套接字描述符）.

第 2 个参数 🔑：命令（如F_GETFL获取标志，F_SETFL设置标志）.

第 3 个参数 🔑：可选参数（如标志位O_NONBLOCK）.

• 示例：

  
  int flags = fcntl(sockfd, F_GETFL, 0);
  
  fcntl(sockfd, F_SETFL, flags | O_NONBLOCK); // 设置非阻塞
  

返回值 📤：

• ✅ 成功时：返回依赖命令（如F_GETFL返回标志值）.

• ❎ 失败时：返回-1（如无效命令，errno=EINVAL）.

20. select()

int select(int 最大描述符+1, fd_set *读集合, fd_set *写集合, fd_set *异常集合, struct timeval *超时时间);

📖 解释：同步I/O多路复用，监控多个文件描述符状态.

第 1 个参数 🔑：监控的最大文件描述符值+1（如max_fd+1）.

第 2-4 个参数 🔑：读/写/异常集合（使用FD_SET宏设置，返回就绪的描述符）.

• 示例：

  
  fd_set read_fds;
  
  FD_ZERO(&read_fds);
  
  FD_SET(sockfd, &read_fds);
  

第 5 个参数 🔑：超时时间（NULL表示无限等待，timeval结构指定秒/微秒）.

返回值 📤：

• ✅ 成功时：返回就绪的描述符总数.

• ❎ 失败时：返回-1（如中断，errno=EINTR）.

21. poll()

int poll(struct pollfd *文件描述符数组, nfds_t 文件描述符数量, int 超时时间);

📖 解释：类似select，但使用数组结构管理描述符.

第 1 个参数 🔑：pollfd结构数组（包含描述符、事件、返回事件）.

• 示例：

  
  struct pollfd fds[1];
  
  fds[0].fd = sockfd;
  
  fds[0].events = POLLIN;
  

第 2 个参数 🔑：数组元素数量（如sizeof(fds)/sizeof(fds[0])）.

第 3 个参数 🔑：超时时间（毫秒，-1表示无限等待）.

返回值 📤：

• ✅ 成功时：返回就绪的描述符数量.

• ❎ 失败时：返回-1（如无效参数，errno=EFAULT）.

22. epoll_create()

int epoll_create(int 大小);

📖 解释：创建epoll实例（内核事件表）.

第 1 个参数 🔑：事件表大小（Linux 2.6.8+忽略此值，建议填0）.

返回值 📤：

• ✅ 成功时：返回epoll文件描述符.

• ❎ 失败时：返回-1（如权限不足，errno=EPERM）.

23. epoll_ctl()

int epoll_ctl(int epoll描述符, int 操作类型, int 目标描述符, struct epoll_event *事件);

📖 解释：注册/修改/删除epoll事件.

第 1 个参数 🔑：epoll描述符（由epoll_create返回）.

第 2 个参数 🔑：操作类型（EPOLL_CTL_ADD添加，EPOLL_CTL_MOD修改，EPOLL_CTL_DEL删除）.

第 3 个参数 🔑：目标描述符（如套接字描述符）.

第 4 个参数 🔑：事件结构（指定监听事件如EPOLLIN）.

• 示例：

  
  struct epoll_event ev;
  
  ev.events = EPOLLIN;
  
  ev.data.fd = sockfd;
  
  epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);
  

返回值 📤：

• ✅ 成功时：返回0.

• ❎ 失败时：返回-1（如描述符已存在，errno=EEXIST）.

24. epoll_wait()

int epoll_wait(int epoll描述符, struct epoll_event *事件数组, int 最大事件数, int 超时时间);

📖 解释：等待epoll事件就绪.

第 1 个参数 🔑：epoll描述符（由epoll_create返回）.

第 2 个参数 🔑：事件数组（保存就绪事件）.

• 示例：

  
  struct epoll_event events[10];
  
  int num = epoll_wait(epfd, events, 10, -1);
  

第 3 个参数 🔑：最大事件数（如数组长度10）.

第 4 个参数 🔑：超时时间（毫秒，-1表示无限等待）.

返回值 📤：

• ✅ 成功时：返回就绪事件数量.

• ❎ 失败时：返回-1（如中断，errno=EINTR）.

Generated by Qwen2.5-Max + QwQ-32B-Preview.

本文2025-03-05首发于M81's Website，最后修改于2025-03-05

作者：M81（zzhx2006@outlook.com）

详细的讲解请看 CppMore 里缪大佬的 这篇文章。

此处学习一下其中的使用 递归继承 技巧实现简易元组类这个例子。

直接 “Show me the code!”

#include <iostream>

/*
    先明晰省略运算符的意思：
       typename... T   --> 把一堆类型折叠到 T 中
       T ...           --> 从 T 中展开之前折叠的变量
*/

// #1: 先是 Tuple 类

// 主模板
template <typename... Types>
class Tuple;
// 全特化：作为终止递归的条件
template <>
class Tuple<> {};

template <typename Head, typename... Tail>  // 将传递进来的参数分为第 1 个（称之为 Head）和其余个（第 2～N 个，折叠在 Tail 里）
class Tuple<Head, Tail...> : public Tuple<Tail...> { // 递归继承（采用公有继承）
public:
  Tuple() {}

  Tuple(Head v, Tail... vtails) : Tuple<Tail...>(vtails...), head_(v) {}

  // 用来返回 Tuple 类的内部成员 head_ 的值，也是这个 Tuple 的第一个值
  Head &head() { return head_; }

protected:
  // head_ : 第一个值的意思，比如作为 Tuple<int, float, char> t(5, 2.7, 'b') 其中的 5
  Head head_;
};


// #2: 然后是 TupleAt 类

// 主模板
template <std::size_t I, typename... TList>
struct TupleAt;


// 暂称 Tuple<T, TList...> 叫做“当前元组”
// 设计 TupleAt 的目的是获取到指定索引（I）处的元素的类型（称之为ValueType）（不必获取到具体的值，这个任务交给 Tuple 类的 head() 方法解决）
// ValueType 是“尾随元组”（意思是当前元组把第一项元素去掉，剩余的元素构成的元组）的第一个元素的类型
// TupleType 是“尾随元组”这一整体类型（它是当前元组的父类，因为 Tuple<Head, Tail...> 公有继承了 Tuple<Tail...>）
template <std::size_t I, typename T, typename... TList>
struct TupleAt<I, Tuple<T, TList...>> {
  using ValueType = typename TupleAt<I - 1, Tuple<TList...>>::ValueType;
  using TupleType = typename TupleAt<I - 1, Tuple<TList...>>::TupleType;
};


// 作为终止递归的条件：I = 0
template <typename T, typename... TList>
struct TupleAt<0, Tuple<T, TList...>> {
  using ValueType = T;
  using TupleType = Tuple<T, TList...>;
};


// #3: 最后还剩个 TupleGet 函数模板

/* TupleGet<I>(tuple) 这个函数模板在使用的时候（比如 TupleGet<2>(t)）直观上接受两个参数：
                    其一，是模板参数 std::size_t I，表示索引；
                    其二，是函数参数 Tuple<TList...>& tuple，表示目标元组
    TList 是目标元组 tuple 的模板参数们
*/
template <std::size_t I, typename... TList>
typename TupleAt<I, Tuple<TList...>>::ValueType &
TupleGet(Tuple<TList...> &tuple) {
  using BaseTupleType = typename TupleAt<I, Tuple<TList...>>::TupleType;
  return static_cast<BaseTupleType &>(tuple).head(); // 把当前元组强制转换其类型为上一层元组（也就是当前元组的尾随元组），.head() 的结果就会变成尾随元组的 head_
}


int
main() {
  Tuple<int, float, char> t(1, 2.7, 'b');
  Tuple<int, Tuple<int, float, char>, double> t2(4, t, 4.7);
  std::cout << TupleGet<2>(t) << std::endl;
  std::cout << TupleGet<0>(t2) << std::endl;
  std::cout << TupleGet<2>(t2) << std::endl;
  std::cout << TupleGet<2>(TupleGet<1>(t2)) << std::endl; // 嵌套元组也能正常处理哦
  return 0;
}

这个程序实现了一个极简元组类，可以把不同类型的元素绑定在一起，并按下表索引访问元素。

每处所起到的作用已包含在注释里。这里举一个例子，简单看一下效果。

例如对于 Tuple<int, float, char> t(1, 2.7, 'b')，在 TupleGet<2>(t) 时会发生什么。预期的结果应该是返回 char 类型的 'b'。

TupleGet 的递归过程可以用下面这张图表示：

                                                强制转换
  TupleAt<2, <int, float, char>>::TupleType <-----+ 
              ^~~  ^~~~~~~~~~~         |          | 
               T      TList            |          | 
                                       |         (t)
                       ----------------+            
                       |                            
                       v                            
     TupleAt<1, <float, char>>::TupleType           
                                     |              
                                     |              
                     ----------------+              
                     |                              
                     v                              
        TupleAt<0, <char>>::TupleType               
                                 |                  
                                 |                  
                      -----------+                  
                      |                             
                      v                             
                  Tuple<char>                       

首先在第 71 行处，t 会被强制类型转换成 TupleAt<2, <int, float, char>>::TupleType 类型。那么这一长串类型到底是什么呢？

由第 48 行可以知道，它会变成 TupleAt<1, <float, char>>::TupleType，这一所谓 “变成” 实际上是通过将传递进来的参数分为第 1 个和其余个（第 2～N 个）。这样每次传递进来的参数会依次减少，达到遍历所有参数的效果（引自 里缪的文章）。递归的每一层，都只保留了 TList，舍弃了 T。

同理，TupleAt<1, <float, char>>::TupleType 会变成 TupleAt<0, <char>>::TupleType，最终通过 I = 0 的偏特化版本变成 Tuple<char>，而此时的 ValueType 是 char，正是我们想要的索引为 2 的那个元素的类型。

同时，Tuple<char> 也是 Tuple<int, float, char> 的基类，因此要通过强制类型转换把 Tuple<int, float, char> 转换成 Tuple<char>，这么做是为了一层一层地舍弃当前元组的 head 而保留基类元组的 head，实现了递归展开的效果。（具体分析和设计思路请看 里缪的文章）

本文2024-11-28首发于M81's Website，最后修改于2024-11-28

作者：M81（zzhx2006@outlook.com）

本文简要记录笔者在 Arch Linux 上编译一个部分支持 C++ 反射的 clang 编译器的过程。

期待 Reflection 能正式被编译器实现的那一天。 :)

本次实验受群友 Yiran Wang 启发。

克隆仓库

GitHub 仓库在 这里，有关这个编译器的介绍详情请看仓库（默认是 purpose 分支，代码在 p2996 分支上）。

先克隆仓库到本地：

$ git clone https://github.com/bloomberg/clang-p2996 --depth 1 --branch=p2996

使用 --depth 1 选项只克隆最新版本的 commit，可大大减小仓库体积（好像只有两百多兆）。

有的仓库有很多分支（比如 llvm 或者 gcc 官方仓库），使用 --branch=xxx 指定克隆某一个分支也可以减小体积。本仓库只有两个分支，作用不大。

建议上网搜一下镜像站，在高级搜索中调整搜索范围为近一周左右，基本就可以找到可用的镜像站，实测有助于提高网速。

编译 Clang

编译选项和步骤可以参考 llvm 官网手册中的介绍，此处给出我的生成命令，供参考：

$ cd clang-p2996
$ mkdir build
$ cd build
$ cmake -DLLVM_ENABLE_PROJECTS=clang \
        -DCMAKE_C_COMPILER=clang \
        -DCMAKE_CXX_COMPILER=clang++ \
        -DLLVM_ENABLE_RUNTIMES="libc;libcxx;libcxxabi;libunwind" \
        -DCMAKE_C_FLAGS="-O3 -march=native -mtune=native" \
        -DCMAKE_CXX_FLAGS="-O3 -march=native -mtune=native" \
        -DCMAKE_BUILD_TYPE=Release \
        -DLLVM_USE_LINKER=lld \
        -DLLVM_BUILD_TOOLS=OFF \
        -DLLVM_BUILD_EXAMPLES=OFF \
        -DLLVM_BUILD_TESTS=OFF \
        -DLLVM_INCLUDE_TESTS=OFF \
        -DLLVM_INCLUDE_DOCS=OFF \
        -DLLVM_TARGETS_TO_BUILD="X86" \
        -DCMAKE_INSTALL_PREFIX=/usr/local/llvm-build \
        -G "Unix Makefiles" \
        ../llvm

具体每一个选项是什么意思以及有哪些可选参数，自己 STFW 或者问 AI。此处仅为精简编译（仅编译 clang），没有添加其他的各种工具。有需者请自选。

值得注意的是，-DLLVM_ENABLE_RUNTIMES 应该至少有 libc;libcxx;libcxxabi;libunwind（感谢群友 Yiran Wang）。

强行添加了 -O3 -march=native -mtune=native，纯属个人喜好。

-DCMAKE_INSTALL_PREFIX=/usr/local/llvm-build 的结果是 llvm-build 下有 bin、lib 等等这些。以免有人怀疑是否会出现重叠安装目录的情况。

如果有提示缺少依赖就安装相应的依赖（貌似是不缺）。

编译的时候，需要注意一下编译使用的任务数，因为可能会遇到内存瓶颈。我在 14 核心 20 线程的笔记本 U 上使用 make -j20 编译会在进度到 55% 左右时直接吃满 32G 内存 + 9G 交换内存导致桌面卡死。解决方法之一是改为 make -j14。

测试运行

先贴一个简单的编译命令：

$ /usr/local/llvm-build/bin/clang++ main.cpp \
                          --std=c++26 \
                          -I/usr/local/llvm-build/include/c++/v1 \
                          -I/usr/local/llvm-build/include/x86_64-unknown-linux-gnu/c++/v1 \
                          -freflection \
                          -stdlib=libc++ \
                          -Wl,-rpath,/usr/local/llvm-build/lib/x86_64-unknown-linux-gnu \
                          -g3 -Og -march=native -mtune=native

别忘了使用 -freflection。

-stdlib=libc++ 必不可少，否则一顿 -I 也会报错。

仅仅 -L/usr/local/llvm-build/lib/x86_64-unknown-linux-gnu 貌似不行。

贴一段简单的测试程序：

#include <experimental/meta>
#include <print>

int main()
{
    constexpr auto r = ^int;
    typename[:r:] x = 42;      // Same as: int x = 42;
    typename[:^char:] c = '*'; // Same as: char c = '*';
    std::println("{}", std::same_as<decltype(x), int>);
    std::println("{}", std::same_as<decltype(c), char>);
}

输出结果为：

true
true

本文2024-11-24首发于M81's Website，最后修改于2024-11-24

作者：M81（zzhx2006@outlook.com）

在本地试验

先在本地试一试修改 gcc 的翻译吧. 新建一个用来折腾的文件夹 ~/test/.

$ mkdir ~/test
$ cd ~/test

下载最新翻译

下载 Translation Project 上的最新版 gcc 简体中文翻译文件. 截至发稿时，gcc 最新版本为 14.2.0 版.

$ wget https://translationproject.org/PO-files/zh_CN/gcc-14.2.0.zh_CN.po

下载了一个叫做 gcc-14.2.0.zh_CN.po 的文件.

关于 Translation Project，AI 是这样介绍的：

GNU 翻译项目（GNU Translation Project）是一项由社区推动的倡议，致力于将 GNU 软件的用户界面、文档和手册翻译成多种语言，以实现软件的国际化和本地化. 该项目欢迎志愿者参与，提供翻译工具和资源，旨在确保自由软件能够跨越语言障碍，惠及全球用户，增强其可及性和用户体验.

gcc 的最新版翻译文件和其他语言翻译可以在这里找到；其他软件的翻译项目可以在这里找到. 这些都可以在官网找到，我们先暂时不管它们.

编辑翻译文件

接下来需要编辑这个 .po 文件，选择其中的词条（称为 msgid）翻译成中文（在 msgstr）.

当然可以用文本编辑器直接开干. 更推荐的是用专门的编辑 .po 文件的软件来干活更方便啦.

这里推荐使用 Poedit 软件. 下载安装（比如 Arch Linux；其他各发行版请使用各自的工具安装）：

$ sudo pacman -S poedit

然后右键点击 gcc-14.2.0.zh_CN.po，选择“使用 Poedit 打开”.

可以看到如下的工作区. 其中没有中文的黑色条目是缺少翻译的；有中文但黄色字体的是“需要处理”的（带“fuzzy”标签），表示中文翻译仍不准确，需要修改.

黄色的条目即使有中文翻译，但是被标记了 fuzzy 标签（Poedit 显示“需要处理”），最终仍不会显示出来.

我们选择有待处理的条目，在下方翻译区输入自己的中文翻译.

翻译完成后，点击保存. Poedit 会先验证文件是否有问题. 若无任何错误提示，说明已经成功保存了修改. 而且可以在 ~/test/ 中看到已经自动编译好了的 .mo 文件.

由于 .po 文件以文本格式存储，计算机查找速度慢，故需先将 .po 文件编译为 .mo 二进制文件，才能正常使用.

也可以手动输入命令来编译：

$ msgfmt gcc-14.2.0.zh_CN.po -o gcc-14.2.0.zh_CN.mo

若提示找不到 msgfmt 命令，需下载安装 gettext 包：

$ sudo pacman -S gettext

替换系统翻译

接下来，先备份系统中的 gcc.mo，然后用编译好的 .mo 文件替换系统中预设的 gcc.mo：

$ mv /usr/share/locale/zh_CN/LC_MESSAGES/gcc.mo /usr/share/locale/zh_CN/LC_MESSAGES/gcc.mo.old
$ cp ~/test/gcc-14.2.0.zh_CN.mo /usr/share/locale/zh_CN/LC_MESSAGES/gcc.mo

这样，就成功地将 gcc 的英文提示翻译成中文啦！当然，可能大多数词条不那么容易显示出来. 你可以在使用 gcc 的过程中看到英文提示时，复制英文提示，在 Poedit 中查找到这个未翻译的词条，将它翻译成中文. 然后按照上述操作，就可以看到原来的英文提示变成中文啦.

申请加入翻译团队

那么，如何将自己的翻译上传到官方项目中，为翻译工作做贡献呢？

所有信息在官网上都可以查到，这里仅总结一下操作流程.

首先加入简体中文翻译团队的邮件列表来接收成员们发送的邮件. 成员们可能会在邮件列表中讨论翻译项目，协调翻译工作，分享翻译相关的资源，寻求帮助或建议等.

接下来，你需要填写一份免责声明（disclaimer）. 在此处填写你的姓、名、填写日期和电子邮件地址，勾选“Yes”，点击“Save”. 以后使用这个电子邮件来提交自己的翻译.

然后分别向 Translation Project Coordinator 和简体中文团队负责人 Boyuan Yang 发送邮件，请求他们同意你加入简体中文翻译团队. 只有团队成员才有权提交翻译.

大约两三天后，会陆续收到抄送的邮件，是负责人和 Coordinator 沟通同意加入申请.

成功加入后，你就可以在简体中文翻译团队的 Translator 列中找到自己的名字啦.

在这个页面中还可以看到各个软件包的简体中文翻译进度. 有的软件包还被指定了译员（Assigned translator）. 点击包名称即可跳转到它的主页面；点击版本号可以查看和下载最新的 .po 翻译.

提交翻译

现在，你要使用 Translation Project robot (or TP-robot) 来将自己的 .po 文件提交到项目中.

你可以在此处查看关于 TP-robot 的说明. 官网是这么介绍的：

翻译项目机器人（或 TP-robot）是一个处理 PO 文件提交的电子邮件服务. 它检查文件是否可以被接受——也就是说，检查译者是否填写了她的免责声明（在需要的地方）——以及她的团队是否允许她进行这项工作. 它还会调用 msgfmt 来查看 PO 文件是否健全，并检查其他各种问题.

下载提交脚本

你需要下载一个 shell 脚本，用来处理你的 .po 文件，并将其发送给 TP-robot：

$ wget https://translationproject.org/extra/sendpo.sh
$ chmod +x sendpo.sh

要想让脚本正确处理 .po 文件，需要让 .po 文件的文件名符合 <软件包名称>-<版本号>.<语言代码>.po 的格式. 例如 gcc-14.2.0.zh_CN.po.

$ mv 不规范的文件名.po gcc-14.2.0.zh_CN.po

解决一些小问题

按照正常流程，现在应该使用 sendpo.sh 发送翻译文件. 但是在使用它之前，需要先处理掉几个小问题（笔者在此处停顿了很长时间）.

首先，按照要求，用编辑器打开 sendpo.sh，更改第 5 行 USERLANG="" 为 USERLANG="zh_CN".

然后，观察文件末尾. 不难发现使用到了 gzip, uuencode 和 mail 命令.

先解决掉前两个：

$ sudo pacman -S gzip
$ sudo pacman -S sharutils

至于最后一个 mail 命令，我们将其替换为更现代的邮件客户端（比如 outlook）.

删除文件末两行，替换为如下命令：

$ gzip <$file | uuencode -m $name.gz | tee ./output.txt

执行命令来处理 .po 文件：

$ ./sendpo.sh gcc-14.2.0.zh_CN.po

如果没有错误提示，会在目录下生成 messages.mo 和 output.txt.

打开 output.txt，复制文件内容.

使用客户端发送

打开邮件客户端（比如 outlook）. 将邮件正文的样式切换到“纯文本”；发件人需为之前在 Disclaimer 中填写的邮件地址；收件人填 robot@translationproject.org；邮件主题填 TP-robot gcc-14.2.0.zh_CN.po；邮件正文（不是附件）则为刚刚生成的 output.txt 的内容，复制粘贴即可.

成功发送邮件，几分钟后就会收到来自 TP-robot 的邮件反馈.

收到邮件反馈

若提示：

***> According to my notes, XXX is not a member of the Chinese (simplified) team.

说明未成功加入简体中文翻译团队. 只加入邮件列表和提交 Disclaimer 并不足够，还要向 Translation Project Coordinator 和简体中文团队负责人发送邮件，请求他们同意你加入简体中文翻译团队.

若提示：

***> Your PO file seems to have no entries at all, like if it were empty.

请检查 .po 文件是否有问题；注意应该发送的是 .po 的 base64 编码（而不是 .po.gz 的）.

若提示：

Your file has been accepted and stored in the archives. Thank you!

恭喜你成功地为项目贡献了自己的翻译！可以在此处看到最新的提交者.

本文2024-09-14首发于M81's Website，最后修改于2024-09-14