CN·语言

教程·类与泛型

类、构造与析构、可见性、继承与接口、泛型类与泛型函数、运算符重载——面向对象与泛型编程全套。

第一个类:字段、方法、可见性

类=字段+方法的蓝图;公开:/保护:/私有: 标签分段控制可见性(默认私有);实例化即 类名() 表达式,方法用 . 调用。

主.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 ===== 类成员增强测试完成 =====

静态成员与常量成员函数

静态 字段全类共享(类名.字段 访问);常量 函数 承诺不改对象状态——可在常量上下文调用。

主.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 个右操作数」。
  • 字符串 + 数值 拼接是语言内置(自动转字符串),无需重载。