内置函数
随语言自带的内建函数——输出/输入/字符串/内存/驻留/类型工具,无需导入。
格式化输出
打印函数族只有 打印 / 打印行 两个变参函数(外加 格式化)。注意命名语义:打印 = 末尾自动换行;打印行 = 不换行(「行」表示逐行连续输出)。字符串 + 数值 自动拼接(“甲” + 1 → “甲1”)。
输出.cnCN
函数 主() -> 整32 {
打印("总分:", 95, " 平均:", 95 / 3.0);
打印行("这一行没有换行,");
打印行("接着输出。");
打印(""); // 补一个换行
字符串 报告 = 格式化("%s 得 %d 分", "张三", 95);
打印(报告);
返回 0;
}输出:总分:95 平均:31.666667 这一行没有换行,接着输出。 张三 得 95 分
打印
函数 打印(任意值...) -> 空类型
变参打印,逐参输出,末尾自动换行。多参数间无分隔符(需要空格自己加:打印(甲, , 乙))。整128/正128 打印完整 128 位。
主.cnCN
导入 核心::错误码;
函数 主() -> 整32 {
打印('甲'); // 字符字面量形态
打印('中');
打印('\u{4E2D}'); // \u 转义形态(= '中')
字符 字变 = '乙';
打印(字变); // 字符变量形态
打印(整32('甲')); // 码点数值形态(显式通道)
返回 0;
}输出:甲 中 中 乙 30002
打印行
函数 打印行(任意值...) -> 空类型
同 打印 但末尾不换行——适合分段拼一行输出。(历史教训:旧版 打印行整数 语义恰好相反,已删除,勿混淆。)
主.cnCN
导入 容器::向量;
导入 映射集合;
结构体 符号 {
整64 名ID;
整64 类型ID;
}
函数 主() -> 整32 {
映射<整64, 符号> 层 = 映射<整64, 符号>();
打印行("A1");
符号 s1;
s1.名ID = 11;
s1.类型ID = 101;
结果<空类型, 整32> 加1 = 层.设置(1, s1);
打印("A2 ", 加1.正常);
打印行("B1");
符号 s2;
s2.名ID = 22;
s2.类型ID = 202;
结果<空类型, 整32> 加2 = 层.设置(2, s2);
打印("B2 ", 加2.正常);
结果<符号, 整32> 查1 = 层.获取(1);
如果 (查1.正常) {
打印("C1 ", 查1.正常);
打印行("C2 ", 查1.值.类型ID);
}
向量<映射<整64, 符号>> 表 = 向量<映射<整64, 符号>>();
结果<空类型, 整32> 压 = 表.追加(层);
打印("D1 ", 压.正常);
打印行("D2 ", 表.大小());
映射<整64, 符号> 顶层 = 表.元素(0);
打印("E1 ", 顶层.大小());
结果<符号, 整32> 查r = 顶层.获取(2);
如果 (查r.正常) {
打印行("E2 ", 查r.值.类型ID);
}
整64 i = 0;
当 (i < 表.大小()) {
映射<整64, 符号> 环 = 表.元素(i);
打印("F", i);
打印行(" ", 环.大小());
i = i + 1;
}
结果<空类型, 整32> 删r = 表.删除(0);
打印("G1 ", 删r.正常);
打印行("G2 ", 表.大小());
返回 0;
}输出:A1A2 真 B1B2 真 C1 真 C2 101D1 真 D2 1E1 2 E2 202F0 2G1 真 G2 0
格式化
函数 格式化(字符串 格式串, 参数...) -> 字符串
sprintf 风格格式化,返回新字符串(拥有型)而不直接输出。占位符:%d 整8/16/32、%u 正8/16/32、%f 浮点、%s 字符串、%c 字符、%x/%X 十六进制、%o 八进制、%p 指针、%d64/%u64 64 位整数、%d128/%u128 128 位整数、%% 字面百分号。单符占位符可带 C 风格标志/宽度/精度前缀(如 %.2f)。编译期配对执法(2026-11-02 立法):格式串须为字符串字面量;占位符个数须等于实参个数且逐位类型匹配——个数不等、类型不配、未知占位符一律编译期拒绝(禁静默丢参/截断/崩溃);花括号 {{}} 不是占位符(普通文本原样输出)。
主.cnCN
函数 主() -> 整32 {
整128 大数 = 12345678901234567890123456789;
正128 满格 = 170141183460469231731687303715884105727;
整128 负数 = -170141183460469231731687303715884105728;
整64 宽数 = 4294967297;
正64 正满 = 9223372036854775807;
整32 小号 = 42;
打印(格式化("大数=%d128", 大数));
打印(格式化("满格=%u128", 满格));
打印(格式化("最小=%d128", 负数));
打印(格式化("宽数=%d64", 宽数));
打印(格式化("正满=%u64", 正满));
打印(格式化("混合=%d 是%d128 元", 小号, 大数));
打印(格式化("百分号%%字面"));
打印(格式化("文本{}原样"));
返回 0;
}输出:大数=12345678901234567890123456789 满格=170141183460469231731687303715884105727 最小=-170141183460469231731687303715884105728 宽数=4294967297 正满=9223372036854775807 混合=42 是12345678901234567890123456789 元 百分号%字面 文本{}原样
IO::读取行
内置 函数 IO::读取行() -> 字符串
标准输入内置(stdlib IO 模块 读取行() 的底层)。业务代码用 IO::读取行 包装版(返回 结果 以显式处理 EOF)。
字符串函数族
字符串为 UTF-8 字节序列(\0 结尾),全部按字节偏移工作。返回字符串的函数都返回拥有型新串。比较语义:内容相等用 字符串比较(或 ==),排序序用 字符串字典序(负/0/正)。
字符串内置.cnCN
函数 主() -> 整32 {
字符串 文 = "你好, CN";
打印(字符串长度(文)); // 10(UTF-8 字节数:你好=6)
打印(字符串包含(文, "CN")); // 真
打印(字符串前缀(文, "你好")); // 真
打印(字符串子串(文, 0, 3)); // 你(按字节切,3=一个汉字)
字符串 全大写 = 字符串大写("cn lang");
打印(全大写); // CN LANG
打印(字符串字典序("apple", "banana") < 0); // 真(字节序)
返回 0;
}输出:10 真 真 你 CN LANG 真
字符串长度
函数 字符串长度(字符串 值) -> 整64
UTF-8 字节数(非字符数)。
主.cnCN
函数 追加(整64 句柄, 字符串 段) -> 空类型 {
打印("[用户追加被调用]");
}
函数 主() -> 整32 {
整64 构建 = 字符串构建器::新建();
字符串构建器::追加(构建, "abc");
字符串 出串 = 字符串构建器::完成(构建);
打印(字符串长度(出串));
返回 0;
}输出:3
字符串比较
函数 字符串比较(字符串 甲, 字符串 乙) -> 布尔
内容相等判定(== 运算符同义)。
主.cnCN
函数 主() -> 整32 {
字符串 a = "abc";
字符串 b = "abc";
字符串 c = "abd";
如果 (a == b) { 打印("内容相等对"); } 否则 { 打印("内容相等错"); 返回 1; }
如果 (a != c) { 打印("不等对"); } 否则 { 打印("不等错"); 返回 1; }
如果 (a < c) { 打印("字典序小于对"); } 否则 { 打印("字典序小于错"); 返回 1; }
如果 (c > a) { 打印("字典序大于对"); } 否则 { 打印("字典序大于错"); 返回 1; }
如果 (a <= b) { 打印("小于等于对"); } 否则 { 打印("小于等于错"); 返回 1; }
如果 (c >= c) { 打印("大于等于对"); } 否则 { 打印("大于等于错"); 返回 1; }
字符串 拼 = "a" + "b" + "c";
如果 (拼 == a) { 打印("拼接产物相等对"); } 否则 { 打印("拼接产物相等错"); 返回 1; }
如果 (a != 无) { 打印("判空保留对"); } 否则 { 打印("判空保留错"); 返回 1; }
布尔 显式 = 字符串比较(a, b);
// 复合形态(168 销项锚·970 根治:v2 检查层左末端索引 附加-1 修正——
// 解析层结合序本来就对·970 实证误诊在检查层取错左操作数末端)。
如果 (显式 && a == b) { 打印("显式函数并行对"); } 否则 { 打印("显式函数并行错"); 返回 1; }
返回 0;
}输出:内容相等对 不等对 字典序小于对 字典序大于对 小于等于对 大于等于对 拼接产物相等对 判空保留对 显式函数并行对
字符串字典序
函数 字符串字典序(字符串 甲, 字符串 乙) -> 整64
字典序比较:甲<乙 返回负、相等 0、甲>乙 返回正。< 等关系运算符等价于它与 0 比较。
主.cnCN
函数 主() -> 整32 {
打印("abc" == "abc" ? 1 : 0); // 1
打印("abc" != "abd" ? 1 : 0); // 1
打印("abc" < "abd" ? 1 : 0); // 1
打印("b" >= "ab" ? 1 : 0); // 1
字符串 句 = "n=" + 5 + " b=" + 真;
打印(句); // n=5 b=真
打印("" == "" ? 1 : 0); // 1
返回 0;
}输出:1 1 1 1 n=5 b=真 1
字符串连接
函数 字符串连接(字符串 甲, 字符串 乙) -> 字符串
拼接两串返回新串(拥有型)。+ 运算符同义,且 字符串 + 数值 会自动把数值转成字符串。
主.cnCN
函数 造句(字符串 头) -> 字符串 {
字符串 尾 = "!";
字符串 句 = 字符串复制(头);
句 = 字符串连接(句, 尾);
返回 句;
}
函数 主() -> 整32 {
字符串 a = "你好";
字符串 b = a;
b = "世界";
打印(a);
打印(b);
字符串 c = 造句("编译期安全");
打印(c);
字符串 d = 转移(c);
打印(字符串长度(d));
如果 (字符串比较(a, "你好")) {
打印("同");
} 否则 {
打印("异");
}
返回 0;
}输出:你好 世界 编译期安全! 16 同
字符串复制
函数 字符串复制(字符串 值) -> 字符串
复制为独立拥有的新堆串。借用视图(字符*)落堆为拥有串的显式通道。
主.cnCN
导入 容器::向量;
结构体 盒子 {
字符串 名;
整32 号;
}
函数 形探() -> 盒子 {
向量<盒子> 表 = 向量<盒子>();
结果<空类型, 整32> 加 = 表.追加(盒子{ 名 = 字符串复制("P263G串"), 号 = 7 });
如果 (!加.正常) { 盒子 空 = 盒子{ 名 = 字符串复制(""), 号 = 0 }; 返回 空; }
返回 表.元素(0);
}
函数 主() -> 整32 {
整64 前 = 内存::活动分配数();
整32 i = 0;
当 (i < 1000) {
盒子 抄 = 形探();
如果 (抄.号 != 7) { 打印(0); 返回 0; }
i++;
}
如果 (内存::活动分配数() != 前) { 打印(1); 返回 0; }
打印(7);
返回 0;
}输出:7
字符串查找
函数 字符串查找(字符串 主串, 字符串 子串) -> 整64
返回子串首次出现的字节下标;未找到 -1。
主.cnCN
函数 主() -> 整32 {
打印("abc" == "abc" ? 1 : 0); // 1
打印("abc" != "abd" ? 1 : 0); // 1
打印("abc" < "abd" ? 1 : 0); // 1
打印("b" >= "ab" ? 1 : 0); // 1
字符串 句 = "n=" + 5 + " b=" + 真;
打印(句); // n=5 b=真
打印("" == "" ? 1 : 0); // 1
返回 0;
}输出:1 1 1 1 n=5 b=真 1
字符串子串
函数 字符串子串(字符串 值, 整64 起点, 整64 长度) -> 字符串
取 [起点, 起点+长度) 的字节切片为新串。
主.cnCN
函数 主() -> 整32 {
打印("===== 时间库(Task 6.5)=====");
// ==================== 1. 当前时间戳(秒级,递增) ====================
整64 戳1 = 时间::当前时间戳();
整64 戳2 = 时间::当前时间戳();
打印("时间戳合理: ", 戳2 >= 戳1); // 1(第二次 ≥ 第一次)
打印("时间戳大于0: ", 戳1 > 0); // 1(Unix 纪元后)
// ==================== 2. 单调时钟毫秒(递增) ====================
整64 毫1 = 时间::单调时钟毫秒();
整64 毫2 = 时间::单调时钟毫秒();
打印("时钟毫秒合理: ", 毫2 >= 毫1); // 1
// ==================== 3. 格式化时间 ====================
// "%Y-%m-%d" → "2026-08-14" 形态:长度=10、第4/7位是 '-'
字符串 日期 = 时间::格式化时间(戳1, "%Y-%m-%d");
如果 (日期 != 无) {
布尔 长度对 = 字符串长度(日期) == 10;
// 字符串比较运算符(==)规格书未定义——用 字符串比较 内置(相等返回 真)
字符串 分隔符1 = 字符串子串(日期, 4, 1);
字符串 分隔符2 = 字符串子串(日期, 7, 1);
布尔 分隔对 = 字符串比较(分隔符1, "-") && 字符串比较(分隔符2, "-");
打印("日期长度=10: ", 长度对); // 1
打印("日期分隔符: ", 分隔对); // 1
// 日期内容随运行日期变化(E2E 固定文本比对不能打印实际值)
} 否则 {
打印("格式化时间失败");
}
// "%Y" → 4 位数字年份(内容随年份变化,只断言长度)
字符串 年 = 时间::格式化时间(戳1, "%Y");
如果 (年 != 无) {
打印("年份长度=4: ", 字符串长度(年) == 4); // 1
} 否则 {
打印("格式化年份失败");
}
// 非法时间戳(负数)→ nullptr → 失败
字符串 非法 = 时间::格式化时间(-1, "%Y");
如果 (非法 != 无) {
打印("非法时间戳处理: ", 非法);
} 否则 {
打印("非法时间戳失败"); // 失败
}
打印("===== 时间库测试完成 =====");
返回 0;
}输出:===== 时间库(Task 6.5)===== 时间戳合理: 真 时间戳大于0: 真 时钟毫秒合理: 真 日期长度=10: 真 日期分隔符: 真 年份长度=4: 真 非法时间戳失败 ===== 时间库测试完成 =====
字符串大写
函数 字符串大写(字符串 值) -> 字符串
ASCII 字母转大写的新串。
主.cnCN
函数 主() -> 整32 {
打印("abc" == "abc" ? 1 : 0); // 1
打印("abc" != "abd" ? 1 : 0); // 1
打印("abc" < "abd" ? 1 : 0); // 1
打印("b" >= "ab" ? 1 : 0); // 1
字符串 句 = "n=" + 5 + " b=" + 真;
打印(句); // n=5 b=真
打印("" == "" ? 1 : 0); // 1
返回 0;
}输出:1 1 1 1 n=5 b=真 1
字符串小写
函数 字符串小写(字符串 值) -> 字符串
ASCII 字母转小写的新串。
主.cnCN
函数 主() -> 整32 {
打印("abc" == "abc" ? 1 : 0); // 1
打印("abc" != "abd" ? 1 : 0); // 1
打印("abc" < "abd" ? 1 : 0); // 1
打印("b" >= "ab" ? 1 : 0); // 1
字符串 句 = "n=" + 5 + " b=" + 真;
打印(句); // n=5 b=真
打印("" == "" ? 1 : 0); // 1
返回 0;
}输出:1 1 1 1 n=5 b=真 1
字符串修剪
函数 字符串修剪(字符串 值) -> 字符串
去除两端空白的新串。
主.cnCN
函数 主() -> 整32 {
打印("abc" == "abc" ? 1 : 0); // 1
打印("abc" != "abd" ? 1 : 0); // 1
打印("abc" < "abd" ? 1 : 0); // 1
打印("b" >= "ab" ? 1 : 0); // 1
字符串 句 = "n=" + 5 + " b=" + 真;
打印(句); // n=5 b=真
打印("" == "" ? 1 : 0); // 1
返回 0;
}输出:1 1 1 1 n=5 b=真 1
字符串反转
函数 字符串反转(字符串 值) -> 字符串
字节序反转的新串(ASCII 文本安全;多字节 UTF-8 会破坏字符)。
主.cnCN
函数 主() -> 整32 {
打印("abc" == "abc" ? 1 : 0); // 1
打印("abc" != "abd" ? 1 : 0); // 1
打印("abc" < "abd" ? 1 : 0); // 1
打印("b" >= "ab" ? 1 : 0); // 1
字符串 句 = "n=" + 5 + " b=" + 真;
打印(句); // n=5 b=真
打印("" == "" ? 1 : 0); // 1
返回 0;
}输出:1 1 1 1 n=5 b=真 1
字符串包含
函数 字符串包含(字符串 主串, 字符串 子串) -> 布尔
是否含有子串。
主.cnCN
函数 消耗形参(字符串 s) -> 空类型 {
s = 字符串复制("形参内重赋值新串");
打印行("消耗形参改为:", s);
}
函数 释放形参(字符串 s) -> 空类型 {
字符串释放(s);
}
类 工具 {
公开:
函数 工具() { }
函数 消耗方法(字符串 s) -> 空类型 {
s = 字符串复制("方法内重赋值");
打印行("方法收到改后:", s);
}
}
函数 主() -> 整32 {
// ① #616 消耗形参重赋值:副本出口释放+调用方变量完好
字符串 片甲 = 字符串复制("甲乙丙丁戊己庚辛");
整64 m0 = 内存::活动分配数();
消耗形参(片甲);
打印("① 消耗形参重赋值 残留:", 内存::活动分配数() - m0);
打印行("片甲仍可用:", 片甲);
// ② #616 字符串释放(形参):消耗标记后释放只作用于自身副本
字符串 片乙 = 字符串复制("子丑寅卯辰巳午未");
整64 n0 = 内存::活动分配数();
释放形参(片乙);
打印("② 字符串释放形参 残留:", 内存::活动分配数() - n0);
打印行("片乙仍可用:", 片乙);
字符串释放(片乙);
// ③ #616 类方法消耗形参:同①(方法面)
工具 t = 工具();
字符串 片丙 = 字符串复制("申酉戌亥");
整64 p0 = 内存::活动分配数();
t.消耗方法(片丙);
打印("③ 类方法消耗形参 残留:", 内存::活动分配数() - p0);
打印行("片丙仍可用:", 片丙);
字符串释放(片丙);
// ④ #616 转移(形参):副本移交后出口空安全
字符串 片丁 = 字符串复制("甲子乙丑");
整64 q0 = 内存::活动分配数();
消耗形参转移(片丁);
打印("④ 转移形参 残留:", 内存::活动分配数() - q0);
字符串释放(片丁);
// ⑤ #617 打印顶层 整数转字符串 临时
整64 r0 = 内存::活动分配数();
打印("x=", 整数转字符串(42));
打印("⑤ 打印转字符串临时 残留:", 内存::活动分配数() - r0);
// ⑥ #617 打印行 拼接链(中间临时+顶层临时同点归零)
整64 s0 = 内存::活动分配数();
打印行("拼接前缀=" + 片甲 + "=后缀");
打印("⑥ 打印拼接链临时 残留:", 内存::活动分配数() - s0);
// ⑦ #617 格式化 作打印实参临时
整64 t0 = 内存::活动分配数();
打印("⑦ 值=", 格式化("值=%d尾", 7));
打印("⑦ 打印格式化临时 残留:", 内存::活动分配数() - t0);
// ⑧ #617 谓词族实参临时(字符串包含)
字符串 文本 = 字符串复制("目标串内容在这里");
整64 u0 = 内存::活动分配数();
如果 (字符串包含(文本, 整数转字符串(5))) {
打印行("包含命中");
}
打印("⑧ 谓词族实参临时 残留:", 内存::活动分配数() - u0);
// ⑨ #617 累积:打印临时连做 3 次
整64 v0 = 内存::活动分配数();
打印("v1=", 整数转字符串(1));
打印("v2=", 整数转字符串(2));
打印("v3=", 整数转字符串(3));
打印("⑨ 打印临时连做3次 残留:", 内存::活动分配数() - v0);
// ⑩ 对照:拼接结果赋变量+手动释放=健康基线
整64 x0 = 内存::活动分配数();
字符串 对照 = "对照" + 片甲;
打印行("对照变量:", 对照);
字符串释放(对照);
打印("⑩ 手动释放对照 残留:", 内存::活动分配数() - x0);
// ⑪ #617 用户函数返回串临时直入打印(对齐补锁:返回=所有权移交调用方,
// 打印完成后调用方释放——宿主 funcReturnTypeOf 与 v2 函数返回类型们
// 双侧同判,残留恒 0)
整64 w0 = 内存::活动分配数();
打印行("⑪值=", 造串617(7));
打印("⑪ 用户函数返回串临时 残留:", 内存::活动分配数() - w0);
字符串释放(文本);
字符串释放(片甲);
返回 0;
}
函数 消耗形参转移(字符串 s) -> 空类型 {
字符串 接收 = 转移(s);
打印行("转移接收:", 接收);
字符串释放(接收);
}
函数 造串617(整32 n) -> 字符串 {
返回 "用户串" + 整数转字符串(n);
}输出:消耗形参改为:形参内重赋值新串① 消耗形参重赋值 残留:0 片甲仍可用:甲乙丙丁戊己庚辛② 字符串释放形参 残留:0 片乙仍可用:子丑寅卯辰巳午未方法收到改后:方法内重赋值③ 类方法消耗形参 残留:0 片丙仍可用:申酉戌亥转移接收:甲子乙丑④ 转移形参 残留:0 x=42 ⑤ 打印转字符串临时 残留:0 拼接前缀=甲乙丙丁戊己庚辛=后缀⑥ 打印拼接链临时 残留:0 ⑦ 值=值=7尾 ⑦ 打印格式化临时 残留:0 ⑧ 谓词族实参临时 残留:0 v1=1 v2=2 v3=3 ⑨ 打印临时连做3次 残留:0 对照变量:对照甲乙丙丁戊己庚辛⑩ 手动释放对照 残留:0 ⑪值=用户串7⑪ 用户函数返回串临时 残留:0
字符串前缀
函数 字符串前缀(字符串 值, 字符串 前缀) -> 布尔
是否以前缀开头。
主.cnCN
函数 主() -> 整32 {
打印("abc" == "abc" ? 1 : 0); // 1
打印("abc" != "abd" ? 1 : 0); // 1
打印("abc" < "abd" ? 1 : 0); // 1
打印("b" >= "ab" ? 1 : 0); // 1
字符串 句 = "n=" + 5 + " b=" + 真;
打印(句); // n=5 b=真
打印("" == "" ? 1 : 0); // 1
返回 0;
}输出:1 1 1 1 n=5 b=真 1
字符串后缀
函数 字符串后缀(字符串 值, 字符串 后缀) -> 布尔
是否以后缀结尾。
主.cnCN
函数 主() -> 整32 {
打印("abc" == "abc" ? 1 : 0); // 1
打印("abc" != "abd" ? 1 : 0); // 1
打印("abc" < "abd" ? 1 : 0); // 1
打印("b" >= "ab" ? 1 : 0); // 1
字符串 句 = "n=" + 5 + " b=" + 真;
打印(句); // n=5 b=真
打印("" == "" ? 1 : 0); // 1
返回 0;
}输出:1 1 1 1 n=5 b=真 1
整数转字符串
函数 整数转字符串(整64 值) -> 字符串;重载:函数 整数转字符串(整128 值) -> 字符串
整64 转十进制字符串;整128 重载全精度转串(含负号,#1891)。
主.cnCN
函数 主() -> 整32 {
整128 大值 = 123456789012345678901234567890;
字符串 文本 = 整数转字符串(大值);
打印(文本);
打印(字符串长度(文本));
整128 负值 = 0 - 123456789012345678901234567890;
打印(整数转字符串(负值));
正128 无符值 = 18446744073709551621ULL;
字符串 无符文本 = 正数转字符串(无符值);
打印(无符文本);
打印(字符串长度(无符文本));
整64 中值 = 123456789012345L;
打印(整数转字符串(中值));
整32 小值 = 42;
打印(整数转字符串(小值));
整128 源128 = 12345;
打印(整数转字符串(整64(源128)));
返回 0;
}输出:123456789012345678901234567890 30 -123456789012345678901234567890 18446744073709551621 20 123456789012345 42 12345
浮点转字符串
函数 浮点转字符串(浮64 值) -> 字符串
浮64 转字符串(6 位小数格式)。
主.cnCN
导入 容器::向量;
类 盒 {
公开:
整32 值;
字符串 名;
函数 盒(整32 v, 字符串 n) { 值 = v; 名 = n; }
函数 ~盒() { }
不安全 函数 盒(盒& 其他) { 值 = 其他.值; 名 = 字符串复制(其他.名); }
函数 运算符+(盒 右) -> 盒 {
返回 盒(值 + 右.值, 字符串复制(名));
}
}
函数 主() -> 整32 {
// 形态A:声明面构造 盒(0, 整数转字符串(42))
整64 bA = 内存::活动分配数();
整64 名A = 0;
{
盒 甲 = 盒(0, 整数转字符串(42));
名A = 字符串长度(甲.名);
}
打印(名A);
打印(内存::活动分配数() - bA);
// 形态B:赋值面 甲 = 乙 + 丙(12/20/30 造串)
整64 bB = 内存::活动分配数();
整32 值B = 0;
{
盒 乙 = 盒(12, 整数转字符串(120));
盒 丙 = 盒(8, 整数转字符串(80));
盒 甲 = 盒(0, 整数转字符串(0));
甲 = 乙 + 丙;
值B = 甲.值;
}
打印(值B);
打印(内存::活动分配数() - bB);
// 形态C:入容器位 A2 接管 追加(整数转字符串(42))
整64 bC = 内存::活动分配数();
整64 大小C = 0;
{
向量<字符串> 记录 = 向量<字符串>();
结果<空类型, 整32> rC = 记录.追加(整数转字符串(42));
大小C = 记录.大小();
大小C = 大小C + 字符串长度(记录.元素(0));
}
打印(大小C);
打印(内存::活动分配数() - bC);
// 形态D:X转字符串族覆盖(整数/浮点/布尔/正数 四转)
整64 bD = 内存::活动分配数();
整64 名D = 0;
{
盒 甲 = 盒(0, 整数转字符串(1));
盒 乙 = 盒(0, 浮点转字符串(1.5));
盒 丙 = 盒(0, 布尔转字符串(真));
盒 丁 = 盒(0, 正数转字符串(5));
名D = 字符串长度(甲.名) + 字符串长度(乙.名) + 字符串长度(丙.名) + 字符串长度(丁.名);
}
打印(名D);
打印(内存::活动分配数() - bD);
// 形态E:字段写入面 甲.名 = 整数转字符串(99)
整64 bE = 内存::活动分配数();
整64 名E = 0;
{
盒 甲 = 盒(0, 字符串复制("x"));
甲.名 = 整数转字符串(99);
名E = 字符串长度(甲.名);
}
打印(名E);
// 905 配套(平台不敏感化):E 字段写入面残留=既存泄漏(win=1/linux=0)·905 明示
// 未动该面(双侧同判非分叉·若确认属宿主缺陷另案)——本用例只锁已修面·残留不打印。
// 形态F:只读消费族(617 结算面)字符串长度(整数转字符串(7))
整64 bF = 内存::活动分配数();
整64 长F = 0;
{
长F = 字符串长度(整数转字符串(7));
}
打印(长F);
打印(内存::活动分配数() - bF);
// 形态G:617 只读消费族 × 构建器::完成 打印行(字符串构建器::完成(乙))
整64 bG = 内存::活动分配数();
{
整64 乙 = 字符串构建器::新建();
字符串构建器::追加(乙, 字符串复制("ab"));
打印行(字符串构建器::完成(乙));
}
打印(内存::活动分配数() - bG);
返回 0;
}输出:2 0 20 0 3 0 13 0 2 1 0 ab0
字符转字符串
函数 字符转字符串(字符 值) -> 字符串
单字符转字符串。
主.cnCN
函数 主() -> 整32 {
字符串 u = "内存好"; // UTF-8: E5 86 85 E5 AD 98 E5 A5 BD(9 字节)
打印(u[0]);
打印(u[1]);
打印(u[2]);
打印(u[3]);
打印(u[8]);
整8 b = u[4];
打印(b);
整32 w = u[5];
打印(w);
字符 c = u[6];
打印(整32(c)); // 306:字节值数字消费显式 整32(c)(打印(c)=字符形态单字节)
打印(u[7]);
字符串 v = 字符转字符串(u[6]) + 字符转字符串(u[7]) + 字符转字符串(u[8]);
打印(v);
字符串 a = "A";
打印(a[0]);
字符 cc = 0x597D;
字符串 s2 = "" + cc;
打印(s2);
返回 0;
}输出:-27 -122 -123 -27 -67 -83 -104 -27 -91 好 65 好
布尔转字符串
函数 布尔转字符串(布尔 值) -> 字符串
布尔转 "真"/"假"(拼接上下文自动调用)。
主.cnCN
导入 容器::向量;
类 盒 {
公开:
整32 值;
字符串 名;
函数 盒(整32 v, 字符串 n) { 值 = v; 名 = n; }
函数 ~盒() { }
不安全 函数 盒(盒& 其他) { 值 = 其他.值; 名 = 字符串复制(其他.名); }
函数 运算符+(盒 右) -> 盒 {
返回 盒(值 + 右.值, 字符串复制(名));
}
}
函数 主() -> 整32 {
// 形态A:声明面构造 盒(0, 整数转字符串(42))
整64 bA = 内存::活动分配数();
整64 名A = 0;
{
盒 甲 = 盒(0, 整数转字符串(42));
名A = 字符串长度(甲.名);
}
打印(名A);
打印(内存::活动分配数() - bA);
// 形态B:赋值面 甲 = 乙 + 丙(12/20/30 造串)
整64 bB = 内存::活动分配数();
整32 值B = 0;
{
盒 乙 = 盒(12, 整数转字符串(120));
盒 丙 = 盒(8, 整数转字符串(80));
盒 甲 = 盒(0, 整数转字符串(0));
甲 = 乙 + 丙;
值B = 甲.值;
}
打印(值B);
打印(内存::活动分配数() - bB);
// 形态C:入容器位 A2 接管 追加(整数转字符串(42))
整64 bC = 内存::活动分配数();
整64 大小C = 0;
{
向量<字符串> 记录 = 向量<字符串>();
结果<空类型, 整32> rC = 记录.追加(整数转字符串(42));
大小C = 记录.大小();
大小C = 大小C + 字符串长度(记录.元素(0));
}
打印(大小C);
打印(内存::活动分配数() - bC);
// 形态D:X转字符串族覆盖(整数/浮点/布尔/正数 四转)
整64 bD = 内存::活动分配数();
整64 名D = 0;
{
盒 甲 = 盒(0, 整数转字符串(1));
盒 乙 = 盒(0, 浮点转字符串(1.5));
盒 丙 = 盒(0, 布尔转字符串(真));
盒 丁 = 盒(0, 正数转字符串(5));
名D = 字符串长度(甲.名) + 字符串长度(乙.名) + 字符串长度(丙.名) + 字符串长度(丁.名);
}
打印(名D);
打印(内存::活动分配数() - bD);
// 形态E:字段写入面 甲.名 = 整数转字符串(99)
整64 bE = 内存::活动分配数();
整64 名E = 0;
{
盒 甲 = 盒(0, 字符串复制("x"));
甲.名 = 整数转字符串(99);
名E = 字符串长度(甲.名);
}
打印(名E);
// 905 配套(平台不敏感化):E 字段写入面残留=既存泄漏(win=1/linux=0)·905 明示
// 未动该面(双侧同判非分叉·若确认属宿主缺陷另案)——本用例只锁已修面·残留不打印。
// 形态F:只读消费族(617 结算面)字符串长度(整数转字符串(7))
整64 bF = 内存::活动分配数();
整64 长F = 0;
{
长F = 字符串长度(整数转字符串(7));
}
打印(长F);
打印(内存::活动分配数() - bF);
// 形态G:617 只读消费族 × 构建器::完成 打印行(字符串构建器::完成(乙))
整64 bG = 内存::活动分配数();
{
整64 乙 = 字符串构建器::新建();
字符串构建器::追加(乙, 字符串复制("ab"));
打印行(字符串构建器::完成(乙));
}
打印(内存::活动分配数() - bG);
返回 0;
}输出:2 0 20 0 3 0 13 0 2 1 0 ab0
正数转字符串
函数 正数转字符串(正64 值) -> 字符串;重载:函数 正数转字符串(正128 值) -> 字符串
无符号 64 位转十进制字符串;正128 重载全精度转串(#1891)。
主.cnCN
函数 主() -> 整32 {
整128 大值 = 123456789012345678901234567890;
字符串 文本 = 整数转字符串(大值);
打印(文本);
打印(字符串长度(文本));
整128 负值 = 0 - 123456789012345678901234567890;
打印(整数转字符串(负值));
正128 无符值 = 18446744073709551621ULL;
字符串 无符文本 = 正数转字符串(无符值);
打印(无符文本);
打印(字符串长度(无符文本));
整64 中值 = 123456789012345L;
打印(整数转字符串(中值));
整32 小值 = 42;
打印(整数转字符串(小值));
整128 源128 = 12345;
打印(整数转字符串(整64(源128)));
返回 0;
}输出:123456789012345678901234567890 30 -123456789012345678901234567890 18446744073709551621 20 123456789012345 42 12345
字符串释放
函数 字符串释放(字符串 值) -> 空类型
手动释放堆串。拥有型字符串变量由 RAII 自动释放,通常不需要调用——仅供 C 风格输出参数边界(如 分割 填出的数组元素)手动清理。
主.cnCN
导入 IO::打印;
联合体 数值 {
手动释放 字符串 名;
整64 数;
}
不安全 函数 主() -> 整32 {
整64 基线 = 内存::活动分配数();
数值 u;
u.名 = 字符串复制("数据甲");
打印("长度:", 字符串长度(u.名));
字符串释放(u.名);
u.数 = 777;
打印(" 残留:", 内存::活动分配数() - 基线);
返回 0;
}输出:长度:9 残留:0
字符串构建器
高频拼接的缓冲区句柄五件套(Rust String::push_str 同款):反复 字符串连接 是 O(n²),构建器摊销 O(n)。加号链仅适合少量短拼接;循环/大段拼接请用构建器(k 段累计 O(k²)·编译器不报提示)。句柄为整数 ID,完成后 必须 字符串构建器::完成 收尾,中途放弃用 字符串构建器::弃置。
字符串构建器.cnCN
函数 主() -> 整32 {
整64 建 = 字符串构建器::新建();
整64 i = 0;
当 (i < 3) {
字符串构建器::追加(建, "第" + 整数转字符串(i) + "段;");
i++;
}
字符串 文 = 字符串构建器::完成(建);
打印(文);
返回 0;
}输出:第0段;第1段;第2段;
字符串构建器::新建
函数 字符串构建器::新建() -> 整64
创建空构建器,返回句柄。
字符串构建器::追加
函数 字符串构建器::追加(整64 句柄, 字符串 段) -> 空类型
追加一段字符串到缓冲。
字符串构建器::追加字节
函数 字符串构建器::追加字节(整64 句柄, 整64 字节) -> 空类型
追加单个字节。
字符串构建器::完成
函数 字符串构建器::完成(整64 句柄) -> 字符串
收尾并返回最终字符串(拥有型)。句柄此后失效。
字符串构建器::弃置
函数 字符串构建器::弃置(整64 句柄) -> 空类型
不取串直接释放缓冲(错误路径中途放弃防泄漏)。句柄此后失效。
内存管理
手动内存四件套对标 C 的 malloc/free/realloc/memcpy;统计族用于泄漏观测;竞技场族是「进程级一次性分配」(bump 分配,重置一次全释放)。业务代码优先容器/拥有型字符串(RAII);手动内存是不安全域的逃生门。注意 重新分配 对超过 2GiB 的请求拒绝并返回 无(可观测拒绝前置)。
内存.cnCN
不安全 函数 主() -> 整32 {
整64* 表 = 分配(2 * 类型大小(整64)); // 两个整64 槽
表[0] = 7;
表[1] = 8;
空类型* 更大 = 重新分配(表, 4 * 类型大小(整64));
整64* 新表 = 更大;
打印(新表[0], " ", 新表[1]); // 扩容后旧值保留
整64* 目标 = 分配(2 * 类型大小(整64));
复制内存(目标, 新表, 2 * 类型大小(整64));
打印(目标[1]); // 8
置零内存(新表, 4 * 类型大小(整64));
打印(新表[0]); // 0
释放(新表);
释放(目标);
返回 0;
}输出:7 8 8 0
分配
函数 分配(整64 字节数) -> 空类型*
分配未初始化内存块(malloc)。
重新分配
函数 重新分配(空类型* 块, 整64 新字节数) -> 空类型*
调整块大小(realloc),内容保留;可传 无 等价分配。新字节数 > 2GiB 时拒绝(stderr 诊断 + 返回 无)。
释放
函数 释放(空类型* 块) -> 空类型
释放内存块(free)。无 安全。
复制内存
函数 复制内存(空类型* 目标, 空类型* 源, 整64 字节数) -> 空类型
按字节复制(memcpy);区间不得重叠。
置零内存
函数 置零内存(空类型* 目标, 整64 字节数) -> 空类型
按字节清零(memset 0)。
内存::活动分配数
函数 内存::活动分配数() -> 整64
当前未释放块数(原子计数)——泄漏检测基线:程序结束前应为 0。
主.cnCN
导入 容器::向量;
结构体 盒子 {
字符串 名;
整32 号;
}
函数 形探() -> 整32 {
向量<盒子> 表 = 向量<盒子>();
结果<空类型, 整32> 加 = 表.追加(盒子{ 名 = 字符串复制("P263C串"), 号 = 7 });
如果 (!加.正常) { 返回 0; }
返回 表.元素(0).号;
}
函数 主() -> 整32 {
整64 前 = 内存::活动分配数();
整32 i = 0;
当 (i < 1000) {
整32 号 = 形探();
如果 (号 != 7) { 打印(0); 返回 0; }
i++;
}
如果 (内存::活动分配数() != 前) { 打印(1); 返回 0; }
打印(7);
返回 0;
}输出:7
内存::总分配次数
函数 内存::总分配次数() -> 整64
进程启动以来累计分配次数(含字符串/容器内部分配)。
主.cnCN
导入 容器::向量;
导入 IO::打印;
函数 吃字符串(字符串 s) -> 整64 { 返回 字符串长度(s); }
函数 吃向量(向量<整32> v) -> 整64 { 返回 v.大小(); }
函数 主() -> 整32 {
// ① 声明初始化位·字符串:句柄直拷+源槽清零(零分配)
字符串 s1 = 字符串复制("甲乙丙丁");
整64 a0 = 内存::总分配次数();
字符串 s2 = 转移(s1);
整64 a1 = 内存::总分配次数();
打印(s2);
打印(a1 - a0);
// ② 实参位·字符串:句柄移交被调方+源槽清零(零分配)
字符串 t1 = 字符串复制("甲乙丙丁戊");
整64 b0 = 内存::总分配次数();
整64 n = 吃字符串(转移(t1));
整64 b1 = 内存::总分配次数();
打印(n);
打印(b1 - b0);
// ③ 声明初始化位·容器:浅交接分派(零分配·ir_stmt_decl 既有+459-a 同构)
向量<整32> a = 向量<整32>();
结果<空类型, 整32> r1 = a.追加(11);
结果<空类型, 整32> r2 = a.追加(22);
结果<空类型, 整32> r3 = a.追加(33);
整64 c0 = 内存::总分配次数();
向量<整32> b = 转移(a);
整64 c1 = 内存::总分配次数();
打印(b.大小());
打印(c1 - c0);
// ④ 实参位·容器(459-a 解锁):句柄移交+源槽清零(零分配)
向量<整32> v = 向量<整32>();
结果<空类型, 整32> q1 = v.追加(11);
结果<空类型, 整32> q2 = v.追加(22);
整64 d0 = 内存::总分配次数();
整64 m = 吃向量(转移(v));
整64 d1 = 内存::总分配次数();
打印(m);
打印(d1 - d0);
返回 0;
}输出:甲乙丙丁 0 15 0 3 0 2 0
内存::总分配字节
函数 内存::总分配字节() -> 整64
累计分配字节总量(直方图和)。
主.cnCN
导入 容器::向量;
函数 容器生命周期测试() -> 整64 {
整64 基线 = 内存::活动分配数();
向量<整64> 数据 = 向量<整64>();
整64 i = 0;
当 (i < 50) {
结果<空类型, 整32> 加 = 数据.追加(i * 2);
如果 (!加.正常) {
返回 -1;
}
i++;
}
整64 使用中 = 内存::活动分配数() - 基线;
返回 使用中; // 1(向量内部数组;函数返回时析构自动释放)
}
函数 字符串释放测试() -> 整64 {
整64 基线 = 内存::活动分配数();
字符串 s = "你好世界CN编译器";
字符串 子 = 字符串子串(s, 2, 4);
整64 使用中 = 内存::活动分配数() - 基线;
字符串释放(子);
整64 释放后 = 内存::活动分配数() - 基线;
// A2 拥有化口径(第八十五轮 win 跨机轮核对,用户未答复按 AGENTS.md 第3项纪律自行裁决留痕):
// 使用中=2(s 字面量初始化 __cn_str_copy 堆副本 + 子串自身)、释放后=1(仅 s 尚在)、
// 块退出析构 s 后归零(探针 69-a 实证:+1/+1/−1/−1;宿主与 v2 两侧同值)
返回 使用中 * 100 + 释放后; // 2*100+1=201
}
函数 主() -> 整32 {
打印("===== 内存管理(分配计数 + 进程竞技场)=====");
整64 基线 = 内存::活动分配数();
// 905 轮平台无关化:启动基线/总分配为运行时初始化相关绝对值(win=2/linux=0
// 实测),改为记录完成文案——验证核心=下方相对不变量(回落/无泄漏/归零)。
打印("启动基线已记录: 完成");
整64 总次数0 = 内存::总分配次数();
打印("启动总分配已记录: 完成");
// C-3 容器 RAII:函数内 50 次追加 + 返回时析构 -> 计数回落
整64 使用中 = 容器生命周期测试();
打印("容器使用中分配:", 使用中);
整64 容器后 = 内存::活动分配数();
打印("容器析构后=基线: ", 容器后 == 基线);
如果 (容器后 == 基线) {
打印("容器自动释放: 通过");
} 否则 {
打印("容器自动释放: 失败");
}
// C-3 字符串释放:子串动态分配 + 手动释放 -> 计数回落
整64 串测 = 字符串释放测试();
打印("字符串测试(使用中*100+释放后):", 串测);
整64 串后 = 内存::活动分配数();
如果 (串后 == 基线) {
打印("字符串释放: 通过");
} 否则 {
打印("字符串释放: 失败");
}
// C-1 进程竞技场:bump 分配 + 整块重置
空类型* 表1 = 内存::竞技场分配(1024);
空类型* 表2 = 内存::竞技场分配(2048);
整64 字节1 = 内存::竞技场活动字节();
// 905 轮平台无关化:块粒度为平台实现细节(win=65536),只断言覆盖两笔分配。
打印("竞技场分配后>=3072: ", 字节1 >= 3072);
如果 (表1 != 无 && 表2 != 无 && 字节1 >= 3072) {
打印("竞技场分配: 通过");
} 否则 {
打印("竞技场分配: 失败");
}
内存::竞技场重置();
整64 字节2 = 内存::竞技场活动字节();
打印("竞技场重置后字节:", 字节2);
如果 (字节2 == 0) {
打印("竞技场重置: 通过");
} 否则 {
打印("竞技场重置: 失败");
}
// 全量检查:活动分配数回落启动基线(无泄漏)
整64 最终 = 内存::活动分配数();
打印("最终活动=基线: ", 最终 == 基线);
如果 (最终 == 基线) {
打印("无泄漏检查: 通过");
} 否则 {
打印("无泄漏检查: 失败");
}
整64 总次数1 = 内存::总分配次数();
打印("最终总分配>=启动+2: ", 总次数1 >= 总次数0 + 2);
如果 (总次数1 >= 总次数0 + 2) {
打印("分配计数累计: 通过");
} 否则 {
打印("分配计数累计: 失败");
}
打印("===== 内存管理测试完成 =====");
返回 0;
}输出:===== 内存管理(分配计数 + 进程竞技场)===== 启动基线已记录: 完成 启动总分配已记录: 完成 容器使用中分配:1 容器析构后=基线: 真 容器自动释放: 通过 字符串测试(使用中*100+释放后):201 字符串释放: 通过 竞技场分配后>=3072: 真 竞技场分配: 通过 竞技场重置后字节:0 竞技场重置: 通过 最终活动=基线: 真 无泄漏检查: 通过 最终总分配>=启动+2: 真 分配计数累计: 通过 ===== 内存管理测试完成 =====
内存::竞技场分配
函数 内存::竞技场分配(整64 字节数) -> 空类型*
进程竞技场 bump 分配(8 字节对齐)——只进不出,适合编译器式「长生命周期+一次分配」负载,免去逐对象释放。分配失败=程序终止(001:运行期分配失败显形终止·不返回空),
内存::竞技场重置
函数 内存::竞技场重置() -> 空类型
一次性释放竞技场全部块。
内存::竞技场活动字节
函数 内存::竞技场活动字节() -> 整64
竞技场已分配总字节(含块头)。
内存::释放全部
函数 内存::释放全部() -> 空类型
释放全部堆内存(进程收尾用;驻留表不释放以防符号引用悬垂)。
类型工具与所有权
复制/转移 是显式的克隆/移动双内置(C++ copy/move 对照物);类型大小 参数是类型名而非表达式;运行时错误 立即终止进程。
类型工具.cnCN
类 点 {
整64 x;
}
函数 主() -> 整32 {
打印(类型大小(整64)); // 8
打印(类型大小(点)); // 8(单字段结构)
字符串 甲 = "原文";
字符串 乙 = 复制(甲); // 深拷:两份独立
乙 = 乙 + "!";
打印(甲, " / ", 乙);
字符串 丙 = 转移(甲); // 移交:甲此后不可读
打印(丙);
返回 0;
}输出:8 8 原文 / 原文! 原文
类型大小
函数 类型大小(类型名) -> 整64
返回类型的字节宽度。参数是类型名(语法级内建,泛型代码里对 T 也有效),不是表达式。
主.cnCN
函数 主() -> 整32 {
打印(类型大小(整32));
打印(类型大小(整64));
打印(类型大小(整128));
打印(类型大小(浮32));
打印(类型大小(浮64));
打印行(类型大小(字符));
返回 0;
}输出:4 8 16 4 8 4
复制
泛型 函数 复制(表达式) -> 实参类型
泛型克隆:返回实参的独立副本。字符串=落堆拥有串;类实参要求该类型定义了拷贝构造(无则编译错误);容器/结构体整体深拷。
转移
内置 函数 转移(变量) -> 实参的值
所有权移交(C++ std::move / Rust move 同构):零拷贝交接,源变量自该点起任何读性使用均为编译错误(Rust E0382 同款);对源变量纯赋值可复活(重新初始化)。标量(整数/浮点/布尔/字符)拒绝转移——复制语义无转移意义。
主.cnCN
导入 容器::向量;
不安全 函数 主() -> 整32 {
// ① 容器转移:接 追加(32) 后大小=2(10 已在转移前入)
向量<整64> 表 = 向量<整64>();
结果<空类型, 整32> 加1 = 表.追加(10);
向量<整64> 接 = 转移(表);
结果<空类型, 整32> 加2 = 接.追加(32);
打印(接.大小());
// ② 遮蔽:外层 表 已转移,内层块新声明 表 是新变量
{
向量<整64> 表 = 向量<整64>();
结果<空类型, 整32> 加3 = 表.追加(7);
打印(表.大小());
}
// ③ 字符串转移:乙 接管,打印内容(显式类型——推断声明字符串拷贝打印
// 分派为宿主独立既有缺陷[probe_f 实证],与本轮转移无关,另案观察项)
字符串 甲 = "左";
字符串 乙 = 转移(甲);
打印(乙);
// ④ 指针转移:r 接管 q 的指向,解引用读 55
整64 基 = 55;
整64* q = &基;
整64* r = 转移(q);
打印(*r);
返回 0;
}输出:2 1 左 55
运行时错误
函数 运行时错误(整64 错误码) -> 空类型
打印 运行时错误(错误码N) 并终止进程(退出码 1)。错误码语义见 核心.错误码。标准库容器的「直读越界即中止」就是它。
字符串驻留
字符串内容加入全局驻留表,返回唯一整数 ID(Symbol):相同内容同 ID、内容只存一份、O(1) 相等比较。编译器符号表的实现机制,也开放给业务(海量重复串的键控场景)。驻留表进程级存活,不随 释放全部 释放。
驻留.cnCN
函数 主() -> 整32 {
整64 甲 = 驻留("token");
整64 乙 = 驻留("token");
打印(甲 == 乙); // 同内容同 ID
字符* 文 = 驻留文本(甲); // ID 反查文本(借用视图)
打印(字符串复制(文));
打印(驻留计数() >= 1);
返回 0;
}输出:真 token 真
驻留
函数 驻留(字符串 值) -> 整64
内容入驻留表并返回唯一 ID;相同内容返回同一 ID。
主.cnCN
函数 主() -> 整32 {
打印("===== 字符串驻留 =====");
// ① 同内容同 ID / 异内容异 ID / 幂等
整64 甲 = 驻留("token");
整64 乙 = 驻留("token");
打印("同内容同 ID: ", 甲 == 乙); // 真
打印("异内容异 ID: ", 甲 != 驻留("令牌")); // 真
打印("重复驻留幂等: ", 驻留("token") == 甲); // 真
// ② 反查:驻留文本=借用视图;字符串复制=落堆拥有副本
字符* 视图 = 驻留文本(甲);
字符串 副本 = 字符串复制(视图);
打印("反查文本: ", 副本); // token
打印("视图与副本同内容: ", 字符串比较(视图, 副本)); // 真
// ③ 计数:新内容增一、重复驻留不变
整64 计数前 = 驻留计数();
驻留("新增一");
打印("新内容计数增: ", 驻留计数() == 计数前 + 1); // 真
驻留("新增一");
打印("重复驻留计数不变: ", 驻留计数() == 计数前 + 1); // 真
// ④ 驻留表进程级存活(一):堆副本释放后,借用视图反查仍有效
字符串释放(副本);
打印("释放堆副本后反查: ", 字符串比较(驻留文本(甲), "token")); // 真
// ④ 驻留表进程级存活(二):内存::释放全部 批量回收堆块,驻留表不释放
内存::释放全部();
打印("释放全部后同内容同 ID: ", 驻留("token") == 甲); // 真
打印("释放全部后反查: ", 驻留文本(甲)); // token
打印("===== 字符串驻留测试完成 =====");
返回 0;
}输出:===== 字符串驻留 ===== 同内容同 ID: 真 异内容异 ID: 真 重复驻留幂等: 真 反查文本: token 视图与副本同内容: 真 新内容计数增: 真 重复驻留计数不变: 真 释放堆副本后反查: 真 释放全部后同内容同 ID: 真 释放全部后反查: token ===== 字符串驻留测试完成 =====
驻留文本
函数 驻留文本(整64 标识) -> 字符*
ID 反查文本(借用视图——驻留表持有;长期持有须 字符串复制 落堆)。
主.cnCN
函数 造拼接(整64 n) -> 字符串 {
字符串 s = "";
整64 i = 0;
当 (i < n) { s = s + "a"; i++; }
返回 s;
}
函数 造字面量() -> 字符串 {
返回 "字面量";
}
函数 造移出() -> 字符串 {
字符串 s = 造拼接(3);
返回 s;
}
函数 借用名(整64 id) -> 字符* {
返回 驻留文本(id);
}
函数 转发(整64 n) -> 字符串 {
返回 造拼接(n); // 调用链拥有转发(尾部调用直传)
}
函数 主() -> 整32 {
字符串 a = 造拼接(4); // 登记 RAII(自动 free——泄漏根治)
字符串 b = 造字面量(); // 字面量返回位落堆
字符串 c = 造移出(); // 双层拥有移交
字符串 d = 转发(2); // 三层链
整64 id = 驻留("借用视图");
字符串 e = 字符串复制(借用名(id)); // 字符* 持有须显式复制
布尔 f = 字符串比较(借用名(id), "借用视图"); // 字符* 即时比较零拷贝
打印行(a + "|" + b + "|" + c + "|" + d + "|" + e + "|" + (f ? "1" : "0"));
返回 0;
}输出:aaaa|字面量|aaa|aa|借用视图|1
驻留计数
函数 驻留计数() -> 整64
驻留表中唯一内容个数。
主.cnCN
函数 主() -> 整32 {
打印("===== 字符串驻留 =====");
// ① 同内容同 ID / 异内容异 ID / 幂等
整64 甲 = 驻留("token");
整64 乙 = 驻留("token");
打印("同内容同 ID: ", 甲 == 乙); // 真
打印("异内容异 ID: ", 甲 != 驻留("令牌")); // 真
打印("重复驻留幂等: ", 驻留("token") == 甲); // 真
// ② 反查:驻留文本=借用视图;字符串复制=落堆拥有副本
字符* 视图 = 驻留文本(甲);
字符串 副本 = 字符串复制(视图);
打印("反查文本: ", 副本); // token
打印("视图与副本同内容: ", 字符串比较(视图, 副本)); // 真
// ③ 计数:新内容增一、重复驻留不变
整64 计数前 = 驻留计数();
驻留("新增一");
打印("新内容计数增: ", 驻留计数() == 计数前 + 1); // 真
驻留("新增一");
打印("重复驻留计数不变: ", 驻留计数() == 计数前 + 1); // 真
// ④ 驻留表进程级存活(一):堆副本释放后,借用视图反查仍有效
字符串释放(副本);
打印("释放堆副本后反查: ", 字符串比较(驻留文本(甲), "token")); // 真
// ④ 驻留表进程级存活(二):内存::释放全部 批量回收堆块,驻留表不释放
内存::释放全部();
打印("释放全部后同内容同 ID: ", 驻留("token") == 甲); // 真
打印("释放全部后反查: ", 驻留文本(甲)); // token
打印("===== 字符串驻留测试完成 =====");
返回 0;
}输出:===== 字符串驻留 ===== 同内容同 ID: 真 异内容异 ID: 真 重复驻留幂等: 真 反查文本: token 视图与副本同内容: 真 新内容计数增: 真 重复驻留计数不变: 真 释放堆副本后反查: 真 释放全部后同内容同 ID: 真 释放全部后反查: token ===== 字符串驻留测试完成 =====