CN·语言

教程·进阶篇

内存模型、指针与不安全域、手动内存、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

泄漏统计随手可查内存::活动分配数() 返回当前未释放块数——程序收尾处断言它为 0,泄漏当场现形(见 内置函数·内存)。

安全区边界:不安全 域

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 总账列着全部在办任务。

文档全景回到 文档总览;语法细节进 语言参考。