CN·语言

教程·语法基础

变量、类型、运算符、控制流、函数、lambda 闭包、数组、字符串、结构体、枚举——写过程式 CN 的全部基础。

程序骨架与语句

CN 源文件 UTF-8 编码、.cn 扩展名;顶层由函数/结构体/枚举/类/接口/导入/全局变量声明组成;入口=名为 主 的函数。

主.cnCN

函数 主() -> 整32 {
    打印("你好,世界");
    返回 0;
}

输出:你好,世界

分号是语句边界的唯一标记与 C/Rust 同款:每条语句必须以分号 ; 结束。换行在词法层只是空白——表达式可以任意换行续写,但行尾漏分号不会被「自动补分号」救回来,而是直接报语法错误。这避免了行尾/行首词法拼接类的事故。

变量与常量

声明即初始化是 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 整1281~16B整8:-128~127 …… 整128:±2^127
无符号整数正8 正16 正32 正64 正1281~16B正8:0~255 …… 正128:0~2^128-1
浮点浮32 浮644B / 8BIEEE 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 持有定义帧局部变量的地址——赋给局部变量+同帧调用放行;作返回值(含经局部变量的传播链)、作实参传出、存进全局变量/对象字段/容器等长寿命载体=编译错误「逃逸当前栈帧」(悬垂零容忍;分析不确定也按逃逸拒绝,永不静默放行)。要带出去?改快照形态([=]/[变量])——快照无悬垂面。完整规则见语言参考·函数指针与 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;
}
枚举成员引用形态成员引用=枚举名.成员 或 选择条件位裸成员名;枚举名::成员 非法(:: 保留给模块路径限定)。

下一步