容器
向量 / 链表 / 栈 / 队列——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 槽) -> 空类型
内部辅助:同 链表.归还槽。