函数
声明与调用、重载、默认参数、按值/引用/常量引用传参、泛型单态化、函数指针、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