CN·语言

核心

错误码枚举与四个泛型工具函数——全部模块的地基。

导入写法CN

导入 核心::错误码;
导入 核心::{交换, 最小, 最大, 断言};

错误码(枚举)

全标准库统一的错误码枚举。所有 结果<T, 整32> 中的错误值都取自这里,不要写魔法数字。

错误码

枚举 错误码 { 除零=1, 越界=2, 空指针=3, 内存=4, 文件=5, 参数=6, 未初始化=7, 溢出=8 }

值域与《设计规格书》附录 B 一致(1~8 入枚举)。成员访问用点号:错误码.越界。与内置构造器 错误(...) 搭配使用:返回 错误(错误码.文件);。附录 B 的 9=栈溢出 由运行时直接输出,不在本枚举内。

主.cnCN

函数 可能耗败(整32 模式) -> 结果<整32, 字符串> {
    如果 模式 == 0 {
        返回 正常(42);
    }
    返回 错误("失败原因");
}
函数 主() -> 整32 {
    结果<整32, 字符串> 甲 = 可能耗败(0);
    如果 甲.正常 {
        打印行(甲.值);
    }
    结果<整32, 字符串> 乙 = 可能耗败(1);
    如果 乙.正常 {
        打印行(乙.值);
    } 否则 {
        打印行(乙.错误);
    }
    返回 0;
}

输出:42失败原因

工具函数

三个泛型函数编译期单态化(T 替换为实参类型),要求类型支持对应的比较运算符。

工具函数.cnCN

导入 核心::{交换, 最小, 最大, 断言};

函数 主() -> 整32 {
    整32 甲 = 3;
    整32 乙 = 7;
    交换<整32>(&甲, &乙);            // 泛型调用(省略<整32>亦可·实参推导)
    打印(甲, " ", 乙);               // 7 3
    打印(最小<整32>(甲, 乙), " ", 最大<整32>(甲, 乙));   // 3 7
    断言(甲 > 乙, "甲应大于乙");     // 条件为假时终止进程
    返回 0;
}

输出:7 3 3 7

交换

泛型 <类型 T> 函数 交换(T* 左, T* 右) -> 空类型

交换两个变量的值。参数为指针(T*),调用时取地址:交换(&甲, &乙)。函数体内用下标写法 左[0] 读写(等价 *左;行首解引用赋值与乘法有词法歧义,标准库统一用下标)。

参数类型说明
左T*指向第一个变量的指针
右T*指向第二个变量的指针

返回 无。原地交换。

主.cnCN

函数 交换(整32& 甲, 整32& 乙) -> 空类型 {
    整32 临时 = 甲;
    甲 = 乙;
    乙 = 临时;
}
函数 主() -> 整32 {
    整32 甲 = 1;
    整32 乙 = 2;
    交换(甲, 乙);
    打印(甲);
    打印行(乙);
    返回 0;
}

输出:2 1

最小

泛型 <类型 T> 函数 最小(T 左, T 右) -> T

返回两者中较小的一个。按值传参,支持所有实现了 < 比较的类型。

参数类型说明
左T候选值一
右T候选值二

返回 较小者(类型 T)。

主.cnCN

导入 核心::交换;
导入 核心::最小;
导入 核心::最大;
导入 核心::断言;
导入 核心::错误码;

函数 主() -> 整32 {
    打印("===== 核心库(Task 6.1)=====");

    // ---- 1. 错误码枚举(导入后纯名引用)----
    打印("除零: ", 错误码.除零);
    打印("越界: ", 错误码.越界);
    打印("内存: ", 错误码.内存);
    打印("溢出: ", 错误码.溢出);

    // ---- 2. 交换(整32)----
    整32 a = 1;
    整32 b = 2;
    交换<整32>(&a, &b);
    打印("交换整32: ", a, " ", b);         // 2 1

    // ---- 3. 交换(浮64)----
    浮64 x = 3.5;
    浮64 y = 7.5;
    交换<浮64>(&x, &y);
    打印("交换浮64: ", x, " ", y);         // 7.500000 3.500000

    // ---- 4. 最小 / 最大(整32 + 浮64)----
    打印("最小整32: ", 最小<整32>(10, 20));     // 10
    打印("最大整32: ", 最大<整32>(10, 20));     // 20
    打印("最小浮64: ", 最小<浮64>(2.5, 1.5));   // 1.500000
    打印("最大浮64: ", 最大<浮64>(2.5, 1.5));   // 2.500000

    // ---- 5. 断言(真条件通过)----
    断言(真, "不应触发");
    断言(1 < 2, "不应触发");
    打印("断言通过");

    打印("===== 核心库测试完成 =====");
    返回 0;
}

输出:===== 核心库(Task 6.1)===== 除零: 1 越界: 2 内存: 4 溢出: 8 交换整32: 2 1 交换浮64: 7.500000 3.500000 最小整32: 10 最大整32: 20 最小浮64: 1.500000 最大浮64: 2.500000 断言通过 ===== 核心库测试完成 =====

最大

泛型 <类型 T> 函数 最大(T 左, T 右) -> T

返回两者中较大的一个。要求类型支持 > 比较。

参数类型说明
左T候选值一
右T候选值二

返回 较大者(类型 T)。

主.cnCN

导入 核心::交换;
导入 核心::最小;
导入 核心::最大;
导入 核心::断言;
导入 核心::错误码;

函数 主() -> 整32 {
    打印("===== 核心库(Task 6.1)=====");

    // ---- 1. 错误码枚举(导入后纯名引用)----
    打印("除零: ", 错误码.除零);
    打印("越界: ", 错误码.越界);
    打印("内存: ", 错误码.内存);
    打印("溢出: ", 错误码.溢出);

    // ---- 2. 交换(整32)----
    整32 a = 1;
    整32 b = 2;
    交换<整32>(&a, &b);
    打印("交换整32: ", a, " ", b);         // 2 1

    // ---- 3. 交换(浮64)----
    浮64 x = 3.5;
    浮64 y = 7.5;
    交换<浮64>(&x, &y);
    打印("交换浮64: ", x, " ", y);         // 7.500000 3.500000

    // ---- 4. 最小 / 最大(整32 + 浮64)----
    打印("最小整32: ", 最小<整32>(10, 20));     // 10
    打印("最大整32: ", 最大<整32>(10, 20));     // 20
    打印("最小浮64: ", 最小<浮64>(2.5, 1.5));   // 1.500000
    打印("最大浮64: ", 最大<浮64>(2.5, 1.5));   // 2.500000

    // ---- 5. 断言(真条件通过)----
    断言(真, "不应触发");
    断言(1 < 2, "不应触发");
    打印("断言通过");

    打印("===== 核心库测试完成 =====");
    返回 0;
}

输出:===== 核心库(Task 6.1)===== 除零: 1 越界: 2 内存: 4 溢出: 8 交换整32: 2 1 交换浮64: 7.500000 3.500000 最小整32: 10 最大整32: 20 最小浮64: 1.500000 最大浮64: 2.500000 断言通过 ===== 核心库测试完成 =====

断言

函数 断言(布尔 条件, 字符串 消息) -> 空类型

条件为假时调用 运行时错误(错误码.参数) 终止进程,并在标准输出打印诊断行。用于开发期前置条件检查;发布构建不会自动移除断言(需手动裁剪)。

参数类型说明
条件布尔断言条件;假则终止
消息字符串失败时的诊断消息

返回 无。条件为真时什么也不做。

主.cnCN

导入 核心::交换;
导入 核心::最小;
导入 核心::最大;
导入 核心::断言;
导入 核心::错误码;

函数 主() -> 整32 {
    打印("===== 核心库(Task 6.1)=====");

    // ---- 1. 错误码枚举(导入后纯名引用)----
    打印("除零: ", 错误码.除零);
    打印("越界: ", 错误码.越界);
    打印("内存: ", 错误码.内存);
    打印("溢出: ", 错误码.溢出);

    // ---- 2. 交换(整32)----
    整32 a = 1;
    整32 b = 2;
    交换<整32>(&a, &b);
    打印("交换整32: ", a, " ", b);         // 2 1

    // ---- 3. 交换(浮64)----
    浮64 x = 3.5;
    浮64 y = 7.5;
    交换<浮64>(&x, &y);
    打印("交换浮64: ", x, " ", y);         // 7.500000 3.500000

    // ---- 4. 最小 / 最大(整32 + 浮64)----
    打印("最小整32: ", 最小<整32>(10, 20));     // 10
    打印("最大整32: ", 最大<整32>(10, 20));     // 20
    打印("最小浮64: ", 最小<浮64>(2.5, 1.5));   // 1.500000
    打印("最大浮64: ", 最大<浮64>(2.5, 1.5));   // 2.500000

    // ---- 5. 断言(真条件通过)----
    断言(真, "不应触发");
    断言(1 < 2, "不应触发");
    打印("断言通过");

    打印("===== 核心库测试完成 =====");
    返回 0;
}

输出:===== 核心库(Task 6.1)===== 除零: 1 越界: 2 内存: 4 溢出: 8 交换整32: 2 1 交换浮64: 7.500000 3.500000 最小整32: 10 最大整32: 20 最小浮64: 1.500000 最大浮64: 2.500000 断言通过 ===== 核心库测试完成 =====