教程·语法基础
变量、类型、运算符、控制流、函数、lambda 闭包、数组、字符串、结构体、枚举——写过程式 CN 的全部基础。
程序骨架与语句
CN 源文件 UTF-8 编码、.cn 扩展名;顶层由函数/结构体/枚举/类/接口/导入/全局变量声明组成;入口=名为 主 的函数。
主.cnCN
函数 主() -> 整32 {
打印("你好,世界");
返回 0;
}输出:你好,世界
; 结束。换行在词法层只是空白——表达式可以任意换行续写,但行尾漏分号不会被「自动补分号」救回来,而是直接报语法错误。这避免了行尾/行首词法拼接类的事故。变量与常量
声明即初始化是 CN 的默认姿势——未初始化的局部值类型变量读取是编译错误(编译期数据流检查,零运行时成本)。
主.cnCN
静态 整32 全局计 = 7;
常量 上限 = 100;
函数 主() -> 整32 {
常量 PI = 3;
变量 推断值 = PI * 2;
整32 显式值 = 4;
正16 窄值 = 5;
整32[3] 数据 = { 1, 2, 3 };
循环 (整32 j = 0; j < 3; j++) {
推断值 = 推断值 + 数据[j];
}
打印("合计: ", 推断值 + 显式值 + 全局计);
打印("窄值: ", 窄值);
打印("上限: ", 上限);
返回 0;
}输出:合计: 23 窄值: 5 上限: 100
主.cnCN
常量 基础 = 10;
常量 增量 = 基础 + 5;
常量 双倍 = 基础 * 2;
常量 减半 = 双倍 / 4;
常量 取余 = 双倍 % 3;
常量 负 = -基础;
函数 主() -> 整32 {
打印("===== 顶层常量表达式(P3-22)=====");
打印("基础: ", 基础); // 10
打印("增量: ", 增量); // 15
打印("双倍: ", 双倍); // 20
打印("减半: ", 减半); // 5
打印("取余: ", 取余); // 2
打印("负: ", 负); // -10
打印("===== 完成 =====");
返回 0;
}输出:===== 顶层常量表达式(P3-22)===== 基础: 10 增量: 15 双倍: 20 减半: 5 取余: 2 负: -10 ===== 完成 =====
常量值在编译期折叠进引用处,可为算术表达式(常量 尺寸2 = 尺寸 * 2;)。静态变量生存期=整个进程;顶层静态无初值=零初始化放行,函数内静态必须显式初值(静态 整32 槽;无初值=编译拒绝),写入须在 不安全 域。- 未初始化读取(
整32 x; 打印(x);)是编译错误——不会读到垃圾值。
全局变量与静态变量
| 形态 | 默认可见性 | 初始化规则 | 写限制 |
|---|---|---|---|
裸全局(无 静态 前缀) | 默认外部可见(跨模块无须 公开:) | 仅限常量表达式(字面量/常量引用/常量算术)——函数调用/构造调用=编译错误「初始值必须是常量表达式」 | 仅限 不安全 函数 体内 |
静态(顶层) | 文件私有(公开: 可放行) | 常量=加载期直存;非常量=入口注入通道 | 同上 |
静态(函数内) | 函数内局部名 | 常量=加载期直存;非常量=声明点守卫快照(首调求值一次、再调不重初始化) | 同上(初始化求值不属写执法面) |
主.cnCN
导入 供给;
导入 容器::向量;
常量 系数 = 10;
整32 计数 = 5; // ① 字面量初始化
整32 算术 = 系数 * 2 + 1; // ② 常量算术(=21·函数内 ++ 后 22)
整32 零值; // ③ 零初始化(函数内写 7·⑩后 8)
整数 别名槽 = 4; // ⑥ 别名关键字形态(constinit 同 d 款执法)
整32* 槽指针; // ⑦ 指针形态零初始化(.bss=空)
整32[4] 表槽; // ⑧ 数组形态(元素写读)
向量<整32> 容器槽; // ⑨ 泛型容器形态(728c 补锁·声明即构造)
静态 结果<整32, 整32> 结果槽; // ⑩ 静态合成体形态(728c 补锁·零值=正常假)
不安全 函数 累积() {
计数 += 3; // ④ 复合赋值(5→8)
零值 = 7; // ④ 赋值(0→7)
算术++; // ④ 自增(21→22)
如果 (槽指针 == 无) { // ⑦ 零初始化空判(8→9)
计数 = 计数 + 1;
}
表槽[0] = 6; // ⑧ 数组元素写
表槽[1] = 7; // ⑧ 数组元素写
结果<空类型, 整32> 加容器 = 容器槽.追加(6); // ⑨ 容器追加(构造后写)
如果 (!加容器.正常) {
零值 = 98; // ⑨ 追加失败=异常值(可发现)
}
}
不安全 函数 校验静态结果槽() {
如果 (结果槽.正常) {
零值 = 99; // ⑩ 零值结果正常=真 → 注入失败(可发现异常值)
} 否则 {
零值 = 零值 + 1; // ⑩ 零值结果正常=假 → 7→8(+1 贡献)
}
}
函数 主() -> 整32 {
累积();
校验静态结果槽();
返回 计数 + 算术 + 零值 + 库计数 + 别名槽 + 表槽[0] + 表槽[1]
+ 整32(容器槽.大小()) + 容器槽.元素(0);
}输出:[p6h] 已解析: target/audit2/v2src797/供给.cn [p6h] 已解析: target/audit2/v2src797/主.cn
主.cnCN
不安全 函数 计次() -> 整32 {
静态 整32 次 = 0;
次 = 次 + 1;
返回 次;
}
函数 标量快照(整32 轮) -> 整32 {
整32 源 = 轮 * 10;
静态 整32 甲 = 源;
返回 甲;
}
函数 数组快照(整32 轮) -> 整32 {
整32[3] 源;
源[0] = 轮;
源[1] = 轮 + 1;
源[2] = 轮 + 2;
静态 整32[3] 乙 = 源;
返回 乙[0] * 100 + 乙[1] * 10 + 乙[2];
}
函数 主() -> 整32 {
打印行(计次());
打印行(计次());
打印行(计次());
打印行(标量快照(1));
打印行(标量快照(2));
打印行(标量快照(3));
打印行(数组快照(1));
打印行(数组快照(5));
打印行(数组快照(9));
返回 0;
}输出:123101010123123123
- 裸全局无初始化器=零初始化(
.bss);跨模块同名的裸全局定义=重定义编译错误;写入限制统一(赋值/复合赋值/自增自减仅限不安全 函数体内)——安全函数内写全局容器的方法调用(追加/设置/清空…)同样拒绝,读方法(大小/元素/读取/获取/包含)放行。 - 函数内静态守卫双槽(主槽+哨兵):首触哨兵为零→求值写主槽并置哨兵;再调直读主槽、跨调用保持。数组初值=整块拷贝(按数组类型精确字节数·非首元素/非截断);可折叠常量初值由
.data直存(守卫只承载非常量初值)。 - 守卫快照初始化不算「可变静态写」——安全函数内的函数内静态照常可带非常量初值;静态变量本身的显式改写仍须
不安全 函数。 - 跨线程初始化=单线程语义(哨兵为普通布尔槽·无锁非原子)——多线程并发首触的竞争语义为未来扩展项;需要跨线程初始化保障的场景用
互斥锁自行组织(见安全与并发)。
基本类型全景
整型 10 种(有符号/无符号 × 5 位宽)、浮点 2 种、布尔/字符/字符串,以及别名 整数=整32、小数=浮64。
| 类别 | 类型 | 大小 | 范围/说明 |
|---|---|---|---|
| 默认别名 | 整数 / 小数 | 4B / 8B | = 整32 / = 浮64(保留中文习惯的别名) |
| 有符号整数 | 整8 整16 整32 整64 整128 | 1~16B | 整8:-128~127 …… 整128:±2^127 |
| 无符号整数 | 正8 正16 正32 正64 正128 | 1~16B | 正8:0~255 …… 正128:0~2^128-1 |
| 浮点 | 浮32 浮64 | 4B / 8B | IEEE 754 单/双精度 |
| 其他 | 布尔 字符 字符串 空类型 | 1B / 4B / - / - | 真/假;Unicode 码点;UTF-8 拥有串;void |
主.cnCN
函数 主() -> 整32 {
打印("L: ", 100L);
打印("U: ", 7U);
打印("UL: ", 9UL);
打印("hex: ", 0xFF);
打印("bin: ", 0b1010);
打印("oct: ", 0o17);
返回 0;
}输出:L: 100 U: 7 UL: 9 hex: 255 bin: 10 oct: 15
整8 + 整8 = 整8),溢出=错误码 8 确定性失败(127+1 运行时终止;需回绕语义用显式 回绕加/回绕减/回绕乘);字面量向窄类型赋值做编译期值域检查(整16 甲 = 40000; 拒绝)。混合符号(整N × 正M)变量运算编译期拒绝、字面量豁免——详见类型参考。类型转换
宽化隐式进行;窄化/跨符号/浮整/指针↔整数一律显式 类型名(表达式),语义=位模式变换(Rust as 同款)。
主.cnCN
函数 主() -> 整32 {
正32 小 = 4000000000;
整64 负 = -1;
正64 大 = 9223372036854775808;
整32 累计 = 0;
如果 (整64(小) > 负) { 累计 = 累计 + 1; }
如果 (整64(小) < 负) { 累计 = 累计 + 2; }
如果 (大 > 100) { 累计 = 累计 + 4; }
如果 (负 < 100) { 累计 = 累计 + 8; }
如果 (小 < 大) { 累计 = 累计 + 16; }
打印(整64(小) + 负);
打印(累计);
返回 0;
}输出:3999999999 29
- 升宽:有符号源符号扩展、无符号源零扩展。
- 同宽跨符号:位模式重解释(
整64(正64(2^63))= -2^63)。 - 降宽:低位截断。
- 字符串拼接语境例外:
"编号-" + 7自动把数值转字符串(布尔转「真/假」),见字符串节。
运算符与优先级
全套 C 风格运算符,13 级优先级;这里只讲 CN 有立法规矩的部分,完整优先级表见词法参考。
主.cnCN
类 复数 {
公开:
整32 实部;
整32 虚部;
函数 复数(整32 r, 整32 i) {
实部 = r;
虚部 = i;
}
// 运算符+ :返回新复数(构造调用返回类对象)
函数 运算符+(复数 右) -> 复数 {
返回 复数(实部 + 右.实部, 虚部 + 右.虚部);
}
// 运算符== :比较实部虚部
函数 运算符==(复数 右) -> 布尔 {
返回 (实部 == 右.实部) && (虚部 == 右.虚部);
}
// 运算符!= :取反 ==
函数 运算符!=(复数 右) -> 布尔 {
返回 !((实部 == 右.实部) && (虚部 == 右.虚部));
}
// 普通方法:显示复数
函数 显示() -> 字符串 {
返回 整数转字符串(实部) + "+" + 整数转字符串(虚部) + "i";
}
}
函数 主() -> 整32 {
打印("===== 运算符重载(Task 3.7)=====");
// ---- 1. 复数加法(运算符+ 重载)----
复数 甲 = 复数(1, 2);
复数 乙 = 复数(3, 4);
复数 和 = 甲 + 乙; // 调用 复数.运算符+
打印("甲: ", 甲.显示()); // 1+2i
打印("乙: ", 乙.显示()); // 3+4i
打印("和: ", 和.显示()); // 4+6i
// 注意:链式运算(甲 + 乙 + 丙)的中间对象(运算符+ 返回的 NewObject 堆对象)
// 作为左操作数传给第二次 + 时字段读取错乱(输出垃圾值)——这是"运算符重载
// 返回类对象赋值语义"的已知遗留风险(plans 阶段3 文档记录),留待 Debug
// 全面审查子任务处理;本用例聚焦 Task 3.7 双目运算符重载验证。
复数 丙 = 复数(10, 20);
复数 两步 = 甲 + 乙; // 单次重载(中间对象直接赋值,无链式)
打印("甲+乙: ", 两步.显示()); // 4+6i
// 链式运算(缺陷2 修复验证):甲+乙+丙 = 14+26i
复数 链 = 甲 + 乙 + 丙;
打印("链式甲+乙+丙: ", 链.显示());
// ---- 3. 相等比较(运算符== 重载)----
复数 甲2 = 复数(1, 2);
布尔 相等1 = 甲 == 甲2; // 真(实部虚部相同)
布尔 相等2 = 甲 == 乙; // 假(3+4i)
打印("甲==甲2: " + 相等1); // 甲==甲2: 真
打印("甲==乙: " + 相等2); // 甲==乙: 假
// ---- 4. 不等比较(运算符!= 重载)----
布尔 不等1 = 甲 != 乙; // 真
布尔 不等2 = 甲 != 甲2; // 假
打印("甲!=乙: " + 不等1); // 甲!=乙: 真
打印("甲!=甲2: " + 不等2); // 甲!=甲2: 假
// ---- 5. 运算符重载结果参与普通方法调用 ----
复数 差 = 乙 + 丙; // 13+24i(单次重载)
打印("乙+丙显示: ", 差.显示()); // 13+24i
// ---- 6. 字符串 + 数值拼接不受用户重载影响(编译器隐式转换)----
打印("字符串拼接: " + 甲.实部 + "+" + 甲.虚部 + "i"); // 字符串拼接: 1+2i
// 说明:单目运算符重载(- ! ~)IR 层 operatorSymText 未映射(仅双目),
// 留待 Debug 全面审查子任务/运算符重载完善子任务处理。
打印("===== 运算符重载测试完成 =====");
返回 0;
}输出:===== 运算符重载(Task 3.7)===== 甲: 1+2i 乙: 3+4i 和: 4+6i 甲+乙: 4+6i 链式甲+乙+丙: 14+26i 甲==甲2: 真 甲==乙: 假 甲!=乙: 真 甲!=甲2: 假 乙+丙显示: 13+24i 字符串拼接: 1+2i ===== 运算符重载测试完成 =====
/对整数=截断除;%取余(除零=运行时错误码 1,常量除零=编译错误)。- 逻辑
&&||短路;位运算只适用整型(浮点位运算编译拒绝);>>有符号=算术右移(符号扩展),无符号=逻辑右移;移位量超宽=确定性失败(常量=编译期硬错误,变量=错误码 8;取模用x << (k % 位宽)显式写)。 - 后缀
++/--表达式值=自增前原值;前缀=自增后新值。 - 三元
条件 ? 真值 : 假值右结合、惰性求值。
控制流:如果/当/循环/选择/遍历
条件括号可选(裸条件与带括号均合法);中断 绑定最近的循环或选择;选择 默认贯穿(fall-through)、显式 中断 停住。
主.cnCN
函数 主() -> 整32 {
// ---- 1. 如果/否则 链 ----
整数 x = 5;
如果 (x > 10) {
打印("x>10");
} 否则 如果 (x > 3) {
打印("3<x<=10");
} 否则 {
打印("x<=3");
}
// ---- 2. 当循环 + 继续 ----
整数 i = 0;
当 (i < 6) {
i++;
如果 (i == 3) {
继续; // 跳过3
}
如果 (i > 5) {
中断; // 提前退出
}
打印(i);
}
// ---- 3. 循环(for风格)+ 中断 ----
循环 (整32 j = 0; j < 10; j++) {
如果 (j == 4) {
中断;
}
打印(j);
}
// ---- 4. 选择语句:每个分支显式中断 ----
整数 v = 2;
选择(v) {
情况 1:
打印("一");
中断;
情况 2:
打印("二");
中断;
情况 3:
打印("三");
中断;
默认:
打印("其他");
}
// ---- 5. 选择语句:默认缺省(无匹配不输出) ----
选择(v) {
情况 10:
打印("十");
中断;
情况 20:
打印("二十");
中断;
}
// ---- 6. 选择语句:字符匹配 ----
字符 c = 'B';
选择(c) {
情况 'A':
打印("A");
中断;
情况 'B':
打印("B");
中断;
默认:
打印("其他字符");
}
// ---- 7. 嵌套选择:switch 内嵌 if/当 ----
选择(v) {
情况 2:
整数 n = 0;
当 (n < 2) {
打印("嵌套");
n++;
}
中断;
默认:
打印("默认");
}
// ---- 8. 选择语句:fallthrough(无中断贯穿到下一情况) ----
整数 w = 1;
选择(w) {
情况 1:
打印("fall1");
// 无中断:贯穿到 情况 2
情况 2:
打印("fall2");
中断;
默认:
打印("fall默认");
}
返回 0;
}输出:3<x<=10 1 2 4 5 0 1 2 3 二 B 嵌套 嵌套 fall1 fall2
主.cnCN
枚举 颜色 {
红,
绿,
蓝,
自定义 = 100
}
函数 主() -> 整32 {
打印("===== 模式匹配增强(C-4)=====");
// 1. 字符串选择:匹配分支
字符串 命令 = "开始";
选择 (命令) {
情况 "开始":
打印("命令: 开始");
中断;
情况 "停止":
打印("命令: 停止");
中断;
默认:
打印("命令: 未知");
}
// 2. 字符串选择:默认分支
字符串 命令2 = "暂停";
选择 (命令2) {
情况 "开始":
打印("命令2: 开始");
中断;
情况 "停止":
打印("命令2: 停止");
中断;
默认:
打印("命令2: 未知");
}
// 3. 多值情况标签(整数分组)
整32 级别 = 2;
选择 (级别) {
情况 0, 1:
打印("低级别");
中断;
情况 2, 3:
打印("中级别");
中断;
默认:
打印("高级别");
}
// 4. 裸枚举成员名(类型定向解析)
颜色 c = 颜色.蓝;
选择 (c) {
情况 红:
打印("红色");
中断;
情况 绿:
打印("绿色");
中断;
情况 蓝:
打印("蓝色");
中断;
默认:
打印("未知色");
}
// 5. 限定枚举成员 + 多值组合
颜色 c2 = 颜色.自定义;
选择 (c2) {
情况 颜色.红, 颜色.绿:
打印("基础色");
中断;
情况 颜色.自定义:
打印("自定义色");
中断;
默认:
打印("其他色");
}
// 6. 字符串选择 + 多值分组
字符串 键 = "甲";
选择 (键) {
情况 "甲", "乙":
打印("键: 甲乙组");
中断;
情况 "丙":
打印("键: 丙");
中断;
默认:
打印("键: 其他");
}
打印("===== 模式匹配测试完成 =====");
返回 0;
}输出:===== 模式匹配增强(C-4)===== 命令: 开始 命令2: 未知 中级别 蓝色 自定义色 键: 甲乙组 ===== 模式匹配测试完成 =====
主.cnCN
导入 容器::向量;
结构体 班级 {
整32[3] 成绩;
}
函数 主() -> 整32 {
打印("===== 遍历...中每个 迭代语句(C-2)=====");
// 1. 数组迭代:打印每个元素(值拷贝)
整32[5] 数据 = { 10, 20, 30, 40, 50 };
遍历 数据 中 每个 x {
打印(x);
}
// 2. 数组累加
整32 总和 = 0;
遍历 数据 中 每个 值 {
总和 += 值;
}
打印("总和: ", 总和);
// 3. 向量<整32> 迭代
向量<整32> 数表 = 向量<整32>();
结果<空类型, 整32> 增1 = 数表.追加(1);
结果<空类型, 整32> 增2 = 数表.追加(2);
结果<空类型, 整32> 增3 = 数表.追加(3);
如果 增1.正常 && 增2.正常 && 增3.正常 {
遍历 数表 中 每个 v {
打印("向量: ", v);
}
} 否则 {
打印("向量追加失败");
}
// 4. 向量<字符串> 迭代
向量<字符串> 名字 = 向量<字符串>();
结果<空类型, 整32> 增4 = 名字.追加("张三");
结果<空类型, 整32> 增5 = 名字.追加("李四");
如果 增4.正常 && 增5.正常 {
遍历 名字 中 每个 名 {
打印("名字: ", 名);
}
} 否则 {
打印("名字追加失败");
}
// 5. 继续:跳过偶数(混合数组)
整32[5] 混合 = { 1, 2, 3, 4, 5 };
遍历 混合 中 每个 值 {
如果 值 % 2 == 0 {
继续;
}
打印("奇数: ", 值);
}
// 6. 中断:提前退出
遍历 数据 中 每个 值 {
如果 值 > 30 {
中断;
}
打印("直到30: ", 值);
}
// 7. 嵌套迭代(结构体数组 -> 字段数组逐元素求和)
班级[2] 各班 = { 班级{ 成绩 = { 60, 70, 80 } },
班级{ 成绩 = { 90, 91, 92 } } };
整32 全体和 = 0;
遍历 各班 中 每个 班 {
遍历 班.成绩 中 每个 成绩 {
全体和 += 成绩;
}
}
打印("全体和: ", 全体和);
// 8. 结构体字段数组迭代(成员访问迭代对象)
班级 班 = 班级{ 成绩 = { 60, 70, 80 } };
遍历 班.成绩 中 每个 成绩 {
打印("成绩: ", 成绩);
}
打印("===== 遍历...中每个 测试完成 =====");
返回 0;
}输出:===== 遍历...中每个 迭代语句(C-2)===== 10 20 30 40 50 总和: 150 向量: 1 向量: 2 向量: 3 名字: 张三 名字: 李四 奇数: 1 奇数: 3 奇数: 5 直到30: 10 直到30: 20 直到30: 30 全体和: 483 成绩: 60 成绩: 70 成绩: 80 ===== 遍历...中每个 测试完成 =====
中断 跳出最近进入的一层 选择 或 循环(谁近绑谁,与 C 的 break 一致):循环内选择体写 中断 只跳出该选择,循环继续;从选择内直接跳出外层循环无直接语法。继续 仅对循环有意义。函数:重载、默认参数、引用参数
函数是first-class公民:同名重载按参数类型区分、默认参数从右向左连续、T& 引用参数直写调用方、泛型函数编译期单态化。
主.cnCN
函数 计算(整32 n) -> 整32
函数 使用前向() -> 整32 {
返回 计算(10); // 调用时 计算 仅有原型声明,定义在文件末尾
}
// ---- 2. 递归调用:阶乘 ----
函数 阶乘(整32 n) -> 整32 {
如果 (n <= 1) {
返回 1;
}
返回 n * 阶乘(n - 1); // 递归调用自身
}
// ---- 3. 函数指针:声明/赋值/调用(规格书5.8 C风格) ----
函数 加(整32 a, 整32 b) -> 整32 {
返回 a + b;
}
函数 减(整32 a, 整32 b) -> 整32 {
返回 a - b;
}
函数 主() -> 整32 {
// ---- 1. 前向引用验证:计算 定义在文件末尾,这里调用 ----
打印("前向引用: 计算(10)=");
打印(使用前向());
// ---- 2. 递归验证:阶乘 ----
打印("递归: 阶乘(5)=");
打印(阶乘(5));
// ---- 3. 函数指针声明(C风格类型)+ 赋值 + 调用 ----
整32(*回调)(整32, 整32);
回调 = 加;
打印("函数指针: 回调(20, 30)=");
打印(回调(20, 30));
// 重新赋值后调用另一个函数
回调 = 减;
打印("函数指针: 回调(50, 30)=");
打印(回调(50, 30));
// 函数指针作为参数传递
打印("函数指针作参数: 执行(回调, 100, 40)=");
打印(执行(回调, 100, 40));
返回 0;
}
// 定义在调用之后(前向引用依赖原型声明)
函数 计算(整32 n) -> 整32 {
返回 n * 2;
}
// 函数指针作参数:func(整32, 整32) -> 整32
函数 执行(整32(*func)(整32, 整32), 整32 x, 整32 y) -> 整32 {
返回 func(x, y);
};输出:前向引用: 计算(10)= 20 递归: 阶乘(5)= 120 函数指针: 回调(20, 30)= 50 函数指针: 回调(50, 30)= 20 函数指针作参数: 执行(回调, 100, 40)= 60
复制(对象)。详见函数参考。主.cnCN
泛型 <类型 T>
类 盒子 {
私有:
T 数据;
公开:
不安全 函数 盒子() {
数据 = 0;
}
函数 放(T 值) {
数据 = 值;
}
常量 函数 取() -> T {
返回 数据;
}
}
泛型 <类型 K>
函数 查找位置(K* 数组, 整64 长度, K 目标) -> 整64 {
整64 索引 = 0;
当 (索引 < 长度) {
如果 (数组[索引] == 目标) {
返回 索引;
}
索引++;
}
返回 0 - 1;
}
函数 主() -> 整32 {
盒子<整32> 盒;
盒.放(53);
返回 盒.取();
}lambda 与闭包:捕获的四形态
lambda=匿名函数——可存变量、作实参;体内引用外层变量时,[捕获] 决定「怎么拿」:[]/[=]/[变量] 拍快照(定义那一瞬间的副本),[&] 记地址(读写穿原变量)。
lambda起步.cnCN
函数 主() -> 整32 {
变量 加倍 = [](整32 x) -> 整32 { 返回 x * 2; };
打印(加倍(21)); // 42:存变量,像函数一样调用
变量 三倍 = [](整32 x) { 返回 x * 3; }; // 单一 返回 表达式→返回类型可省略
打印(三倍(5)); // 15
返回 0;
}输出:42 15
| 形态 | 一句话 | 拿到的是 | 体内能写吗 | 能带出函数吗(逃逸) |
|---|---|---|---|---|
[] 空捕获 | 显式承诺不依赖类环境 | 局部变量=隐式值快照;类字段=编译错 | 不能(快照只读) | 能(快照无悬垂) |
[=] 值捕获 | 拍快照带走 | 每个被引用外层变量的定义处副本 | 不能(快照只读) | 能(快照无悬垂) |
[&] 引用捕获 | 记地址读穿原变量 | 原变量本体(读最新、写穿) | 能(写穿原变量) | 不能(逃逸=编译错) |
[变量] 显式捕获 | 只带走点名的 | 点名变量的快照(值语义) | 不能(快照只读) | 能(快照无悬垂) |
[=] 值捕获:定义那一瞬间拍快照——之后修改外部变量,闭包读到的仍是旧值。
主.cnCN
函数 主() -> 整32 {
变量 a = 3;
变量 b = 4;
变量 求和 = [=]() -> 整32 { 返回 a + b; };
a = 30;
b = 40;
打印(求和()); // 7(两变量均快照·非 70)
返回 0;
}输出:7
[] 空捕获:体内读局部变量按隐式值捕获(同样快照语义)——但它对类成员零容忍,见类与泛型·方法内 lambda。
主.cnCN
函数 主() -> 整32 {
变量 m = 6;
变量 取m = []() -> 整32 { 返回 m; };
m = 66;
打印(取m()); // 6(隐式值捕获快照·非 66)
返回 0;
}输出:6
[&] 引用捕获:体内赋值直接写穿原变量——体外再读是改后的新值。
主.cnCN
函数 主() -> 整32 {
变量 y = 5;
变量 改y = [&]() -> 整32 {
y = y + 1; // 写穿外部
返回 y;
};
打印(改y()); // 6(自增可见)
打印(y); // 6(外部被写穿·非 5)
返回 0;
}输出:6 6
[x, y] 显式捕获:点名谁带走谁——体内引用了没点名的局部变量=编译错误(列表即承诺清单)。
主.cnCN
函数 主() -> 整32 {
整32 x = 6;
整32 y = 7;
变量 乘x = [x, y](整32 v) -> 整32 { 返回 x * v + y; };
打印(乘x(2));
返回 0;
}输出:19
- 全局变量/顶层常量不属捕获域——任何捕获形态下体内直读均合法(符号直读非环境捕获)。
[=]是「按需快照」:只快照体内实际引用的外层变量,没引用的不拷贝。- 快照三形态(
[]/[=]/[变量])可安全带出定义处(存变量、作返回值皆可);[&]的地址借条只在定义帧内有效——逃逸限制见下方批注。
[] 读类字段=编译错误([] 是「不依赖外部环境」的显式承诺,读字段=隐式 自身 依赖当场显形,见方法内 lambda);[=] 才会快照字段。②快照是只读的:[]/[=]/[变量] 的快照只许读——体内对捕获变量赋值/自增/调容器的写方法=编译错误(写只能落到快照副本:不写回外部变量、也不跨调用持久,语言直接禁掉这个假动作)。要修改原变量,明明白白用 [&]。快照只读.cn(负例·编译拒绝)CN
函数 主() -> 整32 {
变量 n = 1;
变量 加n = [=]() -> 整32 {
n = n + 1; // ✗ 值捕获快照只读:写的是副本
返回 n;
};
打印(加n());
返回 0;
}[=]/[变量])——快照无悬垂面。完整规则见语言参考·函数指针与 lambda。数组:定长、值语义、编译期长度
数组=类型[长度],长度可为编译期常量表达式;整体赋值=整块值拷贝(两态独立);越界=运行时错误(错误码 2)。
主.cnCN
不安全 函数 主() -> 整32 {
// ---- 1. 数组声明与初始化 ----
整32[5] 数据 = { 1, 2, 3, 4, 5 };
打印("数组[2]: ");
打印(数据[2]); // 3
// 部分初始化补零(C语义)
整32[4] 部分 = { 7, 8 };
打印("部分初始化[2]: ");
打印(部分[2]); // 0
// 下标写
数据[0] = 100;
打印("写后[0]: ");
打印(数据[0]); // 100
// 下标变量表达式
整32 i = 4;
打印("下标变量[4]: ");
打印(数据[i]); // 5
// ---- 2. 指针取地址/解引用 ----
整32 x = 42;
整32* p = &x;
打印("解引用: ");
打印(*p); // 42
*p = 99;
打印("解引用写: ");
打印(x); // 99
// ---- 3. 指针算术与遍历 ----
整32[3] 数据3 = { 10, 20, 30 };
整32* q = &数据3[0];
q = q + 1;
打印("指针+1: ");
打印(*q); // 20
q = q - 1;
打印("指针-1: ");
打印(*q); // 10
q++;
打印("q++: ");
打印(*q); // 20
q--;
打印("q--: ");
打印(*q); // 10
// 数组名退化(数组名 -> 指向首元素的指针)
整32* r = 数据3;
打印("数组退化: ");
打印(*r); // 10
// 指针比较
整32* s = &数据3[2];
打印("指针比较: ");
如果 (r < s) {
打印("r < s");
} 否则 {
打印("r >= s");
}
// ---- 4. 空指针 ----
整32* n = 无;
打印("空指针比较: ");
如果 (n == 无) {
打印("是空指针");
} 否则 {
打印("非空指针");
}
// 空类型* 与任意指针双向转换(规格书3.7)
空类型* vp = 无;
整32* t = vp; // 空类型* -> 整32*(隐式)
打印("空类型*转换: ");
如果 (t == 无) {
打印("转换后为空");
}
返回 0;
}输出:数组[2]: 3 部分初始化[2]: 0 写后[0]: 100 下标变量[4]: 5 解引用: 42 解引用写: 99 指针+1: 20 指针-1: 10 q++: 20 q--: 10 数组退化: 10 指针比较: r < s 空指针比较: 是空指针 空类型*转换: 转换后为空
- 下标从 0 起;越界读/写=运行时错误
错误码2 越界终止。 - 数组作为实参传给函数=按值整块拷贝(形参内改不影响实参);要原地改用
T*或T&形参。 - 定长数组之外,动态容器用标准库 向量<T>。
字符串:拥有型 UTF-8
字符串变量=拥有型(堆上 UTF-8,作用域结束自动释放);+ 拼接(右侧数值自动转字符串);s[i] 按字节读(UTF-8);写入不可(不可变类型)。
主.cnCN
函数 主() -> 整32 {
// 1. 普通字符串与转义
打印("你好"); // 你好
打印("带制表\t符"); // 带制表 符(\t 转义为制表符)
// 2. 原始字符串(反斜杠不转义,所见即所得)
打印(原始"路径\dir\file"); // 路径\dir\file(\d 不转义)
// 3. 多行字符串(内部仍处理 \n \t 转义)
打印(多行"""第一行\n第二行"""); // 输出两行:第一行 / 第二行
// 4. 原始多行组合(完全原始,\n 不转义)
打印(原始多行"""A\nB"""); // A\nB(字面反斜杠 n)
// 5. 字符串变量声明
字符串 s = "你好";
打印(s); // 你好
// 6. 字符* 变量声明(字符串字面量 -> 字符*)
字符* p = "世界";
打印(p); // 世界
// 7. 字符串 + 连接
打印(s + p); // 你好世界
打印("连接" + "字符串"); // 连接字符串
// 8. 字符串 ↔ 字符* 转换(A2 2026-09-11 方案甲:拥有→借用自动;借用→拥有须显式复制)
字符串 s2 = 字符串复制(p); // 字符* -> 字符串(显式落堆)
打印(s2); // 世界
字符* p2 = s; // 字符串 -> 字符*
打印(p2); // 你好
// 9. 字符串 API:长度(UTF-8 字节数,同 C strlen)
打印(字符串长度("hello")); // 5
打印(字符串长度(s)); // 6(你=3字节 + 好=3字节)
// 10. 字符串比较(相等返回真,否则假)
如果 (字符串比较("abc", "abc")) {
打印("比较相等: 真");
} 否则 {
打印("比较相等: 假");
}
如果 (字符串比较("abc", "abd")) {
打印("比较不等: 真");
} 否则 {
打印("比较不等: 假");
}
// 11. 字符串查找(子串位置,-1 表示未找到)
打印(字符串查找("hello world", "world")); // 6
打印(字符串查找("hello", "xyz")); // -1
// 12. 字符串复制(深拷贝)
字符串 cp = 字符串复制("副本");
打印(cp); // 副本
// 13. 打印行多参数(格式化为一行输出)
打印("值:", 42); // 值:42
打印("浮点:", 3.5); // 浮点:3.500000
打印(s, "与", p); // 你好与世界
返回 0;
}输出:你好 带制表 符 路径\dir\file 第一行 第二行 A\nB 你好 世界 你好世界 连接字符串 世界 你好 5 6 比较相等: 真 比较不等: 假 6 -1 副本 值:42 浮点:3.500000 你好与世界
- 长度/查找/子串/下标全部按 UTF-8 字节 口径(一个汉字 3 字节)——
字符串长度("中")= 3。 s[i]返回整8(带符号字节);字符串不可原地下标写(编译拒绝)——修改=用内置函数重建新串。- 完整的字符串函数族(20 个内置)见内置函数·字符串族。
结构体:值聚合与指定初始化器
结构体是纯值聚合(无方法);用 类型{字段=值} 指定初始化器构造——穷举纪律:缺字段/未知字段/重复字段=编译错误。
主.cnCN
结构体 点对 {
整32 x;
整32 y;
}
结构体 学生 {
整32 学号;
整32 成绩;
整32 班级;
}
结构体 班级 {
整32 编号;
整32[3] 分数;
}
// 小结构体(8字节)按值传参:返回修改后的副本
函数 移动(点对 起点, 整32 dx, 整32 dy) -> 点对 {
返回 点对{ x = 起点.x + dx, y = 起点.y + dy };
}
// 大结构体(12字节)按值传参 + 返回:成绩加 5
函数 加分(学生 入) -> 学生 {
学生 出 = 入;
出.成绩 = 出.成绩 + 5;
返回 出;
}
// 结构体数组元素作为参数(下标访问实参)
函数 取学号(学生 入) -> 整32 {
返回 入.学号;
}
// 含数组字段的结构体整体赋值(拷贝整个结构体,含数组字段)
函数 翻倍(班级 入) -> 班级 {
班级 出 = 入;
出.分数[0] = 出.分数[0] * 2;
出.分数[1] = 出.分数[1] * 2;
出.分数[2] = 出.分数[2] * 2;
返回 出;
}
函数 主() -> 整32 {
// ---- 1. 小结构体按值传参/返回(寄存器) ----
点对 原 = 点对{ x = 1, y = 2 };
打印("小结构体传参: ");
点对 移后 = 移动(原, 10, 20);
打印("移后.x: ");
打印(移后.x); // 11
打印("移后.y: ");
打印(移后.y); // 22
// 按值传递不修改原对象
打印("原.x: ");
打印(原.x); // 1
// ---- 2. 大结构体按值传参/返回(栈分配+指针) ----
学生 张三 = 学生{ 学号 = 1, 成绩 = 80, 班级 = 3 };
打印("大结构体传参: ");
学生 张三加 = 加分(张三);
打印("加后成绩: ");
打印(张三加.成绩); // 85
打印("原成绩: ");
打印(张三.成绩); // 80(按值传递,原对象不变)
// ---- 3. 结构体数组元素作为参数 ----
学生[2] 名单;
名单[0] = 学生{ 学号 = 7, 成绩 = 60, 班级 = 1 };
名单[1] = 学生{ 学号 = 9, 成绩 = 70, 班级 = 2 };
打印("数组元素参数: ");
打印(取学号(名单[0])); // 7
打印(取学号(名单[1])); // 9
// ---- 4. 结构体整体赋值(b = a 整体拷贝) ----
点对 a = 点对{ x = 100, y = 200 };
点对 b = a; // 声明并整体赋值
打印("整体赋值b.x: ");
打印(b.x); // 100
打印("整体赋值b.y: ");
打印(b.y); // 200
// 修改 a 不影响 b(拷贝语义)
a.x = 999;
打印("改a后b.x: ");
打印(b.x); // 100(b 是独立副本)
// ---- 5. 含数组字段结构体整体赋值 ----
班级 一班 = 班级{ 编号 = 1, 分数 = { 80, 90, 70 } };
班级 一班副本 = 一班; // 整体赋值拷贝数组字段
打印("含数组拷贝[1]: ");
打印(一班副本.分数[1]); // 90
一班副本.分数[1] = 0;
打印("改副本后原[1]: ");
打印(一班.分数[1]); // 90(原对象数组不受影响)
打印("改副本后副[1]: ");
打印(一班副本.分数[1]); // 0
// ---- 6. 链式赋值(b = a; c = b) ----
点对 c = a; // a.x=999, a.y=200
点对 d = c;
打印("链式d.x: ");
打印(d.x); // 999
打印("链式d.y: ");
打印(d.y); // 200
// ---- 7. 大结构体返回(含数组字段) ----
班级 翻倍一班 = 翻倍(一班);
打印("翻倍[0]: ");
打印(翻倍一班.分数[0]); // 160
打印("翻倍[1]: ");
打印(翻倍一班.分数[1]); // 180
打印("翻倍[2]: ");
打印(翻倍一班.分数[2]); // 140
// ---- 8. 结构体整体赋值后修改再重新赋值 ----
点对 e = 点对{ x = 1, y = 1 };
点对 f = e;
e.x = 50;
f = e; // 重新整体赋值
打印("重新赋值f.x: ");
打印(f.x); // 50
打印("重新赋值f.y: ");
打印(f.y); // 1
返回 0;
}输出:小结构体传参: 移后.x: 11 移后.y: 22 原.x: 1 大结构体传参: 加后成绩: 85 原成绩: 80 数组元素参数: 7 9 整体赋值b.x: 100 整体赋值b.y: 200 改a后b.x: 100 含数组拷贝[1]: 90 改副本后原[1]: 90 改副本后副[1]: 0 链式d.x: 999 链式d.y: 200 翻倍[0]: 160 翻倍[1]: 180 翻倍[2]: 140 重新赋值f.x: 50 重新赋值f.y: 1
- 成员访问统一
.;指针左侧自动解引用一级(p.x等价(*p).x)——->已废除。 - 缺字段/多写字段/重复字段全部编译期拒绝(静默零填禁入安全域)。
- 拥有型字段(字符串/容器)的释放随结构体变量作用域自动级联(RAII)。
- 不能自己装自己:值字段(非指针/引用)直接或间接自包含 = 无穷大小类型,编译期拒绝——诊断「值字段递归」并指路「改该字段为指针或改用类」(类字段=句柄不落值布局·Rust E0072 同类)。
递归结构体.cn(负例·编译拒绝)CN
结构体 节点 {
整32 值;
节点 下个; // ✗ 值字段自包含:无穷大小类型
}
函数 主() -> 整32 {
返回 0;
}枚举:命名常量族
枚举成员=命名整数常量,可显式赋值(含负数);引用形态=枚举名.成员(点号);选择 内可裸写成员名。
主.cnCN
导入 工具::错误码;
// 424 枚举全链(418-a D40 细分防线·v2 闭环多文件)
// 覆盖:枚举声明(显式值)/跨模块导入(模块::枚举名+公开性)/成员链常量
// 折叠(错误码.成员→编译期常量)/枚举变量类型位/转换 整32()
// 退出码校验和 = 越界(2)*10 + 参数(6) + 除零(1)*100 = 126
函数 主() -> 整32 {
错误码 e = 错误码.越界;
返回 整32(e) * 10 + 整32(错误码.参数) + 整32(错误码.除零) * 100;
}枚举名.成员 或 选择条件位裸成员名;枚举名::成员 非法(:: 保留给模块路径限定)。