教程·安全与并发
结果与可选、所有权与转移、线程、互斥锁——CN 的安全模型不靠运行时罚站,靠编译器拦截。
结果<T, E>:失败是类型的一部分
可能失败的函数返回 结果<T, 整32>;成功=正常(值),失败=错误(错误码)。丢弃返回值不检查=编译错误——这是 CN 最重要的一条纪律。
主.cnCN
函数 工作(整32 模式) -> 结果<整32, 整32> {
如果 模式 == 0 {
返回 正常(7);
}
返回 错误(3);
}
函数 主() -> 结果<整32, 整32> {
整32 甲 = 工作(0)?;
打印行(甲);
返回 正常(0);
}输出:7
.值只能在「该分支已检查.正常」的前提下访问——编译器跟踪检查状态(NLL 同款数据流)。- 错误码用 核心.错误码 枚举(除零1/越界2/空指针3/内存4/文件5/参数6/未初始化7/溢出8;9=栈溢出由运行时直接输出、未入枚举)。
- 多级失败传播可用后缀
?(见错误处理参考)。
可选<T>:可能没有值没有自然错误码的「可能缺失」用
可选<T>:某些(值) / 无(常量·写作 返回 无;无 无值() 构造器),检查 .有值 后取 .值。语义=结果但错误侧无载荷。所有权与转移:默认安全的核心
资源类型(字符串/容器/类对象)变量拥有其资源;转移(x) 把所有权显式交接给另一个变量——源变量从此禁止读用(编译错误);对源变量重新赋值=复活。
主.cnCN
函数 造值() -> 字符串 {
字符串 甲 = "拥有串";
返回 甲;
}
函数 主() -> 整32 {
字符串 乙 = 造值();
打印行(乙);
返回 0;
}输出:拥有串
- 标量(整数/浮点/布尔/字符)是复制语义,
转移对它们拒绝(无意义)。 复制(x)是显式深拷贝克隆(与 转移 构成复制/移动双内置)。- 编译器还有最后使用消除:源变量在拷贝后不再使用时,自动降级为转移(零拷贝)——多数时候你不用手写 转移。
借用:引用参数与只读借用
不想转移也不想拷贝?T& 可变借用(直写调用方)、常量 T& 只读借用(体内禁止写)。
主.cnCN
函数 读数(常量 整64& 值) -> 整64 {
返回 值 * 2;
}
函数 借读(常量 整64& 值) -> 整64 {
返回 读数(值);
}
函数 主() -> 整32 {
整64 x = 21;
打印(读数(x));
打印(借读(x));
返回 0;
}输出:42 42
标准库的通道选择容器读取三形态正交并存:
元素(i) 副本读取、设置(i, v) 写回、元素引用(i) 引用写穿(不安全域)——大对象高频读用 引用 避免 131072 字节/次级别的深拷。见 向量.元素引用。- 引用不止形参:引用变量
整32& r = x;是 x 的别名(读写直达);函数可返回T&(返回被引用左值地址)——但返回局部变量地址=编译错误(悬垂在编译期拦下)。 - 借用纪律:引用实参须为左值(传字面量=编译错误「引用参数要求左值实参」);同一调用中同一变量被可变引用借两次(
双改(x, x))或可变×只读混借(混(甲, 甲))=编译错误「被可变借用两次(别名可变冲突)」/「可变借用与只读借用互斥」;引用参数不能带默认值。完整规则与实测示例见语言参考·函数·传参语义。
借出视图:什么时候不能再用
字符串元素容器的访问器返回的是容器内元素句柄的浅拷——借出视图。容器一改,视图就可能悬垂;编译器按「借用活跃区间」在编译期拒绝这类使用(NLL 顺序近似·Rust E0502 同构)。
- 视图形访问器(返回浅拷·非深拷):向量/链表/栈/队列/映射的「元素/读取/栈顶/队首/头部元素/读取头部/读取尾部/获取」。
- 失效方法:删除/设置/清空/弹出/出队/删除头部/删除尾部/释放内部数组——调用之后,之前借出的视图不得再使用。
- 判据(NLL 顺序近似):借用活跃区间=绑定→最后使用;区间内出现失效点即编译期拒绝——诊断「借出视图 … 在容器失效点(…)之后仍被使用——该元素已被释放/移出(悬垂)」,并指路
字符串复制(...)取拥有副本。 - 容器先亡同拒:视图不得比容器活得长(容器作用域结束后使用=「容器作用域结束后仍被使用」)。
悬垂视图.cn(负例·编译拒绝)CN
导入 容器::向量;
函数 主() -> 整32 {
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加 = 表.追加(字符串复制("数据"));
如果 (!加.正常) { 返回 1; }
字符串 借出 = 表.元素(0); // 借出视图
结果<空类型, 整32> 删 = 表.删除(0);
如果 (!删.正常) { 返回 1; }
打印(字符串长度(借出)); // ✗ 编译错误:失效点之后仍被使用
返回 0;
}主.cnCN
导入 容器::向量;
// ① 立即消费
函数 形态一() -> 整64 {
整64 校验 = 0;
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加 = 表.追加(字符串复制("形态一元素甲乙丙丁戊己庚辛壬癸"));
如果 (!加.正常) { 返回 0; }
如果 (字符串比较(表.元素(0), "形态一元素甲乙丙丁戊己庚辛壬癸")) { 校验 = 校验 + 1; }
结果<空类型, 整32> 删 = 表.删除(0);
如果 (!删.正常) { 返回 0; }
返回 校验;
}
// ② 显式复制(拥有副本)后容器修改
函数 形态二() -> 整64 {
整64 校验 = 0;
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加 = 表.追加(字符串复制("形态二元素甲乙丙丁戊己庚辛壬癸"));
如果 (!加.正常) { 返回 0; }
字符串 副本 = 字符串复制(表.元素(0));
结果<空类型, 整32> 删 = 表.删除(0);
如果 (!删.正常) { 返回 0; }
如果 (字符串比较(副本, "形态二元素甲乙丙丁戊己庚辛壬癸")) { 校验 = 校验 + 2; }
返回 校验;
}
// ③ 借出→消费→修改(NLL 活跃区间已结束)
函数 形态三() -> 整64 {
整64 校验 = 0;
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加 = 表.追加(字符串复制("形态三元素甲乙丙丁戊己庚辛壬癸"));
如果 (!加.正常) { 返回 0; }
字符串 借出 = 表.元素(0);
如果 (字符串比较(借出, "形态三元素甲乙丙丁戊己庚辛壬癸")) { 校验 = 校验 + 4; }
结果<空类型, 整32> 删 = 表.删除(0);
如果 (!删.正常) { 返回 0; }
返回 校验;
}
// ④ 借出后修改但不使用借出
函数 形态四() -> 整64 {
整64 校验 = 0;
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加 = 表.追加(字符串复制("形态四元素甲乙丙丁戊己庚辛壬癸"));
如果 (!加.正常) { 返回 0; }
字符串 借出 = 表.元素(0);
结果<空类型, 整32> 删 = 表.删除(0);
如果 (!删.正常) { 返回 0; }
校验 = 校验 + 8;
返回 校验;
}
// ⑤ 非字符串元素容器(值语义深拷贝,非借用面)
函数 形态五() -> 整64 {
整64 校验 = 0;
向量<整64> 表 = 向量<整64>();
结果<空类型, 整32> 加 = 表.追加(7);
如果 (!加.正常) { 返回 0; }
整64 借出值 = 表.元素(0);
结果<空类型, 整32> 删 = 表.删除(0);
如果 (!删.正常) { 返回 0; }
如果 (借出值 == 7) { 校验 = 校验 + 16; }
返回 校验;
}
// ⑥ 结果变量:消费在失效点之前
函数 形态六() -> 整64 {
整64 校验 = 0;
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加 = 表.追加(字符串复制("形态六元素甲乙丙丁戊己庚辛壬癸"));
如果 (!加.正常) { 返回 0; }
结果<字符串, 整32> 读 = 表.读取(0);
如果 (读.正常) {
如果 (字符串比较(读.值, "形态六元素甲乙丙丁戊己庚辛壬癸")) { 校验 = 校验 + 32; }
} 否则 {
返回 0;
}
结果<空类型, 整32> 设 = 表.设置(0, 字符串复制("形态六新值甲乙丙丁戊己庚辛壬癸"));
如果 (!设.正常) { 返回 0; }
返回 校验;
}
// ⑦ 扩容类修改点后同一借出继续用(字符串句柄独立于容器槽)
函数 形态七() -> 整64 {
整64 校验 = 0;
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加 = 表.追加(字符串复制("形态七元素甲乙丙丁戊己庚辛壬癸"));
如果 (!加.正常) { 返回 0; }
字符串 借出 = 表.元素(0);
整64 i = 0;
当 (i < 6) {
结果<空类型, 整32> 增 = 表.追加(字符串复制("形态七填充甲"));
如果 (!增.正常) { 返回 0; }
i++;
}
如果 (字符串比较(借出, "形态七元素甲乙丙丁戊己庚辛壬癸")) { 校验 = 校验 + 64; }
返回 校验;
}
// ⑧ 循环内每轮重新借出(消费后再修改)
函数 形态八() -> 整64 {
整64 校验 = 0;
向量<字符串> 表 = 向量<字符串>();
结果<空类型, 整32> 加 = 表.追加(字符串复制("形态八元素甲"));
如果 (!加.正常) { 返回 0; }
布尔 首次 = 真;
整64 i = 0;
当 (i < 3) {
字符串 行 = 表.元素(i);
如果 (字符串长度(行) > 0 && 首次) { 校验 = 校验 + 128; 首次 = 假; }
结果<空类型, 整32> 增 = 表.追加(字符串复制("形态八追加乙"));
如果 (!增.正常) { 返回 0; }
i++;
}
返回 校验;
}
函数 主() -> 整32 {
整64 校验和 = 0;
如果 (形态一() == 1) { 校验和 = 校验和 + 1; }
如果 (形态二() == 2) { 校验和 = 校验和 + 2; }
如果 (形态三() == 4) { 校验和 = 校验和 + 4; }
如果 (形态四() == 8) { 校验和 = 校验和 + 8; }
如果 (形态五() == 16) { 校验和 = 校验和 + 16; }
如果 (形态六() == 32) { 校验和 = 校验和 + 32; }
如果 (形态七() == 64) { 校验和 = 校验和 + 64; }
如果 (形态八() == 128) { 校验和 = 校验和 + 128; }
返回 整32(校验和);
}输出:[p6h] 已解析: target/audit2/v2src216/主.cn
- 同源互斥(跨函数别名窄面):容器与其借出视图同时作为实参传入同一调用=编译期拒绝(被调方可能修改容器)——成员链接收者(
架.表.元素(0))同规则。 - 修正两条路:
字符串复制(视图)取拥有副本;或调整使用顺序(消费完再改容器)。 - 非字符串元素容器(
向量<整64>等)的元素()=值语义深拷,不是借用——不受本规则约束。
线程:新线程 与 并入线程
新线程(入口函数, 实参) 启动线程(实参按值拷贝、无别名),并入线程(句柄) 等待结束并取回返回值——每个线程必须被并入(未并入=运行时错误,宁严勿松)。
线程.cn(linux 真线程·win 为运行时桩)CN
导入 线程::{新线程, 并入线程};
不安全 函数 作业(空类型* 未用) -> 整64 {
整64 和 = 0;
循环 (整64 i = 1; i <= 1000000; i++) { 和 = 和 + i; }
返回 和;
}
不安全 函数 主() -> 整32 {
结果<空类型*, 整32> 建 = 新线程(作业, 无);
如果 (建.正常) {
打印(并入线程(建.值)); // 500000500000
} 否则 {
返回 1;
}
返回 0;
}- 入口签名固定:
整64(空类型*)函数;实参按值拷贝进新线程,须可搬运——含裸指针字段的类型编译期拦截(标量/字符串/函数指针恒可搬运;豁免=不安全 可搬运修饰),详见并发参考。 不安全 函数 主():线程句柄是裸指针形态,线程域整体属不安全面(见进阶篇)。
互斥锁<T>:锁与数据绑死
类型化互斥锁把「锁」和「被护数据」绑在一个类型里——拿 A 锁护 B 数据的锁错对象错误在类型检查下不可表达(Rust Mutex<T> 同位)。
互斥锁.cn(win 为运行时桩·linux 真锁)CN
导入 线程::互斥锁;
不安全 函数 主() -> 整32 {
互斥锁<整64> 计数器 = 互斥锁<整64>(0);
计数器.上锁();
计数器.值 = 计数器.值 + 1; // 受护区间内访问公开字段 值
计数器.解锁();
打印(计数器.值);
返回 0;
}- 受护数据在公开字段
值中——纪律是「上锁/解锁 之间访问」,RAII 锁守卫在路线图中。 - 实例=对象句柄语义:跨线程共享同一实例=共用同一把锁(正确形态)。
- 互斥锁 可搬运 ⇔ T 可搬运——不可搬运类型(如裸指针)进不了跨线程通道。
继续:进阶篇——内存模型、FFI、优化与调试。