CN·语言

函数

声明与调用、重载、默认参数、按值/引用/常量引用传参、泛型单态化、函数指针、lambda。

声明与调用

主.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

重载与默认参数

  • 重载:同名函数按参数类型与个数区分;仅返回类型不同不构成重载;名称修饰按签名编码。
  • 默认参数:从右向左连续声明(有默认值的参数右侧不得出现无默认值参数);调用按位置补缺省。默认值须为编译期常量表达式(字面量/常量算式/顶层常量);引用前形参等运行期表达式编译期拒绝(裁决 #1814)。

主.cnCN

函数 幂底(浮64 底, 浮64 指数 = 2.0) -> 浮64 {
    浮64 结果值 = 1.0;
    循环 (整32 i = 0; i < 整32(指数); i++) { 结果值 = 结果值 * 底; }
    返回 结果值;
}

函数 主() -> 整32 {
    打印(幂底(3.0), " ", 幂底(2.0, 10.0));
    返回 0;
}

输出:9.000000 1024.000000

传参语义:副本 / 引用 / 只读借用 / 类=写穿

CN 传参有四种语义,按形参类型决定——这是最容易被其他语言经验带偏的地方,务必读全。

形参形态语义体内写对调用方的影响
标量 / 结构体 按值副本(整块值拷贝)无影响
T& 引用写穿(左值地址传递)直接影响调用方
常量 T&只读借用(体内写=编译错误)无影响(也不可能)
类类型按值引用语义(形参槽=对象句柄拷贝,体内经句柄写同一堆对象)字段写/方法调用写穿调用方

主.cnCN

导入 容器::向量;
导入 映射集合;

类 盒子 {
公开:
    整64 值槽;
    函数 盒子() { 值槽 = 0; }
}

结构体 点 {
    整64 x;
    整64 y;
}

函数 临时读(映射<整64, 整64> 表) -> 整64 {
    结果<整64, 整32> 读 = 表.获取(7);
    如果 (读.正常) {
        返回 读.值;
    }
    返回 0;
}

函数 改盒子(盒子 对象) -> 整64 {
    对象.值槽 = 55;
    返回 对象.值槽;
}

函数 改点(点 p) -> 整64 {
    p.x = 99;
    返回 p.x;
}

函数 主() -> 整32 {
    整64 临时值 = 临时读(映射<整64, 整64>());
    打印("临时实参: ", 临时值);
    盒子 对象 = 盒子();
    整64 函数内 = 改盒子(对象);
    打印("类函数内: ", 函数内);
    打印("类主函数: ", 对象.值槽);
    点 坐标;
    坐标.x = 1;
    坐标.y = 2;
    整64 点函数内 = 改点(坐标);
    打印("结构体函数内: ", 点函数内);
    打印("结构体主函数: ", 坐标.x);
    返回 0;
}

输出:临时实参: 0 类函数内: 55 类主函数: 55 结构体函数内: 99 结构体主函数: 1

主.cnCN

函数 传回(整32& x) -> 整32& {
    返回 x;
}
函数 主() -> 整32 {
    打印("===== 引用返回(P3-18)=====");
    整32 值 = 100;
    整32& 别名 = 传回(值);
    打印("绑定读: ", 别名);          // 100
    别名 = 200;
    打印("引用写: ", 值);            // 200
    传回(值) = 300;
    打印("返回引用写: ", 值);         // 300
    打印("===== 完成 =====");
    返回 0;
}

输出:===== 引用返回(P3-18)===== 绑定读: 100 引用写: 200 返回引用写: 300 ===== 完成 =====

  • 引用变量 整32& r = x;:绑定既有左值,读自动解引用、赋值经地址写回原变量(C++ 引用语义)。
  • 函数返回 T&:返回被引用左值的地址(可继续作赋值目标/绑定新引用);返回本函数局部变量地址=编译错误「引用返回不能返回局部变量的地址」——悬垂引用在编译期拦下(Rust 同构)。
  • 实参须左值:引用形参传字面量/纯右值(含显式取址 f(&x)——&x 是指针不同类型,不是同类型左值)=编译错误「引用参数要求左值实参」(右值无处取址;静默物化临时槽=被调方写参落空)。
  • 引用默认值禁止:函数 f(整32& a = 值)=编译错误「引用参数不能有默认值(引用须绑定调用方左值)」。
  • 借用互斥(第一版·语句级):同一调用中同一变量以可变引用借出两次=编译错误「… 被可变借用两次(别名可变冲突)」(双改(x, x));可变引用实参与常量引用实参解析到同一基础变量=编译错误「… 的可变借用与只读借用互斥」(混(甲, 甲))。常量引用只读三纪律(体内赋值/复合赋值/转传可变引用=编译错误「是只读借用,不能赋值/传参」)见 教程·安全与并发·借用。

返回局部引用.cn(负例·编译拒绝)CN

函数 坏() -> 整32& {
    整32 局部 = 5;
    返回 局部;                 // ✗ 悬垂:局部变量随函数返回失效
}

函数 主() -> 整32 {
    返回 0;
}

双可变借用.cn(负例·编译拒绝)CN

函数 双改(整64& 甲, 整64& 乙) -> 空类型 {
    甲 = 甲 + 乙;
}

函数 主() -> 整32 {
    整64 x = 5;
    双改(x, x);                // ✗ 同一变量可变借用两次
    返回 0;
}
  • 要与「副本语义」传类,传前显式 复制(对象)(深拷克隆)。
  • 容器元素读取(元素/获取)返回副本(快照)——写回用 设置、写穿用 元素引用:与形参语义正交。
  • 临时实参传类形参合法(编译器物化临时槽)。
  • 字符串元素容器的访问器(元素/读取/栈顶/队首/头部元素/读取头部/读取尾部/获取)返回元素句柄浅拷=借出视图——容器失效方法(删除/设置/清空/弹出/出队/删除头部/删除尾部/释放内部数组)之后该视图悬垂,编译期拒绝(NLL 顺序近似,Rust E0502 同构);正则见 教程·安全与并发·借出视图。

泛型函数:编译期单态化

主.cnCN

泛型 <类型 T>
函数 首个(T* 数组, 整64 长度) -> T {
    返回 数组[0];
}

函数 主() -> 整32 {
    整32[3] 数据;
    数据[0] = 5;
    数据[1] = 6;
    数据[2] = 7;
    返回 整32(首个<整32>(数据, 3));
}
  • 泛型调用双形态:显式 名<类型>(实参) 与省略类型的隐式推导 名(实参) 均合法——实参类型可唯一确定时(含后置定义的泛型函数)省略 <类型>;推导不适用的形态(如引用形参位)写显式 <类型> 即可。
  • 每个实例化生成一份专用代码:零运行时开销、可内联优化。
  • 类型参数可约束接口:泛型 <类型 T : 可比较>。

函数指针与 lambda

主.cnCN

函数 加一(整32 甲) -> 整32 {
    返回 甲 + 1;
}
函数 应用(整32(*处理)(整32), 整32 值) -> 整32 {
    返回 处理(值);
}
函数 主() -> 整32 {
    打印行(应用(加一, 41));
    返回 0;
}

输出:42

  • 函数名可衰减为函数指针(折叠(表, 加));函数指针=代码指针,恒可搬运(可传给新线程)。
  • 声明位形态:整32(*名)(整32, 整32);字段/数组元素/返回位/静态位全部支持(规格 §5.8)。
  • 来源封口:合法来源仅两种——函数名衰减(含静态方法 类名.静态方法、泛型实例名)与同签名函数指针;整数/空指针等任何其他类型赋给函数指针=编译错误「无法将 … 隐式转换为 '函数指针<…>'」(代码地址与数据地址通道分离——函数指针恒指向真实函数)。
  • 空调用防线:零值(未赋值)函数指针间接调用=运行期确定性失败——每个间接调用点内置判零检查,零值报 运行时错误(错误码3): 空指针解引用(Rust 裸 fn pointer 调用为 UB;CN 安全区更严)。
  • 方法作值:静态方法 类名.方法 可直接作函数指针值(实参位/变量初值/返回位全通);实例方法 对象.方法 作值=绑定 this 的闭包——经变量调用(变量 cb = 对象.方法; cb(实参))捕获对象地址、读最新状态,不可直接作裸 fnptr 实参(裸地址无法携带 this=编译错误「须先赋值给变量」)。
  • lambda 捕获形态:[] 不捕获 / [=] 值捕获 / [&] 引用捕获 / [变量] 显式捕获。
  • [] 空捕获=显式无环境承诺:类方法体内 [] lambda 读取/写入类字段,或经 自身 的成员访问(自身.字段 / 自身.方法())=隐式 this 依赖=编译错误「[] 空捕获 lambda 访问类成员」(闭包体是独立函数帧、无 自身 绑定=隐式依赖读垃圾值;指路:改 [=] 值捕获 / [&] 引用捕获,或显式列出要捕获的字段)。合法面:[=]/[&]/[字段名] 已显式声明捕获照常(字段捕获=定义处字段值快照);全局变量/顶层常量不属捕获域,任何捕获形态下体内直读均合法。
  • [&] 引用捕获逃逸限制:引用捕获 lambda 持有定义帧局部变量地址——赋给局部变量+同帧调用(含立即调用)放行;作返回值(含经局部变量的传播链)/作实参传出/存长寿命载体=编译错误「逃逸当前栈帧」(指路:改 [=] 值捕获快照,或改在 不安全 函数 内定义豁免——责任上移);分析不确定按逃逸拒绝(永不静默放行)。值捕获/空捕获=快照语义无悬垂面,不受限(可安全逃逸),快照为只读(见下)。
  • 值捕获快照只读:值捕获([=]/[变量])与空捕获([])的快照为只读——lambda 体内对值捕获变量的一切写(赋值/复合赋值/自增自减/成员链与下标链写/容器写方法接收者)=编译错误(体内写只能落到快照副本:不写回外部变量,且直调通道每次调用重建快照=修改不持久、蹦床通道快照槽随闭包存活=前后调用行为不一致;指路:改用 [&] 引用捕获写穿原变量)。豁免=不安全 函数 内定义(责任上移同款);lambda 参数同名遮蔽与体内声明同名遮蔽的写=本层槽写(合法)。执法锁面=E2E 1670(写挂点全谱拒)+1671(合法面零误伤对照)。
形态拿到的是体内能写吗可否带出定义帧(逃逸)
[] 空捕获显式无环境承诺:局部/参数照常隐式值捕获(快照);类字段与经 自身 的访问=编译错误不能(快照只读)能(快照无悬垂)
[=] 值捕获体内实际引用的外层变量的定义处快照;类字段=定义处字段值快照不能(指路 [&])能(快照无悬垂)
[&] 引用捕获原变量本体(读写穿最新;字段=[&] 地址引用)能(写穿原变量)不能(逃逸=编译错误)
[变量] 显式捕获点名变量的快照(值语义);体内引用未点名变量=编译错误不能(指路 [&])能(快照无悬垂)
捕获三条铁律(速记)①[] 是承诺——「不依赖外部环境」的显式承诺:类方法体内读/写类字段或经 自身 访问=编译错误「[] 空捕获 lambda 访问类成员」(规格 §lambda 表达式·空捕获条·#1178 执法;锁面=1673)。②快照只读——[]/[=]/[变量] 的快照只许读:体内写捕获变量(赋值/复合赋值/自增自减/成员链与下标链写/容器写方法接收者)=编译错误(规格 §lambda 表达式·值捕获快照只读条〔#1881 立法〕:体内写只落快照副本——不写回外部变量、不跨调用持久,直调与蹦床两通道行为分裂,快照只读是唯一自洽语义;锁面=1670 拒面+1671 合法面)。③[&] 不可逃逸——作返回值(含经局部变量传播链)/作实参传出/存长寿命载体=编译错误「逃逸当前栈帧」(悬垂零容忍·435 立法;锁面=735/736/804/1672;分析不确定按逃逸拒绝,永不静默放行)。

快照只读.cn(负例·编译拒绝)CN

函数 主() -> 整32 {
    变量 n = 1;
    变量 加n = [=]() -> 整32 {
        n = n + 1;   // ✗ 值捕获快照只读——写的是副本
        返回 n;
    };
    打印(加n());
    返回 0;
}

逃逸当前栈帧.cn(负例·编译拒绝)CN

函数 得闭包() -> 整32(*)() {
    变量 x = 5;
    返回 [&]() -> 整32 { 返回 x; };   // ✗ 编译错误:逃逸当前栈帧
}

函数 主() -> 整32 {
    返回 0;
}

主.cnCN

函数 造i128() -> 整128(*)() {
    整128 大值 = 123456789012345;
    变量 取 = [=]() -> 整128 { 返回 大值 * 2; };
    返回 取;
}
函数 造i64() -> 整64(*)() {
    整64 基 = 5000000000;
    变量 取 = [=]() -> 整64 { 返回 基 * 2; };
    返回 取;
}
函数 造浮() -> 浮64(*)() {
    浮64 基 = 3.5;
    变量 取 = [=]() -> 浮64 { 返回 基 * 2; };
    返回 取;
}
结构体 点 { 整32 a; 整32 b; }
函数 造点() -> 整32(*)() {
    变量 v = 点{ a = 7, b = 8 };
    变量 取 = [=]() -> 整32 { 返回 v.a * 10 + v.b; };
    返回 取;
}
函数 主() -> 整32 {
    变量 取i128 = 造i128();
    打印(取i128());
    变量 取i64 = 造i64();
    打印(取i64());
    变量 取浮 = 造浮();
    打印(取浮());
    变量 取点 = 造点();
    打印(取点());
    变量 s = 42;
    打印(s);
    返回 0;
}

输出:246913578024690 10000000000 7.000000 78 42