映射集合
映射<K, V> 哈希表 / 字符串映射<V> / 集合<T>——键值与去重的三件套。
导入写法CN
导入 映射集合::映射;
导入 映射集合::{字符串映射, 集合};
导入 映射集合::{查找键位置, 查找值位置};映射<K, V>(哈希表)
键值对哈希表:桶 + 链结构,负载因子 3/4 自动翻倍重哈希,设置/获取/包含/删除 期望 O(1)。小映射 8 桶起步按需倍增(Rust HashMap 同策略)。键类型须支持 == 与到整64 的位模式转换(数值/字符/枚举键);字符串键用 字符串映射<V>。深拷语义 + RAII 自动释放。
映射.cnCN
导入 映射集合::映射;
函数 主() -> 整32 {
映射<整64, 整64> 字典 = 映射<整64, 整64>();
结果<空类型, 整32> 设 = 字典.设置(3, 300);
设 = 字典.设置(4, 400);
设 = 字典.设置(3, 999); // 已有键=覆盖
结果<整64, 整32> 取 = 字典.获取(3);
如果 (取.正常) { 打印(取.值); } 否则 { 打印("未找到"); } // 999
打印(字典.包含(4), " ", 字典.包含(99));
打印(字典.删除(4)); // 真
打印(字典.大小()); // 1
返回 0;
}输出:999 真 假 真 1
映射() 不安全
不安全 函数 映射()
构造空映射(8 桶起步,不预分配大数组)。
主.cnCN
导入 映射集合::映射;
导入 映射集合::集合;
导入 映射集合::错误码;
函数 主() -> 整32 {
打印("===== 映射集合库(Task 6.4)=====");
// ==================== 1. 映射<K,V>(整32键 → 整32值) ====================
映射<整32, 整32> 表 = 映射<整32, 整32>();
如果 (表.为空()) {
打印("映射初始为空: 是");
} 否则 {
打印("映射初始为空: 否");
}
// 设置 3 对键值(触发扩容 0 -> 4)
结果<空类型, 整32> 设置结果 = 表.设置(1, 100);
如果 (设置结果.正常) {
设置结果 = 表.设置(2, 200);
设置结果 = 表.设置(3, 300);
} 否则 {
打印("映射设置失败: ", 设置结果.错误);
}
打印("映射大小: ", 表.大小());
// 包含(规格书 4.4 表.包含(键))
如果 (表.包含(2)) {
打印("包含键2: 真");
} 否则 {
打印("包含键2: 假");
}
如果 (表.包含(99)) {
打印("包含键99: 真");
} 否则 {
打印("包含键99: 假");
}
// 获取正确值(先存局部变量再打印,规避打印变参内嵌字段下标缺陷)
结果<整32, 整32> 获取结果 = 表.获取(1);
如果 (获取结果.正常) {
整32 值1 = 获取结果.值;
打印("获取键1: ", 值1);
} 否则 {
打印("获取键1失败: ", 获取结果.错误);
}
获取结果 = 表.获取(3);
如果 (获取结果.正常) {
整32 值3 = 获取结果.值;
打印("获取键3: ", 值3);
} 否则 {
打印("获取键3失败: ", 获取结果.错误);
}
// 覆盖已存在键 → 大小仍 3 且值更新
设置结果 = 表.设置(2, 222);
如果 (设置结果.正常) {
获取结果 = 表.获取(2);
如果 (获取结果.正常) {
整32 值2 = 获取结果.值;
打印("覆盖后键2: ", 值2);
} 否则 {
打印("覆盖后读键2失败: ", 获取结果.错误);
}
} 否则 {
打印("覆盖设置失败: ", 设置结果.错误);
}
打印("覆盖后大小: ", 表.大小());
// 获取不存在的键 → 错误码.未初始化(7)
获取结果 = 表.获取(99);
如果 (获取结果.正常) {
打印("获取键99未报错");
} 否则 {
打印("获取键99错误码: ", 获取结果.错误);
}
// 删除键 1 → 包含=假、大小-1
布尔 删除结果 = 表.删除(1);
如果 (删除结果) {
打印("删除键1: 真");
} 否则 {
打印("删除键1: 假");
}
如果 (表.包含(1)) {
打印("删除后包含键1: 真");
} 否则 {
打印("删除后包含键1: 假");
}
打印("删除后大小: ", 表.大小());
// 删除不存在的键 → 返回假
删除结果 = 表.删除(99);
如果 (删除结果) {
打印("删除键99: 真");
} 否则 {
打印("删除键99: 假");
}
// 清空
表.清空();
打印("清空后大小: ", 表.大小());
// ==================== 2. 集合<T>(整32) ====================
集合<整32> 值集 = 集合<整32>();
如果 (值集.为空()) {
打印("集合初始为空: 是");
} 否则 {
打印("集合初始为空: 否");
}
// 添加 1/2/3、再添加 2(幂等)→ 大小=3
设置结果 = 值集.添加(1);
如果 (设置结果.正常) {
设置结果 = 值集.添加(2);
设置结果 = 值集.添加(3);
设置结果 = 值集.添加(2);
} 否则 {
打印("集合添加失败: ", 设置结果.错误);
}
打印("集合大小: ", 值集.大小());
// 包含
如果 (值集.包含(2)) {
打印("集合包含2: 真");
} 否则 {
打印("集合包含2: 假");
}
如果 (值集.包含(99)) {
打印("集合包含99: 真");
} 否则 {
打印("集合包含99: 假");
}
// 删除 → 大小-1
删除结果 = 值集.删除(2);
如果 (删除结果) {
打印("集合删除2: 真");
} 否则 {
打印("集合删除2: 假");
}
打印("集合删除后大小: ", 值集.大小());
如果 (值集.包含(2)) {
打印("删除后包含2: 真");
} 否则 {
打印("删除后包含2: 假");
}
// 删除不存在的值 → 返回假
删除结果 = 值集.删除(99);
如果 (删除结果) {
打印("集合删除99: 真");
} 否则 {
打印("集合删除99: 假");
}
值集.清空();
打印("集合清空后大小: ", 值集.大小());
打印("===== 映射集合库测试完成 =====");
返回 0;
}输出:===== 映射集合库(Task 6.4)===== 映射初始为空: 是 映射大小: 3 包含键2: 真 包含键99: 假 获取键1: 100 获取键3: 300 覆盖后键2: 222 覆盖后大小: 3 获取键99错误码: 7 删除键1: 真 删除后包含键1: 假 删除后大小: 2 删除键99: 假 清空后大小: 0 集合初始为空: 是 集合大小: 3 集合包含2: 真 集合包含99: 假 集合删除2: 真 集合删除后大小: 2 删除后包含2: 假 集合删除99: 假 集合清空后大小: 0 ===== 映射集合库测试完成 =====
映射(其他) 不安全
不安全 函数 映射(映射& 其他)
拷贝构造:桶/键/值/链数组全量深拷(元素按 T 拷贝语义)。
| 参数 | 类型 | 说明 |
|---|---|---|
其他 | 映射& | 被拷贝的映射 |
主.cnCN
导入 映射集合;
导入 容器;
函数 灌(映射<整64, 整64>& 表, 整64 n) -> 整64 {
整64 i = 0;
当 (i < n) {
结果<空类型, 整32> 设 = 表.设置(i, i * 10);
如果 (!设.正常) { 返回 -1; }
i++;
}
返回 0;
}
函数 查(映射<整64, 整64>& 表, 整64 k) -> 整64 {
结果<整64, 整32> 取 = 表.获取(k);
如果 (取.正常) { 返回 取.值; }
返回 -1;
}
函数 造表() -> 映射<整64, 整64> {
映射<整64, 整64> m = 映射<整64, 整64>();
结果<空类型, 整32> 设 = m.设置(5, 50);
如果 (!设.正常) { 返回 m; }
返回 m;
}
函数 主() -> 整32 {
// A 引用参数
映射<整64, 整64> 表 = 映射<整64, 整64>();
整64 r = 灌(表, 20);
如果 (r != 0) { 返回 1; }
整64 和 = 查(表, 3) + 查(表, 7) + 查(表, 29);
打印("引用和=", 和);
// B 元素视图(写共享)
向量<映射<整64, 整64>> 表们 = 向量<映射<整64, 整64>>();
映射<整64, 整64> 层 = 映射<整64, 整64>();
结果<空类型, 整32> 设1 = 层.设置(1, 100);
如果 (!设1.正常) { 返回 2; }
结果<空类型, 整32> 加 = 表们.追加(层);
如果 (!加.正常) { 返回 3; }
映射<整64, 整64> 取 = 表们.元素(表们.大小() - 1);
结果<空类型, 整32> 设9 = 取.设置(9, 90);
如果 (!设9.正常) { 返回 4; }
映射<整64, 整64> 再取 = 表们.元素(0);
结果<整64, 整32> 查9 = 再取.获取(9);
如果 (查9.正常) {
打印("视图写=", 查9.值);
} 否则 {
打印("视图写=不可见");
}
// C 标识符拷贝=深拷贝(A 不见 B 改)
映射<整64, 整64> 甲 = 映射<整64, 整64>();
结果<空类型, 整32> 设甲 = 甲.设置(1, 10);
如果 (!设甲.正常) { 返回 5; }
映射<整64, 整64> 乙 = 甲;
结果<空类型, 整32> 设乙 = 乙.设置(2, 20);
如果 (!设乙.正常) { 返回 6; }
结果<整64, 整32> 查甲 = 甲.获取(2);
如果 (查甲.正常) {
打印("深拷贝=共享");
} 否则 {
打印("深拷贝=独立");
}
// D 函数返回容器接收
映射<整64, 整64> 接 = 造表();
结果<整64, 整32> 查接 = 接.获取(5);
如果 (查接.正常) {
打印("返回接收=", 查接.值);
返回 0;
}
返回 7;
}输出:引用和=99 视图写=不可见 深拷贝=独立 返回接收=50
大小 常量
常量 函数 大小() -> 整64
键值对个数。
主.cnCN
导入 映射集合::映射;
函数 主() -> 整32 {
打印("===== O(1) 哈希映射(自举前置修复)=====");
// 1. 基本 设置/获取/覆盖
映射<整64, 整64> 表 = 映射<整64, 整64>();
结果<空类型, 整32> 设1 = 表.设置(10, 100);
结果<空类型, 整32> 设2 = 表.设置(20, 200);
如果 (设1.正常 && 设2.正常) {
打印("设置: 通过");
} 否则 {
打印("设置: 失败");
}
结果<整64, 整32> 取1 = 表.获取(10);
如果 (取1.正常) {
打印("获取10: ", 取1.值); // 100
} 否则 {
打印("获取10失败: ", 取1.错误);
}
结果<空类型, 整32> 覆盖 = 表.设置(10, 999);
如果 (覆盖.正常) {
结果<整64, 整32> 取2 = 表.获取(10);
如果 (取2.正常) {
打印("覆盖后: ", 取2.值); // 999
} 否则 {
打印("覆盖后获取失败");
}
} 否则 {
打印("覆盖失败");
}
// 2. 包含 / 缺失键 / 删除
如果 (表.包含(20)) {
打印("包含20: 真");
}
如果 (!表.包含(30)) {
打印("包含30: 假");
}
布尔 删 = 表.删除(20);
打印("删除20: ", 删); // 真
如果 (!表.包含(20)) {
打印("删除后不包含: 真");
}
打印("删除后大小: ", 表.大小()); // 1
布尔 删2 = 表.删除(99);
打印("删除缺失键: ", 删2); // 假
// 3. 负数键
结果<空类型, 整32> 设负 = 表.设置(-5, 55);
如果 (设负.正常) {
结果<整64, 整32> 取负 = 表.获取(-5);
如果 (取负.正常) {
打印("负数键: ", 取负.值); // 55
} 否则 {
打印("负数键获取失败");
}
} 否则 {
打印("负数键设置失败");
}
// 4. 扩容重哈希:插入 2000 键(>1024 桶触发桶扩容 + 数组扩容)
整64 i = 0;
当 (i < 2000) {
结果<空类型, 整32> 设 = 表.设置(i, i * 3);
如果 (!设.正常) {
打印("扩容插入失败: ", i);
返回 1;
}
i++;
}
打印("扩容后大小: ", 表.大小()); // 2001(-5 旧键 + 0..1999;键 10 在循环内被 设置(10,30) 覆盖,不再新增)
// 5. 扩容后正确性抽查(前/中/后段键)
结果<整64, 整32> 抽查0 = 表.获取(0);
结果<整64, 整32> 抽查999 = 表.获取(999);
结果<整64, 整32> 抽查1999 = 表.获取(1999);
如果 (抽查0.正常) {
打印("重哈希抽查0: ", 抽查0.值);
} 否则 {
打印("重哈希抽查0失败");
}
如果 (抽查999.正常) {
打印("重哈希抽查999: ", 抽查999.值);
} 否则 {
打印("重哈希抽查999失败");
}
如果 (抽查1999.正常) {
打印("重哈希抽查1999: ", 抽查1999.值);
} 否则 {
打印("重哈希抽查1999失败");
}
// 6. 扩容后删除(空洞 + 交换删除路径)
布尔 删中 = 表.删除(1000);
打印("删除中段: ", 删中); // 真
如果 (!表.包含(1000) && 表.包含(999) && 表.包含(1001)) {
打印("空洞链正确: 真");
}
// 7. 性能断言:2000 次插入 + 2000 次查找 总耗时 < 50ms
// (线性表版本实测 11ms+9ms=20ms;哈希版本应 ≤ 数 ms;50ms 阈值防波动)
整64 开始 = 时间::单调时钟毫秒();
整64 和 = 0;
i = 0;
当 (i < 2000) {
结果<整64, 整32> 取 = 表.获取(i);
如果 (取.正常) {
和 += 取.值;
}
i++;
}
整64 结束 = 时间::单调时钟毫秒();
// 2026-08:不输出耗时(性能抖动 0/1ms 破坏逐行比对),仅输出性能判断
打印("校验和: ", 和);
如果 (结束 - 开始 < 50) {
打印("性能: 通过");
} 否则 {
打印("性能: 失败");
}
打印("===== 哈希映射测试完成 =====");
返回 0;
}输出:===== O(1) 哈希映射(自举前置修复)===== 设置: 通过 获取10: 100 覆盖后: 999 包含20: 真 包含30: 假 删除20: 真 删除后不包含: 真 删除后大小: 1 删除缺失键: 假 负数键: 55 扩容后大小: 2001 重哈希抽查0: 0 重哈希抽查999: 2997 重哈希抽查1999: 5997 删除中段: 真 空洞链正确: 真 校验和: 5994000 性能: 通过 ===== 哈希映射测试完成 =====
为空 常量
常量 函数 为空() -> 布尔
是否为空映射。
主.cnCN
导入 映射集合::映射;
导入 映射集合::集合;
导入 映射集合::错误码;
函数 主() -> 整32 {
打印("===== 映射集合库(Task 6.4)=====");
// ==================== 1. 映射<K,V>(整32键 → 整32值) ====================
映射<整32, 整32> 表 = 映射<整32, 整32>();
如果 (表.为空()) {
打印("映射初始为空: 是");
} 否则 {
打印("映射初始为空: 否");
}
// 设置 3 对键值(触发扩容 0 -> 4)
结果<空类型, 整32> 设置结果 = 表.设置(1, 100);
如果 (设置结果.正常) {
设置结果 = 表.设置(2, 200);
设置结果 = 表.设置(3, 300);
} 否则 {
打印("映射设置失败: ", 设置结果.错误);
}
打印("映射大小: ", 表.大小());
// 包含(规格书 4.4 表.包含(键))
如果 (表.包含(2)) {
打印("包含键2: 真");
} 否则 {
打印("包含键2: 假");
}
如果 (表.包含(99)) {
打印("包含键99: 真");
} 否则 {
打印("包含键99: 假");
}
// 获取正确值(先存局部变量再打印,规避打印变参内嵌字段下标缺陷)
结果<整32, 整32> 获取结果 = 表.获取(1);
如果 (获取结果.正常) {
整32 值1 = 获取结果.值;
打印("获取键1: ", 值1);
} 否则 {
打印("获取键1失败: ", 获取结果.错误);
}
获取结果 = 表.获取(3);
如果 (获取结果.正常) {
整32 值3 = 获取结果.值;
打印("获取键3: ", 值3);
} 否则 {
打印("获取键3失败: ", 获取结果.错误);
}
// 覆盖已存在键 → 大小仍 3 且值更新
设置结果 = 表.设置(2, 222);
如果 (设置结果.正常) {
获取结果 = 表.获取(2);
如果 (获取结果.正常) {
整32 值2 = 获取结果.值;
打印("覆盖后键2: ", 值2);
} 否则 {
打印("覆盖后读键2失败: ", 获取结果.错误);
}
} 否则 {
打印("覆盖设置失败: ", 设置结果.错误);
}
打印("覆盖后大小: ", 表.大小());
// 获取不存在的键 → 错误码.未初始化(7)
获取结果 = 表.获取(99);
如果 (获取结果.正常) {
打印("获取键99未报错");
} 否则 {
打印("获取键99错误码: ", 获取结果.错误);
}
// 删除键 1 → 包含=假、大小-1
布尔 删除结果 = 表.删除(1);
如果 (删除结果) {
打印("删除键1: 真");
} 否则 {
打印("删除键1: 假");
}
如果 (表.包含(1)) {
打印("删除后包含键1: 真");
} 否则 {
打印("删除后包含键1: 假");
}
打印("删除后大小: ", 表.大小());
// 删除不存在的键 → 返回假
删除结果 = 表.删除(99);
如果 (删除结果) {
打印("删除键99: 真");
} 否则 {
打印("删除键99: 假");
}
// 清空
表.清空();
打印("清空后大小: ", 表.大小());
// ==================== 2. 集合<T>(整32) ====================
集合<整32> 值集 = 集合<整32>();
如果 (值集.为空()) {
打印("集合初始为空: 是");
} 否则 {
打印("集合初始为空: 否");
}
// 添加 1/2/3、再添加 2(幂等)→ 大小=3
设置结果 = 值集.添加(1);
如果 (设置结果.正常) {
设置结果 = 值集.添加(2);
设置结果 = 值集.添加(3);
设置结果 = 值集.添加(2);
} 否则 {
打印("集合添加失败: ", 设置结果.错误);
}
打印("集合大小: ", 值集.大小());
// 包含
如果 (值集.包含(2)) {
打印("集合包含2: 真");
} 否则 {
打印("集合包含2: 假");
}
如果 (值集.包含(99)) {
打印("集合包含99: 真");
} 否则 {
打印("集合包含99: 假");
}
// 删除 → 大小-1
删除结果 = 值集.删除(2);
如果 (删除结果) {
打印("集合删除2: 真");
} 否则 {
打印("集合删除2: 假");
}
打印("集合删除后大小: ", 值集.大小());
如果 (值集.包含(2)) {
打印("删除后包含2: 真");
} 否则 {
打印("删除后包含2: 假");
}
// 删除不存在的值 → 返回假
删除结果 = 值集.删除(99);
如果 (删除结果) {
打印("集合删除99: 真");
} 否则 {
打印("集合删除99: 假");
}
值集.清空();
打印("集合清空后大小: ", 值集.大小());
打印("===== 映射集合库测试完成 =====");
返回 0;
}输出:===== 映射集合库(Task 6.4)===== 映射初始为空: 是 映射大小: 3 包含键2: 真 包含键99: 假 获取键1: 100 获取键3: 300 覆盖后键2: 222 覆盖后大小: 3 获取键99错误码: 7 删除键1: 真 删除后包含键1: 假 删除后大小: 2 删除键99: 假 清空后大小: 0 集合初始为空: 是 集合大小: 3 集合包含2: 真 集合包含99: 假 集合删除2: 真 集合删除后大小: 2 删除后包含2: 假 集合删除99: 假 集合清空后大小: 0 ===== 映射集合库测试完成 =====
设置 不安全
不安全 函数 设置(K 键, V 值) -> 结果<空类型, 整32>
写入键值:键已存在→覆盖旧值(旧值字符串正确释放);不存在→追加。负载因子 3/4 触发桶翻倍+全键重哈希。
| 参数 | 类型 | 说明 |
|---|---|---|
键 | K | 键(须支持 == 与位模式转换) |
值 | V | 值 |
返回 正常();扩容失败 → 错误(错误码.内存)。
主.cnCN
导入 容器::向量;
导入 映射集合::映射;
函数 词频统计(向量<字符串> 词表) -> 整64 {
返回 词表.大小();
}
函数 总和(向量<整64> 数据) -> 整64 {
整64 合计 = 0;
整64 i = 0;
当 (i < 数据.大小()) {
合计 += 数据.元素(i);
i++;
}
返回 合计;
}
函数 双表大小(向量<字符串> 甲, 向量<整64> 乙) -> 整64 {
返回 甲.大小() + 乙.大小();
}
函数 映射查找(映射<整64, 整64> 表, 整64 键) -> 整64 {
结果<整64, 整32> 取 = 表.获取(键);
如果 (取.正常) {
返回 取.值;
} 否则 {
返回 -1;
}
}
函数 主() -> 整32 {
打印("===== 泛型实例化类型作函数参数 =====");
向量<字符串> 词表 = 向量<字符串>();
结果<空类型, 整32> 加1 = 词表.追加("你好");
结果<空类型, 整32> 加2 = 词表.追加("世界");
如果 (加1.正常 && 加2.正常) {
打印("词频统计:", 词频统计(词表));
}
向量<整64> 数据 = 向量<整64>();
结果<空类型, 整32> 加3 = 数据.追加(10);
结果<空类型, 整32> 加4 = 数据.追加(20);
结果<空类型, 整32> 加5 = 数据.追加(30);
如果 (加3.正常 && 加4.正常 && 加5.正常) {
打印("数据总和:", 总和(数据));
}
打印("双表大小:", 双表大小(词表, 数据));
映射<整64, 整64> 表 = 映射<整64, 整64>();
结果<空类型, 整32> 设 = 表.设置(100, 7);
如果 (设.正常) {
打印("映射查找100:", 映射查找(表, 100));
打印("映射查找200:", 映射查找(表, 200));
}
返回 0;
}输出:===== 泛型实例化类型作函数参数 ===== 词频统计:2 数据总和:60 双表大小:5 映射查找100:7 映射查找200:-1
获取 不安全
不安全 函数 获取(K 键) -> 结果<V, 整32>
按键取值(副本);键不存在返回 错误(错误码.未初始化)而非垃圾值。
| 参数 | 类型 | 说明 |
|---|---|---|
键 | K | 要查的键 |
返回 正常(值);未命中 → 错误(错误码.未初始化)。
主.cnCN
导入 映射集合;
结构体 符号 {
整64 名ID;
整64 类型ID;
整64 种类;
整64 附加;
整64 已转移;
}
不安全 函数 主() -> 整32 {
映射<整64, 符号> 层 = 映射<整64, 符号>();
符号 s;
s.名ID = 111;
s.类型ID = 222;
s.种类 = 0;
s.附加 = 7;
s.已转移 = 0;
结果<空类型, 整32> 写回 = 层.设置(5, s);
如果 (!写回.正常) { 打印(0); 返回 0; }
结果<符号, 整32> 盒 = 层.获取(5);
如果 (盒.正常) {
如果 (盒.值.名ID != 111) { 打印(0); 返回 0; }
如果 (盒.值.类型ID != 222) { 打印(0); 返回 0; }
如果 (盒.值.附加 != 7) { 打印(0); 返回 0; }
} 否则 {
打印(0);
返回 0;
}
打印(7);
返回 0;
}输出:7
包含 常量
常量 函数 包含(K 键) -> 布尔
键是否存在。
主.cnCN
导入 映射集合::映射;
导入 映射集合::集合;
导入 映射集合::错误码;
函数 主() -> 整32 {
打印("===== 映射集合库(Task 6.4)=====");
// ==================== 1. 映射<K,V>(整32键 → 整32值) ====================
映射<整32, 整32> 表 = 映射<整32, 整32>();
如果 (表.为空()) {
打印("映射初始为空: 是");
} 否则 {
打印("映射初始为空: 否");
}
// 设置 3 对键值(触发扩容 0 -> 4)
结果<空类型, 整32> 设置结果 = 表.设置(1, 100);
如果 (设置结果.正常) {
设置结果 = 表.设置(2, 200);
设置结果 = 表.设置(3, 300);
} 否则 {
打印("映射设置失败: ", 设置结果.错误);
}
打印("映射大小: ", 表.大小());
// 包含(规格书 4.4 表.包含(键))
如果 (表.包含(2)) {
打印("包含键2: 真");
} 否则 {
打印("包含键2: 假");
}
如果 (表.包含(99)) {
打印("包含键99: 真");
} 否则 {
打印("包含键99: 假");
}
// 获取正确值(先存局部变量再打印,规避打印变参内嵌字段下标缺陷)
结果<整32, 整32> 获取结果 = 表.获取(1);
如果 (获取结果.正常) {
整32 值1 = 获取结果.值;
打印("获取键1: ", 值1);
} 否则 {
打印("获取键1失败: ", 获取结果.错误);
}
获取结果 = 表.获取(3);
如果 (获取结果.正常) {
整32 值3 = 获取结果.值;
打印("获取键3: ", 值3);
} 否则 {
打印("获取键3失败: ", 获取结果.错误);
}
// 覆盖已存在键 → 大小仍 3 且值更新
设置结果 = 表.设置(2, 222);
如果 (设置结果.正常) {
获取结果 = 表.获取(2);
如果 (获取结果.正常) {
整32 值2 = 获取结果.值;
打印("覆盖后键2: ", 值2);
} 否则 {
打印("覆盖后读键2失败: ", 获取结果.错误);
}
} 否则 {
打印("覆盖设置失败: ", 设置结果.错误);
}
打印("覆盖后大小: ", 表.大小());
// 获取不存在的键 → 错误码.未初始化(7)
获取结果 = 表.获取(99);
如果 (获取结果.正常) {
打印("获取键99未报错");
} 否则 {
打印("获取键99错误码: ", 获取结果.错误);
}
// 删除键 1 → 包含=假、大小-1
布尔 删除结果 = 表.删除(1);
如果 (删除结果) {
打印("删除键1: 真");
} 否则 {
打印("删除键1: 假");
}
如果 (表.包含(1)) {
打印("删除后包含键1: 真");
} 否则 {
打印("删除后包含键1: 假");
}
打印("删除后大小: ", 表.大小());
// 删除不存在的键 → 返回假
删除结果 = 表.删除(99);
如果 (删除结果) {
打印("删除键99: 真");
} 否则 {
打印("删除键99: 假");
}
// 清空
表.清空();
打印("清空后大小: ", 表.大小());
// ==================== 2. 集合<T>(整32) ====================
集合<整32> 值集 = 集合<整32>();
如果 (值集.为空()) {
打印("集合初始为空: 是");
} 否则 {
打印("集合初始为空: 否");
}
// 添加 1/2/3、再添加 2(幂等)→ 大小=3
设置结果 = 值集.添加(1);
如果 (设置结果.正常) {
设置结果 = 值集.添加(2);
设置结果 = 值集.添加(3);
设置结果 = 值集.添加(2);
} 否则 {
打印("集合添加失败: ", 设置结果.错误);
}
打印("集合大小: ", 值集.大小());
// 包含
如果 (值集.包含(2)) {
打印("集合包含2: 真");
} 否则 {
打印("集合包含2: 假");
}
如果 (值集.包含(99)) {
打印("集合包含99: 真");
} 否则 {
打印("集合包含99: 假");
}
// 删除 → 大小-1
删除结果 = 值集.删除(2);
如果 (删除结果) {
打印("集合删除2: 真");
} 否则 {
打印("集合删除2: 假");
}
打印("集合删除后大小: ", 值集.大小());
如果 (值集.包含(2)) {
打印("删除后包含2: 真");
} 否则 {
打印("删除后包含2: 假");
}
// 删除不存在的值 → 返回假
删除结果 = 值集.删除(99);
如果 (删除结果) {
打印("集合删除99: 真");
} 否则 {
打印("集合删除99: 假");
}
值集.清空();
打印("集合清空后大小: ", 值集.大小());
打印("===== 映射集合库测试完成 =====");
返回 0;
}输出:===== 映射集合库(Task 6.4)===== 映射初始为空: 是 映射大小: 3 包含键2: 真 包含键99: 假 获取键1: 100 获取键3: 300 覆盖后键2: 222 覆盖后大小: 3 获取键99错误码: 7 删除键1: 真 删除后包含键1: 假 删除后大小: 2 删除键99: 假 清空后大小: 0 集合初始为空: 是 集合大小: 3 集合包含2: 真 集合包含99: 假 集合删除2: 真 集合删除后大小: 2 删除后包含2: 假 集合删除99: 假 集合清空后大小: 0 ===== 映射集合库测试完成 =====
删除 不安全
不安全 函数 删除(K 键) -> 布尔
删除键值对:链摘除 + 与数组末元素交换(空洞无引用);被删项的键/值字符串正确释放。存在返回真。
| 参数 | 类型 | 说明 |
|---|---|---|
键 | K | 要删除的键 |
返回 删除成功真;键不存在假。
主.cnCN
导入 容器::向量;
导入 映射集合;
结构体 符号 {
整64 名ID;
整64 类型ID;
整64 种类;
整64 附加;
}
函数 主() -> 整32 {
映射<整64, 符号> 全局层 = 映射<整64, 符号>();
打印("初始大小: ", 全局层.大小());
符号 s1;
s1.名ID = 1;
s1.类型ID = 101;
s1.种类 = 1;
s1.附加 = 0;
结果<空类型, 整32> 加1 = 全局层.设置(1, s1);
打印("设置[1]: ", 加1.正常);
符号 s2;
s2.名ID = 2;
s2.类型ID = 102;
s2.种类 = 1;
s2.附加 = 0;
结果<空类型, 整32> 加2 = 全局层.设置(2, s2);
打印("设置[2]: ", 加2.正常);
结果<符号, 整32> 立查 = 全局层.获取(1);
如果 (立查.正常) {
符号 找到立 = 立查.值;
打印("立即[1].类型ID: ", 找到立.类型ID);
}
打印("层大小: ", 全局层.大小());
结果<符号, 整32> 查1 = 全局层.获取(1);
如果 (查1.正常) {
符号 找到1 = 查1.值;
打印("获取[1].类型ID: ", 找到1.类型ID);
}
结果<符号, 整32> 查3 = 全局层.获取(3);
打印("获取[3].正常: ", 查3.正常);
// 向量 持有 映射 元素(追加 深拷贝独立·H8-5)
向量<映射<整64, 符号>> 符号表 = 向量<映射<整64, 符号>>();
结果<空类型, 整32> 压 = 符号表.追加(全局层);
打印("追加.正常: ", 压.正常);
打印("向量大小: ", 符号表.大小());
// 元素 读取(副本/快照语义·两代一致)
映射<整64, 符号> 顶层 = 符号表.元素(0);
打印("元素[0].大小: ", 顶层.大小());
结果<符号, 整32> 查r = 顶层.获取(1);
如果 (查r.正常) {
符号 找到r = 查r.值;
打印("元素[0][1].类型ID: ", 找到r.类型ID);
}
// 删除 真删除
结果<空类型, 整32> 删r = 符号表.删除(0);
打印("删除.正常: ", 删r.正常);
打印("删除后向量大小: ", 符号表.大小());
返回 0;
}输出:初始大小: 0 设置[1]: 真 设置[2]: 真 立即[1].类型ID: 101 层大小: 2 获取[1].类型ID: 101 获取[3].正常: 假 追加.正常: 真 向量大小: 1 元素[0].大小: 2 元素[0][1].类型ID: 101 删除.正常: 真 删除后向量大小: 0
清空 不安全
不安全 函数 清空()
全部桶头复位、元素数清零(容量保留)。
主.cnCN
导入 核心::内存;
导入 容器::向量;
导入 容器::链表;
导入 容器::队列;
导入 映射集合;
导入 IO::打印;
// 内存搅动:新分配覆盖「已释放内存」,使悬垂元素内容可观测损坏(探针 76-F 手法)
函数 搅动() -> 整64 {
整64 和 = 0;
整64 i = 0;
当 (i < 24) {
字符串 垃圾 = 字符串复制("搅动内存填充占位字符串内容甲乙丙丁戊己庚辛");
和 = 和 + 字符串长度(垃圾);
i++;
}
返回 和;
}
// ① 映射 删除(键):交换式删除(位置!=最后)——被删项值串释放 + 剩余元素完好
函数 形态一() -> 整64 {
整64 校验 = 0;
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设甲 = 表.设置(1, 字符串复制("形态一甲串内容甲乙丙丁戊己庚辛"));
如果 (!设甲.正常) { 返回 0; }
结果<空类型, 整32> 设乙 = 表.设置(2, 字符串复制("形态一乙串内容甲乙丙丁戊己庚辛"));
如果 (!设乙.正常) { 返回 0; }
整64 删前 = 内存::活动分配数();
布尔 删 = 表.删除(1);
整64 删后 = 内存::活动分配数();
如果 (删) { 校验 = 校验 + 1; }
如果 (!表.包含(1)) { 校验 = 校验 + 2; }
结果<字符串, 整32> 取 = 表.获取(2);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态一乙串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
如果 (表.大小() == 1) { 校验 = 校验 + 8; }
如果 (删后 == 删前 - 1) { 校验 = 校验 + 16; } // 被删值串随删除释放
}
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ② 映射 设置覆盖已有键:旧值串随覆盖释放(新值接管与旧值释放相抵)+ 内容=新值
函数 形态二() -> 整64 {
整64 校验 = 0;
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设旧 = 表.设置(2, 字符串复制("形态二旧串内容甲乙丙丁戊己庚辛"));
如果 (!设旧.正常) { 返回 0; }
整64 覆前 = 内存::活动分配数();
结果<空类型, 整32> 设新 = 表.设置(2, 字符串复制("形态二新串内容甲乙丙丁戊己庚辛"));
如果 (!设新.正常) { 返回 0; }
整64 覆后 = 内存::活动分配数();
如果 (覆后 == 覆前) { 校验 = 校验 + 1; }
结果<字符串, 整32> 取 = 表.获取(2);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态二新串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
} 否则 {
返回 0;
}
如果 (表.大小() == 1) { 校验 = 校验 + 4; }
}
整64 消耗 = 搅动();
返回 校验; // 期望 7
}
// ③ 映射 释放内部数组(H8-5 显式销毁路径):4 内部数组 + 值串一并释放
函数 形态三() -> 整64 {
整64 校验 = 0;
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设 = 表.设置(3, 字符串复制("形态三值串内容甲乙丙丁戊己庚辛"));
如果 (!设.正常) { 返回 0; }
整64 释前 = 内存::活动分配数();
表.释放内部数组();
整64 释后 = 内存::活动分配数();
如果 (释后 == 释前 - 5) { 校验 = 1; }
整64 消耗 = 搅动();
返回 校验; // 期望 1
}
// ④ 集合<T>:元素串随 析构/清空 释放
函数 形态四() -> 整64 {
整64 校验 = 0;
整64 析构前 = 内存::活动分配数();
如果 (1 == 1) {
集合<字符串> 集 = 集合<字符串>();
结果<空类型, 整32> 加 = 集.添加(字符串复制("形态四析构元素串内容甲乙丙丁"));
如果 (!加.正常) { 返回 0; }
如果 (集.大小() == 1) { 校验 = 校验 + 1; }
}
整64 析构后 = 内存::活动分配数();
如果 (析构后 == 析构前) { 校验 = 校验 + 2; } // 元素串 + 数据数组随析构释放
集合<字符串> 集二 = 集合<字符串>();
结果<空类型, 整32> 加二 = 集二.添加(字符串复制("形态四清空元素串内容甲乙丙"));
如果 (!加二.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
集二.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 1) { 校验 = 校验 + 4; } // 元素串随清空释放
整64 消耗 = 搅动();
返回 校验; // 期望 7
}
// ⑤ 向量 删除(位置) + 设置覆盖:被删/旧元素串释放 + 元素内容守恒
函数 形态五() -> 整64 {
整64 校验 = 0;
整64 删除前 = 内存::活动分配数();
如果 (1 == 1) {
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加甲 = 表.追加(字符串复制("形态五甲串内容甲乙丙丁戊己庚辛"));
如果 (!加甲.正常) { 返回 0; }
结果<空类型, 整32> 加乙 = 表.追加(字符串复制("形态五乙串内容甲乙丙丁戊己庚辛"));
如果 (!加乙.正常) { 返回 0; }
整64 删前 = 内存::活动分配数();
结果<空类型, 整32> 删 = 表.删除(0);
整64 删后 = 内存::活动分配数();
如果 (!删.正常) { 返回 0; }
如果 (删后 == 删前 - 1) { 校验 = 校验 + 1; }
字符串 元素 = 表.元素(0);
如果 (字符串比较(元素, "形态五乙串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
}
整64 删除后 = 内存::活动分配数();
如果 (删除后 == 删除前) { 校验 = 校验 + 4; }
向量<字符串> 表二 = 向量<字符串>();
结果<空类型, 整32> 加旧 = 表二.追加(字符串复制("形态五旧串内容甲乙丙丁戊己庚辛"));
如果 (!加旧.正常) { 返回 0; }
整64 覆前 = 内存::活动分配数();
结果<空类型, 整32> 设新 = 表二.设置(0, 字符串复制("形态五新串内容甲乙丙丁戊己庚辛"));
如果 (!设新.正常) { 返回 0; }
整64 覆后 = 内存::活动分配数();
如果 (覆后 == 覆前) { 校验 = 校验 + 8; } // 旧值释放 + 新值接管相抵
字符串 元素二 = 表二.元素(0);
如果 (字符串比较(元素二, "形态五新串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 16; }
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ⑥ 链表 删除头部/删除尾部/清空:被摘槽与清空元素串释放 + 链序守恒
函数 形态六() -> 整64 {
整64 校验 = 0;
链表<字符串> 表 = 链表<字符串>();
结果<空类型, 整32> 加甲 = 表.头部追加(字符串复制("形态六甲串内容甲乙丙丁戊己庚辛"));
如果 (!加甲.正常) { 返回 0; }
结果<空类型, 整32> 加乙 = 表.头部追加(字符串复制("形态六乙串内容甲乙丙丁戊己庚辛"));
如果 (!加乙.正常) { 返回 0; }
整64 删头前 = 内存::活动分配数();
结果<空类型, 整32> 删头 = 表.删除头部();
整64 删头后 = 内存::活动分配数();
如果 (!删头.正常) { 返回 0; }
如果 (删头后 == 删头前 - 1) { 校验 = 校验 + 1; }
如果 (表.大小() == 1) { 校验 = 校验 + 2; }
结果<字符串, 整32> 读 = 表.读取头部();
如果 (读.正常) {
如果 (字符串比较(读.值, "形态六甲串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
整64 删尾前 = 内存::活动分配数();
结果<空类型, 整32> 删尾 = 表.删除尾部();
整64 删尾后 = 内存::活动分配数();
如果 (!删尾.正常) { 返回 0; }
如果 (删尾后 == 删尾前 - 1) { 校验 = 校验 + 8; }
结果<空类型, 整32> 加丙 = 表.头部追加(字符串复制("形态六丙串内容甲乙丙丁戊己庚辛"));
如果 (!加丙.正常) { 返回 0; }
结果<空类型, 整32> 加丁 = 表.头部追加(字符串复制("形态六丁串内容甲乙丙丁戊己庚辛"));
如果 (!加丁.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
表.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 2) { 校验 = 校验 + 16; } // 清空元素串随清空释放(按链游)
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ⑦ 队列 清空:元素串随清空释放(按链游)
函数 形态七() -> 整64 {
整64 校验 = 0;
队列<字符串> 表 = 队列<字符串>();
结果<空类型, 整32> 入甲 = 表.入队(字符串复制("形态七甲串内容甲乙丙丁戊己庚辛"));
如果 (!入甲.正常) { 返回 0; }
结果<空类型, 整32> 入乙 = 表.入队(字符串复制("形态七乙串内容甲乙丙丁戊己庚辛"));
如果 (!入乙.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
表.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 2) { 校验 = 1; }
整64 消耗 = 搅动();
返回 校验; // 期望 1
}
// ⑧ 借用来源入映射(UAF 防护)+ 局部标识符入映射(值语义深拷贝)
函数 存入映射(映射<整64, 字符串> 表, 字符串 形参) -> 空类型 {
结果<空类型, 整32> 设 = 表.设置(1, 形参);
如果 (!设.正常) { 运行时错误(4); }
}
函数 形态八() -> 整64 {
整64 校验 = 0;
字符串 本地 = 字符串复制("形态八本地串内容甲乙丙丁戊己庚辛");
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
存入映射(表, 本地);
结果<字符串, 整32> 取 = 表.获取(1);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态八本地串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 1; }
} 否则 {
返回 0;
}
}
整64 消耗 = 搅动(); // 容器析构后搅动:若容器释放了本地串 → 内容损坏
如果 (字符串比较(本地, "形态八本地串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
如果 (1 == 1) {
映射<整64, 字符串> 表二 = 映射<整64, 字符串>();
字符串 源 = 字符串复制("形态八深拷贝串内容甲乙丙丁戊己庚辛");
结果<空类型, 整32> 设二 = 表二.设置(2, 源);
如果 (!设二.正常) { 返回 0; }
结果<字符串, 整32> 取二 = 表二.获取(2);
如果 (取二.正常) {
如果 (字符串比较(取二.值, "形态八深拷贝串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
}
整64 消耗二 = 搅动(); // 源已随块出口释放:若容器浅存句柄 → 元素悬垂损坏
返回 校验; // 期望 7
}
函数 主() -> 整32 {
整64 校验和 = 0;
如果 (形态一() == 31) { 校验和 = 校验和 + 1; }
如果 (形态二() == 7) { 校验和 = 校验和 + 2; }
如果 (形态三() == 1) { 校验和 = 校验和 + 4; }
如果 (形态四() == 7) { 校验和 = 校验和 + 8; }
如果 (形态五() == 31) { 校验和 = 校验和 + 16; }
如果 (形态六() == 31) { 校验和 = 校验和 + 32; }
如果 (形态七() == 1) { 校验和 = 校验和 + 64; }
如果 (形态八() == 7) { 校验和 = 校验和 + 128; }
打印("校验和(期望255)=", 校验和);
返回 0;
}输出:校验和(期望255)=255
释放内部数组 内部 不安全
不安全 函数 释放内部数组()
显式销毁内部数组(映射作为容器元素被弹出/清场时由容器调用)。释放后可安全复用。常规 RAII 路径用析构即可,勿手动调。
桶索引 内部
常量 函数 桶索引(K 键) -> 整64
内部散列辅助:键的 8 字节位模式 Knuth 乘法散列 & 桶掩码。
链查找 内部
常量 不安全 函数 链查找(K 键, 整64& 前驱) -> 整64
内部桶链查找:返回键位置(找不到 -1),前驱 经引用输出(-1=桶头)。含静态未构造防御(零初始化态视为空映射)。
析构键值 / 析构值 内部
函数 析构键值(整64 索引) / 析构值(整64 索引)
编译器注入挂点:K/V 为字符串时释放对应槽并清零(幂等);非字符串实例零注入。删除/覆盖 内部使用。
字符串映射<V>
键类型固定为 字符串 的哈希表(FNV-1a 逐字节散列 + 字符串比较判等),行为与 映射<K, V> 同构。泛型 映射 的键消费链暂不支持字符串键,本类是官方通道(泛型键分派落地后回收为别名)。
字符串映射.cnCN
导入 映射集合::字符串映射;
函数 主() -> 整32 {
字符串映射<整64> 评分 = 字符串映射<整64>();
结果<空类型, 整32> 设 = 评分.设置("张三", 95);
设 = 评分.设置("李四", 88);
结果<整64, 整32> 得分 = 评分.获取("张三");
如果 (得分.正常) { 打印(得分.值); } 否则 { 打印("未找到"); }
打印(评分.包含("李四"), " ", 评分.包含("王五"));
返回 0;
}输出:95 真 假
字符串映射() 不安全
不安全 函数 字符串映射()
构造空字符串键映射。
主.cnCN
导入 映射集合;
不安全 函数 主() -> 整32 {
// ---- 一、功能面:增删查改+覆盖+扩容重哈希(15 键触发两轮翻倍)----
字符串映射<整32> 表 = 字符串映射<整32>();
结果<空类型, 整32> s1 = 表.设置("甲", 1);
结果<空类型, 整32> s2 = 表.设置("乙", 2);
结果<空类型, 整32> s3 = 表.设置("丙", 3);
结果<整32, 整32> g1 = 表.获取("乙");
如果 (g1.正常) { 打印(g1.值); } 否则 { 打印("获取乙失败"); 返回 1; }
如果 (表.包含("丙")) { 打印("包含丙"); }
如果 (!表.包含("戊")) { 打印("不含戊"); }
结果<空类型, 整32> s4 = 表.设置("乙", 22);
结果<整32, 整32> g2 = 表.获取("乙");
如果 (g2.正常 && g2.值 == 22) { 打印("覆盖22"); }
结果<空类型, 整32> a1 = 表.设置("k01", 101);
结果<空类型, 整32> a2 = 表.设置("k02", 102);
结果<空类型, 整32> a3 = 表.设置("k03", 103);
结果<空类型, 整32> a4 = 表.设置("k04", 104);
结果<空类型, 整32> a5 = 表.设置("k05", 105);
结果<空类型, 整32> a6 = 表.设置("k06", 106);
结果<空类型, 整32> a7 = 表.设置("k07", 107);
结果<空类型, 整32> a8 = 表.设置("k08", 108);
结果<空类型, 整32> a9 = 表.设置("k09", 109);
结果<空类型, 整32> a10 = 表.设置("k10", 110);
结果<空类型, 整32> a11 = 表.设置("k11", 111);
结果<空类型, 整32> a12 = 表.设置("k12", 112);
布尔 d1 = 表.删除("k05");
如果 (d1 && !表.包含("k05")) { 打印("删中段k05生效"); }
结果<整32, 整32> g3 = 表.获取("乙");
如果 (g3.正常 && g3.值 == 22) { 打印("删后乙仍在"); }
结果<整32, 整32> g4 = 表.获取("k12");
如果 (g4.正常 && g4.值 == 112) { 打印("末尾k12仍在"); }
结果<整32, 整32> g5 = 表.获取("k04");
如果 (g5.正常 && g5.值 == 104) { 打印("k05邻位k04仍在"); }
如果 (表.包含("甲")) { 打印("扩容后甲仍在"); }
布尔 d2 = 表.删除("甲");
如果 (!d2) { 打印("重复删假错"); } 否则 { 打印("重复删假"); }
// ---- 二、拷贝构造独立(键深拷·改副本不影响原表)----
字符串映射<整32> 副本 = 表;
布尔 d3 = 副本.删除("乙");
如果 (!表.包含("乙")) { 打印("拷贝独立性错"); } 否则 { 打印("拷贝独立"); }
// ---- 三、V=字符串 值形态 + 值链/覆盖 ----
字符串映射<字符串> 名册 = 字符串映射<字符串>();
结果<空类型, 整32> n1 = 名册.设置("甲", "甲的内容串很长");
结果<空类型, 整32> n2 = 名册.设置("乙", "乙的内容串也很长");
结果<字符串, 整32> 取名 = 名册.获取("乙");
如果 (取名.正常 && 字符串比较(取名.值, "乙的内容串也很长")) { 打印("字符串值链对"); }
结果<空类型, 整32> 覆 = 名册.设置("甲", "甲的新内容更长一些");
结果<字符串, 整32> 取2 = 名册.获取("甲");
如果 (取2.正常 && 字符串比较(取2.值, "甲的新内容更长一些")) { 打印("字符串覆盖对"); }
// ---- 四、双形态零泄漏(析构注入验收:76-a kStr 字段判定+~字符串映射 匹配)----
整64 前 = 内存::活动分配数();
{
字符串映射<整32> 泄表 = 字符串映射<整32>();
结果<空类型, 整32> p1 = 泄表.设置("甲乙丙丁", 1);
结果<空类型, 整32> p2 = 泄表.设置("戊己庚辛", 2);
字符串映射<整32> 泄副 = 泄表;
字符串映射<字符串> 泄名 = 字符串映射<字符串>();
结果<空类型, 整32> p3 = 泄名.设置("键", "值串内容很长很长");
}
整64 后 = 内存::活动分配数();
如果 (前 == 后) { 打印("双形态零泄漏"); } 否则 { 打印("泄漏差: ", 后 - 前); }
// ---- 五、泛型版同场对照(零回归锚)----
映射<整64, 整32> 对照 = 映射<整64, 整32>();
结果<空类型, 整32> c1 = 对照.设置(7, 70);
结果<整32, 整32> c2 = 对照.获取(7);
如果 (c2.正常 && c2.值 == 70) { 打印("泛型对照对"); }
返回 0;
}输出:2 包含丙 不含戊 覆盖22 删中段k05生效 删后乙仍在 末尾k12仍在 k05邻位k04仍在 扩容后甲仍在 重复删假 拷贝独立 字符串值链对 字符串覆盖对 双形态零泄漏 泛型对照对
设置 不安全
不安全 函数 设置(字符串 键, V 值) -> 结果<空类型, 整32>
写入键值(存在即覆盖;键字符串入表时拥有化复制)。
| 参数 | 类型 | 说明 |
|---|---|---|
键 | 字符串 | 字符串键 |
值 | V | 值 |
返回 正常();扩容失败 → 错误(错误码.内存)。
主.cnCN
导入 映射集合;
导入 IO::打印;
导入 核心::内存;
// E2E 552(2026-09-30 第 914 轮·任务 091 根治·返回容器声明位接收堆物化):
// 三判据:①值对(深搅动后 11=独立副本);②泄漏归零(块尾活动分配数
// 回落=拥有副本被释放);③退出码 0(析构合法——原豁免=泄漏/原直登记
// =free sret 栈地址崩,双度实证)。宿主对照同源(RAII 全链基准)。
函数 造表() -> 映射<整32, 整32> {
映射<整32, 整32> t;
结果<空类型, 整32> 设 = t.设置(1, 11);
如果 (设.正常) { } 否则 { }
返回 t;
}
函数 搅动() -> 空类型 {
整32 i = 0;
当 (i < 64) {
字符串 垃圾 = 字符串复制("搅动内存复用压力载荷数据0123456789ABCDEF");
i = i + 1;
}
}
函数 主() -> 整32 {
整64 基线 = 内存::活动分配数();
{
映射<整32, 整32> 表 = 造表();
搅动();
结果<整32, 整32> 取 = 表.获取(1);
如果 (取.正常) { 打印(取.值); } 否则 { 打印(0 - 1); }
}
整64 余留 = 内存::活动分配数() - 基线;
打印(余留);
返回 0;
}输出:11 0
获取 不安全
不安全 函数 获取(字符串 键) -> 结果<V, 整32>
按键取值;未命中 → 错误(错误码.未初始化)。
| 参数 | 类型 | 说明 |
|---|---|---|
键 | 字符串 | 要查的键 |
返回 正常(值);未命中 → 错误。
主.cnCN
导入 映射集合;
结构体 符号 {
整64 名ID;
整64 类型ID;
整64 种类;
整64 附加;
整64 已转移;
}
不安全 函数 主() -> 整32 {
映射<整64, 符号> 层 = 映射<整64, 符号>();
符号 s;
s.名ID = 111;
s.类型ID = 222;
s.种类 = 0;
s.附加 = 7;
s.已转移 = 0;
结果<空类型, 整32> 写回 = 层.设置(5, s);
如果 (!写回.正常) { 打印(0); 返回 0; }
结果<符号, 整32> 盒 = 层.获取(5);
如果 (盒.正常) {
如果 (盒.值.名ID != 111) { 打印(0); 返回 0; }
如果 (盒.值.类型ID != 222) { 打印(0); 返回 0; }
如果 (盒.值.附加 != 7) { 打印(0); 返回 0; }
} 否则 {
打印(0);
返回 0;
}
打印(7);
返回 0;
}输出:7
包含 常量
常量 函数 包含(字符串 键) -> 布尔
键是否存在。
主.cnCN
导入 映射集合::映射;
函数 主() -> 整32 {
打印("===== O(1) 哈希映射(自举前置修复)=====");
// 1. 基本 设置/获取/覆盖
映射<整64, 整64> 表 = 映射<整64, 整64>();
结果<空类型, 整32> 设1 = 表.设置(10, 100);
结果<空类型, 整32> 设2 = 表.设置(20, 200);
如果 (设1.正常 && 设2.正常) {
打印("设置: 通过");
} 否则 {
打印("设置: 失败");
}
结果<整64, 整32> 取1 = 表.获取(10);
如果 (取1.正常) {
打印("获取10: ", 取1.值); // 100
} 否则 {
打印("获取10失败: ", 取1.错误);
}
结果<空类型, 整32> 覆盖 = 表.设置(10, 999);
如果 (覆盖.正常) {
结果<整64, 整32> 取2 = 表.获取(10);
如果 (取2.正常) {
打印("覆盖后: ", 取2.值); // 999
} 否则 {
打印("覆盖后获取失败");
}
} 否则 {
打印("覆盖失败");
}
// 2. 包含 / 缺失键 / 删除
如果 (表.包含(20)) {
打印("包含20: 真");
}
如果 (!表.包含(30)) {
打印("包含30: 假");
}
布尔 删 = 表.删除(20);
打印("删除20: ", 删); // 真
如果 (!表.包含(20)) {
打印("删除后不包含: 真");
}
打印("删除后大小: ", 表.大小()); // 1
布尔 删2 = 表.删除(99);
打印("删除缺失键: ", 删2); // 假
// 3. 负数键
结果<空类型, 整32> 设负 = 表.设置(-5, 55);
如果 (设负.正常) {
结果<整64, 整32> 取负 = 表.获取(-5);
如果 (取负.正常) {
打印("负数键: ", 取负.值); // 55
} 否则 {
打印("负数键获取失败");
}
} 否则 {
打印("负数键设置失败");
}
// 4. 扩容重哈希:插入 2000 键(>1024 桶触发桶扩容 + 数组扩容)
整64 i = 0;
当 (i < 2000) {
结果<空类型, 整32> 设 = 表.设置(i, i * 3);
如果 (!设.正常) {
打印("扩容插入失败: ", i);
返回 1;
}
i++;
}
打印("扩容后大小: ", 表.大小()); // 2001(-5 旧键 + 0..1999;键 10 在循环内被 设置(10,30) 覆盖,不再新增)
// 5. 扩容后正确性抽查(前/中/后段键)
结果<整64, 整32> 抽查0 = 表.获取(0);
结果<整64, 整32> 抽查999 = 表.获取(999);
结果<整64, 整32> 抽查1999 = 表.获取(1999);
如果 (抽查0.正常) {
打印("重哈希抽查0: ", 抽查0.值);
} 否则 {
打印("重哈希抽查0失败");
}
如果 (抽查999.正常) {
打印("重哈希抽查999: ", 抽查999.值);
} 否则 {
打印("重哈希抽查999失败");
}
如果 (抽查1999.正常) {
打印("重哈希抽查1999: ", 抽查1999.值);
} 否则 {
打印("重哈希抽查1999失败");
}
// 6. 扩容后删除(空洞 + 交换删除路径)
布尔 删中 = 表.删除(1000);
打印("删除中段: ", 删中); // 真
如果 (!表.包含(1000) && 表.包含(999) && 表.包含(1001)) {
打印("空洞链正确: 真");
}
// 7. 性能断言:2000 次插入 + 2000 次查找 总耗时 < 50ms
// (线性表版本实测 11ms+9ms=20ms;哈希版本应 ≤ 数 ms;50ms 阈值防波动)
整64 开始 = 时间::单调时钟毫秒();
整64 和 = 0;
i = 0;
当 (i < 2000) {
结果<整64, 整32> 取 = 表.获取(i);
如果 (取.正常) {
和 += 取.值;
}
i++;
}
整64 结束 = 时间::单调时钟毫秒();
// 2026-08:不输出耗时(性能抖动 0/1ms 破坏逐行比对),仅输出性能判断
打印("校验和: ", 和);
如果 (结束 - 开始 < 50) {
打印("性能: 通过");
} 否则 {
打印("性能: 失败");
}
打印("===== 哈希映射测试完成 =====");
返回 0;
}输出:===== O(1) 哈希映射(自举前置修复)===== 设置: 通过 获取10: 100 覆盖后: 999 包含20: 真 包含30: 假 删除20: 真 删除后不包含: 真 删除后大小: 1 删除缺失键: 假 负数键: 55 扩容后大小: 2001 重哈希抽查0: 0 重哈希抽查999: 2997 重哈希抽查1999: 5997 删除中段: 真 空洞链正确: 真 校验和: 5994000 性能: 通过 ===== 哈希映射测试完成 =====
删除 不安全
不安全 函数 删除(字符串 键) -> 布尔
删除键值对(链摘除 + 末元素交换;键值字符串正确释放)。存在返回真。
| 参数 | 类型 | 说明 |
|---|---|---|
键 | 字符串 | 要删除的键 |
返回 删除成功真;不存在假。
主.cnCN
导入 映射集合;
不安全 函数 主() -> 整32 {
// ---- 一、功能面:增删查改+覆盖+扩容重哈希(15 键触发两轮翻倍)----
字符串映射<整32> 表 = 字符串映射<整32>();
结果<空类型, 整32> s1 = 表.设置("甲", 1);
结果<空类型, 整32> s2 = 表.设置("乙", 2);
结果<空类型, 整32> s3 = 表.设置("丙", 3);
结果<整32, 整32> g1 = 表.获取("乙");
如果 (g1.正常) { 打印(g1.值); } 否则 { 打印("获取乙失败"); 返回 1; }
如果 (表.包含("丙")) { 打印("包含丙"); }
如果 (!表.包含("戊")) { 打印("不含戊"); }
结果<空类型, 整32> s4 = 表.设置("乙", 22);
结果<整32, 整32> g2 = 表.获取("乙");
如果 (g2.正常 && g2.值 == 22) { 打印("覆盖22"); }
结果<空类型, 整32> a1 = 表.设置("k01", 101);
结果<空类型, 整32> a2 = 表.设置("k02", 102);
结果<空类型, 整32> a3 = 表.设置("k03", 103);
结果<空类型, 整32> a4 = 表.设置("k04", 104);
结果<空类型, 整32> a5 = 表.设置("k05", 105);
结果<空类型, 整32> a6 = 表.设置("k06", 106);
结果<空类型, 整32> a7 = 表.设置("k07", 107);
结果<空类型, 整32> a8 = 表.设置("k08", 108);
结果<空类型, 整32> a9 = 表.设置("k09", 109);
结果<空类型, 整32> a10 = 表.设置("k10", 110);
结果<空类型, 整32> a11 = 表.设置("k11", 111);
结果<空类型, 整32> a12 = 表.设置("k12", 112);
布尔 d1 = 表.删除("k05");
如果 (d1 && !表.包含("k05")) { 打印("删中段k05生效"); }
结果<整32, 整32> g3 = 表.获取("乙");
如果 (g3.正常 && g3.值 == 22) { 打印("删后乙仍在"); }
结果<整32, 整32> g4 = 表.获取("k12");
如果 (g4.正常 && g4.值 == 112) { 打印("末尾k12仍在"); }
结果<整32, 整32> g5 = 表.获取("k04");
如果 (g5.正常 && g5.值 == 104) { 打印("k05邻位k04仍在"); }
如果 (表.包含("甲")) { 打印("扩容后甲仍在"); }
布尔 d2 = 表.删除("甲");
如果 (!d2) { 打印("重复删假错"); } 否则 { 打印("重复删假"); }
// ---- 二、拷贝构造独立(键深拷·改副本不影响原表)----
字符串映射<整32> 副本 = 表;
布尔 d3 = 副本.删除("乙");
如果 (!表.包含("乙")) { 打印("拷贝独立性错"); } 否则 { 打印("拷贝独立"); }
// ---- 三、V=字符串 值形态 + 值链/覆盖 ----
字符串映射<字符串> 名册 = 字符串映射<字符串>();
结果<空类型, 整32> n1 = 名册.设置("甲", "甲的内容串很长");
结果<空类型, 整32> n2 = 名册.设置("乙", "乙的内容串也很长");
结果<字符串, 整32> 取名 = 名册.获取("乙");
如果 (取名.正常 && 字符串比较(取名.值, "乙的内容串也很长")) { 打印("字符串值链对"); }
结果<空类型, 整32> 覆 = 名册.设置("甲", "甲的新内容更长一些");
结果<字符串, 整32> 取2 = 名册.获取("甲");
如果 (取2.正常 && 字符串比较(取2.值, "甲的新内容更长一些")) { 打印("字符串覆盖对"); }
// ---- 四、双形态零泄漏(析构注入验收:76-a kStr 字段判定+~字符串映射 匹配)----
整64 前 = 内存::活动分配数();
{
字符串映射<整32> 泄表 = 字符串映射<整32>();
结果<空类型, 整32> p1 = 泄表.设置("甲乙丙丁", 1);
结果<空类型, 整32> p2 = 泄表.设置("戊己庚辛", 2);
字符串映射<整32> 泄副 = 泄表;
字符串映射<字符串> 泄名 = 字符串映射<字符串>();
结果<空类型, 整32> p3 = 泄名.设置("键", "值串内容很长很长");
}
整64 后 = 内存::活动分配数();
如果 (前 == 后) { 打印("双形态零泄漏"); } 否则 { 打印("泄漏差: ", 后 - 前); }
// ---- 五、泛型版同场对照(零回归锚)----
映射<整64, 整32> 对照 = 映射<整64, 整32>();
结果<空类型, 整32> c1 = 对照.设置(7, 70);
结果<整32, 整32> c2 = 对照.获取(7);
如果 (c2.正常 && c2.值 == 70) { 打印("泛型对照对"); }
返回 0;
}输出:2 包含丙 不含戊 覆盖22 删中段k05生效 删后乙仍在 末尾k12仍在 k05邻位k04仍在 扩容后甲仍在 重复删假 拷贝独立 字符串值链对 字符串覆盖对 双形态零泄漏 泛型对照对
清空 / 拷贝构造
不安全 函数 清空() | 不安全 函数 字符串映射(字符串映射& 其他)
清空=全部桶头复位、元素数清零;拷贝构造=桶/键/值数组全量深拷(与 映射 同构)。注意:本类暂无 大小()/为空() 成员(判空/计数用 包含 或等 泛型键分派落地后补齐)。
主.cnCN
导入 映射集合::映射;
函数 主() -> 整32 {
打印("===== O(1) 哈希映射(自举前置修复)=====");
// 1. 基本 设置/获取/覆盖
映射<整64, 整64> 表 = 映射<整64, 整64>();
结果<空类型, 整32> 设1 = 表.设置(10, 100);
结果<空类型, 整32> 设2 = 表.设置(20, 200);
如果 (设1.正常 && 设2.正常) {
打印("设置: 通过");
} 否则 {
打印("设置: 失败");
}
结果<整64, 整32> 取1 = 表.获取(10);
如果 (取1.正常) {
打印("获取10: ", 取1.值); // 100
} 否则 {
打印("获取10失败: ", 取1.错误);
}
结果<空类型, 整32> 覆盖 = 表.设置(10, 999);
如果 (覆盖.正常) {
结果<整64, 整32> 取2 = 表.获取(10);
如果 (取2.正常) {
打印("覆盖后: ", 取2.值); // 999
} 否则 {
打印("覆盖后获取失败");
}
} 否则 {
打印("覆盖失败");
}
// 2. 包含 / 缺失键 / 删除
如果 (表.包含(20)) {
打印("包含20: 真");
}
如果 (!表.包含(30)) {
打印("包含30: 假");
}
布尔 删 = 表.删除(20);
打印("删除20: ", 删); // 真
如果 (!表.包含(20)) {
打印("删除后不包含: 真");
}
打印("删除后大小: ", 表.大小()); // 1
布尔 删2 = 表.删除(99);
打印("删除缺失键: ", 删2); // 假
// 3. 负数键
结果<空类型, 整32> 设负 = 表.设置(-5, 55);
如果 (设负.正常) {
结果<整64, 整32> 取负 = 表.获取(-5);
如果 (取负.正常) {
打印("负数键: ", 取负.值); // 55
} 否则 {
打印("负数键获取失败");
}
} 否则 {
打印("负数键设置失败");
}
// 4. 扩容重哈希:插入 2000 键(>1024 桶触发桶扩容 + 数组扩容)
整64 i = 0;
当 (i < 2000) {
结果<空类型, 整32> 设 = 表.设置(i, i * 3);
如果 (!设.正常) {
打印("扩容插入失败: ", i);
返回 1;
}
i++;
}
打印("扩容后大小: ", 表.大小()); // 2001(-5 旧键 + 0..1999;键 10 在循环内被 设置(10,30) 覆盖,不再新增)
// 5. 扩容后正确性抽查(前/中/后段键)
结果<整64, 整32> 抽查0 = 表.获取(0);
结果<整64, 整32> 抽查999 = 表.获取(999);
结果<整64, 整32> 抽查1999 = 表.获取(1999);
如果 (抽查0.正常) {
打印("重哈希抽查0: ", 抽查0.值);
} 否则 {
打印("重哈希抽查0失败");
}
如果 (抽查999.正常) {
打印("重哈希抽查999: ", 抽查999.值);
} 否则 {
打印("重哈希抽查999失败");
}
如果 (抽查1999.正常) {
打印("重哈希抽查1999: ", 抽查1999.值);
} 否则 {
打印("重哈希抽查1999失败");
}
// 6. 扩容后删除(空洞 + 交换删除路径)
布尔 删中 = 表.删除(1000);
打印("删除中段: ", 删中); // 真
如果 (!表.包含(1000) && 表.包含(999) && 表.包含(1001)) {
打印("空洞链正确: 真");
}
// 7. 性能断言:2000 次插入 + 2000 次查找 总耗时 < 50ms
// (线性表版本实测 11ms+9ms=20ms;哈希版本应 ≤ 数 ms;50ms 阈值防波动)
整64 开始 = 时间::单调时钟毫秒();
整64 和 = 0;
i = 0;
当 (i < 2000) {
结果<整64, 整32> 取 = 表.获取(i);
如果 (取.正常) {
和 += 取.值;
}
i++;
}
整64 结束 = 时间::单调时钟毫秒();
// 2026-08:不输出耗时(性能抖动 0/1ms 破坏逐行比对),仅输出性能判断
打印("校验和: ", 和);
如果 (结束 - 开始 < 50) {
打印("性能: 通过");
} 否则 {
打印("性能: 失败");
}
打印("===== 哈希映射测试完成 =====");
返回 0;
}输出:===== O(1) 哈希映射(自举前置修复)===== 设置: 通过 获取10: 100 覆盖后: 999 包含20: 真 包含30: 假 删除20: 真 删除后不包含: 真 删除后大小: 1 删除缺失键: 假 负数键: 55 扩容后大小: 2001 重哈希抽查0: 0 重哈希抽查999: 2997 重哈希抽查1999: 5997 删除中段: 真 空洞链正确: 真 校验和: 5994000 性能: 通过 ===== 哈希映射测试完成 =====
析构键值 / 析构值 / 桶索引 / 链查找 / 释放内部数组 内部
(内部方法 × 5)
与 泛型映射 同款的编译器注入挂点与散列辅助(散列=FNV-1a 逐字节)。
集合<T>
值唯一的集合(对标 C++ std::set,哈希桶实现,平均 O(1) 添加/包含/删除):判等与散列同源=**元素槽字节**,删除=链摘除 + 末元素交换。判等边界:整数/布尔=值;结构体=槽字节全等(含 padding——未初始化 padding 参与判等,同字段值未必相等);集合<字符> 当前不支持;集合<枚举> v2 侧当前不支持(类型大小(枚举) 泛型实例内未知);字符串=句柄身份——驻留字面量可按同一字面量查询/删除(宿主与 v2 双侧一致:#1328 后 v2 字面量驻留直存·同文本同句柄),堆串(字符串复制)入容器为拥有化副本、原句柄不可反查(内容键请用 字符串映射<布尔>);浮点 ±0/NaN 按位模式(不等同于 ==:+0.0≠-0.0、仅同 bit NaN 相等;±0 同 Java Double.equals,NaN 比 Java 严格——Java 全部 NaN 相等)。构造零分配(首个元素添加时分配桶),深拷语义 + RAII。
集合.cnCN
导入 映射集合::集合;
函数 主() -> 整32 {
集合<整64> 去重池 = 集合<整64>();
结果<空类型, 整32> 加 = 去重池.添加(5);
加 = 去重池.添加(5); // 按位模式判等:不重复
加 = 去重池.添加(9);
打印(去重池.大小()); // 2
打印(去重池.包含(9)); // 真
打印(去重池.删除(5)); // 真
打印(去重池.包含(5)); // 假
返回 0;
}输出:2 真 真 假
集合()
函数 集合()
构造空集合(零分配·惰性桶:首个元素添加时分配 8 桶)。
主.cnCN
导入 映射集合::映射;
导入 映射集合::集合;
导入 映射集合::错误码;
函数 主() -> 整32 {
打印("===== 映射集合库(Task 6.4)=====");
// ==================== 1. 映射<K,V>(整32键 → 整32值) ====================
映射<整32, 整32> 表 = 映射<整32, 整32>();
如果 (表.为空()) {
打印("映射初始为空: 是");
} 否则 {
打印("映射初始为空: 否");
}
// 设置 3 对键值(触发扩容 0 -> 4)
结果<空类型, 整32> 设置结果 = 表.设置(1, 100);
如果 (设置结果.正常) {
设置结果 = 表.设置(2, 200);
设置结果 = 表.设置(3, 300);
} 否则 {
打印("映射设置失败: ", 设置结果.错误);
}
打印("映射大小: ", 表.大小());
// 包含(规格书 4.4 表.包含(键))
如果 (表.包含(2)) {
打印("包含键2: 真");
} 否则 {
打印("包含键2: 假");
}
如果 (表.包含(99)) {
打印("包含键99: 真");
} 否则 {
打印("包含键99: 假");
}
// 获取正确值(先存局部变量再打印,规避打印变参内嵌字段下标缺陷)
结果<整32, 整32> 获取结果 = 表.获取(1);
如果 (获取结果.正常) {
整32 值1 = 获取结果.值;
打印("获取键1: ", 值1);
} 否则 {
打印("获取键1失败: ", 获取结果.错误);
}
获取结果 = 表.获取(3);
如果 (获取结果.正常) {
整32 值3 = 获取结果.值;
打印("获取键3: ", 值3);
} 否则 {
打印("获取键3失败: ", 获取结果.错误);
}
// 覆盖已存在键 → 大小仍 3 且值更新
设置结果 = 表.设置(2, 222);
如果 (设置结果.正常) {
获取结果 = 表.获取(2);
如果 (获取结果.正常) {
整32 值2 = 获取结果.值;
打印("覆盖后键2: ", 值2);
} 否则 {
打印("覆盖后读键2失败: ", 获取结果.错误);
}
} 否则 {
打印("覆盖设置失败: ", 设置结果.错误);
}
打印("覆盖后大小: ", 表.大小());
// 获取不存在的键 → 错误码.未初始化(7)
获取结果 = 表.获取(99);
如果 (获取结果.正常) {
打印("获取键99未报错");
} 否则 {
打印("获取键99错误码: ", 获取结果.错误);
}
// 删除键 1 → 包含=假、大小-1
布尔 删除结果 = 表.删除(1);
如果 (删除结果) {
打印("删除键1: 真");
} 否则 {
打印("删除键1: 假");
}
如果 (表.包含(1)) {
打印("删除后包含键1: 真");
} 否则 {
打印("删除后包含键1: 假");
}
打印("删除后大小: ", 表.大小());
// 删除不存在的键 → 返回假
删除结果 = 表.删除(99);
如果 (删除结果) {
打印("删除键99: 真");
} 否则 {
打印("删除键99: 假");
}
// 清空
表.清空();
打印("清空后大小: ", 表.大小());
// ==================== 2. 集合<T>(整32) ====================
集合<整32> 值集 = 集合<整32>();
如果 (值集.为空()) {
打印("集合初始为空: 是");
} 否则 {
打印("集合初始为空: 否");
}
// 添加 1/2/3、再添加 2(幂等)→ 大小=3
设置结果 = 值集.添加(1);
如果 (设置结果.正常) {
设置结果 = 值集.添加(2);
设置结果 = 值集.添加(3);
设置结果 = 值集.添加(2);
} 否则 {
打印("集合添加失败: ", 设置结果.错误);
}
打印("集合大小: ", 值集.大小());
// 包含
如果 (值集.包含(2)) {
打印("集合包含2: 真");
} 否则 {
打印("集合包含2: 假");
}
如果 (值集.包含(99)) {
打印("集合包含99: 真");
} 否则 {
打印("集合包含99: 假");
}
// 删除 → 大小-1
删除结果 = 值集.删除(2);
如果 (删除结果) {
打印("集合删除2: 真");
} 否则 {
打印("集合删除2: 假");
}
打印("集合删除后大小: ", 值集.大小());
如果 (值集.包含(2)) {
打印("删除后包含2: 真");
} 否则 {
打印("删除后包含2: 假");
}
// 删除不存在的值 → 返回假
删除结果 = 值集.删除(99);
如果 (删除结果) {
打印("集合删除99: 真");
} 否则 {
打印("集合删除99: 假");
}
值集.清空();
打印("集合清空后大小: ", 值集.大小());
打印("===== 映射集合库测试完成 =====");
返回 0;
}输出:===== 映射集合库(Task 6.4)===== 映射初始为空: 是 映射大小: 3 包含键2: 真 包含键99: 假 获取键1: 100 获取键3: 300 覆盖后键2: 222 覆盖后大小: 3 获取键99错误码: 7 删除键1: 真 删除后包含键1: 假 删除后大小: 2 删除键99: 假 清空后大小: 0 集合初始为空: 是 集合大小: 3 集合包含2: 真 集合包含99: 假 集合删除2: 真 集合删除后大小: 2 删除后包含2: 假 集合删除99: 假 集合清空后大小: 0 ===== 映射集合库测试完成 =====
添加 不安全
不安全 函数 添加(T 值) -> 结果<空类型, 整32>
添加元素;已存在(按元素槽字节判等)则无事发生;不存在则追加(负载/容量不足时扩容)。堆字符串入容器为拥有化副本。
| 参数 | 类型 | 说明 |
|---|---|---|
值 | T | 要添加的值(判等=元素槽字节位模式,不要求 ==) |
返回 正常()(按判等口径幂等);扩容失败 → 错误(错误码.内存)。
主.cnCN
导入 容器::向量;
类 馆藏 {
私有:
向量<整64> 图书ID表;
整64 数量;
公开:
函数 馆藏() {
图书ID表 = 向量<整64>();
数量 = 0;
}
函数 添加(整64 ID) -> 结果<空类型, 整32> {
结果<空类型, 整32> 追加 = 图书ID表.追加(ID);
如果 (追加.正常) {
数量++;
}
返回 追加;
}
函数 读取(整64 位置) -> 整64 {
返回 图书ID表.元素(位置);
}
函数 大小() -> 整64 {
返回 数量;
}
}
函数 主() -> 整32 {
打印("===== 跨模块泛型类字段(A-4)=====");
馆藏 库 = 馆藏();
结果<空类型, 整32> 添加1 = 库.添加(101);
结果<空类型, 整32> 添加2 = 库.添加(202);
结果<空类型, 整32> 添加3 = 库.添加(303);
如果 (添加1.正常 && 添加2.正常 && 添加3.正常) {
打印("添加全部成功");
} 否则 {
打印("添加失败");
}
打印("数量: ", 库.大小());
打印("ID0: ", 库.读取(0));
打印("ID1: ", 库.读取(1));
打印("ID2: ", 库.读取(2));
打印("===== 泛型字段测试完成 =====");
返回 0;
}输出:===== 跨模块泛型类字段(A-4)===== 添加全部成功 数量: 3 ID0: 101 ID1: 202 ID2: 303 ===== 泛型字段测试完成 =====
包含 常量
常量 函数 包含(T 值) -> 布尔
值是否在集合中(按元素槽字节判等;堆字符串按句柄身份,原句柄通常不可反查)。
主.cnCN
导入 核心::内存;
导入 容器::向量;
导入 容器::链表;
导入 容器::队列;
导入 映射集合;
// 内存搅动:新分配覆盖「已释放内存」,使悬垂元素内容可观测损坏(探针 76-F 手法)
函数 搅动() -> 整64 {
整64 和 = 0;
整64 i = 0;
当 (i < 24) {
字符串 垃圾 = 字符串复制("搅动内存填充占位字符串内容甲乙丙丁戊己庚辛");
和 = 和 + 字符串长度(垃圾);
i++;
}
返回 和;
}
// ① 映射 删除(键):交换式删除(位置!=最后)——被删项值串释放 + 剩余元素完好
函数 形态一() -> 整64 {
整64 校验 = 0;
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设甲 = 表.设置(1, 字符串复制("形态一甲串内容甲乙丙丁戊己庚辛"));
如果 (!设甲.正常) { 返回 0; }
结果<空类型, 整32> 设乙 = 表.设置(2, 字符串复制("形态一乙串内容甲乙丙丁戊己庚辛"));
如果 (!设乙.正常) { 返回 0; }
整64 删前 = 内存::活动分配数();
布尔 删 = 表.删除(1);
整64 删后 = 内存::活动分配数();
如果 (删) { 校验 = 校验 + 1; }
如果 (!表.包含(1)) { 校验 = 校验 + 2; }
结果<字符串, 整32> 取 = 表.获取(2);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态一乙串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
如果 (表.大小() == 1) { 校验 = 校验 + 8; }
如果 (删后 == 删前 - 1) { 校验 = 校验 + 16; } // 被删值串随删除释放
}
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ② 映射 设置覆盖已有键:旧值串随覆盖释放(新值接管与旧值释放相抵)+ 内容=新值
函数 形态二() -> 整64 {
整64 校验 = 0;
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设旧 = 表.设置(2, 字符串复制("形态二旧串内容甲乙丙丁戊己庚辛"));
如果 (!设旧.正常) { 返回 0; }
整64 覆前 = 内存::活动分配数();
结果<空类型, 整32> 设新 = 表.设置(2, 字符串复制("形态二新串内容甲乙丙丁戊己庚辛"));
如果 (!设新.正常) { 返回 0; }
整64 覆后 = 内存::活动分配数();
如果 (覆后 == 覆前) { 校验 = 校验 + 1; }
结果<字符串, 整32> 取 = 表.获取(2);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态二新串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
} 否则 {
返回 0;
}
如果 (表.大小() == 1) { 校验 = 校验 + 4; }
}
整64 消耗 = 搅动();
返回 校验; // 期望 7
}
// ③ 映射 释放内部数组(H8-5 显式销毁路径):4 内部数组 + 值串一并释放
函数 形态三() -> 整64 {
整64 校验 = 0;
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设 = 表.设置(3, 字符串复制("形态三值串内容甲乙丙丁戊己庚辛"));
如果 (!设.正常) { 返回 0; }
整64 释前 = 内存::活动分配数();
表.释放内部数组();
整64 释后 = 内存::活动分配数();
如果 (释后 == 释前 - 5) { 校验 = 1; }
整64 消耗 = 搅动();
返回 校验; // 期望 1
}
// ④ 集合<T>:元素串随 析构/清空 释放
函数 形态四() -> 整64 {
整64 校验 = 0;
整64 析构前 = 内存::活动分配数();
如果 (1 == 1) {
集合<字符串> 集 = 集合<字符串>();
结果<空类型, 整32> 加 = 集.添加(字符串复制("形态四析构元素串内容甲乙丙丁"));
如果 (!加.正常) { 返回 0; }
如果 (集.大小() == 1) { 校验 = 校验 + 1; }
}
整64 析构后 = 内存::活动分配数();
如果 (析构后 == 析构前) { 校验 = 校验 + 2; } // 元素串 + 数据数组随析构释放
集合<字符串> 集二 = 集合<字符串>();
结果<空类型, 整32> 加二 = 集二.添加(字符串复制("形态四清空元素串内容甲乙丙"));
如果 (!加二.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
集二.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 1) { 校验 = 校验 + 4; } // 元素串随清空释放
整64 消耗 = 搅动();
返回 校验; // 期望 7
}
// ⑤ 向量 删除(位置) + 设置覆盖:被删/旧元素串释放 + 元素内容守恒
函数 形态五() -> 整64 {
整64 校验 = 0;
整64 删除前 = 内存::活动分配数();
如果 (1 == 1) {
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加甲 = 表.追加(字符串复制("形态五甲串内容甲乙丙丁戊己庚辛"));
如果 (!加甲.正常) { 返回 0; }
结果<空类型, 整32> 加乙 = 表.追加(字符串复制("形态五乙串内容甲乙丙丁戊己庚辛"));
如果 (!加乙.正常) { 返回 0; }
整64 删前 = 内存::活动分配数();
结果<空类型, 整32> 删 = 表.删除(0);
整64 删后 = 内存::活动分配数();
如果 (!删.正常) { 返回 0; }
如果 (删后 == 删前 - 1) { 校验 = 校验 + 1; }
字符串 元素 = 表.元素(0);
如果 (字符串比较(元素, "形态五乙串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
}
整64 删除后 = 内存::活动分配数();
如果 (删除后 == 删除前) { 校验 = 校验 + 4; }
向量<字符串> 表二 = 向量<字符串>();
结果<空类型, 整32> 加旧 = 表二.追加(字符串复制("形态五旧串内容甲乙丙丁戊己庚辛"));
如果 (!加旧.正常) { 返回 0; }
整64 覆前 = 内存::活动分配数();
结果<空类型, 整32> 设新 = 表二.设置(0, 字符串复制("形态五新串内容甲乙丙丁戊己庚辛"));
如果 (!设新.正常) { 返回 0; }
整64 覆后 = 内存::活动分配数();
如果 (覆后 == 覆前) { 校验 = 校验 + 8; } // 旧值释放 + 新值接管相抵
字符串 元素二 = 表二.元素(0);
如果 (字符串比较(元素二, "形态五新串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 16; }
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ⑥ 链表 删除头部/删除尾部/清空:被摘槽与清空元素串释放 + 链序守恒
函数 形态六() -> 整64 {
整64 校验 = 0;
链表<字符串> 表 = 链表<字符串>();
结果<空类型, 整32> 加甲 = 表.头部追加(字符串复制("形态六甲串内容甲乙丙丁戊己庚辛"));
如果 (!加甲.正常) { 返回 0; }
结果<空类型, 整32> 加乙 = 表.头部追加(字符串复制("形态六乙串内容甲乙丙丁戊己庚辛"));
如果 (!加乙.正常) { 返回 0; }
整64 删头前 = 内存::活动分配数();
结果<空类型, 整32> 删头 = 表.删除头部();
整64 删头后 = 内存::活动分配数();
如果 (!删头.正常) { 返回 0; }
如果 (删头后 == 删头前 - 1) { 校验 = 校验 + 1; }
如果 (表.大小() == 1) { 校验 = 校验 + 2; }
结果<字符串, 整32> 读 = 表.读取头部();
如果 (读.正常) {
如果 (字符串比较(读.值, "形态六甲串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
整64 删尾前 = 内存::活动分配数();
结果<空类型, 整32> 删尾 = 表.删除尾部();
整64 删尾后 = 内存::活动分配数();
如果 (!删尾.正常) { 返回 0; }
如果 (删尾后 == 删尾前 - 1) { 校验 = 校验 + 8; }
结果<空类型, 整32> 加丙 = 表.头部追加(字符串复制("形态六丙串内容甲乙丙丁戊己庚辛"));
如果 (!加丙.正常) { 返回 0; }
结果<空类型, 整32> 加丁 = 表.头部追加(字符串复制("形态六丁串内容甲乙丙丁戊己庚辛"));
如果 (!加丁.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
表.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 2) { 校验 = 校验 + 16; } // 清空元素串随清空释放(按链游)
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ⑦ 队列 清空:元素串随清空释放(按链游)
函数 形态七() -> 整64 {
整64 校验 = 0;
队列<字符串> 表 = 队列<字符串>();
结果<空类型, 整32> 入甲 = 表.入队(字符串复制("形态七甲串内容甲乙丙丁戊己庚辛"));
如果 (!入甲.正常) { 返回 0; }
结果<空类型, 整32> 入乙 = 表.入队(字符串复制("形态七乙串内容甲乙丙丁戊己庚辛"));
如果 (!入乙.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
表.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 2) { 校验 = 1; }
整64 消耗 = 搅动();
返回 校验; // 期望 1
}
// ⑧ 借用来源入映射(UAF 防护)+ 局部标识符入映射(值语义深拷贝)
函数 存入映射(映射<整64, 字符串> 表, 字符串 形参) -> 空类型 {
结果<空类型, 整32> 设 = 表.设置(1, 形参);
如果 (!设.正常) { 运行时错误(4); }
}
函数 形态八() -> 整64 {
整64 校验 = 0;
字符串 本地 = 字符串复制("形态八本地串内容甲乙丙丁戊己庚辛");
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
存入映射(表, 本地);
结果<字符串, 整32> 取 = 表.获取(1);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态八本地串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 1; }
} 否则 {
返回 0;
}
}
整64 消耗 = 搅动(); // 容器析构后搅动:若容器释放了本地串 → 内容损坏
如果 (字符串比较(本地, "形态八本地串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
如果 (1 == 1) {
映射<整64, 字符串> 表二 = 映射<整64, 字符串>();
字符串 源 = 字符串复制("形态八深拷贝串内容甲乙丙丁戊己庚辛");
结果<空类型, 整32> 设二 = 表二.设置(2, 源);
如果 (!设二.正常) { 返回 0; }
结果<字符串, 整32> 取二 = 表二.获取(2);
如果 (取二.正常) {
如果 (字符串比较(取二.值, "形态八深拷贝串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
}
整64 消耗二 = 搅动(); // 源已随块出口释放:若容器浅存句柄 → 元素悬垂损坏
返回 校验; // 期望 7
}
函数 主() -> 整32 {
整64 校验和 = 0;
如果 (形态一() == 31) { 校验和 = 校验和 + 1; }
如果 (形态二() == 7) { 校验和 = 校验和 + 2; }
如果 (形态三() == 1) { 校验和 = 校验和 + 4; }
如果 (形态四() == 7) { 校验和 = 校验和 + 8; }
如果 (形态五() == 31) { 校验和 = 校验和 + 16; }
如果 (形态六() == 31) { 校验和 = 校验和 + 32; }
如果 (形态七() == 1) { 校验和 = 校验和 + 64; }
如果 (形态八() == 7) { 校验和 = 校验和 + 128; }
返回 整32(校验和); // 期望 255(八形态全对)
}输出:[p6h] 已解析: target/audit2/v2src211/主.cn
删除 不安全
不安全 函数 删除(T 值) -> 布尔
按元素槽字节判等删除(哈希链摘除 + 末元素交换;字符串/含串结构体正确释放)。存在返回真。
| 参数 | 类型 | 说明 |
|---|---|---|
值 | T | 要删除的值(判等=元素槽字节位模式) |
返回 删除成功真;不存在假。
主.cnCN
导入 核心::内存;
导入 容器::向量;
导入 容器::链表;
导入 容器::队列;
导入 映射集合;
导入 IO::打印;
// 内存搅动:新分配覆盖「已释放内存」,使悬垂元素内容可观测损坏(探针 76-F 手法)
函数 搅动() -> 整64 {
整64 和 = 0;
整64 i = 0;
当 (i < 24) {
字符串 垃圾 = 字符串复制("搅动内存填充占位字符串内容甲乙丙丁戊己庚辛");
和 = 和 + 字符串长度(垃圾);
i++;
}
返回 和;
}
// ① 映射 删除(键):交换式删除(位置!=最后)——被删项值串释放 + 剩余元素完好
函数 形态一() -> 整64 {
整64 校验 = 0;
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设甲 = 表.设置(1, 字符串复制("形态一甲串内容甲乙丙丁戊己庚辛"));
如果 (!设甲.正常) { 返回 0; }
结果<空类型, 整32> 设乙 = 表.设置(2, 字符串复制("形态一乙串内容甲乙丙丁戊己庚辛"));
如果 (!设乙.正常) { 返回 0; }
整64 删前 = 内存::活动分配数();
布尔 删 = 表.删除(1);
整64 删后 = 内存::活动分配数();
如果 (删) { 校验 = 校验 + 1; }
如果 (!表.包含(1)) { 校验 = 校验 + 2; }
结果<字符串, 整32> 取 = 表.获取(2);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态一乙串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
如果 (表.大小() == 1) { 校验 = 校验 + 8; }
如果 (删后 == 删前 - 1) { 校验 = 校验 + 16; } // 被删值串随删除释放
}
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ② 映射 设置覆盖已有键:旧值串随覆盖释放(新值接管与旧值释放相抵)+ 内容=新值
函数 形态二() -> 整64 {
整64 校验 = 0;
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设旧 = 表.设置(2, 字符串复制("形态二旧串内容甲乙丙丁戊己庚辛"));
如果 (!设旧.正常) { 返回 0; }
整64 覆前 = 内存::活动分配数();
结果<空类型, 整32> 设新 = 表.设置(2, 字符串复制("形态二新串内容甲乙丙丁戊己庚辛"));
如果 (!设新.正常) { 返回 0; }
整64 覆后 = 内存::活动分配数();
如果 (覆后 == 覆前) { 校验 = 校验 + 1; }
结果<字符串, 整32> 取 = 表.获取(2);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态二新串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
} 否则 {
返回 0;
}
如果 (表.大小() == 1) { 校验 = 校验 + 4; }
}
整64 消耗 = 搅动();
返回 校验; // 期望 7
}
// ③ 映射 释放内部数组(H8-5 显式销毁路径):4 内部数组 + 值串一并释放
函数 形态三() -> 整64 {
整64 校验 = 0;
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设 = 表.设置(3, 字符串复制("形态三值串内容甲乙丙丁戊己庚辛"));
如果 (!设.正常) { 返回 0; }
整64 释前 = 内存::活动分配数();
表.释放内部数组();
整64 释后 = 内存::活动分配数();
如果 (释后 == 释前 - 5) { 校验 = 1; }
整64 消耗 = 搅动();
返回 校验; // 期望 1
}
// ④ 集合<T>:元素串随 析构/清空 释放
函数 形态四() -> 整64 {
整64 校验 = 0;
整64 析构前 = 内存::活动分配数();
如果 (1 == 1) {
集合<字符串> 集 = 集合<字符串>();
结果<空类型, 整32> 加 = 集.添加(字符串复制("形态四析构元素串内容甲乙丙丁"));
如果 (!加.正常) { 返回 0; }
如果 (集.大小() == 1) { 校验 = 校验 + 1; }
}
整64 析构后 = 内存::活动分配数();
如果 (析构后 == 析构前) { 校验 = 校验 + 2; } // 元素串 + 数据数组随析构释放
集合<字符串> 集二 = 集合<字符串>();
结果<空类型, 整32> 加二 = 集二.添加(字符串复制("形态四清空元素串内容甲乙丙"));
如果 (!加二.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
集二.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 1) { 校验 = 校验 + 4; } // 元素串随清空释放
整64 消耗 = 搅动();
返回 校验; // 期望 7
}
// ⑤ 向量 删除(位置) + 设置覆盖:被删/旧元素串释放 + 元素内容守恒
函数 形态五() -> 整64 {
整64 校验 = 0;
整64 删除前 = 内存::活动分配数();
如果 (1 == 1) {
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加甲 = 表.追加(字符串复制("形态五甲串内容甲乙丙丁戊己庚辛"));
如果 (!加甲.正常) { 返回 0; }
结果<空类型, 整32> 加乙 = 表.追加(字符串复制("形态五乙串内容甲乙丙丁戊己庚辛"));
如果 (!加乙.正常) { 返回 0; }
整64 删前 = 内存::活动分配数();
结果<空类型, 整32> 删 = 表.删除(0);
整64 删后 = 内存::活动分配数();
如果 (!删.正常) { 返回 0; }
如果 (删后 == 删前 - 1) { 校验 = 校验 + 1; }
字符串 元素 = 表.元素(0);
如果 (字符串比较(元素, "形态五乙串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
}
整64 删除后 = 内存::活动分配数();
如果 (删除后 == 删除前) { 校验 = 校验 + 4; }
向量<字符串> 表二 = 向量<字符串>();
结果<空类型, 整32> 加旧 = 表二.追加(字符串复制("形态五旧串内容甲乙丙丁戊己庚辛"));
如果 (!加旧.正常) { 返回 0; }
整64 覆前 = 内存::活动分配数();
结果<空类型, 整32> 设新 = 表二.设置(0, 字符串复制("形态五新串内容甲乙丙丁戊己庚辛"));
如果 (!设新.正常) { 返回 0; }
整64 覆后 = 内存::活动分配数();
如果 (覆后 == 覆前) { 校验 = 校验 + 8; } // 旧值释放 + 新值接管相抵
字符串 元素二 = 表二.元素(0);
如果 (字符串比较(元素二, "形态五新串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 16; }
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ⑥ 链表 删除头部/删除尾部/清空:被摘槽与清空元素串释放 + 链序守恒
函数 形态六() -> 整64 {
整64 校验 = 0;
链表<字符串> 表 = 链表<字符串>();
结果<空类型, 整32> 加甲 = 表.头部追加(字符串复制("形态六甲串内容甲乙丙丁戊己庚辛"));
如果 (!加甲.正常) { 返回 0; }
结果<空类型, 整32> 加乙 = 表.头部追加(字符串复制("形态六乙串内容甲乙丙丁戊己庚辛"));
如果 (!加乙.正常) { 返回 0; }
整64 删头前 = 内存::活动分配数();
结果<空类型, 整32> 删头 = 表.删除头部();
整64 删头后 = 内存::活动分配数();
如果 (!删头.正常) { 返回 0; }
如果 (删头后 == 删头前 - 1) { 校验 = 校验 + 1; }
如果 (表.大小() == 1) { 校验 = 校验 + 2; }
结果<字符串, 整32> 读 = 表.读取头部();
如果 (读.正常) {
如果 (字符串比较(读.值, "形态六甲串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
整64 删尾前 = 内存::活动分配数();
结果<空类型, 整32> 删尾 = 表.删除尾部();
整64 删尾后 = 内存::活动分配数();
如果 (!删尾.正常) { 返回 0; }
如果 (删尾后 == 删尾前 - 1) { 校验 = 校验 + 8; }
结果<空类型, 整32> 加丙 = 表.头部追加(字符串复制("形态六丙串内容甲乙丙丁戊己庚辛"));
如果 (!加丙.正常) { 返回 0; }
结果<空类型, 整32> 加丁 = 表.头部追加(字符串复制("形态六丁串内容甲乙丙丁戊己庚辛"));
如果 (!加丁.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
表.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 2) { 校验 = 校验 + 16; } // 清空元素串随清空释放(按链游)
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ⑦ 队列 清空:元素串随清空释放(按链游)
函数 形态七() -> 整64 {
整64 校验 = 0;
队列<字符串> 表 = 队列<字符串>();
结果<空类型, 整32> 入甲 = 表.入队(字符串复制("形态七甲串内容甲乙丙丁戊己庚辛"));
如果 (!入甲.正常) { 返回 0; }
结果<空类型, 整32> 入乙 = 表.入队(字符串复制("形态七乙串内容甲乙丙丁戊己庚辛"));
如果 (!入乙.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
表.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 2) { 校验 = 1; }
整64 消耗 = 搅动();
返回 校验; // 期望 1
}
// ⑧ 借用来源入映射(UAF 防护)+ 局部标识符入映射(值语义深拷贝)
函数 存入映射(映射<整64, 字符串> 表, 字符串 形参) -> 空类型 {
结果<空类型, 整32> 设 = 表.设置(1, 形参);
如果 (!设.正常) { 运行时错误(4); }
}
函数 形态八() -> 整64 {
整64 校验 = 0;
字符串 本地 = 字符串复制("形态八本地串内容甲乙丙丁戊己庚辛");
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
存入映射(表, 本地);
结果<字符串, 整32> 取 = 表.获取(1);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态八本地串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 1; }
} 否则 {
返回 0;
}
}
整64 消耗 = 搅动(); // 容器析构后搅动:若容器释放了本地串 → 内容损坏
如果 (字符串比较(本地, "形态八本地串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
如果 (1 == 1) {
映射<整64, 字符串> 表二 = 映射<整64, 字符串>();
字符串 源 = 字符串复制("形态八深拷贝串内容甲乙丙丁戊己庚辛");
结果<空类型, 整32> 设二 = 表二.设置(2, 源);
如果 (!设二.正常) { 返回 0; }
结果<字符串, 整32> 取二 = 表二.获取(2);
如果 (取二.正常) {
如果 (字符串比较(取二.值, "形态八深拷贝串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
}
整64 消耗二 = 搅动(); // 源已随块出口释放:若容器浅存句柄 → 元素悬垂损坏
返回 校验; // 期望 7
}
函数 主() -> 整32 {
整64 校验和 = 0;
如果 (形态一() == 31) { 校验和 = 校验和 + 1; }
如果 (形态二() == 7) { 校验和 = 校验和 + 2; }
如果 (形态三() == 1) { 校验和 = 校验和 + 4; }
如果 (形态四() == 7) { 校验和 = 校验和 + 8; }
如果 (形态五() == 31) { 校验和 = 校验和 + 16; }
如果 (形态六() == 31) { 校验和 = 校验和 + 32; }
如果 (形态七() == 1) { 校验和 = 校验和 + 64; }
如果 (形态八() == 7) { 校验和 = 校验和 + 128; }
打印("校验和(期望255)=", 校验和);
返回 0;
}输出:校验和(期望255)=255
大小 常量
常量 函数 大小() -> 整64
元素个数(值唯一)。
主.cnCN
导入 映射集合::映射;
导入 映射集合::集合;
导入 映射集合::错误码;
函数 主() -> 整32 {
打印("===== 映射集合库(Task 6.4)=====");
// ==================== 1. 映射<K,V>(整32键 → 整32值) ====================
映射<整32, 整32> 表 = 映射<整32, 整32>();
如果 (表.为空()) {
打印("映射初始为空: 是");
} 否则 {
打印("映射初始为空: 否");
}
// 设置 3 对键值(触发扩容 0 -> 4)
结果<空类型, 整32> 设置结果 = 表.设置(1, 100);
如果 (设置结果.正常) {
设置结果 = 表.设置(2, 200);
设置结果 = 表.设置(3, 300);
} 否则 {
打印("映射设置失败: ", 设置结果.错误);
}
打印("映射大小: ", 表.大小());
// 包含(规格书 4.4 表.包含(键))
如果 (表.包含(2)) {
打印("包含键2: 真");
} 否则 {
打印("包含键2: 假");
}
如果 (表.包含(99)) {
打印("包含键99: 真");
} 否则 {
打印("包含键99: 假");
}
// 获取正确值(先存局部变量再打印,规避打印变参内嵌字段下标缺陷)
结果<整32, 整32> 获取结果 = 表.获取(1);
如果 (获取结果.正常) {
整32 值1 = 获取结果.值;
打印("获取键1: ", 值1);
} 否则 {
打印("获取键1失败: ", 获取结果.错误);
}
获取结果 = 表.获取(3);
如果 (获取结果.正常) {
整32 值3 = 获取结果.值;
打印("获取键3: ", 值3);
} 否则 {
打印("获取键3失败: ", 获取结果.错误);
}
// 覆盖已存在键 → 大小仍 3 且值更新
设置结果 = 表.设置(2, 222);
如果 (设置结果.正常) {
获取结果 = 表.获取(2);
如果 (获取结果.正常) {
整32 值2 = 获取结果.值;
打印("覆盖后键2: ", 值2);
} 否则 {
打印("覆盖后读键2失败: ", 获取结果.错误);
}
} 否则 {
打印("覆盖设置失败: ", 设置结果.错误);
}
打印("覆盖后大小: ", 表.大小());
// 获取不存在的键 → 错误码.未初始化(7)
获取结果 = 表.获取(99);
如果 (获取结果.正常) {
打印("获取键99未报错");
} 否则 {
打印("获取键99错误码: ", 获取结果.错误);
}
// 删除键 1 → 包含=假、大小-1
布尔 删除结果 = 表.删除(1);
如果 (删除结果) {
打印("删除键1: 真");
} 否则 {
打印("删除键1: 假");
}
如果 (表.包含(1)) {
打印("删除后包含键1: 真");
} 否则 {
打印("删除后包含键1: 假");
}
打印("删除后大小: ", 表.大小());
// 删除不存在的键 → 返回假
删除结果 = 表.删除(99);
如果 (删除结果) {
打印("删除键99: 真");
} 否则 {
打印("删除键99: 假");
}
// 清空
表.清空();
打印("清空后大小: ", 表.大小());
// ==================== 2. 集合<T>(整32) ====================
集合<整32> 值集 = 集合<整32>();
如果 (值集.为空()) {
打印("集合初始为空: 是");
} 否则 {
打印("集合初始为空: 否");
}
// 添加 1/2/3、再添加 2(幂等)→ 大小=3
设置结果 = 值集.添加(1);
如果 (设置结果.正常) {
设置结果 = 值集.添加(2);
设置结果 = 值集.添加(3);
设置结果 = 值集.添加(2);
} 否则 {
打印("集合添加失败: ", 设置结果.错误);
}
打印("集合大小: ", 值集.大小());
// 包含
如果 (值集.包含(2)) {
打印("集合包含2: 真");
} 否则 {
打印("集合包含2: 假");
}
如果 (值集.包含(99)) {
打印("集合包含99: 真");
} 否则 {
打印("集合包含99: 假");
}
// 删除 → 大小-1
删除结果 = 值集.删除(2);
如果 (删除结果) {
打印("集合删除2: 真");
} 否则 {
打印("集合删除2: 假");
}
打印("集合删除后大小: ", 值集.大小());
如果 (值集.包含(2)) {
打印("删除后包含2: 真");
} 否则 {
打印("删除后包含2: 假");
}
// 删除不存在的值 → 返回假
删除结果 = 值集.删除(99);
如果 (删除结果) {
打印("集合删除99: 真");
} 否则 {
打印("集合删除99: 假");
}
值集.清空();
打印("集合清空后大小: ", 值集.大小());
打印("===== 映射集合库测试完成 =====");
返回 0;
}输出:===== 映射集合库(Task 6.4)===== 映射初始为空: 是 映射大小: 3 包含键2: 真 包含键99: 假 获取键1: 100 获取键3: 300 覆盖后键2: 222 覆盖后大小: 3 获取键99错误码: 7 删除键1: 真 删除后包含键1: 假 删除后大小: 2 删除键99: 假 清空后大小: 0 集合初始为空: 是 集合大小: 3 集合包含2: 真 集合包含99: 假 集合删除2: 真 集合删除后大小: 2 删除后包含2: 假 集合删除99: 假 集合清空后大小: 0 ===== 映射集合库测试完成 =====
为空 常量
常量 函数 为空() -> 布尔
是否为空集合。
主.cnCN
导入 映射集合::映射;
导入 映射集合::集合;
导入 映射集合::错误码;
函数 主() -> 整32 {
打印("===== 映射集合库(Task 6.4)=====");
// ==================== 1. 映射<K,V>(整32键 → 整32值) ====================
映射<整32, 整32> 表 = 映射<整32, 整32>();
如果 (表.为空()) {
打印("映射初始为空: 是");
} 否则 {
打印("映射初始为空: 否");
}
// 设置 3 对键值(触发扩容 0 -> 4)
结果<空类型, 整32> 设置结果 = 表.设置(1, 100);
如果 (设置结果.正常) {
设置结果 = 表.设置(2, 200);
设置结果 = 表.设置(3, 300);
} 否则 {
打印("映射设置失败: ", 设置结果.错误);
}
打印("映射大小: ", 表.大小());
// 包含(规格书 4.4 表.包含(键))
如果 (表.包含(2)) {
打印("包含键2: 真");
} 否则 {
打印("包含键2: 假");
}
如果 (表.包含(99)) {
打印("包含键99: 真");
} 否则 {
打印("包含键99: 假");
}
// 获取正确值(先存局部变量再打印,规避打印变参内嵌字段下标缺陷)
结果<整32, 整32> 获取结果 = 表.获取(1);
如果 (获取结果.正常) {
整32 值1 = 获取结果.值;
打印("获取键1: ", 值1);
} 否则 {
打印("获取键1失败: ", 获取结果.错误);
}
获取结果 = 表.获取(3);
如果 (获取结果.正常) {
整32 值3 = 获取结果.值;
打印("获取键3: ", 值3);
} 否则 {
打印("获取键3失败: ", 获取结果.错误);
}
// 覆盖已存在键 → 大小仍 3 且值更新
设置结果 = 表.设置(2, 222);
如果 (设置结果.正常) {
获取结果 = 表.获取(2);
如果 (获取结果.正常) {
整32 值2 = 获取结果.值;
打印("覆盖后键2: ", 值2);
} 否则 {
打印("覆盖后读键2失败: ", 获取结果.错误);
}
} 否则 {
打印("覆盖设置失败: ", 设置结果.错误);
}
打印("覆盖后大小: ", 表.大小());
// 获取不存在的键 → 错误码.未初始化(7)
获取结果 = 表.获取(99);
如果 (获取结果.正常) {
打印("获取键99未报错");
} 否则 {
打印("获取键99错误码: ", 获取结果.错误);
}
// 删除键 1 → 包含=假、大小-1
布尔 删除结果 = 表.删除(1);
如果 (删除结果) {
打印("删除键1: 真");
} 否则 {
打印("删除键1: 假");
}
如果 (表.包含(1)) {
打印("删除后包含键1: 真");
} 否则 {
打印("删除后包含键1: 假");
}
打印("删除后大小: ", 表.大小());
// 删除不存在的键 → 返回假
删除结果 = 表.删除(99);
如果 (删除结果) {
打印("删除键99: 真");
} 否则 {
打印("删除键99: 假");
}
// 清空
表.清空();
打印("清空后大小: ", 表.大小());
// ==================== 2. 集合<T>(整32) ====================
集合<整32> 值集 = 集合<整32>();
如果 (值集.为空()) {
打印("集合初始为空: 是");
} 否则 {
打印("集合初始为空: 否");
}
// 添加 1/2/3、再添加 2(幂等)→ 大小=3
设置结果 = 值集.添加(1);
如果 (设置结果.正常) {
设置结果 = 值集.添加(2);
设置结果 = 值集.添加(3);
设置结果 = 值集.添加(2);
} 否则 {
打印("集合添加失败: ", 设置结果.错误);
}
打印("集合大小: ", 值集.大小());
// 包含
如果 (值集.包含(2)) {
打印("集合包含2: 真");
} 否则 {
打印("集合包含2: 假");
}
如果 (值集.包含(99)) {
打印("集合包含99: 真");
} 否则 {
打印("集合包含99: 假");
}
// 删除 → 大小-1
删除结果 = 值集.删除(2);
如果 (删除结果) {
打印("集合删除2: 真");
} 否则 {
打印("集合删除2: 假");
}
打印("集合删除后大小: ", 值集.大小());
如果 (值集.包含(2)) {
打印("删除后包含2: 真");
} 否则 {
打印("删除后包含2: 假");
}
// 删除不存在的值 → 返回假
删除结果 = 值集.删除(99);
如果 (删除结果) {
打印("集合删除99: 真");
} 否则 {
打印("集合删除99: 假");
}
值集.清空();
打印("集合清空后大小: ", 值集.大小());
打印("===== 映射集合库测试完成 =====");
返回 0;
}输出:===== 映射集合库(Task 6.4)===== 映射初始为空: 是 映射大小: 3 包含键2: 真 包含键99: 假 获取键1: 100 获取键3: 300 覆盖后键2: 222 覆盖后大小: 3 获取键99错误码: 7 删除键1: 真 删除后包含键1: 假 删除后大小: 2 删除键99: 假 清空后大小: 0 集合初始为空: 是 集合大小: 3 集合包含2: 真 集合包含99: 假 集合删除2: 真 集合删除后大小: 2 删除后包含2: 假 集合删除99: 假 集合清空后大小: 0 ===== 映射集合库测试完成 =====
清空 不安全
不安全 函数 清空()
元素数清零(容量保留)。
主.cnCN
导入 核心::内存;
导入 容器::向量;
导入 容器::链表;
导入 容器::队列;
导入 映射集合;
导入 IO::打印;
// 内存搅动:新分配覆盖「已释放内存」,使悬垂元素内容可观测损坏(探针 76-F 手法)
函数 搅动() -> 整64 {
整64 和 = 0;
整64 i = 0;
当 (i < 24) {
字符串 垃圾 = 字符串复制("搅动内存填充占位字符串内容甲乙丙丁戊己庚辛");
和 = 和 + 字符串长度(垃圾);
i++;
}
返回 和;
}
// ① 映射 删除(键):交换式删除(位置!=最后)——被删项值串释放 + 剩余元素完好
函数 形态一() -> 整64 {
整64 校验 = 0;
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设甲 = 表.设置(1, 字符串复制("形态一甲串内容甲乙丙丁戊己庚辛"));
如果 (!设甲.正常) { 返回 0; }
结果<空类型, 整32> 设乙 = 表.设置(2, 字符串复制("形态一乙串内容甲乙丙丁戊己庚辛"));
如果 (!设乙.正常) { 返回 0; }
整64 删前 = 内存::活动分配数();
布尔 删 = 表.删除(1);
整64 删后 = 内存::活动分配数();
如果 (删) { 校验 = 校验 + 1; }
如果 (!表.包含(1)) { 校验 = 校验 + 2; }
结果<字符串, 整32> 取 = 表.获取(2);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态一乙串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
如果 (表.大小() == 1) { 校验 = 校验 + 8; }
如果 (删后 == 删前 - 1) { 校验 = 校验 + 16; } // 被删值串随删除释放
}
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ② 映射 设置覆盖已有键:旧值串随覆盖释放(新值接管与旧值释放相抵)+ 内容=新值
函数 形态二() -> 整64 {
整64 校验 = 0;
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设旧 = 表.设置(2, 字符串复制("形态二旧串内容甲乙丙丁戊己庚辛"));
如果 (!设旧.正常) { 返回 0; }
整64 覆前 = 内存::活动分配数();
结果<空类型, 整32> 设新 = 表.设置(2, 字符串复制("形态二新串内容甲乙丙丁戊己庚辛"));
如果 (!设新.正常) { 返回 0; }
整64 覆后 = 内存::活动分配数();
如果 (覆后 == 覆前) { 校验 = 校验 + 1; }
结果<字符串, 整32> 取 = 表.获取(2);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态二新串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
} 否则 {
返回 0;
}
如果 (表.大小() == 1) { 校验 = 校验 + 4; }
}
整64 消耗 = 搅动();
返回 校验; // 期望 7
}
// ③ 映射 释放内部数组(H8-5 显式销毁路径):4 内部数组 + 值串一并释放
函数 形态三() -> 整64 {
整64 校验 = 0;
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
结果<空类型, 整32> 设 = 表.设置(3, 字符串复制("形态三值串内容甲乙丙丁戊己庚辛"));
如果 (!设.正常) { 返回 0; }
整64 释前 = 内存::活动分配数();
表.释放内部数组();
整64 释后 = 内存::活动分配数();
如果 (释后 == 释前 - 5) { 校验 = 1; }
整64 消耗 = 搅动();
返回 校验; // 期望 1
}
// ④ 集合<T>:元素串随 析构/清空 释放
函数 形态四() -> 整64 {
整64 校验 = 0;
整64 析构前 = 内存::活动分配数();
如果 (1 == 1) {
集合<字符串> 集 = 集合<字符串>();
结果<空类型, 整32> 加 = 集.添加(字符串复制("形态四析构元素串内容甲乙丙丁"));
如果 (!加.正常) { 返回 0; }
如果 (集.大小() == 1) { 校验 = 校验 + 1; }
}
整64 析构后 = 内存::活动分配数();
如果 (析构后 == 析构前) { 校验 = 校验 + 2; } // 元素串 + 数据数组随析构释放
集合<字符串> 集二 = 集合<字符串>();
结果<空类型, 整32> 加二 = 集二.添加(字符串复制("形态四清空元素串内容甲乙丙"));
如果 (!加二.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
集二.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 1) { 校验 = 校验 + 4; } // 元素串随清空释放
整64 消耗 = 搅动();
返回 校验; // 期望 7
}
// ⑤ 向量 删除(位置) + 设置覆盖:被删/旧元素串释放 + 元素内容守恒
函数 形态五() -> 整64 {
整64 校验 = 0;
整64 删除前 = 内存::活动分配数();
如果 (1 == 1) {
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加甲 = 表.追加(字符串复制("形态五甲串内容甲乙丙丁戊己庚辛"));
如果 (!加甲.正常) { 返回 0; }
结果<空类型, 整32> 加乙 = 表.追加(字符串复制("形态五乙串内容甲乙丙丁戊己庚辛"));
如果 (!加乙.正常) { 返回 0; }
整64 删前 = 内存::活动分配数();
结果<空类型, 整32> 删 = 表.删除(0);
整64 删后 = 内存::活动分配数();
如果 (!删.正常) { 返回 0; }
如果 (删后 == 删前 - 1) { 校验 = 校验 + 1; }
字符串 元素 = 表.元素(0);
如果 (字符串比较(元素, "形态五乙串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
}
整64 删除后 = 内存::活动分配数();
如果 (删除后 == 删除前) { 校验 = 校验 + 4; }
向量<字符串> 表二 = 向量<字符串>();
结果<空类型, 整32> 加旧 = 表二.追加(字符串复制("形态五旧串内容甲乙丙丁戊己庚辛"));
如果 (!加旧.正常) { 返回 0; }
整64 覆前 = 内存::活动分配数();
结果<空类型, 整32> 设新 = 表二.设置(0, 字符串复制("形态五新串内容甲乙丙丁戊己庚辛"));
如果 (!设新.正常) { 返回 0; }
整64 覆后 = 内存::活动分配数();
如果 (覆后 == 覆前) { 校验 = 校验 + 8; } // 旧值释放 + 新值接管相抵
字符串 元素二 = 表二.元素(0);
如果 (字符串比较(元素二, "形态五新串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 16; }
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ⑥ 链表 删除头部/删除尾部/清空:被摘槽与清空元素串释放 + 链序守恒
函数 形态六() -> 整64 {
整64 校验 = 0;
链表<字符串> 表 = 链表<字符串>();
结果<空类型, 整32> 加甲 = 表.头部追加(字符串复制("形态六甲串内容甲乙丙丁戊己庚辛"));
如果 (!加甲.正常) { 返回 0; }
结果<空类型, 整32> 加乙 = 表.头部追加(字符串复制("形态六乙串内容甲乙丙丁戊己庚辛"));
如果 (!加乙.正常) { 返回 0; }
整64 删头前 = 内存::活动分配数();
结果<空类型, 整32> 删头 = 表.删除头部();
整64 删头后 = 内存::活动分配数();
如果 (!删头.正常) { 返回 0; }
如果 (删头后 == 删头前 - 1) { 校验 = 校验 + 1; }
如果 (表.大小() == 1) { 校验 = 校验 + 2; }
结果<字符串, 整32> 读 = 表.读取头部();
如果 (读.正常) {
如果 (字符串比较(读.值, "形态六甲串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
整64 删尾前 = 内存::活动分配数();
结果<空类型, 整32> 删尾 = 表.删除尾部();
整64 删尾后 = 内存::活动分配数();
如果 (!删尾.正常) { 返回 0; }
如果 (删尾后 == 删尾前 - 1) { 校验 = 校验 + 8; }
结果<空类型, 整32> 加丙 = 表.头部追加(字符串复制("形态六丙串内容甲乙丙丁戊己庚辛"));
如果 (!加丙.正常) { 返回 0; }
结果<空类型, 整32> 加丁 = 表.头部追加(字符串复制("形态六丁串内容甲乙丙丁戊己庚辛"));
如果 (!加丁.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
表.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 2) { 校验 = 校验 + 16; } // 清空元素串随清空释放(按链游)
整64 消耗 = 搅动();
返回 校验; // 期望 31
}
// ⑦ 队列 清空:元素串随清空释放(按链游)
函数 形态七() -> 整64 {
整64 校验 = 0;
队列<字符串> 表 = 队列<字符串>();
结果<空类型, 整32> 入甲 = 表.入队(字符串复制("形态七甲串内容甲乙丙丁戊己庚辛"));
如果 (!入甲.正常) { 返回 0; }
结果<空类型, 整32> 入乙 = 表.入队(字符串复制("形态七乙串内容甲乙丙丁戊己庚辛"));
如果 (!入乙.正常) { 返回 0; }
整64 清前 = 内存::活动分配数();
表.清空();
整64 清后 = 内存::活动分配数();
如果 (清后 == 清前 - 2) { 校验 = 1; }
整64 消耗 = 搅动();
返回 校验; // 期望 1
}
// ⑧ 借用来源入映射(UAF 防护)+ 局部标识符入映射(值语义深拷贝)
函数 存入映射(映射<整64, 字符串> 表, 字符串 形参) -> 空类型 {
结果<空类型, 整32> 设 = 表.设置(1, 形参);
如果 (!设.正常) { 运行时错误(4); }
}
函数 形态八() -> 整64 {
整64 校验 = 0;
字符串 本地 = 字符串复制("形态八本地串内容甲乙丙丁戊己庚辛");
如果 (1 == 1) {
映射<整64, 字符串> 表 = 映射<整64, 字符串>();
存入映射(表, 本地);
结果<字符串, 整32> 取 = 表.获取(1);
如果 (取.正常) {
如果 (字符串比较(取.值, "形态八本地串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 1; }
} 否则 {
返回 0;
}
}
整64 消耗 = 搅动(); // 容器析构后搅动:若容器释放了本地串 → 内容损坏
如果 (字符串比较(本地, "形态八本地串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 2; }
如果 (1 == 1) {
映射<整64, 字符串> 表二 = 映射<整64, 字符串>();
字符串 源 = 字符串复制("形态八深拷贝串内容甲乙丙丁戊己庚辛");
结果<空类型, 整32> 设二 = 表二.设置(2, 源);
如果 (!设二.正常) { 返回 0; }
结果<字符串, 整32> 取二 = 表二.获取(2);
如果 (取二.正常) {
如果 (字符串比较(取二.值, "形态八深拷贝串内容甲乙丙丁戊己庚辛")) { 校验 = 校验 + 4; }
} 否则 {
返回 0;
}
}
整64 消耗二 = 搅动(); // 源已随块出口释放:若容器浅存句柄 → 元素悬垂损坏
返回 校验; // 期望 7
}
函数 主() -> 整32 {
整64 校验和 = 0;
如果 (形态一() == 31) { 校验和 = 校验和 + 1; }
如果 (形态二() == 7) { 校验和 = 校验和 + 2; }
如果 (形态三() == 1) { 校验和 = 校验和 + 4; }
如果 (形态四() == 7) { 校验和 = 校验和 + 8; }
如果 (形态五() == 31) { 校验和 = 校验和 + 16; }
如果 (形态六() == 31) { 校验和 = 校验和 + 32; }
如果 (形态七() == 1) { 校验和 = 校验和 + 64; }
如果 (形态八() == 7) { 校验和 = 校验和 + 128; }
打印("校验和(期望255)=", 校验和);
返回 0;
}输出:校验和(期望255)=255
析构被移除 / 移动元素 / 数组前移 / 元素位模式 / 元素相等 / 桶序号 / 链查找 内部
(内部方法 × 7)
编译器注入挂点(字符串槽释放/元素移动)、哈希辅助(元素槽位模式/槽字节相等/桶序号/链查找)与前移辅助(保留兼容)。删除 已改为链摘除+交换,前移辅助不再内部使用。数组前移 危险:只移动数据数组、不更新链/桶索引,调用后集合不可用——仅兼容旧线性表代码,勿在哈希集合上调用。
泛型辅助函数
模块级泛型自由函数(映射/集合 的散列构件,也公开可用)。
查找键位置
泛型 <类型 K> 函数 查找键位置(K* 键数组, 整64 长度, K 目标) -> 可选<整64>
在键数组中线性查找(== 比较),命中=某些(下标),未命中=无(#1360 结果化,-1 哨兵废除)。
| 参数 | 类型 | 说明 |
|---|---|---|
键数组 | K* | 数组首地址 |
长度 | 整64 | 元素个数 |
目标 | K | 要找的键 |
返回 首个命中下标(某些);未找到=无。
主.cnCN
导入 映射集合::映射;
导入 映射集合::集合;
导入 映射集合::错误码;
函数 主() -> 整32 {
打印("===== 映射集合库(Task 6.4)=====");
// ==================== 1. 映射<K,V>(整32键 → 整32值) ====================
映射<整32, 整32> 表 = 映射<整32, 整32>();
如果 (表.为空()) {
打印("映射初始为空: 是");
} 否则 {
打印("映射初始为空: 否");
}
// 设置 3 对键值(触发扩容 0 -> 4)
结果<空类型, 整32> 设置结果 = 表.设置(1, 100);
如果 (设置结果.正常) {
设置结果 = 表.设置(2, 200);
设置结果 = 表.设置(3, 300);
} 否则 {
打印("映射设置失败: ", 设置结果.错误);
}
打印("映射大小: ", 表.大小());
// 包含(规格书 4.4 表.包含(键))
如果 (表.包含(2)) {
打印("包含键2: 真");
} 否则 {
打印("包含键2: 假");
}
如果 (表.包含(99)) {
打印("包含键99: 真");
} 否则 {
打印("包含键99: 假");
}
// 获取正确值(先存局部变量再打印,规避打印变参内嵌字段下标缺陷)
结果<整32, 整32> 获取结果 = 表.获取(1);
如果 (获取结果.正常) {
整32 值1 = 获取结果.值;
打印("获取键1: ", 值1);
} 否则 {
打印("获取键1失败: ", 获取结果.错误);
}
获取结果 = 表.获取(3);
如果 (获取结果.正常) {
整32 值3 = 获取结果.值;
打印("获取键3: ", 值3);
} 否则 {
打印("获取键3失败: ", 获取结果.错误);
}
// 覆盖已存在键 → 大小仍 3 且值更新
设置结果 = 表.设置(2, 222);
如果 (设置结果.正常) {
获取结果 = 表.获取(2);
如果 (获取结果.正常) {
整32 值2 = 获取结果.值;
打印("覆盖后键2: ", 值2);
} 否则 {
打印("覆盖后读键2失败: ", 获取结果.错误);
}
} 否则 {
打印("覆盖设置失败: ", 设置结果.错误);
}
打印("覆盖后大小: ", 表.大小());
// 获取不存在的键 → 错误码.未初始化(7)
获取结果 = 表.获取(99);
如果 (获取结果.正常) {
打印("获取键99未报错");
} 否则 {
打印("获取键99错误码: ", 获取结果.错误);
}
// 删除键 1 → 包含=假、大小-1
布尔 删除结果 = 表.删除(1);
如果 (删除结果) {
打印("删除键1: 真");
} 否则 {
打印("删除键1: 假");
}
如果 (表.包含(1)) {
打印("删除后包含键1: 真");
} 否则 {
打印("删除后包含键1: 假");
}
打印("删除后大小: ", 表.大小());
// 删除不存在的键 → 返回假
删除结果 = 表.删除(99);
如果 (删除结果) {
打印("删除键99: 真");
} 否则 {
打印("删除键99: 假");
}
// 清空
表.清空();
打印("清空后大小: ", 表.大小());
// ==================== 2. 集合<T>(整32) ====================
集合<整32> 值集 = 集合<整32>();
如果 (值集.为空()) {
打印("集合初始为空: 是");
} 否则 {
打印("集合初始为空: 否");
}
// 添加 1/2/3、再添加 2(幂等)→ 大小=3
设置结果 = 值集.添加(1);
如果 (设置结果.正常) {
设置结果 = 值集.添加(2);
设置结果 = 值集.添加(3);
设置结果 = 值集.添加(2);
} 否则 {
打印("集合添加失败: ", 设置结果.错误);
}
打印("集合大小: ", 值集.大小());
// 包含
如果 (值集.包含(2)) {
打印("集合包含2: 真");
} 否则 {
打印("集合包含2: 假");
}
如果 (值集.包含(99)) {
打印("集合包含99: 真");
} 否则 {
打印("集合包含99: 假");
}
// 删除 → 大小-1
删除结果 = 值集.删除(2);
如果 (删除结果) {
打印("集合删除2: 真");
} 否则 {
打印("集合删除2: 假");
}
打印("集合删除后大小: ", 值集.大小());
如果 (值集.包含(2)) {
打印("删除后包含2: 真");
} 否则 {
打印("删除后包含2: 假");
}
// 删除不存在的值 → 返回假
删除结果 = 值集.删除(99);
如果 (删除结果) {
打印("集合删除99: 真");
} 否则 {
打印("集合删除99: 假");
}
值集.清空();
打印("集合清空后大小: ", 值集.大小());
打印("===== 映射集合库测试完成 =====");
返回 0;
}输出:===== 映射集合库(Task 6.4)===== 映射初始为空: 是 映射大小: 3 包含键2: 真 包含键99: 假 获取键1: 100 获取键3: 300 覆盖后键2: 222 覆盖后大小: 3 获取键99错误码: 7 删除键1: 真 删除后包含键1: 假 删除后大小: 2 删除键99: 假 清空后大小: 0 集合初始为空: 是 集合大小: 3 集合包含2: 真 集合包含99: 假 集合删除2: 真 集合删除后大小: 2 删除后包含2: 假 集合删除99: 假 集合清空后大小: 0 ===== 映射集合库测试完成 =====
查找值位置
泛型 <类型 T> 函数 查找值位置(T* 数据数组, 整64 长度, T 目标) -> 可选<整64>
在数据数组中线性查找,命中=某些(下标),未命中=无(通用线性构件;集合 哈希化后内部不再使用)。
| 参数 | 类型 | 说明 |
|---|---|---|
数据数组 | T* | 数组首地址 |
长度 | 整64 | 元素个数 |
目标 | T | 要找的值 |
返回 首个命中下标(某些);未找到=无。
主.cnCN
导入 映射集合::映射;
导入 映射集合::集合;
导入 映射集合::错误码;
函数 主() -> 整32 {
打印("===== 映射集合库(Task 6.4)=====");
// ==================== 1. 映射<K,V>(整32键 → 整32值) ====================
映射<整32, 整32> 表 = 映射<整32, 整32>();
如果 (表.为空()) {
打印("映射初始为空: 是");
} 否则 {
打印("映射初始为空: 否");
}
// 设置 3 对键值(触发扩容 0 -> 4)
结果<空类型, 整32> 设置结果 = 表.设置(1, 100);
如果 (设置结果.正常) {
设置结果 = 表.设置(2, 200);
设置结果 = 表.设置(3, 300);
} 否则 {
打印("映射设置失败: ", 设置结果.错误);
}
打印("映射大小: ", 表.大小());
// 包含(规格书 4.4 表.包含(键))
如果 (表.包含(2)) {
打印("包含键2: 真");
} 否则 {
打印("包含键2: 假");
}
如果 (表.包含(99)) {
打印("包含键99: 真");
} 否则 {
打印("包含键99: 假");
}
// 获取正确值(先存局部变量再打印,规避打印变参内嵌字段下标缺陷)
结果<整32, 整32> 获取结果 = 表.获取(1);
如果 (获取结果.正常) {
整32 值1 = 获取结果.值;
打印("获取键1: ", 值1);
} 否则 {
打印("获取键1失败: ", 获取结果.错误);
}
获取结果 = 表.获取(3);
如果 (获取结果.正常) {
整32 值3 = 获取结果.值;
打印("获取键3: ", 值3);
} 否则 {
打印("获取键3失败: ", 获取结果.错误);
}
// 覆盖已存在键 → 大小仍 3 且值更新
设置结果 = 表.设置(2, 222);
如果 (设置结果.正常) {
获取结果 = 表.获取(2);
如果 (获取结果.正常) {
整32 值2 = 获取结果.值;
打印("覆盖后键2: ", 值2);
} 否则 {
打印("覆盖后读键2失败: ", 获取结果.错误);
}
} 否则 {
打印("覆盖设置失败: ", 设置结果.错误);
}
打印("覆盖后大小: ", 表.大小());
// 获取不存在的键 → 错误码.未初始化(7)
获取结果 = 表.获取(99);
如果 (获取结果.正常) {
打印("获取键99未报错");
} 否则 {
打印("获取键99错误码: ", 获取结果.错误);
}
// 删除键 1 → 包含=假、大小-1
布尔 删除结果 = 表.删除(1);
如果 (删除结果) {
打印("删除键1: 真");
} 否则 {
打印("删除键1: 假");
}
如果 (表.包含(1)) {
打印("删除后包含键1: 真");
} 否则 {
打印("删除后包含键1: 假");
}
打印("删除后大小: ", 表.大小());
// 删除不存在的键 → 返回假
删除结果 = 表.删除(99);
如果 (删除结果) {
打印("删除键99: 真");
} 否则 {
打印("删除键99: 假");
}
// 清空
表.清空();
打印("清空后大小: ", 表.大小());
// ==================== 2. 集合<T>(整32) ====================
集合<整32> 值集 = 集合<整32>();
如果 (值集.为空()) {
打印("集合初始为空: 是");
} 否则 {
打印("集合初始为空: 否");
}
// 添加 1/2/3、再添加 2(幂等)→ 大小=3
设置结果 = 值集.添加(1);
如果 (设置结果.正常) {
设置结果 = 值集.添加(2);
设置结果 = 值集.添加(3);
设置结果 = 值集.添加(2);
} 否则 {
打印("集合添加失败: ", 设置结果.错误);
}
打印("集合大小: ", 值集.大小());
// 包含
如果 (值集.包含(2)) {
打印("集合包含2: 真");
} 否则 {
打印("集合包含2: 假");
}
如果 (值集.包含(99)) {
打印("集合包含99: 真");
} 否则 {
打印("集合包含99: 假");
}
// 删除 → 大小-1
删除结果 = 值集.删除(2);
如果 (删除结果) {
打印("集合删除2: 真");
} 否则 {
打印("集合删除2: 假");
}
打印("集合删除后大小: ", 值集.大小());
如果 (值集.包含(2)) {
打印("删除后包含2: 真");
} 否则 {
打印("删除后包含2: 假");
}
// 删除不存在的值 → 返回假
删除结果 = 值集.删除(99);
如果 (删除结果) {
打印("集合删除99: 真");
} 否则 {
打印("集合删除99: 假");
}
值集.清空();
打印("集合清空后大小: ", 值集.大小());
打印("===== 映射集合库测试完成 =====");
返回 0;
}输出:===== 映射集合库(Task 6.4)===== 映射初始为空: 是 映射大小: 3 包含键2: 真 包含键99: 假 获取键1: 100 获取键3: 300 覆盖后键2: 222 覆盖后大小: 3 获取键99错误码: 7 删除键1: 真 删除后包含键1: 假 删除后大小: 2 删除键99: 假 清空后大小: 0 集合初始为空: 是 集合大小: 3 集合包含2: 真 集合包含99: 假 集合删除2: 真 集合删除后大小: 2 删除后包含2: 假 集合删除99: 假 集合清空后大小: 0 ===== 映射集合库测试完成 =====
散列桶序号
泛型 <类型 K> 函数 散列桶序号(K 位模式, 整64 桶数量) -> 整64
Knuth 乘法散列 + 2 的幂掩码(映射/集合 共享的单一散列实现;调用方显式 散列桶序号<整64>(...) 实例化)。
| 参数 | 类型 | 说明 |
|---|---|---|
位模式 | K | 8 字节槽位模式(映射=整64(键);集合=元素槽字节折叠) |
桶数量 | 整64 | 2 的幂 |
返回 桶下标(负数安全)。
主.cnCN
导入 映射集合::映射;
函数 主() -> 整32 {
打印("===== O(1) 哈希映射(自举前置修复)=====");
// 1. 基本 设置/获取/覆盖
映射<整64, 整64> 表 = 映射<整64, 整64>();
结果<空类型, 整32> 设1 = 表.设置(10, 100);
结果<空类型, 整32> 设2 = 表.设置(20, 200);
如果 (设1.正常 && 设2.正常) {
打印("设置: 通过");
} 否则 {
打印("设置: 失败");
}
结果<整64, 整32> 取1 = 表.获取(10);
如果 (取1.正常) {
打印("获取10: ", 取1.值); // 100
} 否则 {
打印("获取10失败: ", 取1.错误);
}
结果<空类型, 整32> 覆盖 = 表.设置(10, 999);
如果 (覆盖.正常) {
结果<整64, 整32> 取2 = 表.获取(10);
如果 (取2.正常) {
打印("覆盖后: ", 取2.值); // 999
} 否则 {
打印("覆盖后获取失败");
}
} 否则 {
打印("覆盖失败");
}
// 2. 包含 / 缺失键 / 删除
如果 (表.包含(20)) {
打印("包含20: 真");
}
如果 (!表.包含(30)) {
打印("包含30: 假");
}
布尔 删 = 表.删除(20);
打印("删除20: ", 删); // 真
如果 (!表.包含(20)) {
打印("删除后不包含: 真");
}
打印("删除后大小: ", 表.大小()); // 1
布尔 删2 = 表.删除(99);
打印("删除缺失键: ", 删2); // 假
// 3. 负数键
结果<空类型, 整32> 设负 = 表.设置(-5, 55);
如果 (设负.正常) {
结果<整64, 整32> 取负 = 表.获取(-5);
如果 (取负.正常) {
打印("负数键: ", 取负.值); // 55
} 否则 {
打印("负数键获取失败");
}
} 否则 {
打印("负数键设置失败");
}
// 4. 扩容重哈希:插入 2000 键(>1024 桶触发桶扩容 + 数组扩容)
整64 i = 0;
当 (i < 2000) {
结果<空类型, 整32> 设 = 表.设置(i, i * 3);
如果 (!设.正常) {
打印("扩容插入失败: ", i);
返回 1;
}
i++;
}
打印("扩容后大小: ", 表.大小()); // 2001(-5 旧键 + 0..1999;键 10 在循环内被 设置(10,30) 覆盖,不再新增)
// 5. 扩容后正确性抽查(前/中/后段键)
结果<整64, 整32> 抽查0 = 表.获取(0);
结果<整64, 整32> 抽查999 = 表.获取(999);
结果<整64, 整32> 抽查1999 = 表.获取(1999);
如果 (抽查0.正常) {
打印("重哈希抽查0: ", 抽查0.值);
} 否则 {
打印("重哈希抽查0失败");
}
如果 (抽查999.正常) {
打印("重哈希抽查999: ", 抽查999.值);
} 否则 {
打印("重哈希抽查999失败");
}
如果 (抽查1999.正常) {
打印("重哈希抽查1999: ", 抽查1999.值);
} 否则 {
打印("重哈希抽查1999失败");
}
// 6. 扩容后删除(空洞 + 交换删除路径)
布尔 删中 = 表.删除(1000);
打印("删除中段: ", 删中); // 真
如果 (!表.包含(1000) && 表.包含(999) && 表.包含(1001)) {
打印("空洞链正确: 真");
}
// 7. 性能断言:2000 次插入 + 2000 次查找 总耗时 < 50ms
// (线性表版本实测 11ms+9ms=20ms;哈希版本应 ≤ 数 ms;50ms 阈值防波动)
整64 开始 = 时间::单调时钟毫秒();
整64 和 = 0;
i = 0;
当 (i < 2000) {
结果<整64, 整32> 取 = 表.获取(i);
如果 (取.正常) {
和 += 取.值;
}
i++;
}
整64 结束 = 时间::单调时钟毫秒();
// 2026-08:不输出耗时(性能抖动 0/1ms 破坏逐行比对),仅输出性能判断
打印("校验和: ", 和);
如果 (结束 - 开始 < 50) {
打印("性能: 通过");
} 否则 {
打印("性能: 失败");
}
打印("===== 哈希映射测试完成 =====");
返回 0;
}输出:===== O(1) 哈希映射(自举前置修复)===== 设置: 通过 获取10: 100 覆盖后: 999 包含20: 真 包含30: 假 删除20: 真 删除后不包含: 真 删除后大小: 1 删除缺失键: 假 负数键: 55 扩容后大小: 2001 重哈希抽查0: 0 重哈希抽查999: 2997 重哈希抽查1999: 5997 删除中段: 真 空洞链正确: 真 校验和: 5994000 性能: 通过 ===== 哈希映射测试完成 =====