CN·语言

IO

标准输入与错误输出——四个函数,全部返回 结果 以显式处理失败。

导入写法CN

导入 IO::{读取行, 读取整数, 读取浮点, 打印到错误};

标准输入

EOF(无数据)或非法输入时返回 错误(错误码.文件),不做静默垃圾值。读取行 返回拥有型字符串(RAII 自动释放)。

标准输入.cnCN

导入 IO::{读取行, 读取整数};

函数 主() -> 整32 {
    打印("名字?");
    结果<字符串, 整32> 名字 = 读取行();
    如果 (名字.正常) {
        打印("你好,", 名字.值);
    } 否则 {
        打印("(输入已关闭)");        // EOF 分支
    }
    结果<整64, 整32> 年龄 = 读取整数();
    如果 (年龄.正常) {
        打印("明年 ", 年龄.值 + 1, " 岁");
    } 否则 {
        打印("(没有读到整数)");
    }
    返回 0;
}

输出:名字? (输入已关闭) (没有读到整数)

读取行

函数 读取行() -> 结果<字符串, 整32>

从标准输入读一行(不含行尾换行符)。EOF 时返回错误。返回字符串为拥有型,作用域结束自动释放。

返回 正常(一行文本);EOF → 错误(错误码.文件)。

主.cnCN

函数 主() -> 整32 {
    打印("===== IO 输入库(Task 6.2)=====");

    // ---- 1. 读取行(整行字符串,不含换行)----
    字符串 行 = IO::读取行();
    如果 (行 != 无) {
        打印("读取行: ", 行);
    } 否则 {
        打印("读取行失败(EOF)");
    }

    // ---- 2. 读取整数(strtoll 整行解析,成功标志输出)----
    整32 整数标志 = 0;
    整64 整数值 = IO::读取整数(&整数标志);
    如果 (整数标志 == 1) {
        打印("读取整数: ", 整数值);
    } 否则 {
        打印("读取整数失败");
    }

    // ---- 3. 读取浮点(strtod 整行解析,成功标志输出)----
    整32 浮点标志 = 0;
    浮64 浮点值 = IO::读取浮点(&浮点标志);
    如果 (浮点标志 == 1) {
        打印("读取浮点: ", 浮点值);
    } 否则 {
        打印("读取浮点失败");
    }

    // ---- 4. EOF 语义:输入已耗尽,读取整数 触发 EOF 返回成功标志0 ----
    整32 结束标志 = 1;
    整64 结束值 = IO::读取整数(&结束标志);
    如果 (结束标志 == 1) {
        打印("EOF读取整数: ", 结束值);
    } 否则 {
        打印("EOF读取整数失败");
    }

    打印("===== IO 输入库测试完成 =====");
    返回 0;
}

输出:===== IO 输入库(Task 6.2)===== 读取行: 第一行测试 读取整数: 42 读取浮点: 3.140000 EOF读取整数失败 ===== IO 输入库测试完成 =====

读取整数

函数 读取整数() -> 结果<整64, 整32>

从标准输入读取一个整数;EOF/非法输入返回错误。

返回 正常(整64值);失败 → 错误(错误码.文件)。

主.cnCN

函数 主() -> 整32 {
    打印("===== IO 输入库(Task 6.2)=====");

    // ---- 1. 读取行(整行字符串,不含换行)----
    字符串 行 = IO::读取行();
    如果 (行 != 无) {
        打印("读取行: ", 行);
    } 否则 {
        打印("读取行失败(EOF)");
    }

    // ---- 2. 读取整数(strtoll 整行解析,成功标志输出)----
    整32 整数标志 = 0;
    整64 整数值 = IO::读取整数(&整数标志);
    如果 (整数标志 == 1) {
        打印("读取整数: ", 整数值);
    } 否则 {
        打印("读取整数失败");
    }

    // ---- 3. 读取浮点(strtod 整行解析,成功标志输出)----
    整32 浮点标志 = 0;
    浮64 浮点值 = IO::读取浮点(&浮点标志);
    如果 (浮点标志 == 1) {
        打印("读取浮点: ", 浮点值);
    } 否则 {
        打印("读取浮点失败");
    }

    // ---- 4. EOF 语义:输入已耗尽,读取整数 触发 EOF 返回成功标志0 ----
    整32 结束标志 = 1;
    整64 结束值 = IO::读取整数(&结束标志);
    如果 (结束标志 == 1) {
        打印("EOF读取整数: ", 结束值);
    } 否则 {
        打印("EOF读取整数失败");
    }

    打印("===== IO 输入库测试完成 =====");
    返回 0;
}

输出:===== IO 输入库(Task 6.2)===== 读取行: 第一行测试 读取整数: 42 读取浮点: 3.140000 EOF读取整数失败 ===== IO 输入库测试完成 =====

读取浮点

函数 读取浮点() -> 结果<浮64, 整32>

从标准输入读取一个浮点数;EOF/非法输入返回错误。

返回 正常(浮64值);失败 → 错误(错误码.文件)。

主.cnCN

函数 主() -> 整32 {
    打印("===== IO 输入库(Task 6.2)=====");

    // ---- 1. 读取行(整行字符串,不含换行)----
    字符串 行 = IO::读取行();
    如果 (行 != 无) {
        打印("读取行: ", 行);
    } 否则 {
        打印("读取行失败(EOF)");
    }

    // ---- 2. 读取整数(strtoll 整行解析,成功标志输出)----
    整32 整数标志 = 0;
    整64 整数值 = IO::读取整数(&整数标志);
    如果 (整数标志 == 1) {
        打印("读取整数: ", 整数值);
    } 否则 {
        打印("读取整数失败");
    }

    // ---- 3. 读取浮点(strtod 整行解析,成功标志输出)----
    整32 浮点标志 = 0;
    浮64 浮点值 = IO::读取浮点(&浮点标志);
    如果 (浮点标志 == 1) {
        打印("读取浮点: ", 浮点值);
    } 否则 {
        打印("读取浮点失败");
    }

    // ---- 4. EOF 语义:输入已耗尽,读取整数 触发 EOF 返回成功标志0 ----
    整32 结束标志 = 1;
    整64 结束值 = IO::读取整数(&结束标志);
    如果 (结束标志 == 1) {
        打印("EOF读取整数: ", 结束值);
    } 否则 {
        打印("EOF读取整数失败");
    }

    打印("===== IO 输入库测试完成 =====");
    返回 0;
}

输出:===== IO 输入库(Task 6.2)===== 读取行: 第一行测试 读取整数: 42 读取浮点: 3.140000 EOF读取整数失败 ===== IO 输入库测试完成 =====

错误输出

打印到错误

函数 打印到错误(字符串 消息) -> 空类型

把消息写到标准错误流(stderr),不换行。诊断/日志走 stderr,程序结果数据走 stdout——两者分离便于管道处理。

参数类型说明
消息字符串要写出的文本

主.cnCN

导入 容器::向量;
导入 映射集合::集合;
导入 映射集合::映射;
导入 算法::排序整64;
导入 算法::最大元素;
导入 算法::计数;
导入 算法::线性查找;
导入 算法::二分查找整64;
导入 字符串扩展::分割;

// 统计结果(结构体按值返回/传参,10_struct_value 已验证)
结构体 统计结果 {
    整64 平均分;
    整64 最高分;
    整64 最低分;
    整64 及格人数;
    浮64 标准差;
}

// ==================== 统计计算(算法.cn 排序/最大元素 + 数学.cn 平方根) ====================
不安全 函数 统计计算(整64* 总分数组, 整64 总人数) -> 统计结果 {
    排序整64(总分数组, 总人数);
    整64 总分和 = 0;
    整64 累加索引 = 0;
    当 (累加索引 < 总人数) {
        总分和 = 总分和 + 总分数组[累加索引];
        累加索引++;
    }
    整64 平均分 = 总分和 / 总人数;
    整64 最高分 = 最大元素<整64>(总分数组, 总人数);
    整64 最低分 = 总分数组[0];
    整64 及格人数 = 0;
    整64 及格索引 = 0;
    当 (及格索引 < 总人数) {
        如果 (总分数组[及格索引] >= 60) {
            及格人数++;
        }
        及格索引++;
    }
    整64 差异和 = 0;
    整64 差索引 = 0;
    当 (差索引 < 总人数) {
        整64 差异 = 总分数组[差索引] - 平均分;
        差异和 = 差异和 + 差异 * 差异;
        差索引++;
    }
    浮64 方差 = 浮64(差异和) / 浮64(总人数);
    浮64 标准差 = 数学::平方根(方差);
    统计结果 统计 = 统计结果{ 平均分 = 平均分, 最高分 = 最高分, 最低分 = 最低分, 及格人数 = 及格人数, 标准差 = 标准差 };
    返回 统计;
}

// ==================== 向量<整64> 总分存储演示(容器.cn) ====================
不安全 函数 向量演示(整64* 总分数组, 整64 总人数) -> 空类型 {
    向量<整64> 总分表 = 向量<整64>();
    整64 索引 = 0;
    当 (索引 < 总人数) {
        结果<空类型, 整32> 追加结果 = 总分表.追加(总分数组[索引]);
        索引++;
    }
    打印("向量大小(总分表): ", 总分表.大小());
}

// ==================== 集合<整64> 总分去重演示(映射集合.cn) ====================
不安全 函数 集合演示(整64* 总分数组, 整64 总人数) -> 空类型 {
    集合<整64> 总分集 = 集合<整64>();
    整64 索引 = 0;
    当 (索引 < 总人数) {
        结果<空类型, 整32> 集合结果 = 总分集.添加(总分数组[索引]);
        索引++;
    }
    打印("总分去重数: ", 总分集.大小());           // 4
}

// ==================== 映射<整64,整64> 总分分布演示(映射集合.cn) ====================
不安全 函数 映射演示(整64* 总分数组, 整64 总人数) -> 空类型 {
    映射<整64, 整64> 分布表 = 映射<整64, 整64>();
    整64 索引 = 0;
    当 (索引 < 总人数) {
        结果<整64, 整32> 已有结果 = 分布表.获取(总分数组[索引]);
        结果<空类型, 整32> 映射结果;
        如果 (已有结果.正常) {
            映射结果 = 分布表.设置(总分数组[索引], 已有结果.值 + 1);
        } 否则 {
            映射结果 = 分布表.设置(总分数组[索引], 1);
        }
        索引++;
    }
    结果<整64, 整32> 分布结果 = 分布表.获取(240);
    如果 (分布结果.正常) {
        打印("映射分布(240): ", 分布结果.值);      // 2
    } 否则 {
        打印("映射分布(240)缺失: ", 分布结果.错误);
    }
}

// ==================== 打印学生列表(姓名 + 总分) ====================
不安全 函数 打印列表(字符串* 姓名数组, 整64* 总分数组, 整64 总人数) -> 空类型 {
    整64 打印索引 = 0;
    当 (打印索引 < 总人数) {
        打印(姓名数组[打印索引], ": ", 总分数组[打印索引]);
        打印索引++;
    }
}

// ==================== 打印统计结果 ====================
不安全 函数 打印统计(统计结果 统计, 整64* 总分数组, 整64 总人数) -> 空类型 {
    打印("排序后: ", 总分数组[0], 总分数组[1], 总分数组[2], 总分数组[3], 总分数组[4]);
    打印("平均分: ", 统计.平均分);                 // 197
    打印("最高分: ", 统计.最高分);                 // 270
    打印("最低分: ", 统计.最低分);                 // 55
    打印("及格人数(≥60): ", 统计.及格人数);        // 4
    打印("标准差: ", 统计.标准差);                 // 76.785415(%f 6 位小数)
}

// ==================== 算法辅助验证一(算法.cn 计数/二分查找) ====================
函数 算法验证一(整64* 总分数组, 整64 总人数, 整64 最高分) -> 空类型 {
    整64 最高分次数 = 计数<整64>(总分数组, 总人数, 最高分);  // 1
    打印("最高分出现次数: ", 最高分次数);
    // #1360 结果化:二分查找整64 返回 可选<整64>,.有值 分流取 .值
    可选<整64> 查找240 = 二分查找整64(总分数组, 总人数, 240);   // 命中=2
    如果 (查找240.有值) {
        打印("二分查找240: ", 查找240.值);
    } 否则 如果 (!查找240.有值) {
        打印("二分查找240: 无");
    }
}

// ==================== 算法辅助验证二(算法.cn 线性查找/二分查找) ====================
函数 算法验证二(整64* 总分数组, 整64 总人数) -> 空类型 {
    可选<整64> 线性240 = 线性查找<整64>(总分数组, 总人数, 240); // 命中=2
    如果 (线性240.有值) {
        打印("线性查找240: ", 线性240.值);
    } 否则 如果 (!线性240.有值) {
        打印("线性查找240: 无");
    }
    可选<整64> 不存在的 = 二分查找整64(总分数组, 总人数, 999);  // 未命中=无
    如果 (不存在的.有值) {
        打印("二分查找999: ", 不存在的.值);
    } 否则 如果 (!不存在的.有值) {
        打印("二分查找999: 无");
    }
}

// ==================== 写入输出文件(文件.cn 模式2=写截断 + 整数转字符串) ====================
函数 写报告行(空类型* 句柄, 字符串 行) -> 整32 {
    整64 写入数 = 文件::写入文件(句柄, 行);
    如果 (写入数 < 0) {
        返回 1;
    }
    返回 0;
}

函数 写报告(字符串 输出路径, 统计结果 统计, 整64 总人数) -> 整32 {
    空类型* 写句柄 = 文件::打开文件(输出路径, 2);
    如果 (写句柄 == 无) {
        IO::打印到错误("打开输出文件失败,错误码=5(文件)\n");
        返回 4;
    }
    写报告行(写句柄, "===== 学生成绩统计报告 =====\n");
    写报告行(写句柄, "学生总数: ");
    字符串 人数文本 = 整数转字符串(总人数);
    写报告行(写句柄, 人数文本);
    写报告行(写句柄, "\n平均分: ");
    字符串 平均文本 = 整数转字符串(统计.平均分);
    写报告行(写句柄, 平均文本);
    写报告行(写句柄, "\n最高分: ");
    字符串 最高文本 = 整数转字符串(统计.最高分);
    写报告行(写句柄, 最高文本);
    写报告行(写句柄, "\n最低分: ");
    字符串 最低文本 = 整数转字符串(统计.最低分);
    写报告行(写句柄, 最低文本);
    写报告行(写句柄, "\n及格人数: ");
    字符串 及格文本 = 整数转字符串(统计.及格人数);
    写报告行(写句柄, 及格文本);
    写报告行(写句柄, "\n===== 报告结束 =====\n");
    文件::关闭文件(写句柄);
    返回 0;
}

// ==================== 读回输出文件验证写入成功(文件.cn 模式1=读) ====================
函数 读回报告(字符串 输出路径) -> 整32 {
    空类型* 回读句柄 = 文件::打开文件(输出路径, 1);
    如果 (回读句柄 == 无) {
        IO::打印到错误("读回输出文件失败,错误码=5(文件)\n");
        返回 5;
    }
    打印("===== 输出文件内容(读回验证)=====");
    当 (真) {
        字符串 报告行 = 文件::读取文件行(回读句柄);
        如果 (报告行 == 无) {
            中断;
        }
        打印(报告行);
    }
    文件::关闭文件(回读句柄);
    返回 0;
}

// ==================== 时间戳断言一(时间.cn) ====================
函数 时间断言一() -> 整32 {
    整64 戳1 = 时间::当前时间戳();
    整64 戳2 = 时间::当前时间戳();
    打印("时间戳合理: ", 戳2 >= 戳1);
    打印("时间戳大于0: ", 戳1 > 0);
    字符串 日期 = 时间::格式化时间(戳1, "%Y-%m-%d");
    如果 (日期 != 无) {
        打印("日期长度=10: ", 字符串长度(日期) == 10);
    } 否则 {
        打印("格式化时间失败");
    }
    如果 (日期 != 无) {
    }
    返回 0;
}

// ==================== 时间戳断言二(时间.cn 分隔符) ====================
函数 时间断言二() -> 整32 {
    整64 戳1 = 时间::当前时间戳();
    字符串 日期 = 时间::格式化时间(戳1, "%Y-%m-%d");
    如果 (日期 != 无) {
        字符串 分隔符1 = 字符串子串(日期, 4, 1);
        字符串 分隔符2 = 字符串子串(日期, 7, 1);
        打印("日期分隔符: ", 字符串比较(分隔符1, "-") && 字符串比较(分隔符2, "-"));
    } 否则 {
        打印("格式化时间失败");
    }
    返回 0;
}

// ==================== 解析单行(字符串扩展.cn 分割/转整数 + 深拷贝) ====================
// 说明:返回 1=成功写入 0=跳过(非法格式/解析失败)
不安全 函数 解析单行(字符串 行, 整64* 总分数组, 字符串* 姓名数组, 整64 位置) -> 整64 {
    字符串[4] 片段;
    结果<整64, 整32> 分割结果 = 分割(行, ",", 片段, 4);
    整64 成功 = 0;
    如果 (分割结果.正常) {
        如果 (分割结果.值 == 4) {
            整32 标志1 = 0;
            整32 标志2 = 0;
            整32 标志3 = 0;
            整64 成绩一 = 解析::转整数(片段[1], &标志1);
            整64 成绩二 = 解析::转整数(片段[2], &标志2);
            整64 成绩三 = 解析::转整数(片段[3], &标志3);
            如果 (标志1 == 1 && 标志2 == 1 && 标志3 == 1) {
                // 姓名深拷贝(分割产物释放后不得悬垂);总分 = 三科之和
                字符串 姓名副本 = 字符串复制(片段[0]);
                整64 总分 = 成绩一 + 成绩二 + 成绩三;
                总分数组[位置] = 总分;
                姓名数组[位置] = 姓名副本;
                成功 = 1;
            }
        }
    }
    整64 释放索引 = 0;
    当 (释放索引 < 4) {
        字符串释放(片段[释放索引]);
        释放索引++;
    }
    返回 成功;
}

// ==================== 解析数据文件(文件.cn + 解析单行) ====================
// 返回 有效总人数;打开失败 返回 0
函数 解析数据(字符串 数据路径, 整64* 总分数组, 字符串* 姓名数组, 整64 最大容量) -> 整64 {
    空类型* 读句柄 = 文件::打开文件(数据路径, 1);
    如果 (读句柄 == 无) {
        IO::打印到错误("打开数据文件失败,错误码=5(文件)\n");
        返回 0;
    }
    整64 跳过行数 = 0;
    整64 总人数 = 0;
    当 (真) {
        字符串 行 = 文件::读取文件行(读句柄);
        如果 (行 == 无) {
            中断;    // EOF
        }
        如果 (总人数 < 最大容量) {
            整64 成功 = 解析单行(行, 总分数组, 姓名数组, 总人数);
            如果 (成功 == 1) {
                总人数++;
            } 否则 {
                跳过行数++;
            }
        } 否则 {
            跳过行数++;
        }
    }
    文件::关闭文件(读句柄);
    打印("跳过非法行: ", 跳过行数);
    返回 总人数;
}

// ==================== 释放姓名数组 ====================
不安全 函数 释放姓名(字符串* 姓名数组, 整64 总人数) -> 空类型 {
    整64 释放姓名 = 0;
    当 (释放姓名 < 总人数) {
        字符串释放(姓名数组[释放姓名]);
        释放姓名++;
    }
}

// ==================== 工具主体:解析 → 统计 → 输出 ====================
函数 工具主体(字符串 数据路径, 字符串 输出路径) -> 整32 {
    整64[8] 总分数组;
    字符串[8] 姓名数组;
    整64 总人数 = 解析数据(数据路径, 总分数组, 姓名数组, 8);
    如果 (总人数 == 0) {
        IO::打印到错误("数据文件为空或打开失败,错误码=5(文件)\n");
        返回 3;
    }
    打印("学生总数: ", 总人数);
    打印("===== 总分列表(排序前)=====");
    打印列表(姓名数组, 总分数组, 总人数);

    向量演示(总分数组, 总人数);
    集合演示(总分数组, 总人数);
    映射演示(总分数组, 总人数);

    统计结果 统计 = 统计计算(总分数组, 总人数);
    打印统计(统计, 总分数组, 总人数);
    算法验证一(总分数组, 总人数, 统计.最高分);
    算法验证二(总分数组, 总人数);

    时间断言一();
    时间断言二();

    整32 写状态 = 写报告(输出路径, 统计, 总人数);
    如果 (写状态 != 0) {
        返回 写状态;
    }
    整32 读状态 = 读回报告(输出路径);
    如果 (读状态 != 0) {
        返回 读状态;
    }
    释放姓名(姓名数组, 总人数);
    打印("===== 学生成绩统计工具运行完成 =====");
    返回 0;
}

// ==================== 主函数:参数校验 → 调 工具主体 ====================
函数 主() -> 整32 {
    打印("===== 学生成绩统计工具(Task 6.11 全链路集成)=====");
    整64 个数 = 系统::参数个数();
    如果 (个数 < 3) {
        IO::打印到错误("用法: 学生成绩统计工具 数据文件.txt 输出文件.txt\n");
        返回 1;
    }
    // 70-a(2026-09-11 方案A 补完):系统::参数 已改 字符*(argv=CRT 持有借用)
    //   ——按借用接收判空;传 字符串 形参须显式 复制(A2 收紧)
    字符* 数据路径 = 系统::参数(1);
    字符* 输出路径 = 系统::参数(2);
    如果 (数据路径 == 无 || 输出路径 == 无) {
        IO::打印到错误("参数解析失败\n");
        返回 2;
    }
    打印("数据文件: ", 数据路径);
    打印("输出文件: ", 输出路径);
    整32 状态 = 工具主体(字符串复制(数据路径), 字符串复制(输出路径));
    返回 状态;
}

输出:===== 学生成绩统计工具(Task 6.11 全链路集成)===== 数据文件: tests/e2e/38_tool/成绩数据.txt 输出文件: target/输出结果.txt 跳过非法行: 1 学生总数: 5 ===== 总分列表(排序前)===== 张三: 240 李四: 240 王五: 55 赵六: 180 周八: 270 向量大小(总分表): 5 总分去重数: 4 映射分布(240): 2 排序后: 55180240240270 平均分: 197 最高分: 270 最低分: 55 及格人数(≥60): 4 标准差: 76.785415 最高分出现次数: 1 二分查找240: 2 线性查找240: 2 二分查找999: 无 时间戳合理: 真 时间戳大于0: 真 日期长度=10: 真 日期分隔符: 真 ===== 输出文件内容(读回验证)===== ===== 学生成绩统计报告 ===== 学生总数: 5 平均分: 197 最高分: 270 最低分: 55 及格人数: 4 ===== 报告结束 ===== ===== 学生成绩统计工具运行完成 =====