教程·类与泛型
类、构造与析构、可见性、继承与接口、泛型类与泛型函数、运算符重载——面向对象与泛型编程全套。
第一个类:字段、方法、可见性
类=字段+方法的蓝图;公开:/保护:/私有: 标签分段控制可见性(默认私有);实例化即 类名() 表达式,方法用 . 调用。
主.cnCN
类 计数器 {
整32 值;
公开:
函数 计数器() { 自身.值 = 0; }
函数 加(整32 v) { 自身.值 = 自身.值 + v; }
常量 函数 读() -> 整32 { 返回 自身.值; }
}
函数 主() -> 整32 {
计数器 c = 计数器();
c.加(5);
打印("值=", c.读());
返回 0;
}
// 496 撞号改号让位,原号 648输出:值=5
公开:(类外可访问)/保护:(子类可访问)/私有:(仅本类)——标签分段,影响其后所有成员直到下一标签。- 构造函数与类同名、无返回类型;可有多个重载(按实参区分)。
- 类实例赋值/传参=句柄(引用语义,见构造析构与类参考)。
构造与析构:RAII 的根基
构造函数=与类同名的函数(可重载);析构函数=~类名,作用域结束自动调用——资源获取即初始化(RAII),忘记释放不可能。
主.cnCN
类 盒子 {
私有:
整64 容量;
公开:
函数 盒子() {
容量 = 0;
}
函数 盒子(整64 初始容量) {
容量 = 初始容量;
}
函数 取容量() -> 整64 {
返回 容量;
}
}
函数 主() -> 整32 {
盒子 无参盒 = 盒子();
盒子 带参盒 = 盒子(42);
打印("无参容量: ", 无参盒.取容量());
打印("带参容量: ", 带参盒.取容量());
返回 0;
}输出:无参容量: 0 带参容量: 42
- 拷贝构造=
函数 类名(类名& 其他)——定义了它,容器元素、按值传参等拷贝场合都会深拷(标准库容器全部定义了拷贝构造)。 - 析构顺序与构造相反;成员对象、容器元素、字符串全部自动级联释放。
- 构造函数重载已支持:无参构造+带参构造可共存。
字符串释放(字段) = 编译期拒绝(级联将二次释放)。提前放手用 摘除(槽):一步完成「释放旧值+清槽」,级联读到空槽自然跳过——手动与自动幂等组合,双释放机械杜绝。整块接管用 手动释放<T> 包装(对标 Rust ManuallyDrop):级联跳过+赋值覆盖不释放旧值,释放责任随声明归用户。继承与多态:虚拟/重写/自身/父类
单继承 类 子 : 父;父类方法标 虚拟,子类 重写;自身 指本实例(this),父类.方法() 调父类实现。经父类引用/指针调用=动态分派。
主.cnCN
类 形状 {
公开:
虚拟 函数 面积() -> 整32 { 返回 0; }
函数 描述() -> 字符串 { 返回 "面积=" + 整数转字符串(自身.面积()); }
}
类 方 : 形状 {
公开:
整32 边;
函数 方(整32 b) { 边 = b; }
重写 函数 面积() -> 整32 { 返回 边 * 边; }
}
类 长 : 形状 {
公开:
整32 宽;
整32 高;
函数 长(整32 w, 整32 h) { 宽 = w; 高 = h; }
重写 函数 面积() -> 整32 { 返回 宽 * 高; }
}
类 幼长 : 长 {
公开:
函数 幼长(整32 w, 整32 h) : 长(w, h) { }
重写 函数 面积() -> 整32 { 返回 宽 * 高 * 2; }
}
函数 印面积(形状& s) -> 整32 { 返回 s.面积(); }
函数 主() -> 整32 {
方 a = 方(3);
长 b = 长(4, 5);
形状* p = a;
打印(p.面积());
p = b;
打印(p.面积());
打印(印面积(a));
幼长 c = 幼长(2, 3);
形状* q = c;
打印(q.面积());
打印(q.描述());
返回 0;
}输出:9 20 9 12 面积=12
自身(this)在任何标识符位(字段名/变量名/参数名)都不可用——Rust self 同款硬保留。接口:行为契约
接口=纯虚拟方法集合;类 实现类 : 接口 实现全部方法;接口引用可指向任何实现类实例(鸭子类型的静态版)。
主.cnCN
接口 可打印 {
虚拟 函数 打印自身() -> 空类型;
}
接口 可计数 {
虚拟 函数 计数() -> 整32;
}
类 文档 : 可打印, 可计数 {
公开:
整32 行数;
函数 文档(整32 甲) { 行数 = 甲; }
虚拟 函数 打印自身() -> 空类型 {
打印行("文档内容");
}
虚拟 函数 计数() -> 整32 {
返回 行数;
}
}
函数 主() -> 整32 {
文档 甲 = 文档(5);
甲.打印自身();
打印行(甲.计数());
返回 0;
}输出:文档内容5
泛型类:向量 的原理
泛型 <类型 T> 声明类型参数;使用处 类名<实参> 实例化——编译期单态化(每个实例化生成一份专用代码,零运行时开销)。
主.cnCN
类 计数器 {
公开:
静态 整32 总数 = 0; // 静态字段(全类共享)
函数 计数器() {
// 静态字段自增(缺陷5 修复验证):总数++ 经"读-算-写回"正确计数
总数++;
}
静态 函数 获取总数() -> 整32 {
返回 总数; // 静态方法访问静态字段
}
}
// 只读包装:常量成员函数(读取私有成员)
类 只读包装 {
私有:
整32 值;
公开:
函数 只读包装(整32 v) {
值 = v;
}
常量 函数 获取() -> 整32 { // 常量成员:不修改成员
返回 值;
}
函数 修改(整32 新值) {
值 = 新值;
}
}
// 账户 + 友元函数(访问私有余额)
// 说明:友元引用参数(账户&)的成员访问(账.余额)经 A-1(2026-08)引用
// 全链路修复已支持(语义保留 & 签名、IR byRef 解引用、字段读写经引用指针);
// 指针参数(账户*)与引用参数(账户&)两种形态均验证私有成员授权访问。
类 账户 {
私有:
整64 余额;
公开:
函数 账户(整64 初始) {
余额 = 初始;
}
友元 函数 检查余额(账户* 账); // 声明友元函数(指针参数)
友元 函数 取余额(账户& 账); // 友元函数(引用参数,缺陷5 修复验证)
}
// 友元函数定义:可访问私有 余额(授权访问,不改值)
不安全 函数 检查余额(账户* 账) -> 布尔 {
返回 账.余额 > 0;
}
// 友元引用参数(账户&)成员访问(缺陷5 修复验证)
函数 取余额(账户& 账) -> 整64 {
返回 账.余额;
}
函数 主() -> 整32 {
打印("===== 类成员增强(Task 3.9)=====");
// ---- 1. 静态字段:全类共享 ----
计数器 甲 = 计数器();
计数器 乙 = 计数器();
计数器 丙 = 计数器();
打印("共享总数: ", 计数器.总数); // 3(类名.静态字段 访问)
打印("静态方法: ", 计数器.获取总数()); // 3(静态方法)
// 类外修改静态字段
计数器.总数 = 10;
打印("修改后: ", 计数器.获取总数()); // 10
// ---- 2. 常量成员函数(读取私有成员)----
只读包装 包装 = 只读包装(42);
打印("常量获取: ", 包装.获取()); // 42
包装.修改(100);
打印("修改后: ", 包装.获取()); // 100
// ---- 3. 友元引用参数(账户&)成员访问(缺陷5 修复验证)----
账户 账户实例 = 账户(500);
整64 金额 = 取余额(账户实例);
打印("引用取余额: ", 金额); // 500
打印("===== 类成员增强测试完成 =====");
返回 0;
}输出:===== 类成员增强(Task 3.9)===== 共享总数: 3 静态方法: 3 修改后: 10 常量获取: 42 修改后: 100 引用取余额: 500 ===== 类成员增强测试完成 =====
- 实际工程不重复造轮子:标准库有现成的 向量/链表/栈/队列、映射/集合。
- 泛型类型参数可约束为接口(
泛型 <类型 T : 可比较>)。
静态成员与常量成员函数
静态 字段全类共享(类名.字段 访问);常量 函数 承诺不改对象状态——可在常量上下文调用。
主.cnCN
类 计数器 {
公开:
静态 整32 总数 = 0;
函数 计数器() {
总数++;
}
静态 函数 获取总数() -> 整32 {
返回 总数;
}
}
函数 主() -> 整32 {
计数器 甲;
计数器 乙;
计数器 丙;
打印行(计数器.获取总数());
计数器.总数 = 10;
打印行(计数器.获取总数());
返回 0;
}输出:310
方法内 lambda:捕获类字段
方法体内定义的 lambda 想用类字段?字段不会自动出现在闭包里——闭包体是独立函数帧,须显式捕获;[] 空捕获读/写字段=编译错误(「不依赖环境」的承诺违约当场显形)。
主.cnCN
整32 全局计数 = 100;
类 袋 {
整32 基 = 10;
公开:
函数 值捕获读() -> 整32 {
变量 f = [=]() -> 整32 { 返回 基 + 1; };
返回 f(); // 11(值快照 10+1)
}
函数 引用捕获写() -> 整32 {
变量 g = [&]() -> 整32 { 基 = 基 + 5; 返回 基; };
返回 g(); // 15([&] 写穿·基 变 15)
}
函数 显式捕获读() -> 整32 {
变量 h = [基]() -> 整32 { 返回 基 * 2; };
返回 h(); // 30(定义处字段值快照=15·非 20)
}
函数 空体与全局() -> 整32 {
变量 k = []() -> 整32 { 返回 7; }; // [] 空体=零环境依赖合法
变量 m = []() -> 整32 { 返回 全局计数; }; // [] 读全局=符号直读合法
返回 k() + m() - 7; // 100
}
}
函数 主() -> 整32 {
袋 b;
打印(b.值捕获读());
打印(b.引用捕获写());
打印(b.显式捕获读());
打印(b.空体与全局());
打印(全局计数);
返回 0;
}输出:11 15 30 100 100
- 四形态合法面:
[=]值捕获字段=定义处字段值快照;[&]引用捕获=字段地址读写穿最新;[字段名]显式捕获=该字段定义处快照;[]只许零环境依赖(空体、只读全局/顶层常量)。 []读/写类字段,或经自身的成员访问(自身.字段/自身.方法())=隐式 this 依赖=编译错误「[] 空捕获 lambda 访问类成员」——闭包体无自身绑定,隐式依赖会读出垃圾值;按指路改[=]/[&],或显式列出要捕获的字段名。[自身]不是合法写法——自身是保留字(任何标识符位不可用);经自身的访问请用[=]/[&]。- 四形态完整语义(快照只读/逃逸限制)见语法基础·lambda 与闭包与语言参考。
空捕获读字段.cn(负例·编译拒绝)CN
类 计数器 {
整32 总数 = 0;
公开:
函数 读总数() -> 整32 {
变量 读 = []() -> 整32 { 返回 总数; }; // ✗ [] 读类字段
返回 读();
}
}
函数 主() -> 整32 {
返回 0;
}运算符重载
成员函数 函数 运算符X(参数) 自定义运算符语义;仅限成员(左操作数必须本类实例);双目单参数、单目无参数。
主.cnCN
结构体 向量 { 整32 x; 整32 y; }
类 V {
公开:
整32 x;
整32 y;
函数 V(整32 a, 整32 b) { x = a; y = b; }
函数 运算符+(V 右) -> 向量 {
向量 r;
r.x = x + 右.x;
r.y = y + 右.y;
返回 r;
}
函数 运算符-(V 右) -> 向量 {
向量 r;
r.x = x - 右.x;
r.y = y - 右.y;
返回 r;
}
}
静态 向量 静态和;
函数 求和(向量 v) -> 整32 {
返回 v.x + v.y;
}
类 工具 {
公开:
静态 函数 差(V 甲, V 乙) -> 向量 {
返回 甲 - 乙;
}
}
不安全 函数 静态位测试(V 甲, V 乙) -> 整32 {
静态和 = 甲 + 乙;
返回 静态和.x + 静态和.y;
}
函数 主() -> 整32 {
V 甲 = V(1, 2);
V 乙 = V(10, 20);
向量 和 = 甲 + 乙;
打印("初始化位: ", 和.x + 和.y);
向量 差;
差 = 甲 - 乙;
打印("赋值位: ", 差.x + 差.y);
打印("静态位: ", 静态位测试(甲, 乙));
打印("实参位: ", 求和(甲 + 乙));
打印("成员链: ", (甲 + 乙).x);
向量 返 = 工具.差(乙, 甲);
打印("静态方法返回位: ", 返.x + 返.y);
返回 0;
}输出:初始化位: 33 赋值位: -27 静态位: 33 实参位: 33 成员链: 11 静态方法返回位: 27
- 可重载集合:
+ - * / % == != < > <= >= && || ! & | ^ ~ << >>——[]/()解析层显式拒绝(改用 lambda 或函数指针)。 - 决议:先精确匹配内置运算符,无匹配才查左操作数类型的成员
运算符X。使用点参数个数校验:单目须 0 个右操作数、双目 1 个——不符报「重载期望 N 个右操作数」。 - 字符串
+数值 拼接是语言内置(自动转字符串),无需重载。