object 与 union

本章导读

前五章把 class 的标准形态讲完了：字段固定、方法齐全、协议可扩、derive 可省。本章讲 class 家族的两翼。object 是标准库提供的普通基类，class X extends object 之后实例获得动态字段能力——运行期随手写 p.rank = 9，不需要事先声明，配置袋、 duck typing、快速原型都靠它；第 25 章留下的伏笔（动态字段是否参与序列化）也在本章揭晓。union 走相反方向：它是 C 风格的共享内存布局声明，所有字段占同一块存储，写 d 读 i 看到的是同一批字节的另一种解读——它不是"安全的代数数据类型"，而是 C ABI 的翻译官，为第 32 章的 C 互操作铺路。两者共性值得记住：都不是新的对象系统——object 是普通 class、union 是值类型，语言刻意不造第二套机制。

26.1 两个极端总览

一句话定位：object 给 class 加弹性，union 给类型减抽象。接下来先松后硬。

26.2 extends object 动态字段

继承 object 之后，实例可以在运行期随意增写字段——点号和方括号两种写法等价：

class Actor extends object
    int id = 0
    create(int id)
        self.id = id
    end
end
auto a = Actor(7)
a.hp = 120          // 未声明的字段，直接写
a.name = "hero"
a["score"] = 30     // 方括号形态，等价
println(a.id)       // 7：声明字段照常
println(a.hp)       // 120
println(a["score"])  // 30
a.hp = a.hp + 5
println(a.hp)       // 125：动态字段参与运算
println(type(a))    // Actor

三个要点：动态字段不需要声明，写即创建；点号形态（a.hp）与方括号形态（a["score"]）读写在同一个动态字典上；声明字段、方法、继承、协议一切照常——Actor 仍然是第 21~25 章那个 class，只是基类换成了 object。object 不是保留字，是标准库注入的普通类名；auto o = object() 直接实例化一个"纯动态袋"也合法（o.tag = 1 即用）。

26.3 动态字段的边界

三条实测边界，条条有坑相：

• 读不存在的字段得 null——不报错、不异常，println(a.missing) 输出 null，type 也是 null。写错字段名不会有人提醒你，拼写检查靠自觉（对照：普通 class 写未声明字段是编译错误 [sem] unknown class/union field，见坑 1）。
• 声明字段与动态字典是两套存储——a.id = 42 写声明字段，a["id"] = 43 写动态字典里的同名条目；之后 a.id 读 42、a["id"] 读 43，互不覆盖。点号永远优先走声明字段，方括号永远走动态字典。同名共存是合法状态，也是阅读噩梦——别让两种写法指同一个名字。
• 动态字段写 null 后读回 null——与"从未写过"无法区分；语言不提供动态字段的删除与遍历 API（RC0），把它当"只增不减的袋子"用。

26.4 动态字段与 derive json

第 25 章的伏笔揭晓：动态字段参与序列化，且排在声明字段之前，roundtrip 完整还原：

class Player extends object
    derive json
    int id = 0
    string name = ""
    create()
    end
end
auto p = Player()
p.id = 7
p.name = "hero"
p.rank = 9             // 动态字段
p.guild = "红宝石"     // 动态字段
string text = json.stringify(p)
println(text)   // {"rank":9,"guild":"红宝石","id":7,"name":"hero"}
auto q = json.parse::<Player>(text)
println(q.rank)  // 9：动态字段被还原
println(q.guild) // 红宝石

这使 extends object + derive json 成为弱结构数据的最佳载体：声明字段放稳定核心（id、name），动态字段收零散附加（rank、guild），序列化一键带走。注意 25.10 的边界依旧有效——动态字段值若是 null 的 class 引用同样危险；袋里只放标量、string、容器最安全。

26.5 object 与 var 选型

两者都能"装任意东西"，但抽象层级不同：

经验法则：要"像个对象"用 object，要"装个值"用 var。配置、记录、 duck typing 选 object（还能挂方法）；跨函数搬运算术值、异构容器元素选 var。var dict 也能当动态袋（bag["hp"]），但没有点号语法、不能挂方法——那是数据，不是对象。

26.6 union 与共享内存

union 在顶层必须具名，字段用 类型 名 声明（不带默认值），裸声明即零初始化：

union Payload
    int i
    float64 d
end
Payload p          // 零初始化，无 create
println(p.i)        // 0
p.i = 42
println(p.i)        // 42
println(type(p))    // Payload
p.d = 3.5
println(p.d)        // 3.5
println(p.i)        // 4615063718147915776：3.5 的位模式！

最后一行是 union 的灵魂：所有字段共享同一块内存。写入 d 后，i 读到的不是旧值 42，而是 3.5 的 IEEE 754 位模式按整数解读的结果。xlang 不记录"当前激活字段"、不生成 tag、不做任何保护——读哪个字段是你的责任。这是故意的：union 的全部意义就是描述 C 的内存布局，多一分抽象就偏离 ABI 一分。

26.7 union 的值语义

union 与 int、float 一样是值类型——传参复制、赋值复制、进容器复制：

union Bits
    int i
    float64 f
end
func mutate(Bits b)
    b.i = 999
end
Bits a
a.i = 10
mutate(a)
println(a.i)         // 10：传参是复制，函数改不到原件
Bits c
c = a
c.i = 20
println(a.i)         // 10：赋值也是复制
array<Bits> arr = [a]
arr[0].i = 30
println(a.i)         // 10：进容器还是复制

与 class 的引用语义（第 21 章）恰好相反——这份"怎么折腾都不影响原件"正是 C 结构体的行为。容器配合也到位：set<Payload> 按位内容去重（set{42, 42, 43} 的 length 是 2），底层是 memcmp。但注意一个 RC0 裂缝：a == b 直接比较两个 union 会报下游 tcc 错误（坑 5），值比较目前只存在于容器内部路径。

26.8 匿名 union 与嵌套

class 体内可以写匿名 union，字段直接暴露为 class 的字段——用来模拟 C 结构体里的匿名 union：

class Packet
    int tag = 0
    union
        int code
        float64 ratio
    end
    create()
    end
end
auto pkt = Packet()
pkt.tag = 7
pkt.code = 200
println(pkt.code)     // 200：像普通字段一样访问
pkt.ratio = 1.5
println(pkt.code)     // 4609434218613702656：共享内存依旧

union Payload2
    int i
    float64 d
end
class Envelope
    Payload2 payload    // 具名 union 作 class 字段
    create()
    end
end
auto e = Envelope()
e.payload.i = 9
println(e.payload.i)  // 9：嵌套访问

两种嵌套形态各司其职：匿名 union 让 Packet 拥有"tag 加一段共享内存"的 C 结构体布局；具名 union 作字段则保持独立类型身份（Envelope 嵌套 Payload2）。匿名 union 的字段名不能与 class 其他成员冲突（报 [sem] duplicate union field name 同款检查）。

26.9 union 限制清单

九条限制全部实测，诊断原文照录：

另有两处实测出入要留意：string 字段可以声明使用（文档口径禁止非平凡类型，实测漏网——写入后读其它字段看到的是字符串指针的位值，生命周期风险自担，别依赖）；typedef 别名 union 的字段访问失效——typedef Bits = Payload 后 type(b) 正确显示 Payload，但 b.i 读写都报 [checked] class field receiver is not a class value，别名目前只能用于类型标注场景。

26.10 口径：union 不是 struct

设计文档把话挑明了：DEMO6 不提供 struct 语句，union 也不是"未来安全联合类型"的雏形——它就是 C ABI 的声明工具。三个推论：

• 想要"带 tag 的可辨联合"请绕道——语言不记录激活字段；要"几种形状之一且运行期可知"，用 class 继承（第 22 章）或 var 装箱（第 15 章）表达，别在 union 上等待 enum union。
• 想要普通值聚合也请绕道——没有 struct 意味着"几个字段各占各的内存"的值类型目前只能由 union 单字段形态或 class 承担；多字段 union 天然是共享布局。
• union 的高光场景在边界上——extern/export 函数的参数与返回值（第 32 章 C 互操作详解）、二进制协议头的编解码（本章实战）。具名 union 生成的 C typedef 与 C 侧布局一字节不差，这正是它存在的理由。

实战：二进制头解析

经典场景：收到一个 32 位的"打包字"，既要整体比较，又要拆出其中的字节字段——union 让"两种解读"零成本共存：

union IpAddr
    int u32       // 整体：网络字节序的 32 位地址
    int8 first    // 首字节：共享同一存储的低 8 位
end
IpAddr ip
ip.u32 = 2130706433          // 0x7F000001，即 127.0.0.1
println(ip.u32)              // 2130706433
println(ip.first)            // 1：低 8 位（小端机的首字节）
println(ip.u32 / 16777216)   // 127：高 8 位，A 段

class Header
    int kind = 0
    union
        int code      // 文本协议：状态码
        float64 ratio   // 二进制协议：压缩率
    end
    create()
    end
end
auto h = Header()
h.kind = 1
h.code = 404
println(h.kind * 10000 + h.code)   // 10404
auto h2 = Header()
h2.kind = 2
h2.ratio = 0.75
println(h2.ratio * 100.0)         // 75.0

Header 演示了 C 协议解析的标准手法：kind 当"人工 tag"，匿名 union 承载随 kind 变化的载荷——语言不帮你记激活字段，你自己用 kind 记。这与 C 代码里 struct { int type; union { ... } } 的布局一模一样，也正是它生成的 C 代码的样子（深入细节 2）。读哪支字段之前先看 kind，是这类代码铁律。

深入细节

⚠️ 常见错误

以下报错全部来自真实编译器输出（文件路径已缩短）。

本章小结

复习题

编程练习