教程·进阶篇
内存模型、指针与不安全域、手动内存、FFI、优化与调试——写给要压榨机器的开发者。
内存模型:三种生存期
CN 只有三种内存生存期,每种都有明确的所有者——理解了这张表,内存安全就不用背规则。
| 生存期 | 谁分配/谁释放 | 例子 |
|---|---|---|
| 栈(自动) | 编译器:进入作用域分配、退出释放(含类字段/容器元素级联) | 局部标量/结构体/类实例/容器 |
| 堆(拥有) | 拥有者变量:字符串/容器在声明处分配、作用域结束自动释放(RAII) | 字符串 变量、向量<T> 底层数组 |
| 堆(手动) | 你:分配 拿、释放 还——须在 不安全 域内 | 分配(n) 返回的 空类型* |
主.cnCN
类 计数站 {
公开:
静态 整64 非泛型析构 = 0;
静态 整64 泛型析构 = 0;
}
// 泛型类裸声明(H7 原始复现:盒子<整64> a; a.值=7)
泛型 <类型 T>
类 盒子 {
公开:
T 值;
函数 盒子() {
}
函数 获取() -> T {
返回 值;
}
}
// 非泛型类裸声明(同样受影响)
类 简单盒 {
公开:
整64 值;
函数 简单盒() {
}
函数 获取() -> 整64 {
返回 值;
}
}
// 默认构造做初始化:验证裸声明确实调用构造
类 计数盒 {
公开:
整64 值;
函数 计数盒() {
值 = 42;
}
函数 获取() -> 整64 {
返回 值;
}
}
// 无构造函数:默认构造仅分配(malloc 不置零,须手动设字段)
类 裸盒 {
公开:
整64 值;
函数 获取() -> 整64 {
返回 值;
}
}
// 泛型类带析构:裸声明应登记 RAII,函数返回前 DeleteObject
泛型 <类型 T>
类 资源盒 {
公开:
T 值;
函数 资源盒() {
值 = 0;
}
函数 ~资源盒() {
计数站.泛型析构 = 计数站.泛型析构 + 1;
}
}
// 非泛型类带析构:同样 RAII
类 资源简盒 {
公开:
整64 值;
函数 资源简盒() {
值 = 0;
}
函数 ~资源简盒() {
计数站.非泛型析构 = 计数站.非泛型析构 + 1;
}
}
函数 测试析构() {
资源盒<整64> r;
r.值 = 9;
资源简盒 s;
s.值 = 8;
}
函数 主() -> 整32 {
盒子<整64> a;
a.值 = 7;
打印("泛型裸声明: ", a.获取());
简单盒 b;
b.值 = 8;
打印("非泛型裸声明: ", b.获取());
计数盒 c;
打印("默认构造调用: ", c.获取());
裸盒 d;
d.值 = 5;
打印("无构造仅分配: ", d.获取());
测试析构();
打印("非泛型析构: ", 计数站.非泛型析构);
打印("泛型析构: ", 计数站.泛型析构);
返回 0;
}输出:泛型裸声明: 7 非泛型裸声明: 8 默认构造调用: 42 无构造仅分配: 5 非泛型析构: 1 泛型析构: 1
安全区边界:不安全 域
CN 的安全默认不靠运行时罚站——危险操作在编译期就要求位于 不安全 函数 内(安全函数内=编译错误「[安全区边界] …」),把审计责任显式化。
| # | 仅限 不安全 函数 体内的操作(001 §747 全清单) |
|---|---|
| 1 | 指针算术——裸指针 加减 整数(含数组退化) |
| 2 | 指针下标写——p[i] = x |
| 3 | 裸指针解引用读——*p |
| 4 | 裸指针解引用写——*p = x |
| 5 | 指针下标读——p[i] |
| 6 | 指针成员访问——p.字段(隐含解引用) |
| 7 | 联合体字段访问——含结构体内联合体嵌套 |
| 8 | 可变静态/全局变量写——赋值/复合赋值/自增自减(含全局容器写方法调用:追加/设置/清空/插入/弹出…;读方法 大小/元素/读取/获取/包含 安全区放行) |
| 9 | 外部函数调用——FFI/C 边界 |
| 10 | 裸释放——释放(裸指针) |
边界外.cn(负例·编译拒绝)CN
函数 主() -> 整32 {
整32 值 = 41;
整32* p = &值; // 取地址:安全(出参惯用法通道)
打印(p[0]); // ✗ 编译错误:[安全区边界] 指针下标读应在 不安全 函数 内
返回 0;
}主.cnCN
静态 整64 计数 = 0;
不安全 函数 裸写(整64* p) -> 整64 {
整64* q = p + 1; // A1 指针算术(不安全函数内合法)
*q = 7; // B7 裸指针解引用写
q[0] = 9; // A2 指针下标写
返回 *q; // B6 裸指针解引用读
}
不安全 函数 主() -> 整32 {
整64[2] 基 = { 0, 0 };
整64 v = 裸写(基); // 互调(责任上移)
打印(v);
计数 = 计数 + 1; // B10 静态变量写(不安全函数内合法)
打印(计数);
返回 0;
}输出:[p6h] 已解析: target/audit2/v2src257/主.cn 节点=53
常量空指针.cn(负例·编译拒绝)CN
不安全 函数 主() -> 整32 {
整64* p = 无;
整64 v = *p; // ✗ 编译错误:编译期常量空指针解引用(B11)
返回 整32(v);
}- 豁免与例外:
字符串/字符*为字符串视图(非裸指针)——清单 1/3/5/6 对其不适用(拼接/视图读=安全操作);字符*(借用视图)下标访问=编译期拒绝(视图按 UTF-8 字节序列解释,与裸指针步进错位——先字符串复制(...)转拥有串再下标);字符串下标读安全(字节语义·越界=运行期错误码 2);取地址、指针比较、指针类型转换=安全(Rust 对照)。 - B11 常量空指针=独立硬错误(不属十项清单、不因不安全区豁免):
无字面量解引用/成员访问/下标(*无/无.x/无[0]),及「变量经无初始化且全函数无其他写入」的常量传播形态——编译期硬错误「编译期常量空指针解引用」(§1.1a①编译期能证必须编译期拦;运行期数据面判零由错误码 3 兜底)。 - 调用 不安全 函数=允许(责任上移;审计面=不安全函数清单);
不安全是保留字(46 个保留字之一)。 - 溢出检查在此豁免:
不安全 函数内不插溢出检查(按两补码回绕继续执行)——「真零运行期检查」;对照:安全区变量面溢出=错误码 8 确定性失败(见 类型参考·整数)。 - 标准库容器内部全是不安全域,但使用容器不需要不安全——危险面被库收口,这正是安全区的意义。
手动内存:分配/释放/重新分配
逃生舱四件套对标 C(malloc/free/realloc/memcpy);另有统计族(泄漏检测)与竞技场族(进程级一次性分配)。
主.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: 真 分配计数累计: 通过 ===== 内存管理测试完成 =====
- 企业级建议:动态容器直接用标准库 向量——扩容翻倍+RAII+元素析构全替你管好;手动内存留给 FFI 边界与极致优化点。
重新分配对 >2GiB 请求拒绝(stderr 诊断+返回 无)——垃圾尺寸静默失败会在解引用时崩,可观测拒绝前置。- 竞技场族(
内存::竞技场分配)适合编译器式「长生命周期+一次分配」负载:只进不出,内存::竞技场重置一次全清。
FFI:与 C 互操作
CN 与 C 的 ABI 天然互通:外部函数声明+--链接 库名;字符串边界遵守「借用/拥有」契约(字符* 借用视图 vs 字符串 拥有串)。
主.cnCN
外部 函数 strlen(字符串 s) -> 整64
外部 函数 toupper(整32 c) -> 整32
外部 函数 rand() -> 整32
外部 函数 llabs(整64 x) -> 整64
不安全 函数 主() -> 整32 {
打印("===== FFI 外部 函数(C-3)=====");
// 1. strlen:字节长度(UTF-8 "中文" 2 字 = 6 字节;NUL 结尾兼容)
打印("长度: ", strlen("中文"));
// 2. toupper:97('a') -> 65('A')
打印("大写: ", toupper(97));
// 3. rand:无参外部函数(C 标准库三平台通用;返回值恒非负)
打印("随机非负: ", rand() >= 0);
// 4. llabs:整64 参数+整64 返回(64 位位宽通道·确定性小值)
// 注:大值(>2^32)整64 往返边界面由 725_外部函数整64传参 锁定(任务 110 根治——
// 返回值接收通道 32 位读塌缩·实参装载本无病);本行保留小值回归对照。
打印("六十四位绝对值: ", llabs(0 - 100));
// 5. 返回值参与表达式运算(toupper(97) + 1 = 66)
打印("大写加一: ", toupper(97) + 1);
打印("===== FFI 测试完成 =====");
返回 0;
}输出:===== FFI 外部 函数(C-3)===== 长度: 6 大写: 65 随机非负: 真 六十四位绝对值: 100 大写加一: 66 ===== FFI 测试完成 =====
- 链接:
cn build 程序.cn --链接 库名(可多次);库搜索遵循平台惯例。 - 字符串契约:
字符*=借用(C 层持有的视图,不释放);字符串=拥有(RAII)。借用转拥有用字符串复制,反之直接传。 - 返回类型白名单:仅标量(整数族/浮点,含 字符/布尔)/ 指针 / 字符串(句柄);聚合(类/结构体/结果)与引用(
T&)返回=编译期拒绝「外部 函数 返回类型 '<T>' 不支持」(待 sret 跨语言约定立法后放行);无返回值(缺->或 空类型)不属限制面。 - 声明形态规则:外部 函数 不得带函数体(符号由外部库提供);同名同签名重复声明=允许(C 语义,同一 C 符号多次声明;链接符号=函数名本身,无 mangling)。
- 整64 标量 FFI 形参的 arm64 传参 ABI 有在案限制(大值塌缩),跨平台 FFI 密集场景关注 仓库 021 总账 #110。
聚合返回拒绝.cn(负例·编译拒绝)CN
结构体 点 { 整32 x; 整32 y; }
外部 函数 取点(整32 x) -> 点 // ✗ 聚合返回越白名单
函数 主() -> 整32 {
返回 0;
}字符串与容器的性能面
拥有型字符串的每一次 + 都是分配+拷贝。高频拼接用字符串构建器(摊销 O(n)),高频读取用引用访问。加号链适合少量短拼接;循环/大段拼接(k 段累计 O(k²))请用构建器(编译器不报提示·这条边界须自觉)。
主.cnCN
导入 字符串扩展::{字符串构建器新建, 字符串构建器追加, 字符串构建器追加整数, 字符串构建器完成, 字符串构建器弃置};
// 出串段:完成出串 RAII 泄漏断言——返回「完成时刻-入口」活动分配数差
// (应=1:完成出串经 cn_alloc_tracked 计 1;出串随本函数退出 RAII 自动释放)。
// 〔面注〕段内禁打印——打印 的字符串变参临时串存在不释放的既有缺口
// (非本用例面·另案立项),断言窗口内不得混入无关分配。
函数 出串段() -> 整64 {
整64 前分配 = 内存::活动分配数();
整64 句 = 字符串构建器::新建();
循环 (整64 k = 0; k < 100; k++) {
字符串构建器::追加(句, "片段");
}
字符串 出串 = 字符串构建器::完成(句);
整64 中分配 = 内存::活动分配数();
返回 中分配 - 前分配;
}
函数 主() -> 整32 {
// ① 内建层:追加多段(含中文 UTF-8)+追加字节(33='!')
整64 句甲 = 字符串构建器::新建();
字符串构建器::追加(句甲, "你好,");
字符串构建器::追加(句甲, "构建器");
字符串构建器::追加字节(句甲, 33);
字符串 内建串 = 字符串构建器::完成(句甲);
打印(内建串);
// ② stdlib 门面 + 追加整数便利
整64 句乙 = 字符串构建器新建();
字符串构建器追加(句乙, "编号=");
字符串构建器追加整数(句乙, 366);
字符串 门面串 = 字符串构建器完成(句乙);
打印(门面串);
// ③ 连接对照:64 段同源——朴素逐段连接 vs 构建器一次成型
字符串 片段 = "片段";
字符串 朴素 = "";
整64 句丙 = 字符串构建器::新建();
循环 (整64 k = 0; k < 64; k++) {
朴素 = 字符串连接(朴素, 片段);
字符串构建器::追加(句丙, 片段);
}
字符串 构建串 = 字符串构建器::完成(句丙);
如果 (字符串比较(构建串, 朴素)) {
打印("对照: 相等 长度=", 整数转字符串(字符串长度(构建串)));
} 否则 {
打印("对照: 不等");
}
// ④ 边界:空串追加(缓冲仍空)→ 出串=空串(长 0)
整64 句丁 = 字符串构建器::新建();
字符串构建器::追加(句丁, "");
字符串构建器::追加(句丁, "");
字符串 空串 = 字符串构建器::完成(句丁);
打印("空缓冲长=", 整数转字符串(字符串长度(空串)));
// ⑤ 大串出串校验:100 段×6 字节("片段" UTF-8)=600
整64 句丙二 = 字符串构建器::新建();
循环 (整64 k = 0; k < 100; k++) {
字符串构建器::追加(句丙二, 片段);
}
字符串 大出串 = 字符串构建器::完成(句丙二);
打印("出串长=", 整数转字符串(字符串长度(大出串)));
// ⑥ 泄漏断言:出串计 1(tracked)+函数退出 RAII 回落差=0(216 口径)
// 断言窗口(基线→回落差)内零打印零传参——打印变参临时/变量传参形参槽
// 均存在既有缺口(另案立项),不得混入本断言。
整64 基线 = 内存::活动分配数();
整64 出串差 = 出串段();
整64 回落差 = 内存::活动分配数() - 基线;
打印("出串差=", 整数转字符串(出串差));
打印("回落差=", 整数转字符串(回落差));
// ⑦ 弃置:错误路径中途放弃(不取串·句柄一次性)——只验全链不崩
整64 句戊 = 字符串构建器::新建();
循环 (整64 k = 0; k < 100; k++) {
字符串构建器::追加(句戊, 片段);
}
字符串构建器::弃置(句戊);
打印("弃置: 完成");
返回 0;
}输出:你好,构建器! 编号=366 对照: 相等 长度=384 空缓冲长=0 出串长=600 出串差=1 回落差=0 弃置: 完成
主.cnCN
类 甲 {
公开:
整32 x;
函数 甲(整32 v) { x = v; }
虚拟 函数 取() -> 整32 {
返回 x;
}
函数 翻倍() -> 整32 {
返回 x * 2;
}
}
类 乙 : 甲 {
公开:
函数 乙(整32 v) : 甲(v) { }
重写 函数 取() -> 整32 {
返回 x + 100;
}
}
函数 读(甲& 参) -> 整32 {
返回 参.x;
}
函数 主() -> 整32 {
甲 对 = 甲(7);
甲& 参 = 对;
打印(参.x); // 7 字段读
参.x = 42; // 字段写
打印(参.x); // 42 写后读
打印(对.x); // 42 别名可见
打印(参.翻倍()); // 84 非虚直调
甲& 参1 = 对;
甲& 参2 = 参1;
打印(参2.x); // 42 引用再绑
打印(读(参)); // 42 转发引用形参
乙 对象 = 乙(5);
甲& 虚参 = 对象;
打印(虚参.取()); // 105 虚分派
对 = 甲(60); // 别名重赋
打印(参.x); // 60 别名语义
打印(参1.x); // 60 同源别名
返回 0;
}输出:7 42 42 84 42 42 105 60 60
优化级别与调试
四级优化 -O0 ~ -O3;--debug 在汇编中嵌入源码位置注释;调试模式 编译期常量做发布/调试分支(死分支零开销消除)。
| 级别 | 内容 |
|---|---|
-O0 | 不做优化(默认)——编译最快,逐语句直译 |
-O1 | 常量折叠+死代码消除+代数简化+复写传播 |
-O2 | 增加 公共子表达式消除(CSE)+跨块死代码消除+寄存器分配启用 |
-O3 | 增加 全局值传播 |
主.cnCN
常量 布尔开关 = 真;
常量 调试模式 = 假;
函数 主() -> 整32 {
如果 (调试模式) {
打印行("用户值: 调试");
} 否则 {
打印行("用户值: 发布");
}
如果 (布尔开关) {
打印行("开关开");
}
返回 0;
}输出:用户值: 发布开关开
调试模式两个分支都做完整语义检查(区别于条件编译——不存在裁剪盲区);未选中分支零运行时开销。- 调试实战:
cn build 程序.cn --debug -O0产出的汇编带源码行注记,配合cn ir 程序.cn/cn ast 程序.cn可逐层下探(详见 命令行参考)。
自举与双编译对照(项目故事)
CN 的终极目标是用 CN 编译器自己编译 CN 编译器。项目保持「宿主 C++ 实现」与「v2 CN 自举实现」两套功能完全一致的编译器,全部测试双跑对照(dual)——这也是文档示例可信的根基。
- 自举固定点:v2 编译出的编译器再编译自己,产物逐字节一致(fix_p ≡ fix_s)——语言已完备到能承载自身工具链。
- 双编译对照:每个用例同时跑宿主与 v2 两侧,任何行为分叉=缺陷(零分叉红线)。你看到的文档输出都经此流程。
- 性能双目标:①编译速度对标 C++ 编译器;②内存安全对标 Rust(悬垂/越界/泄漏零容忍)——冲突时提交用户裁决。
- 想参与?源码仓库 的 021 总账列着全部在办任务。