CN·语言

语言参考总览

九篇参考的导航与语言全貌——写给自己查,也写给评审你的人看。

九篇导航

篇回答的问题
词法结构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 规格书 为唯一权威。
  • 发现文档与实现不一致?那是缺陷——欢迎在仓库提单(提及即立项)。