拷贝语义

本章导读

前面六章埋下了三条关于"复制"的线索：第 12 章讲参数传递时说"byval 对 class 复制的是句柄不是对象"；第 25 章讲 derive 时区分了 copy 浅复制与 clone 深复制；第 26 章讲 union 时看到值语义的实现就是 memcpy。本章把它们拼成完整图景，回答四个问题：默认什么时候复制？（几乎从不——赋值、传参、返回、闭包、进容器都只搬引用）；想复制时怎么复制？（显式 copy()/clone()，且类型必须事先用 derive 或手写协议开放能力）；浅与深差在哪？（只差在 class 引用字段/元素——标量、string、容器字段在浅复制里也按值走）；哪些坑会无声致命？（无 derive 调 copy 静默 fatal、循环引用 clone 直接崩溃）。读完本章，"b = a 之后改 b，a 会变吗"这类问题你将有确定性的答案。

27.1 三层复制模型

三层的共同点：复制从不隐式发生两次——值类型一次按位复制就够了，class 和容器则永远先共享、想要独立再显式开口。这个"默认共享、显式复制"的原则是本章所有规则的源头。

27.2 默认值：不复制

把第 12 章的结论放进复制框架再看一遍：赋值、默认参数、byval、返回、闭包捕获、容器存储，全都不调用任何复制协议——它们只让两个名字指向同一个对象：

class Item
    derive copy
    int v = 0
    create(int v)
        self.v = v
    end
end
func touch(byval Item x)
    x.v = 99          // byval 也不是复制！改的是同一个对象
end
auto a = Item(1)
auto b = a           // 共享
touch(a)
println(b.v)          // 99：赋值共享 + byval 共享，两处都看得见

byval 复制的只是"句柄"（参数变量本身），被调函数里给参数重新赋值不影响调用方，但通过句柄改成员双方都可见。要真正的独立对象，只有一个入口：copy()/clone()——而且类型得先开放这个能力。

27.3 copy() 浅复制

copy(obj) 要求类声明 derive copy 或手写 __copy__，返回一个"一层新"的对象：

class Config
    derive copy
    derive clone
    int level = 0
    create(int level)
        self.level = level
    end
end
class App
    derive copy
    derive clone
    string name = ""
    Config cfg = Config(0)
    create(string name, int level)
        self.name = name
        self.cfg = Config(level)
    end
end
auto app = App("demo", 1)
auto twin = copy(app)
twin.cfg.level = 9      // cfg 是共享引用
twin.name = "twin"       // name 是按值带走的
println(app.cfg.level)  // 9：改副本的 class 字段，原件遭殃
println(app.name)       // demo：string 字段早已各走各路

"浅"的精确含义：标量、string、array 字段按值复制，class 类型字段只复制引用。副本与原对象因此"半独立"——顶层字段互不干扰，深层对象藕断丝连。第 25 章已见过这个模型，本章的增量是：它同样适用于容器（27.6），且有手写定制的入口（27.5）。

27.4 clone() 深复制

clone(obj) 递归到底——class 字段也各自生成独立副本：

auto ghost = clone(app)
ghost.cfg.level = 5
println(app.cfg.level)  // 9：clone 的 cfg 是独立副本，互不波及
println(ghost.name)     // demo：顶层字段照旧按值

三条规则：嵌套的类自己也必须开放 clone 能力（derive clone 或手写 __clone__），否则编译报"字段类型必须可复制"；深复制不会中途退化为浅复制（XRT 为 copy/clone 提供独立操作槽）；clone 的对象图必须无环——循环引用会让进程崩溃（27.9）。

27.5 手写 __copy__/__clone__

复制协议可以完全自己写——签名固定，返回新实例；与 derive 共存时手写优先：

class Session
    derive copy          // derive 在场，但下面的手写版胜出
    int token = 0
    create(int token)
        self.token = token
    end
    func __copy__() as Session
        auto fresh = Session(0)   // 复制即脱敏：token 不带过去
        return fresh
    end
end
auto s = Session(99)
auto guest = copy(s)
println(s.token)      // 99
println(guest.token)  // 0：手写 __copy__ 的定制逻辑

手写协议的价值场景：复制时脱敏（凭证、缓存不带走）、复制时重置（统计清零、时间戳刷新）、复制时换算（官方测试用例里 __copy__ 给 value +10、__clone__ +20，用来区分两条路径）。与第 24 章协议家族同一规则：协议就是普通方法，只是名字被预定。手写版与 derive 同在一个类时，实测手写生效（derive 产物被覆盖）——与第 25 章 __eq__/__toString__ 的优先级结论一致。

27.6 容器的复制

容器赋值共享 backing——没有写时复制（见深入细节 2 的考证）；copy()/clone() 才建独立容器。差异在"容器里装 class"时显现，而且 typed 与 var 两个世界不对称：

var items = [Item(1), Item(2)]
var shared = items
shared[0].v = 99
println(items[0].v)    // 99：赋值共享 backing
var shallow = copy(items)
shallow[0].v = 55
println(items[0].v)    // 55：copy 复制容器壳，class 元素仍共享
var deep = clone(items)
deep[0].v = 11
println(items[0].v)    // 55：clone 连元素一起克隆，彻底独立
println(deep[0].v)     // 11

实测汇总四条：var 容器——copy 递归复制嵌套容器（三层实测均独立）但 class 元素保持共享引用；clone 连 class 元素也调 __clone__，完全独立。typed 容器——copy/clone 都只复制容器壳，class 元素在 clone 里也不克隆（array<Item> 实测 clone 后改元素仍波及原数组），要深复制 typed 容器得手动遍历逐个 clone。嵌套 typed 容器读出即复制——array<array<int>> 的 m[0] 取出的是内层副本，改它影响不到 m；链式 m[0][0] 读写直接编译报错（坑 5）。标量元素容器（array<int> 等）——壳独立即全独立，copy/clone 效果相同。

27.7 标量与 union 的复制

值类型不需要复制协议——copy()/clone() 对它们就是原样返回：

println(copy(42))       // 42
println(clone("hello"))  // hello
var v = 7
println(copy(v))         // 7
union Bits
    int i
    float64 f
end
Bits b
b.i = 99
Bits b2 = copy(b)
b.i = 1
println(b2.i)            // 99：union 复制=memcpy，天然独立

union 的复制就是第 26 章那块 memcpy——不需要 derive、不需要协议，和 int 一样是"复制免费户"。string 看似引用类型，但不可变，按值传递从不出事。

27.8 move 与 moveOnly

第 25 章见过 derive moveOnly，本章给它的语义画上句号：xlang 没有用户级 move() 函数——写 move(a) 报 [sem] undeclared identifier 'move'。"移动"发生在两个地方：

• 返回值优化——函数 return 一个局部 class/native 对象时，所有权直接转交调用方，不经过复制协议，析构恰好一次（官方测试用例锁定：native 资源 return 后只关闭一次）。这是"移动"唯一真实发生的场景，而且是编译器自动做的。
• derive moveOnly 的声明意义——它不为移动提供新语法，而是明确"此类型禁止复制"（与 derive copy/clone 互斥，第 25 章坑 5），把资源型类的身份写进类型系统，让误用 copy() 的人至少在阅读代码时得到提示。

所以"xlang 有移动语义吗"的准确回答是：有，但只在返回值的边界上自动发生；你能控制的只有"禁止复制"（moveOnly）与"显式复制"（copy/clone）两个开关。

27.9 两条危险边界

边界一：无能力复制 = 静默 fatal。对没写 derive copy/clone（或手写协议）的类调 copy()/clone()，编译期放行，运行期进程直接退出（退出码 4，零输出）。防御写法有两层：写库时——class 一定义就决定复制能力（可复制就 derive，资源型就 moveOnly），把决定留在类型旁边；用时——复制别人的类之前先翻它的声明，"这个类 derive 了什么"应该成为肌肉记忆。这也是 review 清单的好条目：搜索 copy( 与 clone( 调用点，逐一核对目标类型。

边界二：循环引用 clone = 崩溃。a.next = b、b.next = a 之后 clone(a)，进程崩溃（退出码 127，与第 25 章 json 循环序列化同病）。规避：clone 前把对象图树形化（断开回边）；必须用图结构时放弃 clone，手写"按 id 重建"的复制逻辑。这两条边界的共同教训：复制能力是把对象图当树来处理的——环与资源都不在它的合同里。

27.10 复制决策表

口诀：共享是默认，复制要开口，深浅看字段，环资源莫入。

实战：文档快照

把本章的决策串起来：一个文档系统，页面是 var dict（文档对象 + 历史数组），存档要完全独立的快照，外发要脱敏副本：

class Doc
    derive copy
    derive clone
    string title = ""
    create(string title)
        self.title = title
    end
end
var page = {"doc": Doc("v1"), "history": [Doc("h1")]}
var snap = clone(page)          // 存档：连 class 元素一起克隆
snap["doc"].title = "v2"
snap["history"][0].title = "h2"
println(page["doc"].title)          // v1：原件不动
println(page["history"][0].title)   // h1：嵌套元素也不动
println(snap["doc"].title)          // v2：快照自有一方天地

注意这个程序依赖的是 var 容器的 clone 行为（27.6：元素递归克隆）——若把 page 换成 typed 容器，快照就不会这么彻底，得手动遍历重建。选容器类型时，"未来要不要整体深复制"是一个真实的考量因素。

深入细节

⚠️ 常见错误

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

本章小结

复习题

编程练习