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 ===== 报告结束 ===== ===== 学生成绩统计工具运行完成 =====