CN·语言

容器

向量 / 链表 / 栈 / 队列——RAII 自动释放,元素按真实类型大小紧凑存储。

导入写法CN

导入 容器::向量;
导入 容器::{链表, 栈, 队列};

使用总览

四个容器全部深拷语义 + RAII 自动释放:作用域结束自动释放底层内存,元素为字符串/类对象时自动逐元素析构。扩容策略统一为「0 → 4,之后每次翻倍」。返回 结果 的方法返回值不可丢弃(编译错误),须按本文示例接收检查。

总览.cnCN

导入 容器::向量;

函数 主() -> 整32 {
    向量<整64> 表 = 向量<整64>();
    结果<空类型, 整32> 加 = 表.追加(10);
    加 = 表.追加(32);
    整64 首 = 表.元素(0);        // 副本读取(快照语义)
    遍历 表 中 每个 x {           // 遍历循环逐元素只读访问
        打印行(x, " ");
    }
    打印("");
    打印(首 + 表.大小());        // 12
    返回 0;
}

输出:10 32 12

向量<T>(动态数组)

对标 C++ std::vector。底层一块连续内存,支持下标随机访问;元素按 类型大小(T) 字节紧凑存储(与数组 C 布局、指针步进统一)。拷贝构造为深拷贝(逐元素按 T 的拷贝语义)。

向量() 不安全

不安全 函数 向量()

构造空向量(容量 0,不分配内存)。首次 追加/插入 时分配。

主.cnCN

导入 容器::向量;
导入 映射集合;

向量<整32> 全局向量;            // 裸全局容器(读方法调用面)
映射<整64, 整64> 全局映射;     // 裸全局映射(读方法调用面)
集合<整64> 全局集合;           // 裸全局集合(读方法调用面)

不安全 函数 造数据() {          // 写方法调用(不安全 函数内=合法豁免面)
    结果<空类型, 整32> a = 全局向量.追加(6);
    如果 (!a.正常) { 返回; }
    结果<空类型, 整32> b = 全局映射.设置(1, 2);
    如果 (!b.正常) { 返回; }
    结果<空类型, 整32> c = 全局集合.添加(3);
}

函数 读面() -> 整32 {
    整64 大小值 = 全局向量.大小();
    整64 容量值 = 全局向量.容量();
    布尔 空值 = 全局向量.为空();
    整32 元素值 = 全局向量.元素(0);
    结果<整32, 整32> 读取值 = 全局向量.读取(0);
    结果<整64, 整32> 获取值 = 全局映射.获取(1);
    布尔 包含值 = 全局集合.包含(3);
    整32 累 = 整32(大小值) + 元素值;
    如果 (读取值.正常) { 累 = 累 + 读取值.值; }
    如果 (获取值.正常) { 累 = 累 + 整32(获取值.值); }
    如果 (包含值) { 累 = 累 + 1; }
    返回 累;
}

函数 主() -> 整32 {
    造数据();
    打印行("读面累加");
    打印行(读面());
    返回 读面();
}

输出:读面累加16

向量(其他) 不安全

不安全 函数 向量(向量& 其他)

拷贝构造:深拷贝数据数组,逐元素按 T 的拷贝语义复制(元素为类对象时调用其拷贝构造),两容器析构互不影响。

参数类型说明
其他向量&被拷贝的向量

主.cnCN

导入 容器::向量;
导入 映射集合::映射;

函数 主() -> 整32 {
    // ---- 1. 向量拷贝构造(深拷贝)----
    向量<整64> 甲 = 向量<整64>();
    结果<空类型, 整32> 加1 = 甲.追加(10);
    结果<空类型, 整32> 加2 = 甲.追加(20);
    结果<空类型, 整32> 加3 = 甲.追加(30);
    打印("甲大小: ", 甲.大小());

    向量<整64> 乙 = 甲;
    打印("乙大小: ", 乙.大小());
    打印("乙[0]: ", 乙.元素(0));
    打印("乙[2]: ", 乙.元素(2));

    结果<空类型, 整32> 加4 = 乙.追加(99);
    打印("甲大小 仍: ", 甲.大小());
    打印("乙大小 变: ", 乙.大小());

    // ---- 2. 映射拷贝构造(深拷贝)----
    映射<整64, 整64> 表 = 映射<整64, 整64>();
    结果<空类型, 整32> 设1 = 表.设置(1, 100);
    结果<空类型, 整32> 设2 = 表.设置(2, 200);
    打印("表大小: ", 表.大小());

    映射<整64, 整64> 副本 = 表;
    打印("副本大小: ", 副本.大小());
    结果<整64, 整32> 取1 = 副本.获取(1);
    如果 (取1.正常) {
        打印("副本[1]: ", 取1.值);
    }
    结果<整64, 整32> 取2 = 副本.获取(2);
    如果 (取2.正常) {
        打印("副本[2]: ", 取2.值);
    }

    结果<空类型, 整32> 设3 = 副本.设置(1, 999);
    结果<整64, 整32> 取3 = 表.获取(1);
    如果 (取3.正常) {
        打印("表[1] 仍: ", 取3.值);
    }

    返回 0;
}

输出:甲大小: 3 乙大小: 3 乙[0]: 10 乙[2]: 30 甲大小 仍: 3 乙大小 变: 4 表大小: 2 副本大小: 2 副本[1]: 100 副本[2]: 200 表[1] 仍: 100

大小 常量

常量 函数 大小() -> 整64

当前元素个数。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 容器::错误码;

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

    // ==================== 1. 向量<T> ====================
    向量<整32> 数据 = 向量<整32>();
    如果 (数据.为空()) {
        打印("向量初始为空: 是");
    } 否则 {
        打印("向量初始为空: 否");
    }

    // 追加 6 个元素(触发扩容 0 -> 4 -> 8)
    结果<空类型, 整32> 追加结果 = 数据.追加(1);
    如果 (追加结果.正常) {
        追加结果 = 数据.追加(2);
        追加结果 = 数据.追加(3);
        追加结果 = 数据.追加(4);
        追加结果 = 数据.追加(5);
        追加结果 = 数据.追加(6);
    } 否则 {
        打印("向量追加失败: ", 追加结果.错误);
    }
    打印("向量大小: ", 数据.大小());
    打印("向量容量: ", 数据.容量());

    // 读取(正常路径)
    结果<整32, 整32> 读取结果 = 数据.读取(0);
    如果 (读取结果.正常) {
        打印("读取[0]: ", 读取结果.值);
    } 否则 {
        打印("读取[0]失败: ", 读取结果.错误);
    }

    // 读取(越界路径:错误码 2)
    读取结果 = 数据.读取(99);
    如果 (读取结果.正常) {
        打印("读取[99]未报错");
    } 否则 {
        打印("读取[99]越界: ", 读取结果.错误);
    }

    // 插入 + 删除 + 设置
    追加结果 = 数据.插入(0, 99);
    如果 (追加结果.正常) {
        打印("插入后[0]: ", 数据.元素(0));
    } 否则 {
        打印("插入失败: ", 追加结果.错误);
    }
    追加结果 = 数据.删除(0);
    如果 (追加结果.正常) {
        打印("删除后[0]: ", 数据.元素(0));
    } 否则 {
        打印("删除失败: ", 追加结果.错误);
    }
    追加结果 = 数据.设置(0, 7);
    如果 (追加结果.正常) {
        打印("设置后[0]: ", 数据.元素(0));
    } 否则 {
        打印("设置失败: ", 追加结果.错误);
    }

    // ==================== 2. 链表<T> ====================
    链表<整32> 列表 = 链表<整32>();
    追加结果 = 列表.追加(10);
    如果 (追加结果.正常) {
        追加结果 = 列表.追加(20);
        追加结果 = 列表.追加(30);
    } 否则 {
        打印("链表追加失败: ", 追加结果.错误);
    }
    打印("链表大小: ", 列表.大小());
    结果<整32, 整32> 头结果 = 列表.读取头部();
    如果 (头结果.正常) {
        打印("链表头: ", 头结果.值);
    } 否则 {
        打印("链表头失败: ", 头结果.错误);
    }
    结果<整32, 整32> 尾结果 = 列表.读取尾部();
    如果 (尾结果.正常) {
        打印("链表尾: ", 尾结果.值);
    } 否则 {
        打印("链表尾失败: ", 尾结果.错误);
    }

    // 头部追加
    追加结果 = 列表.头部追加(5);
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("头部追加后链表头: ", 头结果.值);
        } 否则 {
            打印("头部追加后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("头部追加失败: ", 追加结果.错误);
    }
    打印("头部追加后链表大小: ", 列表.大小());

    // 删除头部 + 删除尾部
    追加结果 = 列表.删除头部();
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("删除头部后链表头: ", 头结果.值);
        } 否则 {
            打印("删除头部后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("删除头部失败: ", 追加结果.错误);
    }
    追加结果 = 列表.删除尾部();
    如果 (追加结果.正常) {
        尾结果 = 列表.读取尾部();
        如果 (尾结果.正常) {
            打印("删除尾部后链表尾: ", 尾结果.值);
        } 否则 {
            打印("删除尾部后读尾失败: ", 尾结果.错误);
        }
    } 否则 {
        打印("删除尾部失败: ", 追加结果.错误);
    }

    // ==================== 3. 栈<T> ====================
    栈<整32> 数据栈 = 栈<整32>();
    追加结果 = 数据栈.压入(1);
    如果 (追加结果.正常) {
        追加结果 = 数据栈.压入(2);
        追加结果 = 数据栈.压入(3);
    } 否则 {
        打印("压入失败: ", 追加结果.错误);
    }
    打印("栈大小: ", 数据栈.大小());
    结果<整32, 整32> 栈顶结果 = 数据栈.栈顶();
    如果 (栈顶结果.正常) {
        打印("栈顶: ", 栈顶结果.值);
    } 否则 {
        打印("栈顶失败: ", 栈顶结果.错误);
    }
    结果<整32, 整32> 弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("弹出: ", 弹出结果.值);
    } 否则 {
        打印("弹出失败: ", 弹出结果.错误);
    }
    弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("再弹出: ", 弹出结果.值);
    } 否则 {
        打印("再弹出失败: ", 弹出结果.错误);
    }
    打印("弹后栈大小: ", 数据栈.大小());

    // ==================== 4. 队列<T> ====================
    队列<整32> 数据队列 = 队列<整32>();
    追加结果 = 数据队列.入队(5);
    如果 (追加结果.正常) {
        追加结果 = 数据队列.入队(6);
        追加结果 = 数据队列.入队(7);
    } 否则 {
        打印("入队失败: ", 追加结果.错误);
    }
    打印("队列大小: ", 数据队列.大小());
    结果<整32, 整32> 队首结果 = 数据队列.队首();
    如果 (队首结果.正常) {
        打印("队首: ", 队首结果.值);
    } 否则 {
        打印("队首失败: ", 队首结果.错误);
    }
    结果<整32, 整32> 出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("出队: ", 出队结果.值);
    } 否则 {
        打印("出队失败: ", 出队结果.错误);
    }
    出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("再出队: ", 出队结果.值);
    } 否则 {
        打印("再出队失败: ", 出队结果.错误);
    }
    打印("出队后队列大小: ", 数据队列.大小());

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

输出:===== 容器库(Task 6.1)===== 向量初始为空: 是 向量大小: 6 向量容量: 8 读取[0]: 1 读取[99]越界: 2 插入后[0]: 99 删除后[0]: 1 设置后[0]: 7 链表大小: 3 链表头: 10 链表尾: 30 头部追加后链表头: 5 头部追加后链表大小: 4 删除头部后链表头: 10 删除尾部后链表尾: 20 栈大小: 3 栈顶: 3 弹出: 3 再弹出: 2 弹后栈大小: 1 队列大小: 3 队首: 5 出队: 5 再出队: 6 出队后队列大小: 1 ===== 容器库测试完成 =====

容量 常量

常量 函数 容量() -> 整64

底层已分配的槽位数(≥ 大小())。扩容翻倍策略:0 → 4 → ×2。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 容器::错误码;

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

    // ==================== 1. 向量<T> ====================
    向量<整32> 数据 = 向量<整32>();
    如果 (数据.为空()) {
        打印("向量初始为空: 是");
    } 否则 {
        打印("向量初始为空: 否");
    }

    // 追加 6 个元素(触发扩容 0 -> 4 -> 8)
    结果<空类型, 整32> 追加结果 = 数据.追加(1);
    如果 (追加结果.正常) {
        追加结果 = 数据.追加(2);
        追加结果 = 数据.追加(3);
        追加结果 = 数据.追加(4);
        追加结果 = 数据.追加(5);
        追加结果 = 数据.追加(6);
    } 否则 {
        打印("向量追加失败: ", 追加结果.错误);
    }
    打印("向量大小: ", 数据.大小());
    打印("向量容量: ", 数据.容量());

    // 读取(正常路径)
    结果<整32, 整32> 读取结果 = 数据.读取(0);
    如果 (读取结果.正常) {
        打印("读取[0]: ", 读取结果.值);
    } 否则 {
        打印("读取[0]失败: ", 读取结果.错误);
    }

    // 读取(越界路径:错误码 2)
    读取结果 = 数据.读取(99);
    如果 (读取结果.正常) {
        打印("读取[99]未报错");
    } 否则 {
        打印("读取[99]越界: ", 读取结果.错误);
    }

    // 插入 + 删除 + 设置
    追加结果 = 数据.插入(0, 99);
    如果 (追加结果.正常) {
        打印("插入后[0]: ", 数据.元素(0));
    } 否则 {
        打印("插入失败: ", 追加结果.错误);
    }
    追加结果 = 数据.删除(0);
    如果 (追加结果.正常) {
        打印("删除后[0]: ", 数据.元素(0));
    } 否则 {
        打印("删除失败: ", 追加结果.错误);
    }
    追加结果 = 数据.设置(0, 7);
    如果 (追加结果.正常) {
        打印("设置后[0]: ", 数据.元素(0));
    } 否则 {
        打印("设置失败: ", 追加结果.错误);
    }

    // ==================== 2. 链表<T> ====================
    链表<整32> 列表 = 链表<整32>();
    追加结果 = 列表.追加(10);
    如果 (追加结果.正常) {
        追加结果 = 列表.追加(20);
        追加结果 = 列表.追加(30);
    } 否则 {
        打印("链表追加失败: ", 追加结果.错误);
    }
    打印("链表大小: ", 列表.大小());
    结果<整32, 整32> 头结果 = 列表.读取头部();
    如果 (头结果.正常) {
        打印("链表头: ", 头结果.值);
    } 否则 {
        打印("链表头失败: ", 头结果.错误);
    }
    结果<整32, 整32> 尾结果 = 列表.读取尾部();
    如果 (尾结果.正常) {
        打印("链表尾: ", 尾结果.值);
    } 否则 {
        打印("链表尾失败: ", 尾结果.错误);
    }

    // 头部追加
    追加结果 = 列表.头部追加(5);
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("头部追加后链表头: ", 头结果.值);
        } 否则 {
            打印("头部追加后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("头部追加失败: ", 追加结果.错误);
    }
    打印("头部追加后链表大小: ", 列表.大小());

    // 删除头部 + 删除尾部
    追加结果 = 列表.删除头部();
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("删除头部后链表头: ", 头结果.值);
        } 否则 {
            打印("删除头部后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("删除头部失败: ", 追加结果.错误);
    }
    追加结果 = 列表.删除尾部();
    如果 (追加结果.正常) {
        尾结果 = 列表.读取尾部();
        如果 (尾结果.正常) {
            打印("删除尾部后链表尾: ", 尾结果.值);
        } 否则 {
            打印("删除尾部后读尾失败: ", 尾结果.错误);
        }
    } 否则 {
        打印("删除尾部失败: ", 追加结果.错误);
    }

    // ==================== 3. 栈<T> ====================
    栈<整32> 数据栈 = 栈<整32>();
    追加结果 = 数据栈.压入(1);
    如果 (追加结果.正常) {
        追加结果 = 数据栈.压入(2);
        追加结果 = 数据栈.压入(3);
    } 否则 {
        打印("压入失败: ", 追加结果.错误);
    }
    打印("栈大小: ", 数据栈.大小());
    结果<整32, 整32> 栈顶结果 = 数据栈.栈顶();
    如果 (栈顶结果.正常) {
        打印("栈顶: ", 栈顶结果.值);
    } 否则 {
        打印("栈顶失败: ", 栈顶结果.错误);
    }
    结果<整32, 整32> 弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("弹出: ", 弹出结果.值);
    } 否则 {
        打印("弹出失败: ", 弹出结果.错误);
    }
    弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("再弹出: ", 弹出结果.值);
    } 否则 {
        打印("再弹出失败: ", 弹出结果.错误);
    }
    打印("弹后栈大小: ", 数据栈.大小());

    // ==================== 4. 队列<T> ====================
    队列<整32> 数据队列 = 队列<整32>();
    追加结果 = 数据队列.入队(5);
    如果 (追加结果.正常) {
        追加结果 = 数据队列.入队(6);
        追加结果 = 数据队列.入队(7);
    } 否则 {
        打印("入队失败: ", 追加结果.错误);
    }
    打印("队列大小: ", 数据队列.大小());
    结果<整32, 整32> 队首结果 = 数据队列.队首();
    如果 (队首结果.正常) {
        打印("队首: ", 队首结果.值);
    } 否则 {
        打印("队首失败: ", 队首结果.错误);
    }
    结果<整32, 整32> 出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("出队: ", 出队结果.值);
    } 否则 {
        打印("出队失败: ", 出队结果.错误);
    }
    出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("再出队: ", 出队结果.值);
    } 否则 {
        打印("再出队失败: ", 出队结果.错误);
    }
    打印("出队后队列大小: ", 数据队列.大小());

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

输出:===== 容器库(Task 6.1)===== 向量初始为空: 是 向量大小: 6 向量容量: 8 读取[0]: 1 读取[99]越界: 2 插入后[0]: 99 删除后[0]: 1 设置后[0]: 7 链表大小: 3 链表头: 10 链表尾: 30 头部追加后链表头: 5 头部追加后链表大小: 4 删除头部后链表头: 10 删除尾部后链表尾: 20 栈大小: 3 栈顶: 3 弹出: 3 再弹出: 2 弹后栈大小: 1 队列大小: 3 队首: 5 出队: 5 再出队: 6 出队后队列大小: 1 ===== 容器库测试完成 =====

为空 常量

常量 函数 为空() -> 布尔

元素个数是否为 0。

主.cnCN

导入 容器::向量;
导入 映射集合;

向量<整32> 全局向量;            // 裸全局容器(读方法调用面)
映射<整64, 整64> 全局映射;     // 裸全局映射(读方法调用面)
集合<整64> 全局集合;           // 裸全局集合(读方法调用面)

不安全 函数 造数据() {          // 写方法调用(不安全 函数内=合法豁免面)
    结果<空类型, 整32> a = 全局向量.追加(6);
    如果 (!a.正常) { 返回; }
    结果<空类型, 整32> b = 全局映射.设置(1, 2);
    如果 (!b.正常) { 返回; }
    结果<空类型, 整32> c = 全局集合.添加(3);
}

函数 读面() -> 整32 {
    整64 大小值 = 全局向量.大小();
    整64 容量值 = 全局向量.容量();
    布尔 空值 = 全局向量.为空();
    整32 元素值 = 全局向量.元素(0);
    结果<整32, 整32> 读取值 = 全局向量.读取(0);
    结果<整64, 整32> 获取值 = 全局映射.获取(1);
    布尔 包含值 = 全局集合.包含(3);
    整32 累 = 整32(大小值) + 元素值;
    如果 (读取值.正常) { 累 = 累 + 读取值.值; }
    如果 (获取值.正常) { 累 = 累 + 整32(获取值.值); }
    如果 (包含值) { 累 = 累 + 1; }
    返回 累;
}

函数 主() -> 整32 {
    造数据();
    打印行("读面累加");
    打印行(读面());
    返回 读面();
}

输出:读面累加16

追加 不安全

不安全 函数 追加(T 值) -> 结果<空类型, 整32>

尾部追加一个元素(按值拷入)。容量不足时自动翻倍扩容。返回值不可丢弃——须接收并检查。

参数类型说明
值T要追加的元素

返回 正常();重分配失败 → 错误(错误码.内存)。

主.cnCN

导入 容器::向量;

静态 整64 全局析构计数 = 0;

// 带析构计数器的类:构造不计数,析构 +1
类 资源 {
公开:
    整64 编号;

    函数 资源(整64 编号值) {
        编号 = 编号值;
    }

    函数 资源(资源& 其他) {
        编号 = 其他.编号;
    }

    不安全 函数 ~资源() {
        全局析构计数 = 全局析构计数 + 1;
    }
}

函数 主() -> 整32 {
    {
        向量<资源> 资源表 = 向量<资源>();
        资源 r1 = 资源(1);
        资源 r2 = 资源(2);
        资源 r3 = 资源(3);
        结果<空类型, 整32> 加1 = 资源表.追加(r1);
        结果<空类型, 整32> 加2 = 资源表.追加(r2);
        结果<空类型, 整32> 加3 = 资源表.追加(r3);
        打印("追加3 后: ", 资源表.大小());
        打印("析构计数: ", 全局析构计数);

        // 删除(末尾):自动析构被移除元素(计数 +1)
        结果<空类型, 整32> 删 = 资源表.删除(2);
        打印("删除后大小: ", 资源表.大小());
        打印("删除后析构: ", 全局析构计数);

        // 清空:自动逐元素析构剩余 2 个(计数 +2)
        资源表.清空();
        打印("清空后大小: ", 资源表.大小());
    }
    // 块结束:局部 r1/r2/r3 已在块出口析构(块级 RAII)——计数含其 3 次
    打印("总析构: ", 全局析构计数);
    返回 0;
}

输出:追加3 后: 3 析构计数: 0 删除后大小: 2 删除后析构: 1 清空后大小: 0 总析构: 6

插入 不安全

不安全 函数 插入(整64 位置, T 值) -> 结果<空类型, 整32>

在指定位置插入元素,原位置及其后元素整体后移。允许 位置 == 大小() (等价尾部追加);负值或超出尾部 → 越界错误。

参数类型说明
位置整64插入点(0 = 头部,大小() = 尾部)
值T要插入的元素

返回 正常();位置非法 → 错误(错误码.越界);重分配失败 → 错误(错误码.内存)。

主.cnCN

导入 容器::向量;

函数 主() -> 整32 {
    向量<整32> v = 向量<整32>();
    结果<空类型, 整32> 追加11 = v.追加(11);
    如果 追加11.正常 {
        打印(0);
    } 否则 {
        打印(追加11.错误);
    }
    结果<空类型, 整32> 追加22 = v.追加(22);
    如果 追加22.正常 {
        打印(0);
    } 否则 {
        打印(追加22.错误);
    }
    // ---- 负下标四操作:全部命中越界错误码 2(打印 2)----
    结果<整32, 整32> 负读 = v.读取(0 - 1);
    如果 负读.正常 {
        打印(负读.值);
    } 否则 {
        打印(负读.错误);
    }
    结果<空类型, 整32> 负删 = v.删除(0 - 1);
    如果 负删.正常 {
        打印(0);
    } 否则 {
        打印(负删.错误);
    }
    // ---- 合法面零回归:负操作被拒后容器完好 ----
    结果<整32, 整32> 读0 = v.读取(0);
    如果 读0.正常 {
        打印(读0.值);
    } 否则 {
        打印(读0.错误);
    }
    结果<整32, 整32> 读1 = v.读取(1);
    如果 读1.正常 {
        打印(读1.值);
    } 否则 {
        打印(读1.错误);
    }
    结果<空类型, 整32> 插1 = v.插入(1, 15);
    如果 插1.正常 {
        打印(0);
    } 否则 {
        打印(插1.错误);
    }
    结果<整32, 整32> 读15 = v.读取(1);
    如果 读15.正常 {
        打印(读15.值);
    } 否则 {
        打印(读15.错误);
    }
    结果<空类型, 整32> 设16 = v.设置(1, 16);
    如果 设16.正常 {
        打印(0);
    } 否则 {
        打印(设16.错误);
    }
    结果<整32, 整32> 读16 = v.读取(1);
    如果 读16.正常 {
        打印(读16.值);
    } 否则 {
        打印(读16.错误);
    }
    结果<空类型, 整32> 删1 = v.删除(1);
    如果 删1.正常 {
        打印(0);
    } 否则 {
        打印(删1.错误);
    }
    结果<整32, 整32> 读尾 = v.读取(1);
    如果 读尾.正常 {
        打印(读尾.值);
    } 否则 {
        打印(读尾.错误);
    }
    打印(v.大小());
    返回 0;
}

输出:0 0 2 2 11 22 0 15 0 16 0 22 2

读取 不安全

不安全 函数 读取(整64 位置) -> 结果<T, 整32>

带检查的下标读取:越界(含负值)返回错误而非中止,适合无法确信下标合法的场合。

参数类型说明
位置整64下标

返回 正常(元素副本);越界 → 错误(错误码.越界)。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 容器::错误码;

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

    // ==================== 1. 向量<T> ====================
    向量<整32> 数据 = 向量<整32>();
    如果 (数据.为空()) {
        打印("向量初始为空: 是");
    } 否则 {
        打印("向量初始为空: 否");
    }

    // 追加 6 个元素(触发扩容 0 -> 4 -> 8)
    结果<空类型, 整32> 追加结果 = 数据.追加(1);
    如果 (追加结果.正常) {
        追加结果 = 数据.追加(2);
        追加结果 = 数据.追加(3);
        追加结果 = 数据.追加(4);
        追加结果 = 数据.追加(5);
        追加结果 = 数据.追加(6);
    } 否则 {
        打印("向量追加失败: ", 追加结果.错误);
    }
    打印("向量大小: ", 数据.大小());
    打印("向量容量: ", 数据.容量());

    // 读取(正常路径)
    结果<整32, 整32> 读取结果 = 数据.读取(0);
    如果 (读取结果.正常) {
        打印("读取[0]: ", 读取结果.值);
    } 否则 {
        打印("读取[0]失败: ", 读取结果.错误);
    }

    // 读取(越界路径:错误码 2)
    读取结果 = 数据.读取(99);
    如果 (读取结果.正常) {
        打印("读取[99]未报错");
    } 否则 {
        打印("读取[99]越界: ", 读取结果.错误);
    }

    // 插入 + 删除 + 设置
    追加结果 = 数据.插入(0, 99);
    如果 (追加结果.正常) {
        打印("插入后[0]: ", 数据.元素(0));
    } 否则 {
        打印("插入失败: ", 追加结果.错误);
    }
    追加结果 = 数据.删除(0);
    如果 (追加结果.正常) {
        打印("删除后[0]: ", 数据.元素(0));
    } 否则 {
        打印("删除失败: ", 追加结果.错误);
    }
    追加结果 = 数据.设置(0, 7);
    如果 (追加结果.正常) {
        打印("设置后[0]: ", 数据.元素(0));
    } 否则 {
        打印("设置失败: ", 追加结果.错误);
    }

    // ==================== 2. 链表<T> ====================
    链表<整32> 列表 = 链表<整32>();
    追加结果 = 列表.追加(10);
    如果 (追加结果.正常) {
        追加结果 = 列表.追加(20);
        追加结果 = 列表.追加(30);
    } 否则 {
        打印("链表追加失败: ", 追加结果.错误);
    }
    打印("链表大小: ", 列表.大小());
    结果<整32, 整32> 头结果 = 列表.读取头部();
    如果 (头结果.正常) {
        打印("链表头: ", 头结果.值);
    } 否则 {
        打印("链表头失败: ", 头结果.错误);
    }
    结果<整32, 整32> 尾结果 = 列表.读取尾部();
    如果 (尾结果.正常) {
        打印("链表尾: ", 尾结果.值);
    } 否则 {
        打印("链表尾失败: ", 尾结果.错误);
    }

    // 头部追加
    追加结果 = 列表.头部追加(5);
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("头部追加后链表头: ", 头结果.值);
        } 否则 {
            打印("头部追加后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("头部追加失败: ", 追加结果.错误);
    }
    打印("头部追加后链表大小: ", 列表.大小());

    // 删除头部 + 删除尾部
    追加结果 = 列表.删除头部();
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("删除头部后链表头: ", 头结果.值);
        } 否则 {
            打印("删除头部后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("删除头部失败: ", 追加结果.错误);
    }
    追加结果 = 列表.删除尾部();
    如果 (追加结果.正常) {
        尾结果 = 列表.读取尾部();
        如果 (尾结果.正常) {
            打印("删除尾部后链表尾: ", 尾结果.值);
        } 否则 {
            打印("删除尾部后读尾失败: ", 尾结果.错误);
        }
    } 否则 {
        打印("删除尾部失败: ", 追加结果.错误);
    }

    // ==================== 3. 栈<T> ====================
    栈<整32> 数据栈 = 栈<整32>();
    追加结果 = 数据栈.压入(1);
    如果 (追加结果.正常) {
        追加结果 = 数据栈.压入(2);
        追加结果 = 数据栈.压入(3);
    } 否则 {
        打印("压入失败: ", 追加结果.错误);
    }
    打印("栈大小: ", 数据栈.大小());
    结果<整32, 整32> 栈顶结果 = 数据栈.栈顶();
    如果 (栈顶结果.正常) {
        打印("栈顶: ", 栈顶结果.值);
    } 否则 {
        打印("栈顶失败: ", 栈顶结果.错误);
    }
    结果<整32, 整32> 弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("弹出: ", 弹出结果.值);
    } 否则 {
        打印("弹出失败: ", 弹出结果.错误);
    }
    弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("再弹出: ", 弹出结果.值);
    } 否则 {
        打印("再弹出失败: ", 弹出结果.错误);
    }
    打印("弹后栈大小: ", 数据栈.大小());

    // ==================== 4. 队列<T> ====================
    队列<整32> 数据队列 = 队列<整32>();
    追加结果 = 数据队列.入队(5);
    如果 (追加结果.正常) {
        追加结果 = 数据队列.入队(6);
        追加结果 = 数据队列.入队(7);
    } 否则 {
        打印("入队失败: ", 追加结果.错误);
    }
    打印("队列大小: ", 数据队列.大小());
    结果<整32, 整32> 队首结果 = 数据队列.队首();
    如果 (队首结果.正常) {
        打印("队首: ", 队首结果.值);
    } 否则 {
        打印("队首失败: ", 队首结果.错误);
    }
    结果<整32, 整32> 出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("出队: ", 出队结果.值);
    } 否则 {
        打印("出队失败: ", 出队结果.错误);
    }
    出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("再出队: ", 出队结果.值);
    } 否则 {
        打印("再出队失败: ", 出队结果.错误);
    }
    打印("出队后队列大小: ", 数据队列.大小());

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

输出:===== 容器库(Task 6.1)===== 向量初始为空: 是 向量大小: 6 向量容量: 8 读取[0]: 1 读取[99]越界: 2 插入后[0]: 99 删除后[0]: 1 设置后[0]: 7 链表大小: 3 链表头: 10 链表尾: 30 头部追加后链表头: 5 头部追加后链表大小: 4 删除头部后链表头: 10 删除尾部后链表尾: 20 栈大小: 3 栈顶: 3 弹出: 3 再弹出: 2 弹后栈大小: 1 队列大小: 3 队首: 5 出队: 5 再出队: 6 出队后队列大小: 1 ===== 容器库测试完成 =====

元素 不安全

不安全 函数 元素(整64 位置) -> T

直读下标:返回元素副本(快照语义,对副本的修改不影响容器)。越界时直接运行时中止(错误码.越界),适合调用方已保证下标合法的热路径。

参数类型说明
位置整64下标

返回 元素副本(T)。越界 → 运行时错误终止。

主.cnCN

导入 容器::向量;
导入 映射集合::映射;
函数 主() -> 整32 {
    向量<映射<整64, 整64>> 层表 = 向量<映射<整64, 整64>>();
    映射<整64, 整64> 层 = 映射<整64, 整64>();
    结果<空类型, 整32> 设 = 层.设置(1, 10);
    如果 (!设.正常) { 返回 1; }
    结果<空类型, 整32> 加 = 层表.追加(层);
    如果 (!加.正常) { 返回 2; }
    结果<整64, 整32> 取甲 = 层表.元素(0).获取(1);
    如果 (取甲.正常) {
        打印("链式取=", 取甲.值, "(期望 10)");
    } 否则 {
        返回 3;
    }
    返回 0;
}

输出:链式取=10(期望 10)

元素引用 不安全

不安全 函数 元素引用(整64 位置) -> T&

引用访问:返回元素的左值引用(零拷贝),可读可写——写穿容器内的真实槽位(Rust &v[i] 同款)。大对象只读消费或原地修改时用它避开元素(i) 的整份拷贝。

参数类型说明
位置整64下标

返回 元素引用(T&)。越界 → 运行时错误终止。

主.cnCN

导入 容器::向量;
导入 IO::打印;
// E2E 501(2026-10-01 第 929 轮·任务 118 根治·引用返回方法调用作赋值目标):
//   v.元素引用(i) = x(829 立法写通道·001 §5.3 三形态正交:元素引用=引用返回
//   零拷贝借用视图·只读/原地写均写穿容器)。修复前宿主语义层方法路径
//   lastExprIsRefReturn_ 硬编码 false(类型 canonical 剥 & 无从判定)——被拒
//   「赋值目标须为可写左值」(样本 p0930_06 同域);v2 是引用返回调用 只认
//   被调=标识符。断言面:①简单写穿+读回;②复合赋值写穿;③结构体元素字段
//   级写穿(.x=9 不扰相邻字段 y——写宽按字段类型·宿主 memberAssignObjSrcType
//   CallExpr 分支);④读链回归(右值 lvalue-to-rvalue·聚合直传分叉);⑤引用
//   绑定联动写回;⑥中位(非 0 下标)写穿;⑦越界写=运行时错误 2(分层②兜底·
//   与 元素 同款 T18)。双编译对照同源断言(宿主+v2 同语义)。
结构体 点 {
    整32 x;
    整32 y;
}
函数 主() -> 整32 {
    // ① 简单写穿 + ⑥ 中位写穿
    向量<整32> 行;
    结果<空类型, 整32> a = 行.追加(1);
    如果 (a.正常) { } 否则 { 返回 1; }
    结果<空类型, 整32> b = 行.追加(2);
    如果 (b.正常) { } 否则 { 返回 1; }
    结果<空类型, 整32> c = 行.追加(3);
    如果 (c.正常) { } 否则 { 返回 1; }
    行.元素引用(0) = 30;
    打印(行.元素(0));
    行.元素引用(2) = 88;
    打印(行.元素(2));
    // ② 复合赋值写穿
    行.元素引用(0) += 5;
    打印(行.元素(0));
    // ③ 结构体元素字段级写穿(x 写穿·y 不扰)
    向量<点> 表;
    点 p1 = 点{ x = 1, y = 2 };
    结果<空类型, 整32> d = 表.追加(p1);
    如果 (d.正常) { } 否则 { 返回 1; }
    表.元素引用(0).x = 9;
    点 读回 = 表.元素(0);
    打印(读回.x);
    打印(读回.y);
    // ④ 读链回归(右值读=解引用值·非地址)
    整32 v = 行.元素引用(1);
    打印(v);
    // ⑤ 引用绑定联动写回
    整32& 别名 = 行.元素引用(1);
    别名 = 100;
    打印(行.元素(1));
    // ⑦ 未选中位不受扰
    打印(行.元素(0));
    返回 0;
}

输出:30 88 35 9 2 2 100 35

设置 不安全

不安全 函数 设置(整64 位置, T 值) -> 结果<空类型, 整32>

覆盖指定位置的元素。元素为字符串时旧值先释放(唯一持有者语义),不泄漏。越界返回错误。

参数类型说明
位置整64下标
值T新值

返回 正常();越界 → 错误(错误码.越界)。

主.cnCN

导入 容器::向量;
导入 映射集合;

函数 加表(映射<整64, 整64> 表) -> 整64 {
    结果<空类型, 整32> 写 = 表.设置(1, 100);
    如果 (写.正常) {
        返回 1;
    }
    返回 0;
}

函数 主() -> 整32 {
    映射<整64, 整64> 表 = 映射<整64, 整64>();
    整64 写穿 = 加表(表);
    打印("写入成功: ", 写穿);
    打印("主函数表大小: ", 表.大小());
    返回 0;
}

输出:写入成功: 1 主函数表大小: 1

删除 不安全

不安全 函数 删除(整64 位置) -> 结果<空类型, 整32>

删除指定位置的元素,其后元素整体前移;被移除元素正确析构(字符串释放/类对象析构),不泄漏不双释放。

参数类型说明
位置整64要删除的下标

返回 正常();越界 → 错误(错误码.越界)。

主.cnCN

导入 容器::向量;

静态 整64 计数 = 0;

类 资源 {
公开:
    整64 编号;
    函数 资源(整64 v) { 编号 = v; }
    函数 资源(资源& 其他) { 编号 = 其他.编号; }
    不安全 函数 ~资源() { 计数 = 计数 + 1; }
}

函数 主() -> 整32 {
    向量<资源> 表;
    资源 r1 = 资源(1);
    资源 r2 = 资源(2);
    资源 r3 = 资源(3);
    资源 r4 = 资源(4);
    结果<空类型, 整32> a1 = 表.追加(r1);
    结果<空类型, 整32> a2 = 表.追加(r2);
    结果<空类型, 整32> a3 = 表.追加(r3);
    结果<空类型, 整32> a4 = 表.追加(r4);
    打印("追加4: ", 表.大小(), " 计数: ", 计数);   // 4, 0

    // 删除中间(1):被删 r2 恰一次析构 = 计数 1(r3/r4 纯移位)
    结果<空类型, 整32> d1 = 表.删除(1);
    打印("删除(1)后: ", 表.大小(), " 计数: ", 计数);  // 3, 1

    // 再删除中间(1):被删 r3 恰一次(总 2)
    结果<空类型, 整32> d2 = 表.删除(1);
    打印("再删除(1): ", 表.大小(), " 计数: ", 计数);  // 2, 2

    // 删除头部(0):被删 r1 恰一次(总 3)
    结果<空类型, 整32> d3 = 表.删除(0);
    打印("删除(0)后: ", 表.大小(), " 计数: ", 计数);  // 1, 3

    // 清空:剩余 r4 恰一次(总 4)
    表.清空();
    打印("清空后: ", 表.大小(), " 计数: ", 计数);     // 0, 4
    返回 0;
}

输出:追加4: 4 计数: 0 删除(1)后: 3 计数: 1 再删除(1): 2 计数: 2 删除(0)后: 1 计数: 3 清空后: 0 计数: 4

预留

函数 预留(整64 容量) -> 结果<空类型, 整32>

预分配至少 容量 个槽位,之后的 追加 在容量内不再触发重分配。已知规模的批量装载前调用可显著减少分配次数。容量参数不大于当前容量时什么都不做。

参数类型说明
容量整64目标槽位数

返回 正常();重分配失败 → 错误(错误码.内存)。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 容器::错误码;

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

    // ==================== 1. 向量<T> ====================
    向量<整32> 数据 = 向量<整32>();
    如果 (数据.为空()) {
        打印("向量初始为空: 是");
    } 否则 {
        打印("向量初始为空: 否");
    }

    // 追加 6 个元素(触发扩容 0 -> 4 -> 8)
    结果<空类型, 整32> 追加结果 = 数据.追加(1);
    如果 (追加结果.正常) {
        追加结果 = 数据.追加(2);
        追加结果 = 数据.追加(3);
        追加结果 = 数据.追加(4);
        追加结果 = 数据.追加(5);
        追加结果 = 数据.追加(6);
    } 否则 {
        打印("向量追加失败: ", 追加结果.错误);
    }
    打印("向量大小: ", 数据.大小());
    打印("向量容量: ", 数据.容量());

    // 读取(正常路径)
    结果<整32, 整32> 读取结果 = 数据.读取(0);
    如果 (读取结果.正常) {
        打印("读取[0]: ", 读取结果.值);
    } 否则 {
        打印("读取[0]失败: ", 读取结果.错误);
    }

    // 读取(越界路径:错误码 2)
    读取结果 = 数据.读取(99);
    如果 (读取结果.正常) {
        打印("读取[99]未报错");
    } 否则 {
        打印("读取[99]越界: ", 读取结果.错误);
    }

    // 插入 + 删除 + 设置
    追加结果 = 数据.插入(0, 99);
    如果 (追加结果.正常) {
        打印("插入后[0]: ", 数据.元素(0));
    } 否则 {
        打印("插入失败: ", 追加结果.错误);
    }
    追加结果 = 数据.删除(0);
    如果 (追加结果.正常) {
        打印("删除后[0]: ", 数据.元素(0));
    } 否则 {
        打印("删除失败: ", 追加结果.错误);
    }
    追加结果 = 数据.设置(0, 7);
    如果 (追加结果.正常) {
        打印("设置后[0]: ", 数据.元素(0));
    } 否则 {
        打印("设置失败: ", 追加结果.错误);
    }

    // ==================== 2. 链表<T> ====================
    链表<整32> 列表 = 链表<整32>();
    追加结果 = 列表.追加(10);
    如果 (追加结果.正常) {
        追加结果 = 列表.追加(20);
        追加结果 = 列表.追加(30);
    } 否则 {
        打印("链表追加失败: ", 追加结果.错误);
    }
    打印("链表大小: ", 列表.大小());
    结果<整32, 整32> 头结果 = 列表.读取头部();
    如果 (头结果.正常) {
        打印("链表头: ", 头结果.值);
    } 否则 {
        打印("链表头失败: ", 头结果.错误);
    }
    结果<整32, 整32> 尾结果 = 列表.读取尾部();
    如果 (尾结果.正常) {
        打印("链表尾: ", 尾结果.值);
    } 否则 {
        打印("链表尾失败: ", 尾结果.错误);
    }

    // 头部追加
    追加结果 = 列表.头部追加(5);
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("头部追加后链表头: ", 头结果.值);
        } 否则 {
            打印("头部追加后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("头部追加失败: ", 追加结果.错误);
    }
    打印("头部追加后链表大小: ", 列表.大小());

    // 删除头部 + 删除尾部
    追加结果 = 列表.删除头部();
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("删除头部后链表头: ", 头结果.值);
        } 否则 {
            打印("删除头部后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("删除头部失败: ", 追加结果.错误);
    }
    追加结果 = 列表.删除尾部();
    如果 (追加结果.正常) {
        尾结果 = 列表.读取尾部();
        如果 (尾结果.正常) {
            打印("删除尾部后链表尾: ", 尾结果.值);
        } 否则 {
            打印("删除尾部后读尾失败: ", 尾结果.错误);
        }
    } 否则 {
        打印("删除尾部失败: ", 追加结果.错误);
    }

    // ==================== 3. 栈<T> ====================
    栈<整32> 数据栈 = 栈<整32>();
    追加结果 = 数据栈.压入(1);
    如果 (追加结果.正常) {
        追加结果 = 数据栈.压入(2);
        追加结果 = 数据栈.压入(3);
    } 否则 {
        打印("压入失败: ", 追加结果.错误);
    }
    打印("栈大小: ", 数据栈.大小());
    结果<整32, 整32> 栈顶结果 = 数据栈.栈顶();
    如果 (栈顶结果.正常) {
        打印("栈顶: ", 栈顶结果.值);
    } 否则 {
        打印("栈顶失败: ", 栈顶结果.错误);
    }
    结果<整32, 整32> 弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("弹出: ", 弹出结果.值);
    } 否则 {
        打印("弹出失败: ", 弹出结果.错误);
    }
    弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("再弹出: ", 弹出结果.值);
    } 否则 {
        打印("再弹出失败: ", 弹出结果.错误);
    }
    打印("弹后栈大小: ", 数据栈.大小());

    // ==================== 4. 队列<T> ====================
    队列<整32> 数据队列 = 队列<整32>();
    追加结果 = 数据队列.入队(5);
    如果 (追加结果.正常) {
        追加结果 = 数据队列.入队(6);
        追加结果 = 数据队列.入队(7);
    } 否则 {
        打印("入队失败: ", 追加结果.错误);
    }
    打印("队列大小: ", 数据队列.大小());
    结果<整32, 整32> 队首结果 = 数据队列.队首();
    如果 (队首结果.正常) {
        打印("队首: ", 队首结果.值);
    } 否则 {
        打印("队首失败: ", 队首结果.错误);
    }
    结果<整32, 整32> 出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("出队: ", 出队结果.值);
    } 否则 {
        打印("出队失败: ", 出队结果.错误);
    }
    出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("再出队: ", 出队结果.值);
    } 否则 {
        打印("再出队失败: ", 出队结果.错误);
    }
    打印("出队后队列大小: ", 数据队列.大小());

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

输出:===== 容器库(Task 6.1)===== 向量初始为空: 是 向量大小: 6 向量容量: 8 读取[0]: 1 读取[99]越界: 2 插入后[0]: 99 删除后[0]: 1 设置后[0]: 7 链表大小: 3 链表头: 10 链表尾: 30 头部追加后链表头: 5 头部追加后链表大小: 4 删除头部后链表头: 10 删除尾部后链表尾: 20 栈大小: 3 栈顶: 3 弹出: 3 再弹出: 2 弹后栈大小: 1 队列大小: 3 队首: 5 出队: 5 再出队: 6 出队后队列大小: 1 ===== 容器库测试完成 =====

清空

函数 清空()

元素个数清零(容量保留,底层内存不释放)。字符串/类元素为空时会走编译器注入的全量析构面;之后容器可继续使用。

主.cnCN

导入 容器::链表;
导入 容器::栈;
导入 容器::队列;

静态 整64 计数 = 0;
静态 整64 监视 = 0;
静态 整64 累计 = 0;

类 资源 {
公开:
    整64 编号;
    函数 资源(整64 v) { 编号 = v; }
    函数 资源(资源& 其他) { 编号 = 其他.编号; }
    不安全 函数 ~资源() {
        计数 = 计数 + 1;
        如果 (监视 == 1) {
            累计 = 累计 * 10 + 编号;
        }
    }
}

不安全 函数 主() -> 整32 {
    // 链表:删除头部/删除尾部/清空 自动析构被移除元素(身份序 1→3→2)
    {
        链表<资源> 表;
        资源 r1 = 资源(1);
        资源 r2 = 资源(2);
        资源 r3 = 资源(3);
        结果<空类型, 整32> a1 = 表.追加(r1);
        结果<空类型, 整32> a2 = 表.追加(r2);
        结果<空类型, 整32> a3 = 表.追加(r3);
        打印("链表 大小: ", 表.大小());
        监视 = 1;
        累计 = 0;
        结果<空类型, 整32> d1 = 表.删除头部();   // 析构被移除元素 +1(E1)
        打印("删头后: ", 表.大小(), " 析构: ", 计数);
        结果<空类型, 整32> d2 = 表.删除尾部();   // +1(E3)
        打印("删尾后: ", 表.大小(), " 析构: ", 计数);
        表.清空();                               // +1(E2·链游剩余链元素)
        监视 = 0;
        打印("清空后: ", 表.大小(), " 析构: ", 计数);
        打印("链表析构序: ", 累计);              // 132 = E1→E3→E2
    }
    打印("链表块结束: ", 计数);  // r1/r2/r3 块出口已析构(块级 RAII):3+3=6

    // 栈:弹出 返回元素(所有权转移),不析构
    {
        栈<资源> 栈表;
        资源 s1 = 资源(1);
        资源 s2 = 资源(2);
        结果<空类型, 整32> p1 = 栈表.压入(s1);
        结果<空类型, 整32> p2 = 栈表.压入(s2);
        结果<资源, 整32> 弹 = 栈表.弹出();
        打印("栈弹出后大小: ", 栈表.大小(), " 析构: ", 计数);
    }

    // 队列:出队 返回元素(所有权转移给盒)·盒亡析构(182 正账);清空 自动析构剩余
    {
        队列<资源> 队列表;
        资源 q1 = 资源(1);
        资源 q2 = 资源(2);
        资源 q3 = 资源(3);
        结果<空类型, 整32> qa1 = 队列表.入队(q1);
        结果<空类型, 整32> qa2 = 队列表.入队(q2);
        结果<空类型, 整32> qa3 = 队列表.入队(q3);
        结果<资源, 整32> 出 = 队列表.出队();
        打印("队弹出后: ", 队列表.大小(), " 析构: ", 计数);
        监视 = 1;
        累计 = 0;
        队列表.清空();                          // 析构剩余 2 个 +2(E2,E3·链游)
        监视 = 0;
        打印("队清空后: ", 队列表.大小(), " 析构: ", 计数);
        打印("队列清空序: ", 累计);              // 23 = E2→E3
    }
    返回 0;
}

输出:链表 大小: 3 删头后: 2 析构: 1 删尾后: 1 析构: 2 清空后: 0 析构: 3 链表析构序: 132 链表块结束: 6 栈弹出后大小: 1 析构: 6 队弹出后: 2 析构: 10 队清空后: 0 析构: 12 队列清空序: 23

析构元素 内部

函数 析构元素(整64 索引)

编译器注入挂点(源码空体):T 为有析构类时,发射层在此注入单元素析构调用。仅 删除 的移位循环使用,业务代码不要调用。

析构被移除 内部

函数 析构被移除(整64 索引)

编译器注入挂点:T=字符串 时释放被移除/被覆盖槽的字符串并清零(唯一持有者),有析构类零注入(其析构由 析构元素 链负责)。删除/设置 内部使用。

移动元素 内部 不安全

不安全 函数 移动元素(整64 目标, 整64 源)

编译器注入挂点:按元素类型发射 memcpy + 源槽资源清零(Rust ptr::copy + 源失效同款,零拷贝)。插入/删除 的移位循环使用。

链表<T>(索引链表)

对标 C++ std::list。实现为数组索引模拟链(T* 值表 + 整64* 下一索引,-1 表链尾),删除后的槽位经空闲链 O(1) 复用。头尾插删均为 O(1);删除尾部需链游 O(n)。

链表()

函数 链表()

构造空链表。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 容器::错误码;

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

    // ==================== 1. 向量<T> ====================
    向量<整32> 数据 = 向量<整32>();
    如果 (数据.为空()) {
        打印("向量初始为空: 是");
    } 否则 {
        打印("向量初始为空: 否");
    }

    // 追加 6 个元素(触发扩容 0 -> 4 -> 8)
    结果<空类型, 整32> 追加结果 = 数据.追加(1);
    如果 (追加结果.正常) {
        追加结果 = 数据.追加(2);
        追加结果 = 数据.追加(3);
        追加结果 = 数据.追加(4);
        追加结果 = 数据.追加(5);
        追加结果 = 数据.追加(6);
    } 否则 {
        打印("向量追加失败: ", 追加结果.错误);
    }
    打印("向量大小: ", 数据.大小());
    打印("向量容量: ", 数据.容量());

    // 读取(正常路径)
    结果<整32, 整32> 读取结果 = 数据.读取(0);
    如果 (读取结果.正常) {
        打印("读取[0]: ", 读取结果.值);
    } 否则 {
        打印("读取[0]失败: ", 读取结果.错误);
    }

    // 读取(越界路径:错误码 2)
    读取结果 = 数据.读取(99);
    如果 (读取结果.正常) {
        打印("读取[99]未报错");
    } 否则 {
        打印("读取[99]越界: ", 读取结果.错误);
    }

    // 插入 + 删除 + 设置
    追加结果 = 数据.插入(0, 99);
    如果 (追加结果.正常) {
        打印("插入后[0]: ", 数据.元素(0));
    } 否则 {
        打印("插入失败: ", 追加结果.错误);
    }
    追加结果 = 数据.删除(0);
    如果 (追加结果.正常) {
        打印("删除后[0]: ", 数据.元素(0));
    } 否则 {
        打印("删除失败: ", 追加结果.错误);
    }
    追加结果 = 数据.设置(0, 7);
    如果 (追加结果.正常) {
        打印("设置后[0]: ", 数据.元素(0));
    } 否则 {
        打印("设置失败: ", 追加结果.错误);
    }

    // ==================== 2. 链表<T> ====================
    链表<整32> 列表 = 链表<整32>();
    追加结果 = 列表.追加(10);
    如果 (追加结果.正常) {
        追加结果 = 列表.追加(20);
        追加结果 = 列表.追加(30);
    } 否则 {
        打印("链表追加失败: ", 追加结果.错误);
    }
    打印("链表大小: ", 列表.大小());
    结果<整32, 整32> 头结果 = 列表.读取头部();
    如果 (头结果.正常) {
        打印("链表头: ", 头结果.值);
    } 否则 {
        打印("链表头失败: ", 头结果.错误);
    }
    结果<整32, 整32> 尾结果 = 列表.读取尾部();
    如果 (尾结果.正常) {
        打印("链表尾: ", 尾结果.值);
    } 否则 {
        打印("链表尾失败: ", 尾结果.错误);
    }

    // 头部追加
    追加结果 = 列表.头部追加(5);
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("头部追加后链表头: ", 头结果.值);
        } 否则 {
            打印("头部追加后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("头部追加失败: ", 追加结果.错误);
    }
    打印("头部追加后链表大小: ", 列表.大小());

    // 删除头部 + 删除尾部
    追加结果 = 列表.删除头部();
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("删除头部后链表头: ", 头结果.值);
        } 否则 {
            打印("删除头部后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("删除头部失败: ", 追加结果.错误);
    }
    追加结果 = 列表.删除尾部();
    如果 (追加结果.正常) {
        尾结果 = 列表.读取尾部();
        如果 (尾结果.正常) {
            打印("删除尾部后链表尾: ", 尾结果.值);
        } 否则 {
            打印("删除尾部后读尾失败: ", 尾结果.错误);
        }
    } 否则 {
        打印("删除尾部失败: ", 追加结果.错误);
    }

    // ==================== 3. 栈<T> ====================
    栈<整32> 数据栈 = 栈<整32>();
    追加结果 = 数据栈.压入(1);
    如果 (追加结果.正常) {
        追加结果 = 数据栈.压入(2);
        追加结果 = 数据栈.压入(3);
    } 否则 {
        打印("压入失败: ", 追加结果.错误);
    }
    打印("栈大小: ", 数据栈.大小());
    结果<整32, 整32> 栈顶结果 = 数据栈.栈顶();
    如果 (栈顶结果.正常) {
        打印("栈顶: ", 栈顶结果.值);
    } 否则 {
        打印("栈顶失败: ", 栈顶结果.错误);
    }
    结果<整32, 整32> 弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("弹出: ", 弹出结果.值);
    } 否则 {
        打印("弹出失败: ", 弹出结果.错误);
    }
    弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("再弹出: ", 弹出结果.值);
    } 否则 {
        打印("再弹出失败: ", 弹出结果.错误);
    }
    打印("弹后栈大小: ", 数据栈.大小());

    // ==================== 4. 队列<T> ====================
    队列<整32> 数据队列 = 队列<整32>();
    追加结果 = 数据队列.入队(5);
    如果 (追加结果.正常) {
        追加结果 = 数据队列.入队(6);
        追加结果 = 数据队列.入队(7);
    } 否则 {
        打印("入队失败: ", 追加结果.错误);
    }
    打印("队列大小: ", 数据队列.大小());
    结果<整32, 整32> 队首结果 = 数据队列.队首();
    如果 (队首结果.正常) {
        打印("队首: ", 队首结果.值);
    } 否则 {
        打印("队首失败: ", 队首结果.错误);
    }
    结果<整32, 整32> 出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("出队: ", 出队结果.值);
    } 否则 {
        打印("出队失败: ", 出队结果.错误);
    }
    出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("再出队: ", 出队结果.值);
    } 否则 {
        打印("再出队失败: ", 出队结果.错误);
    }
    打印("出队后队列大小: ", 数据队列.大小());

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

输出:===== 容器库(Task 6.1)===== 向量初始为空: 是 向量大小: 6 向量容量: 8 读取[0]: 1 读取[99]越界: 2 插入后[0]: 99 删除后[0]: 1 设置后[0]: 7 链表大小: 3 链表头: 10 链表尾: 30 头部追加后链表头: 5 头部追加后链表大小: 4 删除头部后链表头: 10 删除尾部后链表尾: 20 栈大小: 3 栈顶: 3 弹出: 3 再弹出: 2 弹后栈大小: 1 队列大小: 3 队首: 5 出队: 5 再出队: 6 出队后队列大小: 1 ===== 容器库测试完成 =====

链表(其他) 不安全

不安全 函数 链表(链表& 其他)

拷贝构造:链游复制——链上有效元素逐元素深拷;空闲槽不复值。

参数类型说明
其他链表&被拷贝的链表

主.cnCN

导入 容器::向量;

结构体 表盒 {
    向量<整64> 项;
}

函数 重填引用(向量<整64>& 目标) -> 空类型 {
    向量<整64> 新表 = 向量<整64>();
    结果<空类型, 整32> 加 = 新表.追加(99);
    如果 (!加.正常) { 运行时错误(4); }
    目标 = 新表;
}

函数 重填字段(表盒& 盒) -> 空类型 {
    向量<整64> 新表 = 向量<整64>();
    结果<空类型, 整32> 加 = 新表.追加(7);
    如果 (!加.正常) { 运行时错误(4); }
    盒.项 = 新表;
}

类 袋子 {
公开:
    整64 计数;
    向量<整64> 装;
    函数 袋子() {
        计数 = 0;
        装 = 向量<整64>();
    }
}

函数 主() -> 整32 {
    // ① 标识符左值:乙 = 甲(深拷贝——改乙不影响甲)
    向量<整64> 甲 = 向量<整64>();
    结果<空类型, 整32> 加1 = 甲.追加(1);
    如果 (!加1.正常) { 运行时错误(4); }
    向量<整64> 乙 = 向量<整64>();
    乙 = 甲;
    打印("A1 乙大小=", 乙.大小());
    结果<空类型, 整32> 加2 = 乙.追加(2);
    如果 (!加2.正常) { 运行时错误(4); }
    打印("A1 甲大小=", 甲.大小());
    打印("A1 乙大小=", 乙.大小());
    // ② 引用参数左值:向量引用参数整体赋值写回调用方
    向量<整64> 丙 = 向量<整64>();
    结果<空类型, 整32> 加3 = 丙.追加(1);
    如果 (!加3.正常) { 运行时错误(4); }
    重填引用(丙);
    打印("A2 丙大小=", 丙.大小());
    打印("A2 丙首=", 丙.元素(0));
    // ③ 成员链左值:结构体引用参数的容器字段整体赋值
    表盒 盒 = 表盒{ 项 = 向量<整64>() };
    重填字段(盒);
    打印("A3 盒大小=", 盒.项.大小());
    打印("A3 盒首=", 盒.项.元素(0));
    // ④ 类对象「成员链左值」标量字段 + 容器字段赋值(类基址=对象指针非槽地址)
    袋子 袋;
    袋.计数 = 5;
    打印("A4 袋计数=", 袋.计数);
    // ⑤ 类对象「引用参数」成员链赋值见 442_v2(v2 闭环)——宿主侧该形态为
    //   plans/020 第五十四节 142-a 已登记欠账(用户类字段泛化回退·正解=波4 复制(x)),
    //   双编译对照暂不可用。
    返回 0;
}

输出:A1 乙大小=1 A1 甲大小=1 A1 乙大小=2 A2 丙大小=1 A2 丙首=99 A3 盒大小=1 A3 盒首=7 A4 袋计数=5

大小 常量

常量 函数 大小() -> 整64

当前元素个数。

主.cnCN

导入 容器::链表;
导入 容器::栈;
导入 容器::队列;

静态 整64 计数 = 0;
静态 整64 监视 = 0;
静态 整64 累计 = 0;

类 资源 {
公开:
    整64 编号;
    函数 资源(整64 v) { 编号 = v; }
    函数 资源(资源& 其他) { 编号 = 其他.编号; }
    不安全 函数 ~资源() {
        计数 = 计数 + 1;
        如果 (监视 == 1) {
            累计 = 累计 * 10 + 编号;
        }
    }
}

不安全 函数 主() -> 整32 {
    // 链表:删除头部/删除尾部/清空 自动析构被移除元素(身份序 1→3→2)
    {
        链表<资源> 表;
        资源 r1 = 资源(1);
        资源 r2 = 资源(2);
        资源 r3 = 资源(3);
        结果<空类型, 整32> a1 = 表.追加(r1);
        结果<空类型, 整32> a2 = 表.追加(r2);
        结果<空类型, 整32> a3 = 表.追加(r3);
        打印("链表 大小: ", 表.大小());
        监视 = 1;
        累计 = 0;
        结果<空类型, 整32> d1 = 表.删除头部();   // 析构被移除元素 +1(E1)
        打印("删头后: ", 表.大小(), " 析构: ", 计数);
        结果<空类型, 整32> d2 = 表.删除尾部();   // +1(E3)
        打印("删尾后: ", 表.大小(), " 析构: ", 计数);
        表.清空();                               // +1(E2·链游剩余链元素)
        监视 = 0;
        打印("清空后: ", 表.大小(), " 析构: ", 计数);
        打印("链表析构序: ", 累计);              // 132 = E1→E3→E2
    }
    打印("链表块结束: ", 计数);  // r1/r2/r3 块出口已析构(块级 RAII):3+3=6

    // 栈:弹出 返回元素(所有权转移),不析构
    {
        栈<资源> 栈表;
        资源 s1 = 资源(1);
        资源 s2 = 资源(2);
        结果<空类型, 整32> p1 = 栈表.压入(s1);
        结果<空类型, 整32> p2 = 栈表.压入(s2);
        结果<资源, 整32> 弹 = 栈表.弹出();
        打印("栈弹出后大小: ", 栈表.大小(), " 析构: ", 计数);
    }

    // 队列:出队 返回元素(所有权转移给盒)·盒亡析构(182 正账);清空 自动析构剩余
    {
        队列<资源> 队列表;
        资源 q1 = 资源(1);
        资源 q2 = 资源(2);
        资源 q3 = 资源(3);
        结果<空类型, 整32> qa1 = 队列表.入队(q1);
        结果<空类型, 整32> qa2 = 队列表.入队(q2);
        结果<空类型, 整32> qa3 = 队列表.入队(q3);
        结果<资源, 整32> 出 = 队列表.出队();
        打印("队弹出后: ", 队列表.大小(), " 析构: ", 计数);
        监视 = 1;
        累计 = 0;
        队列表.清空();                          // 析构剩余 2 个 +2(E2,E3·链游)
        监视 = 0;
        打印("队清空后: ", 队列表.大小(), " 析构: ", 计数);
        打印("队列清空序: ", 累计);              // 23 = E2→E3
    }
    返回 0;
}

输出:链表 大小: 3 删头后: 2 析构: 1 删尾后: 1 析构: 2 清空后: 0 析构: 3 链表析构序: 132 链表块结束: 6 栈弹出后大小: 1 析构: 6 队弹出后: 2 析构: 10 队清空后: 0 析构: 12 队列清空序: 23

为空 常量

常量 函数 为空() -> 布尔

元素个数是否为 0。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 容器::错误码;

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

    // ==================== 1. 向量<T> ====================
    向量<整32> 数据 = 向量<整32>();
    如果 (数据.为空()) {
        打印("向量初始为空: 是");
    } 否则 {
        打印("向量初始为空: 否");
    }

    // 追加 6 个元素(触发扩容 0 -> 4 -> 8)
    结果<空类型, 整32> 追加结果 = 数据.追加(1);
    如果 (追加结果.正常) {
        追加结果 = 数据.追加(2);
        追加结果 = 数据.追加(3);
        追加结果 = 数据.追加(4);
        追加结果 = 数据.追加(5);
        追加结果 = 数据.追加(6);
    } 否则 {
        打印("向量追加失败: ", 追加结果.错误);
    }
    打印("向量大小: ", 数据.大小());
    打印("向量容量: ", 数据.容量());

    // 读取(正常路径)
    结果<整32, 整32> 读取结果 = 数据.读取(0);
    如果 (读取结果.正常) {
        打印("读取[0]: ", 读取结果.值);
    } 否则 {
        打印("读取[0]失败: ", 读取结果.错误);
    }

    // 读取(越界路径:错误码 2)
    读取结果 = 数据.读取(99);
    如果 (读取结果.正常) {
        打印("读取[99]未报错");
    } 否则 {
        打印("读取[99]越界: ", 读取结果.错误);
    }

    // 插入 + 删除 + 设置
    追加结果 = 数据.插入(0, 99);
    如果 (追加结果.正常) {
        打印("插入后[0]: ", 数据.元素(0));
    } 否则 {
        打印("插入失败: ", 追加结果.错误);
    }
    追加结果 = 数据.删除(0);
    如果 (追加结果.正常) {
        打印("删除后[0]: ", 数据.元素(0));
    } 否则 {
        打印("删除失败: ", 追加结果.错误);
    }
    追加结果 = 数据.设置(0, 7);
    如果 (追加结果.正常) {
        打印("设置后[0]: ", 数据.元素(0));
    } 否则 {
        打印("设置失败: ", 追加结果.错误);
    }

    // ==================== 2. 链表<T> ====================
    链表<整32> 列表 = 链表<整32>();
    追加结果 = 列表.追加(10);
    如果 (追加结果.正常) {
        追加结果 = 列表.追加(20);
        追加结果 = 列表.追加(30);
    } 否则 {
        打印("链表追加失败: ", 追加结果.错误);
    }
    打印("链表大小: ", 列表.大小());
    结果<整32, 整32> 头结果 = 列表.读取头部();
    如果 (头结果.正常) {
        打印("链表头: ", 头结果.值);
    } 否则 {
        打印("链表头失败: ", 头结果.错误);
    }
    结果<整32, 整32> 尾结果 = 列表.读取尾部();
    如果 (尾结果.正常) {
        打印("链表尾: ", 尾结果.值);
    } 否则 {
        打印("链表尾失败: ", 尾结果.错误);
    }

    // 头部追加
    追加结果 = 列表.头部追加(5);
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("头部追加后链表头: ", 头结果.值);
        } 否则 {
            打印("头部追加后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("头部追加失败: ", 追加结果.错误);
    }
    打印("头部追加后链表大小: ", 列表.大小());

    // 删除头部 + 删除尾部
    追加结果 = 列表.删除头部();
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("删除头部后链表头: ", 头结果.值);
        } 否则 {
            打印("删除头部后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("删除头部失败: ", 追加结果.错误);
    }
    追加结果 = 列表.删除尾部();
    如果 (追加结果.正常) {
        尾结果 = 列表.读取尾部();
        如果 (尾结果.正常) {
            打印("删除尾部后链表尾: ", 尾结果.值);
        } 否则 {
            打印("删除尾部后读尾失败: ", 尾结果.错误);
        }
    } 否则 {
        打印("删除尾部失败: ", 追加结果.错误);
    }

    // ==================== 3. 栈<T> ====================
    栈<整32> 数据栈 = 栈<整32>();
    追加结果 = 数据栈.压入(1);
    如果 (追加结果.正常) {
        追加结果 = 数据栈.压入(2);
        追加结果 = 数据栈.压入(3);
    } 否则 {
        打印("压入失败: ", 追加结果.错误);
    }
    打印("栈大小: ", 数据栈.大小());
    结果<整32, 整32> 栈顶结果 = 数据栈.栈顶();
    如果 (栈顶结果.正常) {
        打印("栈顶: ", 栈顶结果.值);
    } 否则 {
        打印("栈顶失败: ", 栈顶结果.错误);
    }
    结果<整32, 整32> 弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("弹出: ", 弹出结果.值);
    } 否则 {
        打印("弹出失败: ", 弹出结果.错误);
    }
    弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("再弹出: ", 弹出结果.值);
    } 否则 {
        打印("再弹出失败: ", 弹出结果.错误);
    }
    打印("弹后栈大小: ", 数据栈.大小());

    // ==================== 4. 队列<T> ====================
    队列<整32> 数据队列 = 队列<整32>();
    追加结果 = 数据队列.入队(5);
    如果 (追加结果.正常) {
        追加结果 = 数据队列.入队(6);
        追加结果 = 数据队列.入队(7);
    } 否则 {
        打印("入队失败: ", 追加结果.错误);
    }
    打印("队列大小: ", 数据队列.大小());
    结果<整32, 整32> 队首结果 = 数据队列.队首();
    如果 (队首结果.正常) {
        打印("队首: ", 队首结果.值);
    } 否则 {
        打印("队首失败: ", 队首结果.错误);
    }
    结果<整32, 整32> 出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("出队: ", 出队结果.值);
    } 否则 {
        打印("出队失败: ", 出队结果.错误);
    }
    出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("再出队: ", 出队结果.值);
    } 否则 {
        打印("再出队失败: ", 出队结果.错误);
    }
    打印("出队后队列大小: ", 数据队列.大小());

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

输出:===== 容器库(Task 6.1)===== 向量初始为空: 是 向量大小: 6 向量容量: 8 读取[0]: 1 读取[99]越界: 2 插入后[0]: 99 删除后[0]: 1 设置后[0]: 7 链表大小: 3 链表头: 10 链表尾: 30 头部追加后链表头: 5 头部追加后链表大小: 4 删除头部后链表头: 10 删除尾部后链表尾: 20 栈大小: 3 栈顶: 3 弹出: 3 再弹出: 2 弹后栈大小: 1 队列大小: 3 队首: 5 出队: 5 再出队: 6 出队后队列大小: 1 ===== 容器库测试完成 =====

追加 不安全

不安全 函数 追加(T 值) -> 结果<空类型, 整32>

尾部追加(尾插 O(1))。

参数类型说明
值T要追加的元素

返回 正常();扩容失败 → 错误(错误码.内存)。

主.cnCN

导入 容器::链表;
导入 容器::队列;

// ① 链表<整64>:追加 3 + 删除头部 + 追加(槽复用后序列完整)
函数 形一() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(11);
        结果<空类型, 整32> a2 = 链.追加(22);
        结果<空类型, 整32> a3 = 链.追加(33);
        结果<空类型, 整32> d1 = 链.删除头部();
        结果<空类型, 整32> a4 = 链.追加(44);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 223344) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验;
}

// ② 队列<整64>:入队 3 + 出队 + 入队(出队序完整)
函数 形二() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        队列<整64> 队 = 队列<整64>();
        结果<空类型, 整32> q1 = 队.入队(11);
        结果<空类型, 整32> q2 = 队.入队(22);
        结果<空类型, 整32> q3 = 队.入队(33);
        结果<整64, 整32> o1 = 队.出队();
        结果<空类型, 整32> q4 = 队.入队(44);
        整64 序 = 0;
        当 (队.大小() > 0) {
            结果<整64, 整32> o = 队.出队();
            如果 (o.正常) {
                序 = 序 * 100 + o.值;
            } 否则 {
                校验 = 99;
            }
        }
        如果 (序 == 223344) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 2;
}

// ③ 链表<字符串>:槽复用 + 内容守恒 + 残留归零
函数 形三() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<字符串> 链 = 链表<字符串>();
        结果<空类型, 整32> s1 = 链.追加(字符串复制("形三甲串内容甲乙丙丁戊"));
        结果<空类型, 整32> s2 = 链.追加(字符串复制("形三乙串内容甲乙丙丁戊"));
        结果<空类型, 整32> sd = 链.删除头部();
        结果<空类型, 整32> s3 = 链.追加(字符串复制("形三丙串内容甲乙丙丁戊"));
        结果<字符串, 整32> sh = 链.读取头部();
        如果 (sh.正常) {
            如果 (字符串比较(sh.值, "形三乙串内容甲乙丙丁戊")) { 校验 = 1; }
        }
        结果<字符串, 整32> st = 链.读取尾部();
        如果 (st.正常) {
            如果 (!字符串比较(st.值, "形三丙串内容甲乙丙丁戊")) { 校验 = 0; }
        }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 4;
}

// ④ 队列<字符串>:槽复用 + 内容守恒 + 残留归零
函数 形四() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        队列<字符串> 队 = 队列<字符串>();
        结果<空类型, 整32> s1 = 队.入队(字符串复制("形四甲串内容甲乙丙丁戊"));
        结果<空类型, 整32> s2 = 队.入队(字符串复制("形四乙串内容甲乙丙丁戊"));
        结果<字符串, 整32> o1 = 队.出队();
        结果<空类型, 整32> s3 = 队.入队(字符串复制("形四丙串内容甲乙丙丁戊"));
        结果<字符串, 整32> f = 队.队首();
        如果 (f.正常) {
            如果 (字符串比较(f.值, "形四乙串内容甲乙丙丁戊")) { 校验 = 1; }
        }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 8;
}

// ⑤ 链表 删除尾部 + 复用(被摘槽归还后重分配)
函数 形五() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(51);
        结果<空类型, 整32> a2 = 链.追加(52);
        结果<空类型, 整32> a3 = 链.追加(53);
        结果<空类型, 整32> d1 = 链.删除尾部();
        结果<空类型, 整32> a4 = 链.追加(54);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 515254) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 16;
}

// ⑥ 链表 头部追加 + 复用
函数 形六() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(61);
        结果<空类型, 整32> a2 = 链.头部追加(62);
        结果<空类型, 整32> a3 = 链.头部追加(63);
        结果<空类型, 整32> d1 = 链.删除头部();
        结果<空类型, 整32> a4 = 链.头部追加(64);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 646261) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 32;
}

// ⑦ 循环 20 万轮(入队/出队搅动)残留归零 + 值守恒
函数 形七(整64 轮数) -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 i = 0;
    当 (i < 轮数) {
        队列<整64> 队 = 队列<整64>();
        结果<空类型, 整32> q1 = 队.入队(i);
        结果<空类型, 整32> q2 = 队.入队(i + 1);
        结果<整64, 整32> o1 = 队.出队();
        如果 (o1.正常) {
            如果 (o1.值 != i) { 返回 0; }
        } 否则 {
            返回 0;
        }
        i++;
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 64;
}

// ⑧ 链表 清空 + 复用(清空后槽从 0 重分配)
函数 形八() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(81);
        结果<空类型, 整32> a2 = 链.追加(82);
        链.清空();
        结果<空类型, 整32> a3 = 链.追加(83);
        结果<空类型, 整32> a4 = 链.追加(84);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 8384) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 128;
}

函数 主() -> 整32 {
    整64 和 = 0;
    和 = 和 + 形一();
    和 = 和 + 形二();
    和 = 和 + 形三();
    和 = 和 + 形四();
    和 = 和 + 形五();
    和 = 和 + 形六();
    和 = 和 + 形七(200000);
    和 = 和 + 形八();
    返回 整32(和);
}

输出:[p6h] 已解析: target/audit2/v2src227/主.cn

头部追加 不安全

不安全 函数 头部追加(T 值) -> 结果<空类型, 整32>

头部插入(头插 O(1))。

参数类型说明
值T要插入的元素

返回 正常();扩容失败 → 错误(错误码.内存)。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 映射集合;

结构体 盒子 {
    字符串 名;
    整32 号;
}

函数 搅动() -> 整64 {
    整64 和 = 0;
    整64 i = 0;
    当 (i < 16) {
        字符串 垃圾 = 字符串复制("搅动内存填充占位字符串内容甲乙丙丁戊己庚辛壬癸");
        和 = 和 + 字符串长度(垃圾);
        i++;
    }
    返回 和;
}

函数 造盒子(整32 号) -> 盒子 {
    盒子 内 = 盒子{ 名 = 字符串复制("E235占位内容甲乙丙丁戊己庚辛壬癸子丑寅卯辰"), 号 = 号 };
    返回 内;
}

// ① 调用返回实参入容器
函数 形一() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        结果<空类型, 整32> 加 = 表.追加(造盒子(1));
        如果 (!加.正常) { 返回 0; }
        盒子 读 = 表.元素(0);
        如果 (读.号 == 1 && 字符串比较(读.名, "E235占位内容甲乙丙丁戊己庚辛壬癸子丑寅卯辰")) { 校验 = 1; }
        搅动();
        盒子 读2 = 表.元素(0);
        如果 (!字符串比较(读2.名, "E235占位内容甲乙丙丁戊己庚辛壬癸子丑寅卯辰")) { 校验 = 0; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验;
}

// ② 结构体字面量实参入容器
函数 形二() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        结果<空类型, 整32> 加 = 表.追加(盒子{ 名 = 字符串复制("E235字面量内容甲乙丙丁戊己庚辛壬癸子丑"), 号 = 2 });
        如果 (!加.正常) { 返回 0; }
        盒子 读 = 表.元素(0);
        如果 (读.号 == 2 && 字符串比较(读.名, "E235字面量内容甲乙丙丁戊己庚辛壬癸子丑")) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 2;
}

// ③ 结构体字面量实参传普通函数
函数 取号(盒子 箱) -> 整32 {
    返回 箱.号;
}

函数 形三() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        如果 (取号(盒子{ 名 = 字符串复制("E235普通函数内容甲乙丙丁戊己庚辛"), 号 = 3 }) == 3) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 4;
}

// ④ 向量 删除/设置 + 调用返回实参(元素移动路径)
函数 形四() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        结果<空类型, 整32> 加1 = 表.追加(造盒子(41));
        结果<空类型, 整32> 加2 = 表.追加(造盒子(42));
        如果 (!加1.正常 || !加2.正常) { 返回 0; }
        结果<空类型, 整32> 删 = 表.删除(0);
        如果 (!删.正常) { 返回 0; }
        盒子 读 = 表.元素(0);
        如果 (读.号 == 42) { 校验 = 1; }
        结果<空类型, 整32> 设 = 表.设置(0, 造盒子(43));
        如果 (!设.正常) { 返回 0; }
        盒子 读2 = 表.元素(0);
        如果 (读2.号 != 43) { 校验 = 0; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 8;
}

// ⑤ 链表/栈/队列/集合 结构体元素 + 删除/清空
函数 形五() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<盒子> 链 = 链表<盒子>();
        结果<空类型, 整32> 加1 = 链.头部追加(造盒子(51));
        结果<空类型, 整32> 加2 = 链.头部追加(造盒子(52));
        如果 (!加1.正常 || !加2.正常) { 返回 0; }
        结果<空类型, 整32> 删1 = 链.删除头部();
        如果 (!删1.正常) { 返回 0; }
        结果<盒子, 整32> 头 = 链.读取头部();
        如果 (头.正常) {
            如果 (头.值.号 == 51) { 校验 = 1; }
        } 否则 {
            校验 = 0;
        }
        栈<盒子> 栈表 = 栈<盒子>();
        结果<空类型, 整32> 压 = 栈表.压入(造盒子(53));
        如果 (!压.正常) { 返回 0; }
        队列<盒子> 队 = 队列<盒子>();
        结果<空类型, 整32> 入 = 队.入队(造盒子(54));
        如果 (!入.正常) { 返回 0; }
        集合<盒子> 集 = 集合<盒子>();
        结果<空类型, 整32> 添 = 集.添加(造盒子(55));
        如果 (!添.正常) { 返回 0; }
        布尔 删集 = 集.删除(造盒子(55));
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 16;
}

// ⑥ 循环 20 万轮(调用返回实参入容器)
函数 形六(整64 轮数) -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 i = 0;
    当 (i < 轮数) {
        向量<盒子> 表 = 向量<盒子>();
        结果<空类型, 整32> 加 = 表.追加(造盒子(60));
        如果 (!加.正常) { 返回 0; }
        盒子 读 = 表.元素(0);
        如果 (读.号 != 60) { 返回 0; }
        i++;
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 32;
}

// ⑦ 借用来源(形参串)与调用返回实参组合
函数 存入返回(向量<盒子> 表, 字符串 值) -> 整64 {
    结果<空类型, 整32> 加 = 表.追加(盒子{ 名 = 值, 号 = 70 });
    如果 (!加.正常) { 返回 0; }
    返回 1;
}

函数 形七() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        字符串 本地 = 字符串复制("E235借用来源内容甲乙丙丁戊己庚辛壬癸");
        结果<空类型, 整32> 加 = 表.追加(造盒子(71));
        如果 (!加.正常) { 返回 0; }
        如果 (存入返回(表, 本地) == 1) { 校验 = 1; }
        搅动();
        如果 (!字符串比较(本地, "E235借用来源内容甲乙丙丁戊己庚辛壬癸")) { 校验 = 0; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 64;
}

// ⑧ 结构体字面量传「含串字段形参」的被调函数(按值参数 ABI + 参数=借用视图读取)
//   注:被调方**写**按值参数字段 = 归一化复制落堆且被调方不释放(参数=借用视图)
//   ——79-a 登记的诚实边界(宁漏勿错),本用例只覆盖读取面(内容守恒)。
函数 查名(盒子 箱, 字符串 期望) -> 整32 {
    如果 (字符串比较(箱.名, 期望)) { 返回 1; }
    返回 0;
}

函数 形八() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        字符串 期望 = 字符串复制("E235参数读取内容甲乙丙丁戊己庚辛壬癸");
        如果 (查名(盒子{ 名 = 字符串复制("E235参数读取内容甲乙丙丁戊己庚辛壬癸"), 号 = 80 }, 期望) == 1) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 128;
}

函数 主() -> 整32 {
    整64 和 = 0;
    和 = 和 + 形一();
    和 = 和 + 形二();
    和 = 和 + 形三();
    和 = 和 + 形四();
    和 = 和 + 形五();
    和 = 和 + 形六(200000);
    和 = 和 + 形七();
    和 = 和 + 形八();
    打印("校验和(期望255)=", 和);
    返回 0;
}

输出:校验和(期望255)=255

删除头部 不安全

不安全 函数 删除头部() -> 结果<空类型, 整32>

摘除头元素(O(1));空表 → 错误。被摘槽归还空闲链供复用。

返回 正常();空表 → 错误(错误码.未初始化)。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;

结构体 盒子 {
    字符串 名;
    整32 号;
}

函数 搅动() -> 整64 {
    整64 和 = 0;
    整64 i = 0;
    当 (i < 16) {
        字符串 垃圾 = 字符串复制("E245搅动内存填充占位字符串内容甲乙丙丁戊己庚辛壬癸");
        和 = 和 + 字符串长度(垃圾);
        i++;
    }
    返回 和;
}

// ① 向量 追加((三元))
函数 形一() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形一真串甲甲甲甲甲甲甲甲甲甲"), 号 = 1 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形一假串乙乙乙乙乙乙乙乙乙乙"), 号 = 2 };
            结果<空类型, 整32> 加 = 表.追加(真 ? 甲 : 乙);
            如果 (!加.正常) { 返回 0; }
        }
        搅动();
        如果 (字符串比较(表.元素(0).名, "E245形一真串甲甲甲甲甲甲甲甲甲甲")) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 1; }
    返回 0;
}

// ② 向量 插入(0, (三元))
函数 形二() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形二真串甲甲甲甲甲甲甲甲甲甲"), 号 = 3 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形二假串乙乙乙乙乙乙乙乙乙乙"), 号 = 4 };
            结果<空类型, 整32> 插 = 表.插入(0, 假 ? 甲 : 乙);
            如果 (!插.正常) { 返回 0; }
        }
        搅动();
        如果 (字符串比较(表.元素(0).名, "E245形二假串乙乙乙乙乙乙乙乙乙乙")) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 2; }
    返回 0;
}

// ③ 链表 追加((三元))
函数 形三() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<盒子> 表 = 链表<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形三真串甲甲甲甲甲甲甲甲甲甲"), 号 = 5 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形三假串乙乙乙乙乙乙乙乙乙乙"), 号 = 6 };
            结果<空类型, 整32> 加 = 表.追加(真 ? 甲 : 乙);
            如果 (!加.正常) { 返回 0; }
        }
        搅动();
        如果 (字符串比较(表.头部元素().名, "E245形三真串甲甲甲甲甲甲甲甲甲甲")) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 4; }
    返回 0;
}

// ④ 栈 压入((三元)) + 弹出读出
函数 形四() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        栈<盒子> 表 = 栈<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形四真串甲甲甲甲甲甲甲甲甲甲"), 号 = 7 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形四假串乙乙乙乙乙乙乙乙乙乙"), 号 = 8 };
            结果<空类型, 整32> 压 = 表.压入(真 ? 甲 : 乙);
            如果 (!压.正常) { 返回 0; }
        }
        搅动();
        结果<盒子, 整32> 弹 = 表.弹出();
        如果 (弹.正常) {
            如果 (字符串比较(弹.值.名, "E245形四真串甲甲甲甲甲甲甲甲甲甲")) { 校验 = 1; }
        } 否则 {
            校验 = 0;
        }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 8; }
    返回 0;
}

// ⑤ 队列 入队((三元)) + 出队读出
函数 形五() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        队列<盒子> 表 = 队列<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形五真串甲甲甲甲甲甲甲甲甲甲"), 号 = 9 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形五假串乙乙乙乙乙乙乙乙乙乙"), 号 = 10 };
            结果<空类型, 整32> 入 = 表.入队(假 ? 甲 : 乙);
            如果 (!入.正常) { 返回 0; }
        }
        搅动();
        结果<盒子, 整32> 出 = 表.出队();
        如果 (出.正常) {
            如果 (字符串比较(出.值.名, "E245形五假串乙乙乙乙乙乙乙乙乙乙")) { 校验 = 1; }
        } 否则 {
            校验 = 0;
        }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 16; }
    返回 0;
}

// ⑥ 链表 头部追加((三元)) + 删除头部(移除路径 × 三元入容器)
函数 形六() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<盒子> 表 = 链表<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形六真串甲甲甲甲甲甲甲甲甲甲"), 号 = 11 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形六假串乙乙乙乙乙乙乙乙乙乙"), 号 = 12 };
            结果<空类型, 整32> 加 = 表.头部追加(真 ? 甲 : 乙);
            如果 (!加.正常) { 返回 0; }
            如果 (字符串比较(表.头部元素().名, "E245形六真串甲甲甲甲甲甲甲甲甲甲")) { 校验 = 1; }
            结果<空类型, 整32> 删 = 表.删除头部();
            如果 (!删.正常) { 校验 = 0; }
        }
        搅动();
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 32; }
    返回 0;
}

// ⑦ 容器读出(借出视图)→ 三元选择 → 再入容器
函数 形七() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形七真串甲甲甲甲甲甲甲甲甲甲"), 号 = 13 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形七假串乙乙乙乙乙乙乙乙乙乙"), 号 = 14 };
            结果<空类型, 整32> 加 = 表.追加(甲);
            如果 (!加.正常) { 返回 0; }
            盒子 读 = 表.元素(0);   // 借出视图 → 深拷接收
            结果<空类型, 整32> 再加 = 表.追加(真 ? 读 : 乙);
            如果 (!再加.正常) { 返回 0; }
        }
        搅动();
        如果 (字符串比较(表.元素(1).名, "E245形七真串甲甲甲甲甲甲甲甲甲甲")) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 64; }
    返回 0;
}

// ⑧ 循环 5 万轮(三元入容器 + 搅动)
函数 形八(整64 轮数) -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    整64 i = 0;
    当 (i < 轮数) {
        向量<盒子> 表 = 向量<盒子>();
        盒子 甲 = 盒子{ 名 = 字符串复制("E245形八真串甲乙丙丁戊己庚辛壬癸"), 号 = 88 };
        盒子 乙 = 盒子{ 名 = 字符串复制("E245形八假串甲乙丙丁戊己庚辛壬癸"), 号 = 99 };
        结果<空类型, 整32> 加 = 表.追加(真 ? 甲 : 乙);
        如果 (!加.正常) { 校验 = 0; 中断; }
        如果 (!字符串比较(表.元素(0).名, "E245形八真串甲乙丙丁戊己庚辛壬癸")) { 校验 = 0; 中断; }
        校验 = 1;
        i++;
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 128; }
    返回 0;
}

函数 主() -> 整32 {
    整64 和 = 0;
    和 = 和 + 形一();
    和 = 和 + 形二();
    和 = 和 + 形三();
    和 = 和 + 形四();
    和 = 和 + 形五();
    和 = 和 + 形六();
    和 = 和 + 形七();
    和 = 和 + 形八(50000);
    打印("校验和(期望255)=", 和);
    返回 0;
}

输出:校验和(期望255)=255

删除尾部 不安全

不安全 函数 删除尾部() -> 结果<空类型, 整32>

摘除尾元素;除单元素表外需从头部链游到倒数第二节点(O(n))。

返回 正常();空表 → 错误(错误码.未初始化)。

主.cnCN

导入 容器::链表;
导入 容器::队列;

// ① 链表<整64>:追加 3 + 删除头部 + 追加(槽复用后序列完整)
函数 形一() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(11);
        结果<空类型, 整32> a2 = 链.追加(22);
        结果<空类型, 整32> a3 = 链.追加(33);
        结果<空类型, 整32> d1 = 链.删除头部();
        结果<空类型, 整32> a4 = 链.追加(44);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 223344) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验;
}

// ② 队列<整64>:入队 3 + 出队 + 入队(出队序完整)
函数 形二() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        队列<整64> 队 = 队列<整64>();
        结果<空类型, 整32> q1 = 队.入队(11);
        结果<空类型, 整32> q2 = 队.入队(22);
        结果<空类型, 整32> q3 = 队.入队(33);
        结果<整64, 整32> o1 = 队.出队();
        结果<空类型, 整32> q4 = 队.入队(44);
        整64 序 = 0;
        当 (队.大小() > 0) {
            结果<整64, 整32> o = 队.出队();
            如果 (o.正常) {
                序 = 序 * 100 + o.值;
            } 否则 {
                校验 = 99;
            }
        }
        如果 (序 == 223344) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 2;
}

// ③ 链表<字符串>:槽复用 + 内容守恒 + 残留归零
函数 形三() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<字符串> 链 = 链表<字符串>();
        结果<空类型, 整32> s1 = 链.追加(字符串复制("形三甲串内容甲乙丙丁戊"));
        结果<空类型, 整32> s2 = 链.追加(字符串复制("形三乙串内容甲乙丙丁戊"));
        结果<空类型, 整32> sd = 链.删除头部();
        结果<空类型, 整32> s3 = 链.追加(字符串复制("形三丙串内容甲乙丙丁戊"));
        结果<字符串, 整32> sh = 链.读取头部();
        如果 (sh.正常) {
            如果 (字符串比较(sh.值, "形三乙串内容甲乙丙丁戊")) { 校验 = 1; }
        }
        结果<字符串, 整32> st = 链.读取尾部();
        如果 (st.正常) {
            如果 (!字符串比较(st.值, "形三丙串内容甲乙丙丁戊")) { 校验 = 0; }
        }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 4;
}

// ④ 队列<字符串>:槽复用 + 内容守恒 + 残留归零
函数 形四() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        队列<字符串> 队 = 队列<字符串>();
        结果<空类型, 整32> s1 = 队.入队(字符串复制("形四甲串内容甲乙丙丁戊"));
        结果<空类型, 整32> s2 = 队.入队(字符串复制("形四乙串内容甲乙丙丁戊"));
        结果<字符串, 整32> o1 = 队.出队();
        结果<空类型, 整32> s3 = 队.入队(字符串复制("形四丙串内容甲乙丙丁戊"));
        结果<字符串, 整32> f = 队.队首();
        如果 (f.正常) {
            如果 (字符串比较(f.值, "形四乙串内容甲乙丙丁戊")) { 校验 = 1; }
        }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 8;
}

// ⑤ 链表 删除尾部 + 复用(被摘槽归还后重分配)
函数 形五() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(51);
        结果<空类型, 整32> a2 = 链.追加(52);
        结果<空类型, 整32> a3 = 链.追加(53);
        结果<空类型, 整32> d1 = 链.删除尾部();
        结果<空类型, 整32> a4 = 链.追加(54);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 515254) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 16;
}

// ⑥ 链表 头部追加 + 复用
函数 形六() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(61);
        结果<空类型, 整32> a2 = 链.头部追加(62);
        结果<空类型, 整32> a3 = 链.头部追加(63);
        结果<空类型, 整32> d1 = 链.删除头部();
        结果<空类型, 整32> a4 = 链.头部追加(64);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 646261) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 32;
}

// ⑦ 循环 20 万轮(入队/出队搅动)残留归零 + 值守恒
函数 形七(整64 轮数) -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 i = 0;
    当 (i < 轮数) {
        队列<整64> 队 = 队列<整64>();
        结果<空类型, 整32> q1 = 队.入队(i);
        结果<空类型, 整32> q2 = 队.入队(i + 1);
        结果<整64, 整32> o1 = 队.出队();
        如果 (o1.正常) {
            如果 (o1.值 != i) { 返回 0; }
        } 否则 {
            返回 0;
        }
        i++;
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 64;
}

// ⑧ 链表 清空 + 复用(清空后槽从 0 重分配)
函数 形八() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(81);
        结果<空类型, 整32> a2 = 链.追加(82);
        链.清空();
        结果<空类型, 整32> a3 = 链.追加(83);
        结果<空类型, 整32> a4 = 链.追加(84);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 8384) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 128;
}

函数 主() -> 整32 {
    整64 和 = 0;
    和 = 和 + 形一();
    和 = 和 + 形二();
    和 = 和 + 形三();
    和 = 和 + 形四();
    和 = 和 + 形五();
    和 = 和 + 形六();
    和 = 和 + 形七(200000);
    和 = 和 + 形八();
    返回 整32(和);
}

输出:[p6h] 已解析: target/audit2/v2src227/主.cn

头部元素 不安全

不安全 函数 头部元素() -> T

直读头元素(副本);空表 → 运行时中止。

返回 头元素副本。空表 → 运行时错误终止。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;

结构体 盒子 {
    字符串 名;
    整32 号;
}

函数 搅动() -> 整64 {
    整64 和 = 0;
    整64 i = 0;
    当 (i < 16) {
        字符串 垃圾 = 字符串复制("E245搅动内存填充占位字符串内容甲乙丙丁戊己庚辛壬癸");
        和 = 和 + 字符串长度(垃圾);
        i++;
    }
    返回 和;
}

// ① 向量 追加((三元))
函数 形一() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形一真串甲甲甲甲甲甲甲甲甲甲"), 号 = 1 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形一假串乙乙乙乙乙乙乙乙乙乙"), 号 = 2 };
            结果<空类型, 整32> 加 = 表.追加(真 ? 甲 : 乙);
            如果 (!加.正常) { 返回 0; }
        }
        搅动();
        如果 (字符串比较(表.元素(0).名, "E245形一真串甲甲甲甲甲甲甲甲甲甲")) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 1; }
    返回 0;
}

// ② 向量 插入(0, (三元))
函数 形二() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形二真串甲甲甲甲甲甲甲甲甲甲"), 号 = 3 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形二假串乙乙乙乙乙乙乙乙乙乙"), 号 = 4 };
            结果<空类型, 整32> 插 = 表.插入(0, 假 ? 甲 : 乙);
            如果 (!插.正常) { 返回 0; }
        }
        搅动();
        如果 (字符串比较(表.元素(0).名, "E245形二假串乙乙乙乙乙乙乙乙乙乙")) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 2; }
    返回 0;
}

// ③ 链表 追加((三元))
函数 形三() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<盒子> 表 = 链表<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形三真串甲甲甲甲甲甲甲甲甲甲"), 号 = 5 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形三假串乙乙乙乙乙乙乙乙乙乙"), 号 = 6 };
            结果<空类型, 整32> 加 = 表.追加(真 ? 甲 : 乙);
            如果 (!加.正常) { 返回 0; }
        }
        搅动();
        如果 (字符串比较(表.头部元素().名, "E245形三真串甲甲甲甲甲甲甲甲甲甲")) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 4; }
    返回 0;
}

// ④ 栈 压入((三元)) + 弹出读出
函数 形四() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        栈<盒子> 表 = 栈<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形四真串甲甲甲甲甲甲甲甲甲甲"), 号 = 7 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形四假串乙乙乙乙乙乙乙乙乙乙"), 号 = 8 };
            结果<空类型, 整32> 压 = 表.压入(真 ? 甲 : 乙);
            如果 (!压.正常) { 返回 0; }
        }
        搅动();
        结果<盒子, 整32> 弹 = 表.弹出();
        如果 (弹.正常) {
            如果 (字符串比较(弹.值.名, "E245形四真串甲甲甲甲甲甲甲甲甲甲")) { 校验 = 1; }
        } 否则 {
            校验 = 0;
        }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 8; }
    返回 0;
}

// ⑤ 队列 入队((三元)) + 出队读出
函数 形五() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        队列<盒子> 表 = 队列<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形五真串甲甲甲甲甲甲甲甲甲甲"), 号 = 9 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形五假串乙乙乙乙乙乙乙乙乙乙"), 号 = 10 };
            结果<空类型, 整32> 入 = 表.入队(假 ? 甲 : 乙);
            如果 (!入.正常) { 返回 0; }
        }
        搅动();
        结果<盒子, 整32> 出 = 表.出队();
        如果 (出.正常) {
            如果 (字符串比较(出.值.名, "E245形五假串乙乙乙乙乙乙乙乙乙乙")) { 校验 = 1; }
        } 否则 {
            校验 = 0;
        }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 16; }
    返回 0;
}

// ⑥ 链表 头部追加((三元)) + 删除头部(移除路径 × 三元入容器)
函数 形六() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<盒子> 表 = 链表<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形六真串甲甲甲甲甲甲甲甲甲甲"), 号 = 11 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形六假串乙乙乙乙乙乙乙乙乙乙"), 号 = 12 };
            结果<空类型, 整32> 加 = 表.头部追加(真 ? 甲 : 乙);
            如果 (!加.正常) { 返回 0; }
            如果 (字符串比较(表.头部元素().名, "E245形六真串甲甲甲甲甲甲甲甲甲甲")) { 校验 = 1; }
            结果<空类型, 整32> 删 = 表.删除头部();
            如果 (!删.正常) { 校验 = 0; }
        }
        搅动();
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 32; }
    返回 0;
}

// ⑦ 容器读出(借出视图)→ 三元选择 → 再入容器
函数 形七() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        {
            盒子 甲 = 盒子{ 名 = 字符串复制("E245形七真串甲甲甲甲甲甲甲甲甲甲"), 号 = 13 };
            盒子 乙 = 盒子{ 名 = 字符串复制("E245形七假串乙乙乙乙乙乙乙乙乙乙"), 号 = 14 };
            结果<空类型, 整32> 加 = 表.追加(甲);
            如果 (!加.正常) { 返回 0; }
            盒子 读 = 表.元素(0);   // 借出视图 → 深拷接收
            结果<空类型, 整32> 再加 = 表.追加(真 ? 读 : 乙);
            如果 (!再加.正常) { 返回 0; }
        }
        搅动();
        如果 (字符串比较(表.元素(1).名, "E245形七真串甲甲甲甲甲甲甲甲甲甲")) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 64; }
    返回 0;
}

// ⑧ 循环 5 万轮(三元入容器 + 搅动)
函数 形八(整64 轮数) -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    整64 i = 0;
    当 (i < 轮数) {
        向量<盒子> 表 = 向量<盒子>();
        盒子 甲 = 盒子{ 名 = 字符串复制("E245形八真串甲乙丙丁戊己庚辛壬癸"), 号 = 88 };
        盒子 乙 = 盒子{ 名 = 字符串复制("E245形八假串甲乙丙丁戊己庚辛壬癸"), 号 = 99 };
        结果<空类型, 整32> 加 = 表.追加(真 ? 甲 : 乙);
        如果 (!加.正常) { 校验 = 0; 中断; }
        如果 (!字符串比较(表.元素(0).名, "E245形八真串甲乙丙丁戊己庚辛壬癸")) { 校验 = 0; 中断; }
        校验 = 1;
        i++;
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    如果 (校验 == 1) { 返回 128; }
    返回 0;
}

函数 主() -> 整32 {
    整64 和 = 0;
    和 = 和 + 形一();
    和 = 和 + 形二();
    和 = 和 + 形三();
    和 = 和 + 形四();
    和 = 和 + 形五();
    和 = 和 + 形六();
    和 = 和 + 形七();
    和 = 和 + 形八(50000);
    打印("校验和(期望255)=", 和);
    返回 0;
}

输出:校验和(期望255)=255

读取头部 不安全

不安全 函数 读取头部() -> 结果<T, 整32>

带检查读头元素:空表返回错误而非中止。

返回 正常(头元素);空表 → 错误(错误码.未初始化)。

主.cnCN

导入 容器::链表;
导入 容器::队列;

静态 整64 监视 = 0;
静态 整64 累计 = 0;

类 资源 {
公开:
    整64 编号;
    字符串 名;
    函数 资源(整64 v) {
        编号 = v;
        名 = 字符串复制("元素载荷甲乙丙");
    }
    函数 资源(资源& 其他) {
        编号 = 其他.编号;
        名 = 字符串复制(其他.名);
    }
    不安全 函数 ~资源() {
        如果 (监视 == 1) {
            累计 = 累计 * 10 + 编号;
        }
    }
}

// ① 链表:追加3 + 删除头部 + 删除尾部 + 清空——身份 132 + 净差 0
不安全 函数 链形() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 序 = 0;
    {
        链表<资源> 表;
        资源 r1 = 资源(1);
        资源 r2 = 资源(2);
        资源 r3 = 资源(3);
        结果<空类型, 整32> a1 = 表.追加(r1);
        结果<空类型, 整32> a2 = 表.追加(r2);
        结果<空类型, 整32> a3 = 表.追加(r3);
        监视 = 1;
        累计 = 0;
        结果<空类型, 整32> d1 = 表.删除头部();
        结果<空类型, 整32> d2 = 表.删除尾部();
        表.清空();
        监视 = 0;
        序 = 累计;
    }
    打印("链表析构序: ", 序);
    返回 内存::活动分配数() - 前;
}

// ② 队列:入队3 + 清空——身份 123 + 净差 0
不安全 函数 队形() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 序 = 0;
    {
        队列<资源> 队;
        资源 q1 = 资源(1);
        资源 q2 = 资源(2);
        资源 q3 = 资源(3);
        结果<空类型, 整32> b1 = 队.入队(q1);
        结果<空类型, 整32> b2 = 队.入队(q2);
        结果<空类型, 整32> b3 = 队.入队(q3);
        监视 = 1;
        累计 = 0;
        队.清空();
        监视 = 0;
        序 = 累计;
    }
    打印("队列析构序: ", 序);
    返回 内存::活动分配数() - 前;
}

不安全 函数 主() -> 整32 {
    整64 链净 = 链形();
    整64 队净 = 队形();
    打印("链净差: ", 链净);
    打印("队净差: ", 队净);
    返回 0;
}

输出:链表析构序: 132 队列析构序: 123 链净差: 0 队净差: 0

读取尾部 不安全

不安全 函数 读取尾部() -> 结果<T, 整32>

带检查读尾元素:空表返回错误而非中止。

返回 正常(尾元素);空表 → 错误(错误码.未初始化)。

主.cnCN

导入 容器::链表;
导入 容器::队列;

// ① 链表<整64>:追加 3 + 删除头部 + 追加(槽复用后序列完整)
函数 形一() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(11);
        结果<空类型, 整32> a2 = 链.追加(22);
        结果<空类型, 整32> a3 = 链.追加(33);
        结果<空类型, 整32> d1 = 链.删除头部();
        结果<空类型, 整32> a4 = 链.追加(44);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 223344) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验;
}

// ② 队列<整64>:入队 3 + 出队 + 入队(出队序完整)
函数 形二() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        队列<整64> 队 = 队列<整64>();
        结果<空类型, 整32> q1 = 队.入队(11);
        结果<空类型, 整32> q2 = 队.入队(22);
        结果<空类型, 整32> q3 = 队.入队(33);
        结果<整64, 整32> o1 = 队.出队();
        结果<空类型, 整32> q4 = 队.入队(44);
        整64 序 = 0;
        当 (队.大小() > 0) {
            结果<整64, 整32> o = 队.出队();
            如果 (o.正常) {
                序 = 序 * 100 + o.值;
            } 否则 {
                校验 = 99;
            }
        }
        如果 (序 == 223344) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 2;
}

// ③ 链表<字符串>:槽复用 + 内容守恒 + 残留归零
函数 形三() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<字符串> 链 = 链表<字符串>();
        结果<空类型, 整32> s1 = 链.追加(字符串复制("形三甲串内容甲乙丙丁戊"));
        结果<空类型, 整32> s2 = 链.追加(字符串复制("形三乙串内容甲乙丙丁戊"));
        结果<空类型, 整32> sd = 链.删除头部();
        结果<空类型, 整32> s3 = 链.追加(字符串复制("形三丙串内容甲乙丙丁戊"));
        结果<字符串, 整32> sh = 链.读取头部();
        如果 (sh.正常) {
            如果 (字符串比较(sh.值, "形三乙串内容甲乙丙丁戊")) { 校验 = 1; }
        }
        结果<字符串, 整32> st = 链.读取尾部();
        如果 (st.正常) {
            如果 (!字符串比较(st.值, "形三丙串内容甲乙丙丁戊")) { 校验 = 0; }
        }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 4;
}

// ④ 队列<字符串>:槽复用 + 内容守恒 + 残留归零
函数 形四() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        队列<字符串> 队 = 队列<字符串>();
        结果<空类型, 整32> s1 = 队.入队(字符串复制("形四甲串内容甲乙丙丁戊"));
        结果<空类型, 整32> s2 = 队.入队(字符串复制("形四乙串内容甲乙丙丁戊"));
        结果<字符串, 整32> o1 = 队.出队();
        结果<空类型, 整32> s3 = 队.入队(字符串复制("形四丙串内容甲乙丙丁戊"));
        结果<字符串, 整32> f = 队.队首();
        如果 (f.正常) {
            如果 (字符串比较(f.值, "形四乙串内容甲乙丙丁戊")) { 校验 = 1; }
        }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 8;
}

// ⑤ 链表 删除尾部 + 复用(被摘槽归还后重分配)
函数 形五() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(51);
        结果<空类型, 整32> a2 = 链.追加(52);
        结果<空类型, 整32> a3 = 链.追加(53);
        结果<空类型, 整32> d1 = 链.删除尾部();
        结果<空类型, 整32> a4 = 链.追加(54);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 515254) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 16;
}

// ⑥ 链表 头部追加 + 复用
函数 形六() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(61);
        结果<空类型, 整32> a2 = 链.头部追加(62);
        结果<空类型, 整32> a3 = 链.头部追加(63);
        结果<空类型, 整32> d1 = 链.删除头部();
        结果<空类型, 整32> a4 = 链.头部追加(64);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 646261) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 32;
}

// ⑦ 循环 20 万轮(入队/出队搅动)残留归零 + 值守恒
函数 形七(整64 轮数) -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 i = 0;
    当 (i < 轮数) {
        队列<整64> 队 = 队列<整64>();
        结果<空类型, 整32> q1 = 队.入队(i);
        结果<空类型, 整32> q2 = 队.入队(i + 1);
        结果<整64, 整32> o1 = 队.出队();
        如果 (o1.正常) {
            如果 (o1.值 != i) { 返回 0; }
        } 否则 {
            返回 0;
        }
        i++;
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 64;
}

// ⑧ 链表 清空 + 复用(清空后槽从 0 重分配)
函数 形八() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<整64> 链 = 链表<整64>();
        结果<空类型, 整32> a1 = 链.追加(81);
        结果<空类型, 整32> a2 = 链.追加(82);
        链.清空();
        结果<空类型, 整32> a3 = 链.追加(83);
        结果<空类型, 整32> a4 = 链.追加(84);
        整64 序 = 0;
        当 (链.大小() > 0) {
            结果<整64, 整32> h = 链.读取头部();
            如果 (h.正常) {
                序 = 序 * 100 + h.值;
            } 否则 {
                校验 = 99;
            }
            结果<空类型, 整32> dd = 链.删除头部();
        }
        如果 (序 == 8384) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 128;
}

函数 主() -> 整32 {
    整64 和 = 0;
    和 = 和 + 形一();
    和 = 和 + 形二();
    和 = 和 + 形三();
    和 = 和 + 形四();
    和 = 和 + 形五();
    和 = 和 + 形六();
    和 = 和 + 形七(200000);
    和 = 和 + 形八();
    返回 整32(和);
}

输出:[p6h] 已解析: target/audit2/v2src227/主.cn

清空

函数 清空()

链上元素全量析构(编译器注入链游释放)后链端点复位,槽位状态作废(下次分配从 0 重用)。

主.cnCN

导入 容器::链表;
导入 容器::栈;
导入 容器::队列;

静态 整64 计数 = 0;
静态 整64 监视 = 0;
静态 整64 累计 = 0;

类 资源 {
公开:
    整64 编号;
    函数 资源(整64 v) { 编号 = v; }
    函数 资源(资源& 其他) { 编号 = 其他.编号; }
    不安全 函数 ~资源() {
        计数 = 计数 + 1;
        如果 (监视 == 1) {
            累计 = 累计 * 10 + 编号;
        }
    }
}

不安全 函数 主() -> 整32 {
    // 链表:删除头部/删除尾部/清空 自动析构被移除元素(身份序 1→3→2)
    {
        链表<资源> 表;
        资源 r1 = 资源(1);
        资源 r2 = 资源(2);
        资源 r3 = 资源(3);
        结果<空类型, 整32> a1 = 表.追加(r1);
        结果<空类型, 整32> a2 = 表.追加(r2);
        结果<空类型, 整32> a3 = 表.追加(r3);
        打印("链表 大小: ", 表.大小());
        监视 = 1;
        累计 = 0;
        结果<空类型, 整32> d1 = 表.删除头部();   // 析构被移除元素 +1(E1)
        打印("删头后: ", 表.大小(), " 析构: ", 计数);
        结果<空类型, 整32> d2 = 表.删除尾部();   // +1(E3)
        打印("删尾后: ", 表.大小(), " 析构: ", 计数);
        表.清空();                               // +1(E2·链游剩余链元素)
        监视 = 0;
        打印("清空后: ", 表.大小(), " 析构: ", 计数);
        打印("链表析构序: ", 累计);              // 132 = E1→E3→E2
    }
    打印("链表块结束: ", 计数);  // r1/r2/r3 块出口已析构(块级 RAII):3+3=6

    // 栈:弹出 返回元素(所有权转移),不析构
    {
        栈<资源> 栈表;
        资源 s1 = 资源(1);
        资源 s2 = 资源(2);
        结果<空类型, 整32> p1 = 栈表.压入(s1);
        结果<空类型, 整32> p2 = 栈表.压入(s2);
        结果<资源, 整32> 弹 = 栈表.弹出();
        打印("栈弹出后大小: ", 栈表.大小(), " 析构: ", 计数);
    }

    // 队列:出队 返回元素(所有权转移给盒)·盒亡析构(182 正账);清空 自动析构剩余
    {
        队列<资源> 队列表;
        资源 q1 = 资源(1);
        资源 q2 = 资源(2);
        资源 q3 = 资源(3);
        结果<空类型, 整32> qa1 = 队列表.入队(q1);
        结果<空类型, 整32> qa2 = 队列表.入队(q2);
        结果<空类型, 整32> qa3 = 队列表.入队(q3);
        结果<资源, 整32> 出 = 队列表.出队();
        打印("队弹出后: ", 队列表.大小(), " 析构: ", 计数);
        监视 = 1;
        累计 = 0;
        队列表.清空();                          // 析构剩余 2 个 +2(E2,E3·链游)
        监视 = 0;
        打印("队清空后: ", 队列表.大小(), " 析构: ", 计数);
        打印("队列清空序: ", 累计);              // 23 = E2→E3
    }
    返回 0;
}

输出:链表 大小: 3 删头后: 2 析构: 1 删尾后: 1 析构: 2 清空后: 0 析构: 3 链表析构序: 132 链表块结束: 6 栈弹出后大小: 1 析构: 6 队弹出后: 2 析构: 10 队清空后: 0 析构: 12 队列清空序: 23

取空闲槽 内部 不安全

不安全 函数 取空闲槽() -> 整64

槽分配内部辅助:空闲链优先 O(1) 复用,否则取高水位新槽。

归还槽 内部 不安全

不安全 函数 归还槽(整64 槽) -> 空类型

槽回收内部辅助:把槽挂入空闲链。删除头部/尾部 内部使用。

栈<T>(后进先出)

对标 C++ std::stack。独立动态数组实现(压入=尾追加,弹出=尾移除),拷贝构造深拷。

压入 不安全

不安全 函数 压入(T 值) -> 结果<空类型, 整32>

元素压栈(无参构造 栈() 先建实例)。

参数类型说明
值T要压入的元素

返回 正常();扩容失败 → 错误(错误码.内存)。

主.cnCN

导入 容器::链表;
导入 容器::栈;
导入 容器::队列;

静态 整64 计数 = 0;
静态 整64 监视 = 0;
静态 整64 累计 = 0;

类 资源 {
公开:
    整64 编号;
    函数 资源(整64 v) { 编号 = v; }
    函数 资源(资源& 其他) { 编号 = 其他.编号; }
    不安全 函数 ~资源() {
        计数 = 计数 + 1;
        如果 (监视 == 1) {
            累计 = 累计 * 10 + 编号;
        }
    }
}

不安全 函数 主() -> 整32 {
    // 链表:删除头部/删除尾部/清空 自动析构被移除元素(身份序 1→3→2)
    {
        链表<资源> 表;
        资源 r1 = 资源(1);
        资源 r2 = 资源(2);
        资源 r3 = 资源(3);
        结果<空类型, 整32> a1 = 表.追加(r1);
        结果<空类型, 整32> a2 = 表.追加(r2);
        结果<空类型, 整32> a3 = 表.追加(r3);
        打印("链表 大小: ", 表.大小());
        监视 = 1;
        累计 = 0;
        结果<空类型, 整32> d1 = 表.删除头部();   // 析构被移除元素 +1(E1)
        打印("删头后: ", 表.大小(), " 析构: ", 计数);
        结果<空类型, 整32> d2 = 表.删除尾部();   // +1(E3)
        打印("删尾后: ", 表.大小(), " 析构: ", 计数);
        表.清空();                               // +1(E2·链游剩余链元素)
        监视 = 0;
        打印("清空后: ", 表.大小(), " 析构: ", 计数);
        打印("链表析构序: ", 累计);              // 132 = E1→E3→E2
    }
    打印("链表块结束: ", 计数);  // r1/r2/r3 块出口已析构(块级 RAII):3+3=6

    // 栈:弹出 返回元素(所有权转移),不析构
    {
        栈<资源> 栈表;
        资源 s1 = 资源(1);
        资源 s2 = 资源(2);
        结果<空类型, 整32> p1 = 栈表.压入(s1);
        结果<空类型, 整32> p2 = 栈表.压入(s2);
        结果<资源, 整32> 弹 = 栈表.弹出();
        打印("栈弹出后大小: ", 栈表.大小(), " 析构: ", 计数);
    }

    // 队列:出队 返回元素(所有权转移给盒)·盒亡析构(182 正账);清空 自动析构剩余
    {
        队列<资源> 队列表;
        资源 q1 = 资源(1);
        资源 q2 = 资源(2);
        资源 q3 = 资源(3);
        结果<空类型, 整32> qa1 = 队列表.入队(q1);
        结果<空类型, 整32> qa2 = 队列表.入队(q2);
        结果<空类型, 整32> qa3 = 队列表.入队(q3);
        结果<资源, 整32> 出 = 队列表.出队();
        打印("队弹出后: ", 队列表.大小(), " 析构: ", 计数);
        监视 = 1;
        累计 = 0;
        队列表.清空();                          // 析构剩余 2 个 +2(E2,E3·链游)
        监视 = 0;
        打印("队清空后: ", 队列表.大小(), " 析构: ", 计数);
        打印("队列清空序: ", 累计);              // 23 = E2→E3
    }
    返回 0;
}

输出:链表 大小: 3 删头后: 2 析构: 1 删尾后: 1 析构: 2 清空后: 0 析构: 3 链表析构序: 132 链表块结束: 6 栈弹出后大小: 1 析构: 6 队弹出后: 2 析构: 10 队清空后: 0 析构: 12 队列清空序: 23

弹出 不安全

不安全 函数 弹出() -> 结果<T, 整32>

弹出栈顶元素并返回副本;空栈返回错误。

返回 正常(栈顶值);空栈 → 错误(错误码.未初始化)。

主.cnCN

导入 容器::栈;
静态 整64 析构数 = 0;
类 资源 {
公开:
    整64 编号;
    函数 资源(整64 v) { 编号 = v; }
    函数 资源(资源& 其他) { 编号 = 其他.编号; }
    不安全 函数 ~资源() { 析构数 = 析构数 + 1; }
}
不安全 函数 主() -> 整32 {
    整64 前 = 内存::活动分配数();
    {
        栈<字符串> 表 = 栈<字符串>();
        字符串 甲 = 字符串复制("AAAAAAAAAAAAAAAAAAAA");
        结果<空类型, 整32> 压 = 表.压入(甲);
        如果 (压.正常) {
            结果<字符串, 整32> 弹 = 表.弹出();
            如果 (弹.正常) { 打印("串弹值=", 弹.值); } 否则 { 返回 2; }
        } 否则 { 返回 1; }
    }
    {
        栈<资源> 表 = 栈<资源>();
        资源 甲 = 资源(7);
        结果<空类型, 整32> 压 = 表.压入(甲);
        如果 (压.正常) {
            结果<资源, 整32> 弹 = 表.弹出();
            如果 (弹.正常) { 打印("类弹编号=", 弹.值.编号); } 否则 { 返回 4; }
        } 否则 { 返回 3; }
    }
    打印("析构数=", 析构数);
    打印("泄漏=", 内存::活动分配数() - 前);
    返回 0;
}

输出:串弹值=AAAAAAAAAAAAAAAAAAAA 类弹编号=7 析构数=2 泄漏=0

栈顶 不安全

不安全 函数 栈顶() -> 结果<T, 整32>

只读窥视栈顶(不弹出);空栈返回错误。

返回 正常(栈顶值);空栈 → 错误(错误码.未初始化)。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 容器::错误码;

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

    // ==================== 1. 向量<T> ====================
    向量<整32> 数据 = 向量<整32>();
    如果 (数据.为空()) {
        打印("向量初始为空: 是");
    } 否则 {
        打印("向量初始为空: 否");
    }

    // 追加 6 个元素(触发扩容 0 -> 4 -> 8)
    结果<空类型, 整32> 追加结果 = 数据.追加(1);
    如果 (追加结果.正常) {
        追加结果 = 数据.追加(2);
        追加结果 = 数据.追加(3);
        追加结果 = 数据.追加(4);
        追加结果 = 数据.追加(5);
        追加结果 = 数据.追加(6);
    } 否则 {
        打印("向量追加失败: ", 追加结果.错误);
    }
    打印("向量大小: ", 数据.大小());
    打印("向量容量: ", 数据.容量());

    // 读取(正常路径)
    结果<整32, 整32> 读取结果 = 数据.读取(0);
    如果 (读取结果.正常) {
        打印("读取[0]: ", 读取结果.值);
    } 否则 {
        打印("读取[0]失败: ", 读取结果.错误);
    }

    // 读取(越界路径:错误码 2)
    读取结果 = 数据.读取(99);
    如果 (读取结果.正常) {
        打印("读取[99]未报错");
    } 否则 {
        打印("读取[99]越界: ", 读取结果.错误);
    }

    // 插入 + 删除 + 设置
    追加结果 = 数据.插入(0, 99);
    如果 (追加结果.正常) {
        打印("插入后[0]: ", 数据.元素(0));
    } 否则 {
        打印("插入失败: ", 追加结果.错误);
    }
    追加结果 = 数据.删除(0);
    如果 (追加结果.正常) {
        打印("删除后[0]: ", 数据.元素(0));
    } 否则 {
        打印("删除失败: ", 追加结果.错误);
    }
    追加结果 = 数据.设置(0, 7);
    如果 (追加结果.正常) {
        打印("设置后[0]: ", 数据.元素(0));
    } 否则 {
        打印("设置失败: ", 追加结果.错误);
    }

    // ==================== 2. 链表<T> ====================
    链表<整32> 列表 = 链表<整32>();
    追加结果 = 列表.追加(10);
    如果 (追加结果.正常) {
        追加结果 = 列表.追加(20);
        追加结果 = 列表.追加(30);
    } 否则 {
        打印("链表追加失败: ", 追加结果.错误);
    }
    打印("链表大小: ", 列表.大小());
    结果<整32, 整32> 头结果 = 列表.读取头部();
    如果 (头结果.正常) {
        打印("链表头: ", 头结果.值);
    } 否则 {
        打印("链表头失败: ", 头结果.错误);
    }
    结果<整32, 整32> 尾结果 = 列表.读取尾部();
    如果 (尾结果.正常) {
        打印("链表尾: ", 尾结果.值);
    } 否则 {
        打印("链表尾失败: ", 尾结果.错误);
    }

    // 头部追加
    追加结果 = 列表.头部追加(5);
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("头部追加后链表头: ", 头结果.值);
        } 否则 {
            打印("头部追加后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("头部追加失败: ", 追加结果.错误);
    }
    打印("头部追加后链表大小: ", 列表.大小());

    // 删除头部 + 删除尾部
    追加结果 = 列表.删除头部();
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("删除头部后链表头: ", 头结果.值);
        } 否则 {
            打印("删除头部后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("删除头部失败: ", 追加结果.错误);
    }
    追加结果 = 列表.删除尾部();
    如果 (追加结果.正常) {
        尾结果 = 列表.读取尾部();
        如果 (尾结果.正常) {
            打印("删除尾部后链表尾: ", 尾结果.值);
        } 否则 {
            打印("删除尾部后读尾失败: ", 尾结果.错误);
        }
    } 否则 {
        打印("删除尾部失败: ", 追加结果.错误);
    }

    // ==================== 3. 栈<T> ====================
    栈<整32> 数据栈 = 栈<整32>();
    追加结果 = 数据栈.压入(1);
    如果 (追加结果.正常) {
        追加结果 = 数据栈.压入(2);
        追加结果 = 数据栈.压入(3);
    } 否则 {
        打印("压入失败: ", 追加结果.错误);
    }
    打印("栈大小: ", 数据栈.大小());
    结果<整32, 整32> 栈顶结果 = 数据栈.栈顶();
    如果 (栈顶结果.正常) {
        打印("栈顶: ", 栈顶结果.值);
    } 否则 {
        打印("栈顶失败: ", 栈顶结果.错误);
    }
    结果<整32, 整32> 弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("弹出: ", 弹出结果.值);
    } 否则 {
        打印("弹出失败: ", 弹出结果.错误);
    }
    弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("再弹出: ", 弹出结果.值);
    } 否则 {
        打印("再弹出失败: ", 弹出结果.错误);
    }
    打印("弹后栈大小: ", 数据栈.大小());

    // ==================== 4. 队列<T> ====================
    队列<整32> 数据队列 = 队列<整32>();
    追加结果 = 数据队列.入队(5);
    如果 (追加结果.正常) {
        追加结果 = 数据队列.入队(6);
        追加结果 = 数据队列.入队(7);
    } 否则 {
        打印("入队失败: ", 追加结果.错误);
    }
    打印("队列大小: ", 数据队列.大小());
    结果<整32, 整32> 队首结果 = 数据队列.队首();
    如果 (队首结果.正常) {
        打印("队首: ", 队首结果.值);
    } 否则 {
        打印("队首失败: ", 队首结果.错误);
    }
    结果<整32, 整32> 出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("出队: ", 出队结果.值);
    } 否则 {
        打印("出队失败: ", 出队结果.错误);
    }
    出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("再出队: ", 出队结果.值);
    } 否则 {
        打印("再出队失败: ", 出队结果.错误);
    }
    打印("出队后队列大小: ", 数据队列.大小());

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

输出:===== 容器库(Task 6.1)===== 向量初始为空: 是 向量大小: 6 向量容量: 8 读取[0]: 1 读取[99]越界: 2 插入后[0]: 99 删除后[0]: 1 设置后[0]: 7 链表大小: 3 链表头: 10 链表尾: 30 头部追加后链表头: 5 头部追加后链表大小: 4 删除头部后链表头: 10 删除尾部后链表尾: 20 栈大小: 3 栈顶: 3 弹出: 3 再弹出: 2 弹后栈大小: 1 队列大小: 3 队首: 5 出队: 5 再出队: 6 出队后队列大小: 1 ===== 容器库测试完成 =====

为空 常量

常量 函数 为空() -> 布尔

栈是否为空。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 容器::错误码;

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

    // ==================== 1. 向量<T> ====================
    向量<整32> 数据 = 向量<整32>();
    如果 (数据.为空()) {
        打印("向量初始为空: 是");
    } 否则 {
        打印("向量初始为空: 否");
    }

    // 追加 6 个元素(触发扩容 0 -> 4 -> 8)
    结果<空类型, 整32> 追加结果 = 数据.追加(1);
    如果 (追加结果.正常) {
        追加结果 = 数据.追加(2);
        追加结果 = 数据.追加(3);
        追加结果 = 数据.追加(4);
        追加结果 = 数据.追加(5);
        追加结果 = 数据.追加(6);
    } 否则 {
        打印("向量追加失败: ", 追加结果.错误);
    }
    打印("向量大小: ", 数据.大小());
    打印("向量容量: ", 数据.容量());

    // 读取(正常路径)
    结果<整32, 整32> 读取结果 = 数据.读取(0);
    如果 (读取结果.正常) {
        打印("读取[0]: ", 读取结果.值);
    } 否则 {
        打印("读取[0]失败: ", 读取结果.错误);
    }

    // 读取(越界路径:错误码 2)
    读取结果 = 数据.读取(99);
    如果 (读取结果.正常) {
        打印("读取[99]未报错");
    } 否则 {
        打印("读取[99]越界: ", 读取结果.错误);
    }

    // 插入 + 删除 + 设置
    追加结果 = 数据.插入(0, 99);
    如果 (追加结果.正常) {
        打印("插入后[0]: ", 数据.元素(0));
    } 否则 {
        打印("插入失败: ", 追加结果.错误);
    }
    追加结果 = 数据.删除(0);
    如果 (追加结果.正常) {
        打印("删除后[0]: ", 数据.元素(0));
    } 否则 {
        打印("删除失败: ", 追加结果.错误);
    }
    追加结果 = 数据.设置(0, 7);
    如果 (追加结果.正常) {
        打印("设置后[0]: ", 数据.元素(0));
    } 否则 {
        打印("设置失败: ", 追加结果.错误);
    }

    // ==================== 2. 链表<T> ====================
    链表<整32> 列表 = 链表<整32>();
    追加结果 = 列表.追加(10);
    如果 (追加结果.正常) {
        追加结果 = 列表.追加(20);
        追加结果 = 列表.追加(30);
    } 否则 {
        打印("链表追加失败: ", 追加结果.错误);
    }
    打印("链表大小: ", 列表.大小());
    结果<整32, 整32> 头结果 = 列表.读取头部();
    如果 (头结果.正常) {
        打印("链表头: ", 头结果.值);
    } 否则 {
        打印("链表头失败: ", 头结果.错误);
    }
    结果<整32, 整32> 尾结果 = 列表.读取尾部();
    如果 (尾结果.正常) {
        打印("链表尾: ", 尾结果.值);
    } 否则 {
        打印("链表尾失败: ", 尾结果.错误);
    }

    // 头部追加
    追加结果 = 列表.头部追加(5);
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("头部追加后链表头: ", 头结果.值);
        } 否则 {
            打印("头部追加后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("头部追加失败: ", 追加结果.错误);
    }
    打印("头部追加后链表大小: ", 列表.大小());

    // 删除头部 + 删除尾部
    追加结果 = 列表.删除头部();
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("删除头部后链表头: ", 头结果.值);
        } 否则 {
            打印("删除头部后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("删除头部失败: ", 追加结果.错误);
    }
    追加结果 = 列表.删除尾部();
    如果 (追加结果.正常) {
        尾结果 = 列表.读取尾部();
        如果 (尾结果.正常) {
            打印("删除尾部后链表尾: ", 尾结果.值);
        } 否则 {
            打印("删除尾部后读尾失败: ", 尾结果.错误);
        }
    } 否则 {
        打印("删除尾部失败: ", 追加结果.错误);
    }

    // ==================== 3. 栈<T> ====================
    栈<整32> 数据栈 = 栈<整32>();
    追加结果 = 数据栈.压入(1);
    如果 (追加结果.正常) {
        追加结果 = 数据栈.压入(2);
        追加结果 = 数据栈.压入(3);
    } 否则 {
        打印("压入失败: ", 追加结果.错误);
    }
    打印("栈大小: ", 数据栈.大小());
    结果<整32, 整32> 栈顶结果 = 数据栈.栈顶();
    如果 (栈顶结果.正常) {
        打印("栈顶: ", 栈顶结果.值);
    } 否则 {
        打印("栈顶失败: ", 栈顶结果.错误);
    }
    结果<整32, 整32> 弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("弹出: ", 弹出结果.值);
    } 否则 {
        打印("弹出失败: ", 弹出结果.错误);
    }
    弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("再弹出: ", 弹出结果.值);
    } 否则 {
        打印("再弹出失败: ", 弹出结果.错误);
    }
    打印("弹后栈大小: ", 数据栈.大小());

    // ==================== 4. 队列<T> ====================
    队列<整32> 数据队列 = 队列<整32>();
    追加结果 = 数据队列.入队(5);
    如果 (追加结果.正常) {
        追加结果 = 数据队列.入队(6);
        追加结果 = 数据队列.入队(7);
    } 否则 {
        打印("入队失败: ", 追加结果.错误);
    }
    打印("队列大小: ", 数据队列.大小());
    结果<整32, 整32> 队首结果 = 数据队列.队首();
    如果 (队首结果.正常) {
        打印("队首: ", 队首结果.值);
    } 否则 {
        打印("队首失败: ", 队首结果.错误);
    }
    结果<整32, 整32> 出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("出队: ", 出队结果.值);
    } 否则 {
        打印("出队失败: ", 出队结果.错误);
    }
    出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("再出队: ", 出队结果.值);
    } 否则 {
        打印("再出队失败: ", 出队结果.错误);
    }
    打印("出队后队列大小: ", 数据队列.大小());

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

输出:===== 容器库(Task 6.1)===== 向量初始为空: 是 向量大小: 6 向量容量: 8 读取[0]: 1 读取[99]越界: 2 插入后[0]: 99 删除后[0]: 1 设置后[0]: 7 链表大小: 3 链表头: 10 链表尾: 30 头部追加后链表头: 5 头部追加后链表大小: 4 删除头部后链表头: 10 删除尾部后链表尾: 20 栈大小: 3 栈顶: 3 弹出: 3 再弹出: 2 弹后栈大小: 1 队列大小: 3 队首: 5 出队: 5 再出队: 6 出队后队列大小: 1 ===== 容器库测试完成 =====

大小 常量

常量 函数 大小() -> 整64

栈内元素个数。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 映射集合;

结构体 盒子 {
    字符串 名;
    整32 号;
}

// 内存搅动:新分配覆盖「已释放内存」,使悬垂元素内容可观测损坏
函数 搅动() -> 整64 {
    整64 和 = 0;
    整64 i = 0;
    当 (i < 16) {
        字符串 垃圾 = 字符串复制("搅动内存填充占位字符串内容甲乙丙丁戊己庚辛壬癸");
        和 = 和 + 字符串长度(垃圾);
        i++;
    }
    返回 和;
}

// ① 追加 + 容器析构(源结构体与容器元素各自拥有并释放)
函数 形一() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        盒子 局 = 盒子{ 名 = 字符串复制("形一占位内容甲乙丙丁戊己庚辛壬癸子丑"), 号 = 1 };
        结果<空类型, 整32> 加 = 表.追加(局);
        如果 (!加.正常) { 返回 0; }
        盒子 读 = 表.元素(0);
        如果 (读.号 == 1 && 字符串比较(读.名, "形一占位内容甲乙丙丁戊己庚辛壬癸子丑")) { 校验 = 1; }
        如果 (!字符串比较(局.名, "形一占位内容甲乙丙丁戊己庚辛壬癸子丑")) { 校验 = 0; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验;
}

// ② 两元素 + 删除(0)(元素移动 + 被移除槽释放)
函数 形二() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        盒子 甲 = 盒子{ 名 = 字符串复制("形二甲占位内容甲乙丙丁戊己庚辛壬癸"), 号 = 1 };
        盒子 乙 = 盒子{ 名 = 字符串复制("形二乙占位内容甲乙丙丁戊己庚辛壬癸"), 号 = 2 };
        结果<空类型, 整32> 加1 = 表.追加(甲);
        结果<空类型, 整32> 加2 = 表.追加(乙);
        如果 (!加1.正常 || !加2.正常) { 返回 0; }
        结果<空类型, 整32> 删 = 表.删除(0);
        如果 (!删.正常) { 返回 0; }
        盒子 读 = 表.元素(0);
        如果 (读.号 == 2 && 字符串比较(读.名, "形二乙占位内容甲乙丙丁戊己庚辛壬癸")) { 校验 = 1; }
        搅动();
        盒子 读2 = 表.元素(0);
        如果 (!字符串比较(读2.名, "形二乙占位内容甲乙丙丁戊己庚辛壬癸")) { 校验 = 0; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 2;
}

// ③ 设置覆盖(覆盖旧元素释放)
函数 形三() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        盒子 甲 = 盒子{ 名 = 字符串复制("形三甲占位内容甲乙丙丁戊己庚辛壬癸"), 号 = 1 };
        盒子 乙 = 盒子{ 名 = 字符串复制("形三乙占位内容甲乙丙丁戊己庚辛壬癸"), 号 = 2 };
        结果<空类型, 整32> 加 = 表.追加(甲);
        如果 (!加.正常) { 返回 0; }
        结果<空类型, 整32> 设 = 表.设置(0, 乙);
        如果 (!设.正常) { 返回 0; }
        盒子 读 = 表.元素(0);
        如果 (读.号 == 2 && 字符串比较(读.名, "形三乙占位内容甲乙丙丁戊己庚辛壬癸")) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 4;
}

// ④ 清空 + 容器析构(全量释放)
函数 形四() -> 整64 {
    整64 前 = 内存::活动分配数();
    {
        向量<盒子> 表 = 向量<盒子>();
        盒子 局 = 盒子{ 名 = 字符串复制("形四占位内容甲乙丙丁戊己庚辛壬癸子丑"), 号 = 4 };
        结果<空类型, 整32> 加 = 表.追加(局);
        如果 (!加.正常) { 返回 0; }
        表.清空();
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 8;
}

// ⑤ 链表/栈/队列/集合(链式容器按链游释放在 ~容器 注入)
函数 形五() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        链表<盒子> 链 = 链表<盒子>();
        盒子 甲 = 盒子{ 名 = 字符串复制("形五链表占位内容甲乙丙丁戊己庚辛"), 号 = 1 };
        结果<空类型, 整32> 加1 = 链.头部追加(甲);
        如果 (!加1.正常) { 返回 0; }
        栈<盒子> 栈表 = 栈<盒子>();
        盒子 乙 = 盒子{ 名 = 字符串复制("形五栈占位内容甲乙丙丁戊己庚辛壬"), 号 = 2 };
        结果<空类型, 整32> 加2 = 栈表.压入(乙);
        如果 (!加2.正常) { 返回 0; }
        队列<盒子> 队 = 队列<盒子>();
        盒子 丙 = 盒子{ 名 = 字符串复制("形五队列占位内容甲乙丙丁戊己庚辛"), 号 = 3 };
        结果<空类型, 整32> 加3 = 队.入队(丙);
        如果 (!加3.正常) { 返回 0; }
        集合<盒子> 集 = 集合<盒子>();
        盒子 丁 = 盒子{ 名 = 字符串复制("形五集合占位内容甲乙丙丁戊己庚辛"), 号 = 4 };
        结果<空类型, 整32> 加4 = 集.添加(丁);
        如果 (!加4.正常) { 返回 0; }
        如果 (链.大小() == 1 && 栈表.大小() == 1 && 队.大小() == 1) { 校验 = 1; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 16;
}

// ⑥ 调用返回实参(返回结构体入容器)——返回临时(retbuf)由 82-a 的「返回物化
//   到独立槽」保证独立;实参位置物化槽的字段串在调用发射后释放。
函数 造盒子(整32 号) -> 盒子 {
    盒子 内 = 盒子{ 名 = 字符串复制("形六占位内容甲乙丙丁戊己庚辛壬癸子丑寅"), 号 = 号 };
    返回 内;
}

函数 形六() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        结果<空类型, 整32> 加 = 表.追加(造盒子(6));
        如果 (!加.正常) { 返回 0; }
        盒子 读 = 表.元素(0);
        如果 (读.号 == 6 && 字符串比较(读.名, "形六占位内容甲乙丙丁戊己庚辛壬癸子丑寅")) { 校验 = 1; }
        盒子 收 = 造盒子(61);
        如果 (收.号 != 61) { 校验 = 0; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 32;
}

// ⑦ 借用来源(形参串)入容器:调用方串完好
函数 存入(向量<盒子> 表, 字符串 值) -> 整64 {
    盒子 局 = 盒子{ 名 = 值, 号 = 7 };
    结果<空类型, 整32> 加 = 表.追加(局);
    如果 (!加.正常) { 返回 0; }
    返回 1;
}

函数 形七() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 校验 = 0;
    {
        向量<盒子> 表 = 向量<盒子>();
        字符串 本地 = 字符串复制("形七调用方拥有串内容甲乙丙丁戊己庚辛壬");
        如果 (存入(表, 本地) == 1) { 校验 = 1; }
        盒子 读 = 表.元素(0);
        如果 (!字符串比较(读.名, "形七调用方拥有串内容甲乙丙丁戊己庚辛壬")) { 校验 = 0; }
        搅动();
        如果 (!字符串比较(本地, "形七调用方拥有串内容甲乙丙丁戊己庚辛壬")) { 校验 = 0; }
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 校验 * 64;
}

// ⑧ 循环体内结构体(20 万轮块出口 drop + 内容守恒)
函数 形八(整64 轮数) -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 i = 0;
    当 (i < 轮数) {
        盒子 每轮 = 盒子{ 名 = 字符串复制("形八循环体占位内容甲乙丙丁戊己庚辛壬"), 号 = 8 };
        如果 (!字符串比较(每轮.名, "形八循环体占位内容甲乙丙丁戊己庚辛壬")) { 返回 0; }
        i++;
    }
    如果 (内存::活动分配数() != 前) { 返回 0; }
    返回 128;
}

函数 主() -> 整32 {
    整64 和 = 0;
    和 = 和 + 形一();
    和 = 和 + 形二();
    和 = 和 + 形三();
    和 = 和 + 形四();
    和 = 和 + 形五();
    和 = 和 + 形六();
    和 = 和 + 形七();
    和 = 和 + 形八(200000);
    返回 整32(和);
}

输出:[p6h] 已解析: target/audit2/v2src224/主.cn

队列<T>(先进先出)

对标 C++ std::queue。独立索引链表实现(入队=尾追加,出队=头摘除),空闲链槽复用。

入队 不安全

不安全 函数 入队(T 值) -> 结果<空类型, 整32>

元素入队尾(无参构造 队列() 先建实例)。

参数类型说明
值T要入队的元素

返回 正常();扩容失败 → 错误(错误码.内存)。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;

// 内存搅动:新分配覆盖「已释放内存」,使悬垂元素内容可观测损坏
函数 搅动() -> 整64 {
    整64 和 = 0;
    整64 i = 0;
    当 (i < 24) {
        字符串 垃圾 = 字符串复制("搅动内存填充占位字符串内容甲乙丙丁戊己庚辛");
        和 = 和 + 字符串长度(垃圾);
        i++;
    }
    返回 和;
}

// ① 借用来源:字符串形参(借用视图)入容器——容器析构不得释放调用方的串
函数 存入形参(向量<字符串> 表, 字符串 值) -> 空类型 {
    结果<空类型, 整32> 加 = 表.追加(值);
    如果 (!加.正常) { 运行时错误(4); }
}

函数 形态借用() -> 整64 {
    字符串 本地 = 字符串复制("双编译对照·借用来源调用方拥有串内容甲乙丙丁");
    如果 (1 == 1) {
        向量<字符串> 表 = 向量<字符串>();
        存入形参(表, 本地);
    }
    整64 消耗 = 搅动();
    如果 (字符串比较(本地, "双编译对照·借用来源调用方拥有串内容甲乙丙丁")) { 返回 1; }
    返回 0;
}

// ② 拥有串局部裸标识符入容器——容器独立拥有(源照常可用)
函数 收集标识符(向量<字符串> 表) -> 空类型 {
    字符串 值 = 字符串复制("双编译对照·拥有串局部内容甲乙丙丁戊己庚辛");
    结果<空类型, 整32> 加 = 表.追加(值);
    如果 (!加.正常) { 运行时错误(4); }
    如果 (!字符串比较(值, "双编译对照·拥有串局部内容甲乙丙丁戊己庚辛")) { 运行时错误(5); }
}

函数 形态标识符() -> 整64 {
    向量<字符串> 表 = 向量<字符串>();
    收集标识符(表);
    整64 消耗 = 搅动();
    字符串 元素 = 表.元素(0);
    如果 (字符串比较(元素, "双编译对照·拥有串局部内容甲乙丙丁戊己庚辛")) { 返回 1; }
    返回 0;
}

// ③ 成员/下标借出视图入容器——必须复制(共享句柄即随源释放=双释放/悬垂)
函数 形态借出() -> 整64 {
    字符串 来源 = 字符串复制("双编译对照·借出视图来源内容甲乙丙丁戊己庚");
    向量<字符串> 表 = 向量<字符串>();
    结果<空类型, 整32> 加 = 表.追加(来源);
    如果 (!加.正常) { 运行时错误(4); }
    整64 消耗 = 搅动();
    // 源与容器元素各自独立拥有——两侧内容均须完好
    如果 (!字符串比较(来源, "双编译对照·借出视图来源内容甲乙丙丁戊己庚")) { 返回 0; }
    字符串 元素 = 表.元素(0);
    如果 (!字符串比较(元素, "双编译对照·借出视图来源内容甲乙丙丁戊己庚")) { 返回 0; }
    返回 1;
}

// ④ 容器元素守恒:同一容器多次追加 + 搅动后全部元素内容完好
函数 形态守恒() -> 整64 {
    向量<字符串> 表 = 向量<字符串>();
    整64 i = 0;
    当 (i < 3) {
        字符串 值 = 字符串复制("双编译对照·守恒形态元素内容甲乙丙丁戊己庚辛壬");
        结果<空类型, 整32> 加 = 表.追加(值);
        如果 (!加.正常) { 运行时错误(4); }
        i++;
    }
    整64 消耗 = 搅动();
    如果 (表.大小() != 3) { 返回 0; }
    整64 j = 0;
    当 (j < 3) {
        字符串 元素 = 表.元素(j);
        如果 (!字符串比较(元素, "双编译对照·守恒形态元素内容甲乙丙丁戊己庚辛壬")) { 返回 0; }
        j++;
    }
    返回 1;
}

// ⑤ 四容器元素释放面:向量/链表/栈/队列 的元素串随容器析构逐一释放(残留归零)
函数 形态释放面() -> 整64 {
    整64 前 = 内存::活动分配数();
    如果 (1 == 1) {
        向量<字符串> 向量表 = 向量<字符串>();
        结果<空类型, 整32> 加1 = 向量表.追加(字符串复制("双编译对照·向量元素占位内容甲乙丙丁"));
        如果 (!加1.正常) { 运行时错误(4); }
        链表<字符串> 链表表 = 链表<字符串>();
        结果<空类型, 整32> 加2 = 链表表.头部追加(字符串复制("双编译对照·链表元素占位内容甲乙丙丁"));
        如果 (!加2.正常) { 运行时错误(4); }
        栈<字符串> 栈表 = 栈<字符串>();
        结果<空类型, 整32> 加3 = 栈表.压入(字符串复制("双编译对照·栈元素占位内容甲乙丙丁戊"));
        如果 (!加3.正常) { 运行时错误(4); }
        队列<字符串> 队列表 = 队列<字符串>();
        结果<空类型, 整32> 加4 = 队列表.入队(字符串复制("双编译对照·队列元素占位内容甲乙丙丁"));
        如果 (!加4.正常) { 运行时错误(4); }
    }
    整64 后 = 内存::活动分配数();
    如果 (后 == 前) { 返回 1; }
    返回 0;
}

// ⑥ 容器元素读出后容器销毁——借出视图的既有语义面(元素串随容器释放,
//    容器内副本独立拥有;本形态只锚定「容器内元素在容器存活期内恒完好」)
函数 形态读出() -> 整64 {
    向量<字符串> 表 = 向量<字符串>();
    结果<空类型, 整32> 加 = 表.追加(字符串复制("双编译对照·读出形态元素内容甲乙丙丁戊己"));
    如果 (!加.正常) { 运行时错误(4); }
    字符串 元素 = 表.元素(0);
    如果 (字符串比较(元素, "双编译对照·读出形态元素内容甲乙丙丁戊己")) { 返回 1; }
    返回 0;
}

// ⑦ 转移形态(75-a):转移(拥有局部) 入容器=**真 move**(零拷贝);
//    转移(借用形参) 入容器=复制(安全方向——容器不得接管借用句柄)。
//    两子检查都对才置位(折位 64):真 move 失效→分配增量≠0;判定误把借用当
//    拥有→容器析构释放调用方串→本地内容经搅动损坏。
函数 存入转移(向量<字符串> 表, 字符串 值) -> 整64 {
    结果<空类型, 整32> 加 = 表.追加(转移(值));
    如果 (!加.正常) { 返回 0; }
    返回 1;
}

函数 转移真move(向量<字符串> 表) -> 整64 {
    字符串 值 = 字符串复制("双编译对照·转移真move内容甲乙丙丁戊己庚辛");
    整64 前 = 内存::活动分配数();
    结果<空类型, 整32> 加 = 表.追加(转移(值));
    如果 (!加.正常) { 返回 0; }
    如果 (内存::活动分配数() != 前) { 返回 0; }   // 真 move=零拷贝
    字符串 元素 = 表.元素(0);
    如果 (!字符串比较(元素, "双编译对照·转移真move内容甲乙丙丁戊己庚辛")) { 返回 0; }
    返回 1;
}

函数 转移借用形参() -> 整64 {
    字符串 本地 = 字符串复制("双编译对照·转移借用形参内容甲乙丙丁戊己庚");
    如果 (1 == 1) {
        向量<字符串> 表 = 向量<字符串>();
        如果 (存入转移(表, 本地) != 1) { 返回 0; }
        字符串 元素 = 表.元素(0);
        如果 (!字符串比较(元素, "双编译对照·转移借用形参内容甲乙丙丁戊己庚")) { 返回 0; }
    }
    整64 消耗 = 搅动();
    如果 (!字符串比较(本地, "双编译对照·转移借用形参内容甲乙丙丁戊己庚")) { 返回 0; }
    返回 1;
}

函数 形态转移() -> 整64 {
    向量<字符串> 表 = 向量<字符串>();
    结果<空类型, 整32> 预 = 表.预留(8);   // 排除数组扩容分配干扰
    如果 (!预.正常) { 返回 0; }
    如果 (转移真move(表) != 1) { 返回 0; }
    如果 (转移借用形参() != 1) { 返回 0; }
    返回 1;
}

函数 主() -> 整32 {
    整32 校验 = 0;
    如果 (形态借用() == 1) { 校验 = 校验 + 1; }
    如果 (形态标识符() == 1) { 校验 = 校验 + 2; }
    如果 (形态借出() == 1) { 校验 = 校验 + 4; }
    如果 (形态守恒() == 1) { 校验 = 校验 + 8; }
    如果 (形态释放面() == 1) { 校验 = 校验 + 16; }
    如果 (形态读出() == 1) { 校验 = 校验 + 32; }
    如果 (形态转移() == 1) { 校验 = 校验 + 64; }
    返回 校验;
}

输出:[p6h] 已解析: target/audit2/v2src209/主.cn

出队 不安全

不安全 函数 出队() -> 结果<T, 整32>

队首出队并返回副本;空队返回错误。被摘槽归还空闲链。

返回 正常(队首值);空队 → 错误(错误码.未初始化)。

主.cnCN

导入 容器::链表;
导入 容器::栈;
导入 容器::队列;

静态 整64 计数 = 0;
静态 整64 监视 = 0;
静态 整64 累计 = 0;

类 资源 {
公开:
    整64 编号;
    函数 资源(整64 v) { 编号 = v; }
    函数 资源(资源& 其他) { 编号 = 其他.编号; }
    不安全 函数 ~资源() {
        计数 = 计数 + 1;
        如果 (监视 == 1) {
            累计 = 累计 * 10 + 编号;
        }
    }
}

不安全 函数 主() -> 整32 {
    // 链表:删除头部/删除尾部/清空 自动析构被移除元素(身份序 1→3→2)
    {
        链表<资源> 表;
        资源 r1 = 资源(1);
        资源 r2 = 资源(2);
        资源 r3 = 资源(3);
        结果<空类型, 整32> a1 = 表.追加(r1);
        结果<空类型, 整32> a2 = 表.追加(r2);
        结果<空类型, 整32> a3 = 表.追加(r3);
        打印("链表 大小: ", 表.大小());
        监视 = 1;
        累计 = 0;
        结果<空类型, 整32> d1 = 表.删除头部();   // 析构被移除元素 +1(E1)
        打印("删头后: ", 表.大小(), " 析构: ", 计数);
        结果<空类型, 整32> d2 = 表.删除尾部();   // +1(E3)
        打印("删尾后: ", 表.大小(), " 析构: ", 计数);
        表.清空();                               // +1(E2·链游剩余链元素)
        监视 = 0;
        打印("清空后: ", 表.大小(), " 析构: ", 计数);
        打印("链表析构序: ", 累计);              // 132 = E1→E3→E2
    }
    打印("链表块结束: ", 计数);  // r1/r2/r3 块出口已析构(块级 RAII):3+3=6

    // 栈:弹出 返回元素(所有权转移),不析构
    {
        栈<资源> 栈表;
        资源 s1 = 资源(1);
        资源 s2 = 资源(2);
        结果<空类型, 整32> p1 = 栈表.压入(s1);
        结果<空类型, 整32> p2 = 栈表.压入(s2);
        结果<资源, 整32> 弹 = 栈表.弹出();
        打印("栈弹出后大小: ", 栈表.大小(), " 析构: ", 计数);
    }

    // 队列:出队 返回元素(所有权转移给盒)·盒亡析构(182 正账);清空 自动析构剩余
    {
        队列<资源> 队列表;
        资源 q1 = 资源(1);
        资源 q2 = 资源(2);
        资源 q3 = 资源(3);
        结果<空类型, 整32> qa1 = 队列表.入队(q1);
        结果<空类型, 整32> qa2 = 队列表.入队(q2);
        结果<空类型, 整32> qa3 = 队列表.入队(q3);
        结果<资源, 整32> 出 = 队列表.出队();
        打印("队弹出后: ", 队列表.大小(), " 析构: ", 计数);
        监视 = 1;
        累计 = 0;
        队列表.清空();                          // 析构剩余 2 个 +2(E2,E3·链游)
        监视 = 0;
        打印("队清空后: ", 队列表.大小(), " 析构: ", 计数);
        打印("队列清空序: ", 累计);              // 23 = E2→E3
    }
    返回 0;
}

输出:链表 大小: 3 删头后: 2 析构: 1 删尾后: 1 析构: 2 清空后: 0 析构: 3 链表析构序: 132 链表块结束: 6 栈弹出后大小: 1 析构: 6 队弹出后: 2 析构: 10 队清空后: 0 析构: 12 队列清空序: 23

队首 不安全

不安全 函数 队首() -> 结果<T, 整32>

只读窥视队首(不出队);空队返回错误。

返回 正常(队首值);空队 → 错误(错误码.未初始化)。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 容器::错误码;

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

    // ==================== 1. 向量<T> ====================
    向量<整32> 数据 = 向量<整32>();
    如果 (数据.为空()) {
        打印("向量初始为空: 是");
    } 否则 {
        打印("向量初始为空: 否");
    }

    // 追加 6 个元素(触发扩容 0 -> 4 -> 8)
    结果<空类型, 整32> 追加结果 = 数据.追加(1);
    如果 (追加结果.正常) {
        追加结果 = 数据.追加(2);
        追加结果 = 数据.追加(3);
        追加结果 = 数据.追加(4);
        追加结果 = 数据.追加(5);
        追加结果 = 数据.追加(6);
    } 否则 {
        打印("向量追加失败: ", 追加结果.错误);
    }
    打印("向量大小: ", 数据.大小());
    打印("向量容量: ", 数据.容量());

    // 读取(正常路径)
    结果<整32, 整32> 读取结果 = 数据.读取(0);
    如果 (读取结果.正常) {
        打印("读取[0]: ", 读取结果.值);
    } 否则 {
        打印("读取[0]失败: ", 读取结果.错误);
    }

    // 读取(越界路径:错误码 2)
    读取结果 = 数据.读取(99);
    如果 (读取结果.正常) {
        打印("读取[99]未报错");
    } 否则 {
        打印("读取[99]越界: ", 读取结果.错误);
    }

    // 插入 + 删除 + 设置
    追加结果 = 数据.插入(0, 99);
    如果 (追加结果.正常) {
        打印("插入后[0]: ", 数据.元素(0));
    } 否则 {
        打印("插入失败: ", 追加结果.错误);
    }
    追加结果 = 数据.删除(0);
    如果 (追加结果.正常) {
        打印("删除后[0]: ", 数据.元素(0));
    } 否则 {
        打印("删除失败: ", 追加结果.错误);
    }
    追加结果 = 数据.设置(0, 7);
    如果 (追加结果.正常) {
        打印("设置后[0]: ", 数据.元素(0));
    } 否则 {
        打印("设置失败: ", 追加结果.错误);
    }

    // ==================== 2. 链表<T> ====================
    链表<整32> 列表 = 链表<整32>();
    追加结果 = 列表.追加(10);
    如果 (追加结果.正常) {
        追加结果 = 列表.追加(20);
        追加结果 = 列表.追加(30);
    } 否则 {
        打印("链表追加失败: ", 追加结果.错误);
    }
    打印("链表大小: ", 列表.大小());
    结果<整32, 整32> 头结果 = 列表.读取头部();
    如果 (头结果.正常) {
        打印("链表头: ", 头结果.值);
    } 否则 {
        打印("链表头失败: ", 头结果.错误);
    }
    结果<整32, 整32> 尾结果 = 列表.读取尾部();
    如果 (尾结果.正常) {
        打印("链表尾: ", 尾结果.值);
    } 否则 {
        打印("链表尾失败: ", 尾结果.错误);
    }

    // 头部追加
    追加结果 = 列表.头部追加(5);
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("头部追加后链表头: ", 头结果.值);
        } 否则 {
            打印("头部追加后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("头部追加失败: ", 追加结果.错误);
    }
    打印("头部追加后链表大小: ", 列表.大小());

    // 删除头部 + 删除尾部
    追加结果 = 列表.删除头部();
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("删除头部后链表头: ", 头结果.值);
        } 否则 {
            打印("删除头部后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("删除头部失败: ", 追加结果.错误);
    }
    追加结果 = 列表.删除尾部();
    如果 (追加结果.正常) {
        尾结果 = 列表.读取尾部();
        如果 (尾结果.正常) {
            打印("删除尾部后链表尾: ", 尾结果.值);
        } 否则 {
            打印("删除尾部后读尾失败: ", 尾结果.错误);
        }
    } 否则 {
        打印("删除尾部失败: ", 追加结果.错误);
    }

    // ==================== 3. 栈<T> ====================
    栈<整32> 数据栈 = 栈<整32>();
    追加结果 = 数据栈.压入(1);
    如果 (追加结果.正常) {
        追加结果 = 数据栈.压入(2);
        追加结果 = 数据栈.压入(3);
    } 否则 {
        打印("压入失败: ", 追加结果.错误);
    }
    打印("栈大小: ", 数据栈.大小());
    结果<整32, 整32> 栈顶结果 = 数据栈.栈顶();
    如果 (栈顶结果.正常) {
        打印("栈顶: ", 栈顶结果.值);
    } 否则 {
        打印("栈顶失败: ", 栈顶结果.错误);
    }
    结果<整32, 整32> 弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("弹出: ", 弹出结果.值);
    } 否则 {
        打印("弹出失败: ", 弹出结果.错误);
    }
    弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("再弹出: ", 弹出结果.值);
    } 否则 {
        打印("再弹出失败: ", 弹出结果.错误);
    }
    打印("弹后栈大小: ", 数据栈.大小());

    // ==================== 4. 队列<T> ====================
    队列<整32> 数据队列 = 队列<整32>();
    追加结果 = 数据队列.入队(5);
    如果 (追加结果.正常) {
        追加结果 = 数据队列.入队(6);
        追加结果 = 数据队列.入队(7);
    } 否则 {
        打印("入队失败: ", 追加结果.错误);
    }
    打印("队列大小: ", 数据队列.大小());
    结果<整32, 整32> 队首结果 = 数据队列.队首();
    如果 (队首结果.正常) {
        打印("队首: ", 队首结果.值);
    } 否则 {
        打印("队首失败: ", 队首结果.错误);
    }
    结果<整32, 整32> 出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("出队: ", 出队结果.值);
    } 否则 {
        打印("出队失败: ", 出队结果.错误);
    }
    出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("再出队: ", 出队结果.值);
    } 否则 {
        打印("再出队失败: ", 出队结果.错误);
    }
    打印("出队后队列大小: ", 数据队列.大小());

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

输出:===== 容器库(Task 6.1)===== 向量初始为空: 是 向量大小: 6 向量容量: 8 读取[0]: 1 读取[99]越界: 2 插入后[0]: 99 删除后[0]: 1 设置后[0]: 7 链表大小: 3 链表头: 10 链表尾: 30 头部追加后链表头: 5 头部追加后链表大小: 4 删除头部后链表头: 10 删除尾部后链表尾: 20 栈大小: 3 栈顶: 3 弹出: 3 再弹出: 2 弹后栈大小: 1 队列大小: 3 队首: 5 出队: 5 再出队: 6 出队后队列大小: 1 ===== 容器库测试完成 =====

为空 常量

常量 函数 为空() -> 布尔

队列是否为空。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;
导入 容器::错误码;

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

    // ==================== 1. 向量<T> ====================
    向量<整32> 数据 = 向量<整32>();
    如果 (数据.为空()) {
        打印("向量初始为空: 是");
    } 否则 {
        打印("向量初始为空: 否");
    }

    // 追加 6 个元素(触发扩容 0 -> 4 -> 8)
    结果<空类型, 整32> 追加结果 = 数据.追加(1);
    如果 (追加结果.正常) {
        追加结果 = 数据.追加(2);
        追加结果 = 数据.追加(3);
        追加结果 = 数据.追加(4);
        追加结果 = 数据.追加(5);
        追加结果 = 数据.追加(6);
    } 否则 {
        打印("向量追加失败: ", 追加结果.错误);
    }
    打印("向量大小: ", 数据.大小());
    打印("向量容量: ", 数据.容量());

    // 读取(正常路径)
    结果<整32, 整32> 读取结果 = 数据.读取(0);
    如果 (读取结果.正常) {
        打印("读取[0]: ", 读取结果.值);
    } 否则 {
        打印("读取[0]失败: ", 读取结果.错误);
    }

    // 读取(越界路径:错误码 2)
    读取结果 = 数据.读取(99);
    如果 (读取结果.正常) {
        打印("读取[99]未报错");
    } 否则 {
        打印("读取[99]越界: ", 读取结果.错误);
    }

    // 插入 + 删除 + 设置
    追加结果 = 数据.插入(0, 99);
    如果 (追加结果.正常) {
        打印("插入后[0]: ", 数据.元素(0));
    } 否则 {
        打印("插入失败: ", 追加结果.错误);
    }
    追加结果 = 数据.删除(0);
    如果 (追加结果.正常) {
        打印("删除后[0]: ", 数据.元素(0));
    } 否则 {
        打印("删除失败: ", 追加结果.错误);
    }
    追加结果 = 数据.设置(0, 7);
    如果 (追加结果.正常) {
        打印("设置后[0]: ", 数据.元素(0));
    } 否则 {
        打印("设置失败: ", 追加结果.错误);
    }

    // ==================== 2. 链表<T> ====================
    链表<整32> 列表 = 链表<整32>();
    追加结果 = 列表.追加(10);
    如果 (追加结果.正常) {
        追加结果 = 列表.追加(20);
        追加结果 = 列表.追加(30);
    } 否则 {
        打印("链表追加失败: ", 追加结果.错误);
    }
    打印("链表大小: ", 列表.大小());
    结果<整32, 整32> 头结果 = 列表.读取头部();
    如果 (头结果.正常) {
        打印("链表头: ", 头结果.值);
    } 否则 {
        打印("链表头失败: ", 头结果.错误);
    }
    结果<整32, 整32> 尾结果 = 列表.读取尾部();
    如果 (尾结果.正常) {
        打印("链表尾: ", 尾结果.值);
    } 否则 {
        打印("链表尾失败: ", 尾结果.错误);
    }

    // 头部追加
    追加结果 = 列表.头部追加(5);
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("头部追加后链表头: ", 头结果.值);
        } 否则 {
            打印("头部追加后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("头部追加失败: ", 追加结果.错误);
    }
    打印("头部追加后链表大小: ", 列表.大小());

    // 删除头部 + 删除尾部
    追加结果 = 列表.删除头部();
    如果 (追加结果.正常) {
        头结果 = 列表.读取头部();
        如果 (头结果.正常) {
            打印("删除头部后链表头: ", 头结果.值);
        } 否则 {
            打印("删除头部后读头失败: ", 头结果.错误);
        }
    } 否则 {
        打印("删除头部失败: ", 追加结果.错误);
    }
    追加结果 = 列表.删除尾部();
    如果 (追加结果.正常) {
        尾结果 = 列表.读取尾部();
        如果 (尾结果.正常) {
            打印("删除尾部后链表尾: ", 尾结果.值);
        } 否则 {
            打印("删除尾部后读尾失败: ", 尾结果.错误);
        }
    } 否则 {
        打印("删除尾部失败: ", 追加结果.错误);
    }

    // ==================== 3. 栈<T> ====================
    栈<整32> 数据栈 = 栈<整32>();
    追加结果 = 数据栈.压入(1);
    如果 (追加结果.正常) {
        追加结果 = 数据栈.压入(2);
        追加结果 = 数据栈.压入(3);
    } 否则 {
        打印("压入失败: ", 追加结果.错误);
    }
    打印("栈大小: ", 数据栈.大小());
    结果<整32, 整32> 栈顶结果 = 数据栈.栈顶();
    如果 (栈顶结果.正常) {
        打印("栈顶: ", 栈顶结果.值);
    } 否则 {
        打印("栈顶失败: ", 栈顶结果.错误);
    }
    结果<整32, 整32> 弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("弹出: ", 弹出结果.值);
    } 否则 {
        打印("弹出失败: ", 弹出结果.错误);
    }
    弹出结果 = 数据栈.弹出();
    如果 (弹出结果.正常) {
        打印("再弹出: ", 弹出结果.值);
    } 否则 {
        打印("再弹出失败: ", 弹出结果.错误);
    }
    打印("弹后栈大小: ", 数据栈.大小());

    // ==================== 4. 队列<T> ====================
    队列<整32> 数据队列 = 队列<整32>();
    追加结果 = 数据队列.入队(5);
    如果 (追加结果.正常) {
        追加结果 = 数据队列.入队(6);
        追加结果 = 数据队列.入队(7);
    } 否则 {
        打印("入队失败: ", 追加结果.错误);
    }
    打印("队列大小: ", 数据队列.大小());
    结果<整32, 整32> 队首结果 = 数据队列.队首();
    如果 (队首结果.正常) {
        打印("队首: ", 队首结果.值);
    } 否则 {
        打印("队首失败: ", 队首结果.错误);
    }
    结果<整32, 整32> 出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("出队: ", 出队结果.值);
    } 否则 {
        打印("出队失败: ", 出队结果.错误);
    }
    出队结果 = 数据队列.出队();
    如果 (出队结果.正常) {
        打印("再出队: ", 出队结果.值);
    } 否则 {
        打印("再出队失败: ", 出队结果.错误);
    }
    打印("出队后队列大小: ", 数据队列.大小());

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

输出:===== 容器库(Task 6.1)===== 向量初始为空: 是 向量大小: 6 向量容量: 8 读取[0]: 1 读取[99]越界: 2 插入后[0]: 99 删除后[0]: 1 设置后[0]: 7 链表大小: 3 链表头: 10 链表尾: 30 头部追加后链表头: 5 头部追加后链表大小: 4 删除头部后链表头: 10 删除尾部后链表尾: 20 栈大小: 3 栈顶: 3 弹出: 3 再弹出: 2 弹后栈大小: 1 队列大小: 3 队首: 5 出队: 5 再出队: 6 出队后队列大小: 1 ===== 容器库测试完成 =====

大小 常量

常量 函数 大小() -> 整64

队列内元素个数。

主.cnCN

导入 容器::向量;
导入 容器::链表;
导入 容器::栈;
导入 容器::队列;

// 内存搅动:新分配覆盖「已释放内存」,使悬垂元素内容可观测损坏
函数 搅动() -> 整64 {
    整64 和 = 0;
    整64 i = 0;
    当 (i < 24) {
        字符串 垃圾 = 字符串复制("搅动内存填充占位字符串内容甲乙丙丁戊己庚辛");
        和 = 和 + 字符串长度(垃圾);
        i++;
    }
    返回 和;
}

// ① 借用来源:字符串形参(借用视图)入容器——容器析构不得释放调用方的串
函数 存入形参(向量<字符串> 表, 字符串 值) -> 空类型 {
    结果<空类型, 整32> 加 = 表.追加(值);
    如果 (!加.正常) { 运行时错误(4); }
}

函数 形态借用() -> 整64 {
    字符串 本地 = 字符串复制("双编译对照·借用来源调用方拥有串内容甲乙丙丁");
    如果 (1 == 1) {
        向量<字符串> 表 = 向量<字符串>();
        存入形参(表, 本地);
    }
    整64 消耗 = 搅动();
    如果 (字符串比较(本地, "双编译对照·借用来源调用方拥有串内容甲乙丙丁")) { 返回 1; }
    返回 0;
}

// ② 拥有串局部裸标识符入容器——容器独立拥有(源照常可用)
函数 收集标识符(向量<字符串> 表) -> 空类型 {
    字符串 值 = 字符串复制("双编译对照·拥有串局部内容甲乙丙丁戊己庚辛");
    结果<空类型, 整32> 加 = 表.追加(值);
    如果 (!加.正常) { 运行时错误(4); }
    如果 (!字符串比较(值, "双编译对照·拥有串局部内容甲乙丙丁戊己庚辛")) { 运行时错误(5); }
}

函数 形态标识符() -> 整64 {
    向量<字符串> 表 = 向量<字符串>();
    收集标识符(表);
    整64 消耗 = 搅动();
    字符串 元素 = 表.元素(0);
    如果 (字符串比较(元素, "双编译对照·拥有串局部内容甲乙丙丁戊己庚辛")) { 返回 1; }
    返回 0;
}

// ③ 成员/下标借出视图入容器——必须复制(共享句柄即随源释放=双释放/悬垂)
函数 形态借出() -> 整64 {
    字符串 来源 = 字符串复制("双编译对照·借出视图来源内容甲乙丙丁戊己庚");
    向量<字符串> 表 = 向量<字符串>();
    结果<空类型, 整32> 加 = 表.追加(来源);
    如果 (!加.正常) { 运行时错误(4); }
    整64 消耗 = 搅动();
    // 源与容器元素各自独立拥有——两侧内容均须完好
    如果 (!字符串比较(来源, "双编译对照·借出视图来源内容甲乙丙丁戊己庚")) { 返回 0; }
    字符串 元素 = 表.元素(0);
    如果 (!字符串比较(元素, "双编译对照·借出视图来源内容甲乙丙丁戊己庚")) { 返回 0; }
    返回 1;
}

// ④ 容器元素守恒:同一容器多次追加 + 搅动后全部元素内容完好
函数 形态守恒() -> 整64 {
    向量<字符串> 表 = 向量<字符串>();
    整64 i = 0;
    当 (i < 3) {
        字符串 值 = 字符串复制("双编译对照·守恒形态元素内容甲乙丙丁戊己庚辛壬");
        结果<空类型, 整32> 加 = 表.追加(值);
        如果 (!加.正常) { 运行时错误(4); }
        i++;
    }
    整64 消耗 = 搅动();
    如果 (表.大小() != 3) { 返回 0; }
    整64 j = 0;
    当 (j < 3) {
        字符串 元素 = 表.元素(j);
        如果 (!字符串比较(元素, "双编译对照·守恒形态元素内容甲乙丙丁戊己庚辛壬")) { 返回 0; }
        j++;
    }
    返回 1;
}

// ⑤ 四容器元素释放面:向量/链表/栈/队列 的元素串随容器析构逐一释放(残留归零)
函数 形态释放面() -> 整64 {
    整64 前 = 内存::活动分配数();
    如果 (1 == 1) {
        向量<字符串> 向量表 = 向量<字符串>();
        结果<空类型, 整32> 加1 = 向量表.追加(字符串复制("双编译对照·向量元素占位内容甲乙丙丁"));
        如果 (!加1.正常) { 运行时错误(4); }
        链表<字符串> 链表表 = 链表<字符串>();
        结果<空类型, 整32> 加2 = 链表表.头部追加(字符串复制("双编译对照·链表元素占位内容甲乙丙丁"));
        如果 (!加2.正常) { 运行时错误(4); }
        栈<字符串> 栈表 = 栈<字符串>();
        结果<空类型, 整32> 加3 = 栈表.压入(字符串复制("双编译对照·栈元素占位内容甲乙丙丁戊"));
        如果 (!加3.正常) { 运行时错误(4); }
        队列<字符串> 队列表 = 队列<字符串>();
        结果<空类型, 整32> 加4 = 队列表.入队(字符串复制("双编译对照·队列元素占位内容甲乙丙丁"));
        如果 (!加4.正常) { 运行时错误(4); }
    }
    整64 后 = 内存::活动分配数();
    如果 (后 == 前) { 返回 1; }
    返回 0;
}

// ⑥ 容器元素读出后容器销毁——借出视图的既有语义面(元素串随容器释放,
//    容器内副本独立拥有;本形态只锚定「容器内元素在容器存活期内恒完好」)
函数 形态读出() -> 整64 {
    向量<字符串> 表 = 向量<字符串>();
    结果<空类型, 整32> 加 = 表.追加(字符串复制("双编译对照·读出形态元素内容甲乙丙丁戊己"));
    如果 (!加.正常) { 运行时错误(4); }
    字符串 元素 = 表.元素(0);
    如果 (字符串比较(元素, "双编译对照·读出形态元素内容甲乙丙丁戊己")) { 返回 1; }
    返回 0;
}

// ⑦ 转移形态(75-a):转移(拥有局部) 入容器=**真 move**(零拷贝);
//    转移(借用形参) 入容器=复制(安全方向——容器不得接管借用句柄)。
//    两子检查都对才置位(折位 64):真 move 失效→分配增量≠0;判定误把借用当
//    拥有→容器析构释放调用方串→本地内容经搅动损坏。
函数 存入转移(向量<字符串> 表, 字符串 值) -> 整64 {
    结果<空类型, 整32> 加 = 表.追加(转移(值));
    如果 (!加.正常) { 返回 0; }
    返回 1;
}

函数 转移真move(向量<字符串> 表) -> 整64 {
    字符串 值 = 字符串复制("双编译对照·转移真move内容甲乙丙丁戊己庚辛");
    整64 前 = 内存::活动分配数();
    结果<空类型, 整32> 加 = 表.追加(转移(值));
    如果 (!加.正常) { 返回 0; }
    如果 (内存::活动分配数() != 前) { 返回 0; }   // 真 move=零拷贝
    字符串 元素 = 表.元素(0);
    如果 (!字符串比较(元素, "双编译对照·转移真move内容甲乙丙丁戊己庚辛")) { 返回 0; }
    返回 1;
}

函数 转移借用形参() -> 整64 {
    字符串 本地 = 字符串复制("双编译对照·转移借用形参内容甲乙丙丁戊己庚");
    如果 (1 == 1) {
        向量<字符串> 表 = 向量<字符串>();
        如果 (存入转移(表, 本地) != 1) { 返回 0; }
        字符串 元素 = 表.元素(0);
        如果 (!字符串比较(元素, "双编译对照·转移借用形参内容甲乙丙丁戊己庚")) { 返回 0; }
    }
    整64 消耗 = 搅动();
    如果 (!字符串比较(本地, "双编译对照·转移借用形参内容甲乙丙丁戊己庚")) { 返回 0; }
    返回 1;
}

函数 形态转移() -> 整64 {
    向量<字符串> 表 = 向量<字符串>();
    结果<空类型, 整32> 预 = 表.预留(8);   // 排除数组扩容分配干扰
    如果 (!预.正常) { 返回 0; }
    如果 (转移真move(表) != 1) { 返回 0; }
    如果 (转移借用形参() != 1) { 返回 0; }
    返回 1;
}

函数 主() -> 整32 {
    整32 校验 = 0;
    如果 (形态借用() == 1) { 校验 = 校验 + 1; }
    如果 (形态标识符() == 1) { 校验 = 校验 + 2; }
    如果 (形态借出() == 1) { 校验 = 校验 + 4; }
    如果 (形态守恒() == 1) { 校验 = 校验 + 8; }
    如果 (形态释放面() == 1) { 校验 = 校验 + 16; }
    如果 (形态读出() == 1) { 校验 = 校验 + 32; }
    如果 (形态转移() == 1) { 校验 = 校验 + 64; }
    返回 校验;
}

输出:[p6h] 已解析: target/audit2/v2src209/主.cn

清空

函数 清空()

链上元素全量析构后复位(同 链表.清空)。

主.cnCN

导入 容器::链表;
导入 容器::队列;

静态 整64 监视 = 0;
静态 整64 累计 = 0;

类 资源 {
公开:
    整64 编号;
    字符串 名;
    函数 资源(整64 v) {
        编号 = v;
        名 = 字符串复制("元素载荷甲乙丙");
    }
    函数 资源(资源& 其他) {
        编号 = 其他.编号;
        名 = 字符串复制(其他.名);
    }
    不安全 函数 ~资源() {
        如果 (监视 == 1) {
            累计 = 累计 * 10 + 编号;
        }
    }
}

// ① 链表:追加3 + 删除头部 + 删除尾部 + 清空——身份 132 + 净差 0
不安全 函数 链形() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 序 = 0;
    {
        链表<资源> 表;
        资源 r1 = 资源(1);
        资源 r2 = 资源(2);
        资源 r3 = 资源(3);
        结果<空类型, 整32> a1 = 表.追加(r1);
        结果<空类型, 整32> a2 = 表.追加(r2);
        结果<空类型, 整32> a3 = 表.追加(r3);
        监视 = 1;
        累计 = 0;
        结果<空类型, 整32> d1 = 表.删除头部();
        结果<空类型, 整32> d2 = 表.删除尾部();
        表.清空();
        监视 = 0;
        序 = 累计;
    }
    打印("链表析构序: ", 序);
    返回 内存::活动分配数() - 前;
}

// ② 队列:入队3 + 清空——身份 123 + 净差 0
不安全 函数 队形() -> 整64 {
    整64 前 = 内存::活动分配数();
    整64 序 = 0;
    {
        队列<资源> 队;
        资源 q1 = 资源(1);
        资源 q2 = 资源(2);
        资源 q3 = 资源(3);
        结果<空类型, 整32> b1 = 队.入队(q1);
        结果<空类型, 整32> b2 = 队.入队(q2);
        结果<空类型, 整32> b3 = 队.入队(q3);
        监视 = 1;
        累计 = 0;
        队.清空();
        监视 = 0;
        序 = 累计;
    }
    打印("队列析构序: ", 序);
    返回 内存::活动分配数() - 前;
}

不安全 函数 主() -> 整32 {
    整64 链净 = 链形();
    整64 队净 = 队形();
    打印("链净差: ", 链净);
    打印("队净差: ", 队净);
    返回 0;
}

输出:链表析构序: 132 队列析构序: 123 链净差: 0 队净差: 0

取空闲槽 内部 不安全

不安全 函数 取空闲槽() -> 整64

内部辅助:同 链表.取空闲槽(空闲链 O(1) 复用)。

归还槽 内部 不安全

不安全 函数 归还槽(整64 槽) -> 空类型

内部辅助:同 链表.归还槽。