CN·语言

类与对象

类布局、可见性、构造析构链、继承与接口的精确规则、静态成员、友元、运算符重载。

类与实例:句柄模型

类变量槽存对象句柄(不是对象本体)——赋值/传参传句柄、体内写穿同一堆对象;实例在无引用后由 RAII 链释放。

主.cnCN

导入 容器::向量;

类 账本 {
公开:
    整64 计数;
    向量<字符串> 记录;
    函数 账本(整64 初值) {
        计数 = 初值;
        记录 = 向量<字符串>();
    }
    函数 累加(整64 增量) -> 空类型 {
        计数 = 计数 + 增量;
    }
    函数 加倍() -> 整64 {
        返回 计数 * 2;
    }
    函数 组合() -> 整64 {
        返回 自身.加倍() + 计数;
    }
    函数 读数() -> 整64 {
        返回 计数;
    }
}

类 计数器 {
公开:
    整64 次数;
    函数 计数器() {
        次数 = 0;
    }
    函数 走过() -> 空类型 {
        次数 = 次数 + 1;
    }
    函数 取数() -> 整64 {
        返回 次数;
    }
}

函数 主() -> 整32 {
    整64 累 = 0;
    账本 甲 = 账本(5);
    甲.累加(3);
    如果 (甲.读数() == 8) { 累 = 累 + 1; }
    如果 (甲.组合() == 24) { 累 = 累 + 2; }
    结果<空类型, 整32> 加 = 甲.记录.追加(字符串复制("条目甲乙丙丁"));
    如果 (!加.正常) { 返回 0; }
    如果 (甲.记录.大小() == 1) { 累 = 累 + 4; }
    字符串 副本 = 字符串复制(甲.记录.元素(0));
    结果<空类型, 整32> 删 = 甲.记录.删除(0);
    如果 (!删.正常) { 返回 0; }
    如果 (字符串长度(副本) == 18) { 累 = 累 + 8; }
    计数器 乙 = 计数器();
    整64 i = 0;
    当 (i < 5) {
        乙.走过();
        i = i + 1;
    }
    如果 (乙.取数() == 5) { 累 = 累 + 16; }
    返回 整32(累);
}

输出:[p6h] 已解析: target/audit2/v2src218/主.cn

  • 拿到对象的三种通道要分清:传参=句柄拷贝(写穿同一对象);返回(-> 类)=值副本(接收方独立拥有——来源为本体/句柄解引用深拷/转移三分·裁决 #1784 丁案);b = a 声明初始化=拷贝构造——类定义了拷贝构造(如标准库容器)按其语义深拷;没有则拥有字段逐字段深拷(副本完全独立·#1859 类字段所有权模型 §5.6a:字节浅拷废止——含字符串/容器/类字段的类整体拷贝不再句柄共享)。
  • 要独立副本:定义拷贝构造 函数 类名(类名&) 并用 复制(对象) 克隆(标准库容器全部定义了深拷构造)。要共享同一对象(返回面)用借用返回 -> 类&(零拷贝·借用检查约束:生命周期覆盖使用期+可变借用独占);多态一律经引用/指针(值形态禁切片·编译期拒绝)。
  • 取地址 &a 产对象地址(解包句柄),与 C++ &obj 语义一致。

字段所有权:拥有与借用(#1859 §5.6a)

类字段分拥有与借用两态:默认=拥有(字段归对象所有,对象负责其生死);借用态=字段类型带 &(如 字符串& 名字;——对象只搭车、不负责释放;与引用参数 T& 同记号·Rust & 字段同款·#2013 记号裁决)。

  • 拷贝契约:默认拷贝构造对拥有字段逐字段深拷(副本完全独立——字符串/容器/类字段各自复制,不再句柄共享);对借用字段只拷句柄(不释放)。用户自定义拷贝构造=用户全权,但借用字段禁止释放。
  • 析构契约:对象析构时只级联释放拥有字段,借用字段不释放(防双释放)。
  • 容器字段内联头布局(#1970·2026-11-04 批准):容器字段(向量/栈/映射/集合/链表/队列)的容器头(24/24/56/48/64/64 字节)直接嵌在对象内(Rust Vec<T> 字段/C++ std::vector 成员同款)——不再是 8 字节句柄槽+堆上头。空容器零堆分配(头零初始化),首元素追加时数组才落堆;每向量字段对象 +16 字节(映射 +48/链表队列 +56);类型大小(类) 含全部内联头。局部容器变量(函数体内声明)维持句柄模型不变。
  • 副本释放责任:返回值副本(-> 类)产生的副本,释放责任=接收方生命周期——变量接收→变量析构时释放;实参位临时→语句尾释放。泄漏面归零,双释放(double free)在类型层面不可能。
  • 要零拷贝(性能):用 转移(表达式) 移动所有权(源对象此后不可用);手动释放<T> 类型声明「释放权归用户」(编译器级联跳过该槽)。纯标量类(无字符串/容器/类/借用字段)拷贝自动走整块内存复制快通道。
  • 借用字段的完整逃逸悬空检查(编译期证明借的字不会先死)挂借用检查体系扩展——当前请勿让借用字段活得比来源对象久。

可见性、构造、析构、静态

  • 公开:/保护:/私有: 标签分段;缺省=私有。友元 函数名/类名 可越权访问私有。
  • 构造=与类同名(可重载);类类型字段自动级联默认构造(用户构造未显式构造的字段同此)——构造/析构对称。
  • 析构=~类名;作用域结束自动调用,先成员后自身、与构造反序。
  • 静态 字段/函数属于类(类名.成员 访问);常量 函数 承诺不改状态。
  • 虚拟 函数 动态分派;重写 显式标注覆盖;抽象 纯虚(接口成员)。

主.cnCN

类 内层 {
    公开:
    整32 x;
    函数 内层() { x = 7; }
}
类 外层 {
    公开:
    内层 内;
    整32 y;
    函数 外层() { y = 3; }
}
类 盒子 {
    公开:
    整32 值;
    函数 盒子() { 值 = 5; }
    函数 盒子(盒子& 其他) { 值 = 其他.值; }
    函数 ~盒子() { }
}
结构体 S {
    盒子 b;
    整32 x;
}
函数 主() -> 整32 {
    // 形态①:类含类字段级联构造(治理前 rc=139:o.内=空句柄)
    外层 o;
    打印行("y=", o.y);
    打印行("内.x=", o.内.x);
    // 形态②:类字段布局句柄口径(内@0 8B + y@8——y 不再覆写句柄高 4 字节)
    o.y = 30;
    打印行("改后 内.x=", o.内.x);
    // 形态③:结构体含类字段·闭合域级联(治理前 rc=1:s.b=空句柄)
    S s;
    s.x = 9;
    打印行("s.b.值=", s.b.值);
    打印行("s.x=", s.x);
    // 形态④:结构体拷贝=闭合域深拷(postCopy 指针槽深拷——副本独立)
    S t = s;
    t.x = 90;
    打印行("t.b.值=", t.b.值);
    打印行("t.x=", t.x);
    打印行("源 s.x 仍=", s.x);
    返回 0;
}

输出:y=3内.x=7改后 内.x=7s.b.值=5s.x=9t.b.值=5t.x=90源 s.x 仍=9

继承与接口

  • 单继承:类 子 : 父;接口实现同形态:类 实现类 : 接口。
  • 虚拟 开启动态分派;重写 覆盖父类虚拟;父类.方法() 调父类实现;父类.构造(实参) 在子类构造内调用父类构造。
  • 自身 是保留字——任何标识符位不可用。
  • 接口实现三查(逐接口方法校验):①存在——缺实现报「未实现接口 'I' 的方法 'M'」(多层继承未实现有指路诊断);②签名一致——参数类型与返回类型须与接口精确一致,不一致=编译错误「签名不一致」(防静默错位/截断);③修饰——实现方法须 虚拟 或 重写 修饰。
  • 抽象成员=纯虚声明:抽象 函数 名(参数) -> 返回类型 不得带实现体(带体=编译错误「抽象方法不得带实现体」);含抽象成员的类与接口不可实例化(「不能实例化」),派生类/实现类须实现全部抽象成员。
  • 接口可含虚拟函数声明(无体);接口引用可指任何实现类实例。
  • 析构链:子类析构自动级联父类析构(容器元素同此)。

接口签名不一致.cn(负例·编译拒绝)CN

接口 通道 {
    虚拟 函数 发(整32 数据) -> 整32;   // 1870 起接口签名分号强制
}
接口 回执 {
    虚拟 函数 收() -> 整32;
}
类 设备 : 通道 {
公开:
    重写 函数 发(整64 数据) -> 整32 { 返回 1; }   // ✗ 参数类型不一致(整64 vs 整32)
}
类 终端 : 回执 {
公开:
    重写 函数 收() -> 整64 { 返回 2; }             // ✗ 返回类型不一致(整64 vs 整32)
}

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

抽象带体.cn(负例·编译拒绝)CN

类 基 {
公开:
    抽象 函数 f() -> 整64 { 返回 1; }   // ✗ 抽象方法不得带实现体
}

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

运算符重载

  • 成员函数形态:函数 运算符X(参数) -> 返回类型;左操作数必须本类实例;双目单参数、单目无参数。
  • 可重载集合:+ - * / % == != < > <= >= && || ! & | ^ ~ << >>(-> 已随成员访问统一废除;[]/() 解析层显式拒绝——请求重载即报「不支持重载」,改用 lambda 或函数指针)。
  • 使用点参数个数校验:单目 运算符X() 须 0 个右操作数、双目须 1 个——个数不符报「重载期望 N 个右操作数」。
  • 决议:①优先精确匹配内置运算符;②无内置匹配→按左操作数类型查找成员 运算符X;③仍无→「类型不兼容」错误。

主.cnCN

类 计量 {
公开:
    整32 值;
    函数 计量(整32 甲) { 值 = 甲; }
    函数 运算符~() -> 计量 {
        返回 计量(0 - 值 - 1);
    }
}
函数 主() -> 整32 {
    计量 甲 = 计量(10);
    计量 反 = ~甲;          // 重载版:0 - 10 - 1 = -11
    打印(反.值);
    整32 x = 5;
    打印(~x);               // 内置版:5 ^ (0-1) = -6(打印=println 自动换行)
    返回 0;
}

输出:-11 -6