CN·语言

映射集合

映射<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>(...) 实例化)。

参数类型说明
位模式K8 字节槽位模式(映射=整64(键);集合=元素槽字节折叠)
桶数量整642 的幂

返回 桶下标(负数安全)。

主.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 性能: 通过 ===== 哈希映射测试完成 =====