语言参考总览
九篇参考的导航与语言全貌——写给自己查,也写给评审你的人看。
九篇导航
| 篇 | 回答的问题 |
|---|---|
| 词法结构 | 46 个保留字是哪些?运算符优先级怎么排?原始/多行字符串怎么写? |
| 类型系统 | 整8 和 正8 差在哪?转换的位模式语义?未初始化检查的豁免面?联合体为什么禁字符串成员? |
| 控制流 | 条件括号什么时候可省?选择怎么贯穿?中断 绑定谁? |
| 函数 | 四种传参语义?泛型为什么要 显式<类型>?函数指针与 lambda? |
| 类与对象 | 句柄模型下赋值意味着什么?构造级联与析构链?运算符重载集合? |
| 错误处理 | 三条强制检查规则?后缀 ? 的词法消歧?错误码全表? |
| 并发 | 线程必须并入?什么类型可跨线程?互斥锁<T> 怎么用? |
| 模块系统 | 导入的五种形态?名字解析三级优先级?货舱.toml? |
| 标准库 | 13 模块 187 条目逐函数文档 |
语言全貌(一页速览)
主.cnCN
枚举 等级 {
优秀,
良好,
及格,
不及格,
缺考 = -1
}
// 学生结构体:名字(字符串)、分数(浮64)、等级(枚举)
// 注意:结构体值传参/返回未实现(阶段2范围外),函数一律用 学生* 指针传参
结构体 学生 {
字符串 名字;
浮64 分数;
等级 级别;
}
// 联合体:同一内存既可按 整64 读也可按 浮64 读(共享内存验证)
联合体 成绩盒 {
整64 整数形式;
浮64 浮点形式;
}
// 函数指针类型:比较两个学生,返回 整32(-1/0/1 语义,供排序回调使用)
// 原型前向引用(Task 2.2):声明在前,定义在文件末尾
不安全 函数 按分数比较(学生* a, 学生* b) -> 整32
不安全 函数 索引排序(学生* 名单, 整32* 顺序, 整32 人数, 整32(*比较)(学生*, 学生*));
// ==================== 普通函数 ====================
// 递归求和(Task 2.2 递归):计算数组前 n 个学生的分数总和
不安全 函数 递归分数和(学生* 名单, 整32 n) -> 浮64 {
如果 (n <= 0) {
返回 0.0;
}
返回 递归分数和(名单, n - 1) + (名单 + (n - 1)).分数;
}
// 计算数组平均分(用递归求总和 + 循环演示)
函数 计算平均分(学生* 名单, 整32 人数) -> 浮64 {
返回 递归分数和(名单, 人数) / 整32转浮64(人数);
}
// 整32 -> 浮64 显式转换辅助(演示类型转换链)
函数 整32转浮64(整32 v) -> 浮64 {
返回 v * 1.0;
}
// 根据分数设置等级(选择语句 + 枚举,Task 2.7)
不安全 函数 设置等级(学生* s) {
浮64 分数 = s.分数;
如果 (分数 >= 90.0) {
s.级别 = 等级.优秀;
} 否则 如果 (分数 >= 75.0) {
s.级别 = 等级.良好;
} 否则 如果 (分数 >= 60.0) {
s.级别 = 等级.及格;
} 否则 {
s.级别 = 等级.不及格;
}
}
// 打印单个学生信息(-> 成员访问 + 枚举case,Task 2.7)
不安全 函数 打印学生(学生* s) {
打印(" 学生: ", s.名字);
打印(" 分数: ", s.分数);
选择 (s.级别) {
情况 等级.优秀:
打印(" 等级: 优秀");
中断;
情况 等级.良好:
打印(" 等级: 良好");
中断;
情况 等级.及格:
打印(" 等级: 及格");
中断;
情况 等级.不及格:
打印(" 等级: 不及格");
中断;
默认:
打印(" 等级: 未知");
}
}
// ==================== 主函数 ====================
不安全 函数 主() -> 整32 {
打印("===== 学生成绩管理系统(阶段2集成验证)=====");
// ---- 1. 结构体数组初始化(Task 2.7 结构体数组 + Task 2.5 字符串字段)----
学生[5] 名单 = {
学生{ 名字 = "张三", 分数 = 92.5, 级别 = 等级.优秀 },
学生{ 名字 = "李四", 分数 = 78.0, 级别 = 等级.良好 },
学生{ 名字 = "王五", 分数 = 55.5, 级别 = 等级.不及格 },
学生{ 名字 = "赵六", 分数 = 66.5, 级别 = 等级.及格 },
学生{ 名字 = "钱七", 分数 = 88.0, 级别 = 等级.良好 }
};
整32 人数 = 5;
// ---- 2. 循环遍历 + 指针算术(Task 2.4 指针遍历 + Task 2.1 循环)----
打印("---- 原始名单 ----");
循环 (整32 i = 0; i < 人数; i++) {
打印学生(&名单[i]);
}
// ---- 3. 数组名退化 + 指针遍历 + 继续(Task 2.4 + Task 2.1)----
打印("---- 指针遍历(跳过索引2)----");
学生* p = 名单;
整32 索引 = 0;
当 (p < 名单 + 人数) {
如果 (索引 == 2) {
索引++;
p++;
继续;
}
打印(" 第", 索引, "个: ", p.名字);
索引++;
p++;
}
// ---- 4. 递归求平均分(Task 2.2 递归 + Task 2.3 浮点运算)----
打印("---- 统计 ----");
打印("总人数: ", 人数);
浮64 平均分 = 计算平均分(名单, 人数);
打印("平均分: ", 平均分);
// ---- 5. 函数指针回调做排序(Task 2.2 函数指针,定义见文件末尾)----
// 说明:结构体整体赋值/拷贝未实现(阶段2范围外),排序采用"索引数组":
// 交换索引而非结构体元素,函数指针比较 名单[顺序[i]] 的分数
打印("---- 按分数排序(索引数组)----");
整32[5] 顺序 = { 0, 1, 2, 3, 4 };
整32(*比较)(学生*, 学生*) = 按分数比较;
索引排序(名单, 顺序, 人数, 比较);
循环 (整32 j = 0; j < 人数; j++) {
打印学生(&名单[顺序[j]]);
}
// ---- 6. 字符串 API(Task 2.5:长度/查找/连接)----
打印("---- 字符串 API ----");
字符串 报告头 = "成绩报告";
打印("标题长度: ", 字符串长度(报告头));
打印("查找'报告': ", 字符串查找(报告头, "报告"));
打印("查找'缺失': ", 字符串查找(报告头, "缺失"));
// 字符串连接(少量使用,避免多次动态分配)
字符串 第一行 = 名单[0].名字 + " 是第一名";
打印("连接: ", 第一行);
// ---- 7. 原始/多行字符串(Task 2.5)----
打印(原始"原始串: C:\dir\file");
打印(多行"""多行: 第1行\n第2行""");
// ---- 8. 位运算/移位/后缀字面量/隐式转换(Task 2.3)----
打印("---- 类型系统 ----");
整32 掩码 = 0b1100;
整32 数据 = 0b1010;
打印("位与: ", 掩码 & 数据);
打印("位或: ", 掩码 | 数据);
打印("位异或: ", 掩码 ^ 数据);
打印("位非: ", ~掩码);
打印("左移: ", 掩码 << 2);
打印("右移: ", 掩码 >> 1);
整64 大值 = 5000000000L;
正32 无符号 = 4000000000U;
打印("后缀L: ", 大值);
打印("后缀U: ", 无符号);
浮32 单精度 = 3.5f;
浮64 双精度 = 单精度;
打印("浮32->浮64: ", 双精度);
整8 小值 = 100;
整16 中值 = 30000;
打印("整8+50: ", 小值 + 50);
打印("整16-5000: ", 中值 - 5000);
// ---- 9. 联合体共享内存(Task 2.7)----
打印("---- 联合体 ----");
成绩盒 盒;
盒.整数形式 = 42;
打印("联合体整64: ", 盒.整数形式);
盒.浮点形式 = 3.5;
打印("联合体写浮点后整64: ", 盒.整数形式);
// ---- 10. 空指针判空(Task 2.4)----
打印("---- 空指针 ----");
学生* 空指针 = 无;
如果 (空指针 == 无) {
打印("空指针判空: 正确");
} 否则 {
打印("空指针判空: 错误");
}
// ---- 11. 枚举负数 + 选择默认(Task 2.7 + Task 2.1)----
打印("---- 枚举负数 ----");
等级 e = 等级.缺考;
打印("缺考值: ", e);
选择 (e) {
情况 等级.优秀:
打印("优");
中断;
默认:
打印("非优秀(默认分支)");
}
// ---- 12. 优化器一致性(Task 2.6):常量表达式在 -O1 下折叠,输出不变 ----
打印("---- 常量折叠 ----");
打印("折叠 2+3*4: ", 2 + 3 * 4);
打印("折叠 100/5: ", 100 / 5);
打印("折叠 1.5+2.25: ", 1.5 + 2.25);
变量 死代码1 = 100;
变量 死代码2 = 200;
死代码1 + 1; // 结果未使用 -> -O1 DCE 删除
死代码2 * 2; // 结果未使用 -> -O1 DCE 删除
(死代码1 + 死代码2) / 2; // 结果未使用 -> -O1 DCE 删除
打印("DCE后: ", 死代码1, " ", 死代码2);
打印("===== 系统报告完成 =====");
返回 0;
}
// ==================== 文件末尾定义(前向引用验证) ====================
// 索引排序(冒泡思想,交换索引而非结构体元素):函数指针作为回调参数(Task 2.2)
// 结构体整体赋值/拷贝未实现(阶段2范围外),故只交换 顺序 数组里的索引值
不安全 函数 索引排序(学生* 名单, 整32* 顺序, 整32 人数, 整32(*比较)(学生*, 学生*)) {
循环 (整32 i = 0; i < 人数 - 1; i++) {
循环 (整32 j = 0; j < 人数 - 1 - i; j++) {
如果 (比较(&名单[顺序[j]], &名单[顺序[j + 1]]) > 0) {
整32 临时索引 = 顺序[j];
顺序[j] = 顺序[j + 1];
顺序[j + 1] = 临时索引;
}
}
}
}
// 按分数降序比较(分数高者排前)
不安全 函数 按分数比较(学生* a, 学生* b) -> 整32 {
如果 (a.分数 < b.分数) {
返回 1;
}
如果 (a.分数 > b.分数) {
返回 -1;
}
返回 0;
}输出:===== 学生成绩管理系统(阶段2集成验证)===== ---- 原始名单 ---- 学生: 张三 分数: 92.500000 等级: 优秀 学生: 李四 分数: 78.000000 等级: 良好 学生: 王五 分数: 55.500000 等级: 不及格 学生: 赵六 分数: 66.500000 等级: 及格 学生: 钱七 分数: 88.000000 等级: 良好 ---- 指针遍历(跳过索引2)---- 第0个: 张三 第1个: 李四 第3个: 赵六 第4个: 钱七 ---- 统计 ---- 总人数: 5 平均分: 76.100000 ---- 按分数排序(索引数组)---- 学生: 张三 分数: 92.500000 等级: 优秀 学生: 钱七 分数: 88.000000 等级: 良好 学生: 李四 分数: 78.000000 等级: 良好 学生: 赵六 分数: 66.500000 等级: 及格 学生: 王五 分数: 55.500000 等级: 不及格 ---- 字符串 API ---- 标题长度: 12 查找'报告': 6 查找'缺失': -1 连接: 张三 是第一名 原始串: C:\dir\file 多行: 第1行 第2行 ---- 类型系统 ---- 位与: 8 位或: 14 位异或: 6 位非: -13 左移: 48 右移: 6 后缀L: 5000000000 后缀U: 4000000000 浮32->浮64: 3.500000 整8+50: -106 整16-5000: 25000 ---- 联合体 ---- 联合体整64: 42 联合体写浮点后整64: 4615063718147915776 ---- 空指针 ---- 空指针判空: 正确 ---- 枚举负数 ---- 缺考值: -1 非优秀(默认分支) ---- 常量折叠 ---- 折叠 2+3*4: 14 折叠 100/5: 20 折叠 1.5+2.25: 3.750000 DCE后: 100 200 ===== 系统报告完成 =====
- 全部示例经双编译对照实测;语义以 plans/001 规格书 为唯一权威。
- 发现文档与实现不一致?那是缺陷——欢迎在仓库提单(提及即立项)。