SystemVerilog中浅拷贝与深拷贝的全面解析与UVM实践指南

1. 从一次“诡异”的仿真结果说起

最近在带一个新人做验证环境搭建，他负责写一个简单的记分板（scoreboard）。环境跑起来后，数据比对总是间歇性出错，有时对，有时错，毫无规律。他排查了一整天，从接口时序到数据生成，都没发现问题。最后，他把怀疑的目光投向了记分板内部用于缓存期望数据的动态数组。他信誓旦旦地跟我说：“师父，我每次收到事务（transaction）后，都把它push_back到数组里存起来了，比对的时候绝对没错！”我让他把代码发给我看，核心部分大概是这样的：

class Scoreboard; MyTransaction exp_q[$]; // 期望队列 task run(); forever begin MyTransaction tr; // 从monitor接收事务 monitor2scb.get(tr); // 将事务存入期望队列 exp_q.push_back(tr); // ... 后续比对逻辑 end endtask endclass

问题就出在exp_q.push_back(tr);这一行。在SystemVerilog（SV）中，对于类对象（class）的赋值和传递，默认是引用（reference），而不是拷贝（copy）。这意味着，push_back(tr)仅仅是把指向tr这个对象实例的“指针”（或者说句柄）存进了队列。后续如果tr这个变量被修改（比如，下一个时钟周期，monitor又收到了新数据并写入了同一个tr对象），那么队列里存的那个“指针”所指向的内容也跟着变了。这就好比你在笔记本上记下了一个储物柜的号码（引用），而不是把储物柜里的东西（对象内容）拿出来自己保管。别人用钥匙打开储物柜把东西换了，你记的号码没变，但东西已经不是你当初看到的了。

这个问题的本质，就是没有理解SV中对象的浅拷贝（Shallow Copy）和深拷贝（Deep Copy）。这是SV面向对象编程中一个非常核心且容易踩坑的概念，直接关系到数据的正确性、独立性和内存管理。无论是构建UVM验证环境，还是编写复杂的测试用例，这个概念都无处不在。今天，我们就来彻底拆解它，让你不仅知道区别，更能理解背后的原理，并在实际项目中游刃有余地应用。

2. 对象、句柄与内存：理解拷贝的底层基础

在深入浅/深拷贝之前，我们必须夯实基础：SV中类对象是如何存在和被操作的。这不同于int、bit这些内置数据类型（它们直接存储在变量位置），也不同于结构体struct（在SV中，除非声明为packed，否则struct也是引用语义）。

2.1 类对象：活在堆上的“居民”

当你声明一个类变量时，例如MyTransaction tr;，你实际上只是创建了一个句柄（handle），或者通俗地理解，一个可以为null的“遥控器”或“指针”。此时，tr是null，它不指向任何实际的对象。

MyTransaction tr; // tr是一个句柄，初始值为null

真正的对象实例，需要通过new()函数在堆（Heap）内存中创建。new()操作符会向仿真器申请一块内存，按照类的蓝图构造出对象，并返回这个对象在内存中的地址（即句柄值）。

tr = new(); // 在堆上创建对象，并将对象的地址赋给句柄tr

现在，tr这个句柄就“指向”了堆上的那个对象实体。你可以通过tr.data、tr.addr来访问和修改这个对象的成员。

2.2 赋值操作：复制的是“遥控器”还是“电视机”？

这是关键所在。当我们进行句柄赋值时，发生了什么？

MyTransaction tr1, tr2; tr1 = new(); tr1.data = 8'hAA; tr2 = tr1; // 注意！这里发生了什么？

tr2 = tr1;这条语句，复制的是句柄（地址值），而不是堆上的对象本身。执行后，tr1和tr2这两个句柄存储了相同的内存地址，它们指向同一个对象实例。这就好比你有两个遥控器（tr1,tr2），都配对到了同一台电视机（堆上的对象）。无论你用哪个遥控器换台，控制的都是同一台电视机。

tr2.data = 8'h55; // 通过tr2修改对象 $display(“tr1.data = %h”, tr1.data); // 输出：tr1.data = 55

你会发现，通过tr2修改了data，通过tr1看到的data也变了。因为它们指向同一个地方。这就是引用语义。文章开头新人的错误，正是把这种引用直接push_back到了队列里，导致队列里所有的条目都指向monitor那个不断被重用的tr对象，数据自然全乱套了。

注意：内置数据类型（如int,bit,logic）和打包结构体（packed struct）是值语义。赋值时是真正的值拷贝，会创建独立的副本。

int a = 10; int b = a; // b是a值的一个独立副本 b = 20; // 修改b，a不变 $display(a); // 输出：10

理解了引用语义，我们就可以正式探讨如何打破这种“共享”，创建对象的独立副本，也就是拷贝。

3. 浅拷贝（Shallow Copy）：创建新壳，共享内核

浅拷贝是SV中new操作符的一个内置功能。语法是：

destination_handle = new source_handle;

或者更常见的是在自定义new函数（构造函数）中调用：

function new (MyTransaction src); super.new(); // 如果有父类，先调用父类构造函数 this.copy(src); // 调用自定义的copy函数，内部通常用浅拷贝或深拷贝逻辑 endfunction

但直接使用new src就是浅拷贝。它的行为可以概括为：为新句柄分配新的内存，创建目标对象的新实例，然后递归地将其所有属性（properties）的值从源对象复制到目标对象。

这里“递归地复制所有属性的值”需要仔细理解：

• 对于内置数据类型（int,bit,string等），复制的是值本身。新对象拥有独立的int变量。
• 对于类对象句柄，复制的是句柄的值（即内存地址）。这意味着，新对象和源对象中的对应句柄，将指向同一个子对象。

让我们用一个例子来可视化这个过程：

class Packet; int id; int data_q[$]; // 动态数组，注意它是内置类型 endclass class Transaction; int addr; Packet pkt; // 类句柄成员 endclass // 创建源对象并初始化 Transaction src = new(); src.addr = 32'h1000; src.pkt = new(); src.pkt.id = 1; src.pkt.data_q = {10, 20, 30}; // 执行浅拷贝 Transaction dst = new src;

此时的内存模型如下图所示（概念示意）：

源对象 src (在堆上) 浅拷贝生成的目标对象 dst (在堆上) +------------------+ +------------------+ | addr: 0x1000 | | addr: 0x1000 | // 值拷贝，独立 +------------------+ +------------------+ | pkt: -------+---------------->| pkt: -------+ +------------------+ +------------------+ | 指向同一个Packet对象 | v +------------------+ | Packet对象 | | id: 1 | | data_q: {10,20,30}| // 动态数组，值独立！ +------------------+

关键点分析：

1. dst是一个全新的Transaction对象，拥有独立的内存空间。
2. dst.addr直接从src.addr复制了值（32‘h1000），两者独立。
3. dst.pkt句柄被复制了。它和src.pkt指向同一个Packet对象。这就是“浅”的含义——只拷贝了一层，对于嵌套的对象，只拷贝了引用。
4. 一个重要的特例：Packet里的data_q。data_q是一个动态数组（int队列）。在SV中，动态数组是内置类型，虽然它在堆上管理存储空间，但赋值操作（包括浅拷贝中的成员赋值）默认是值拷贝。所以，dst.pkt.data_q会是src.pkt.data_q的一个独立副本。修改其中一个队列，不会影响另一个。这有时会造成迷惑，让人误以为浅拷贝对动态数组也是“引用”，其实不然。

让我们验证一下：

// 修改dst的addr，不影响src dst.addr = 32'h2000; $display(“src.addr = %h, dst.addr = %h”, src.addr, dst.addr); // src=1000, dst=2000 // 通过dst修改共享的Packet对象 dst.pkt.id = 99; $display(“src.pkt.id = %0d, dst.pkt.id = %0d”, src.pkt.id, dst.pkt.id); // 都是99！因为指向同一个对象 // 修改dst的data_q（独立副本） dst.pkt.data_q.push_front(999); $display(“src.pkt.data_q = %p”, src.pkt.data_q); // {10, 20, 30} $display(“dst.pkt.data_q = %p”, dst.pkt.data_q); // {999, 10, 20, 30} // 独立！

浅拷贝的适用场景与陷阱：

• 适用：当你的类结构简单，没有嵌套的类对象成员，或者你故意希望共享某些子对象时（例如，共享一个配置类对象）。
• 陷阱：最常见的坑就是无意中共享了嵌套对象。比如一个Transaction里有一个DataPacket句柄，浅拷贝后，两个Transaction操作的是同一个DataPacket，极易导致数据污染。这也是UVM中uvm_object的copy()方法默认是浅拷贝，但强烈建议重写为深拷贝的原因。

4. 深拷贝（Deep Copy）：彻底的“克隆”

深拷贝的目标是创建一个完全独立的对象副本，包括它所有嵌套的子对象，以及子对象嵌套的子对象，一直递归到最底层的基本数据类型。在SV中，没有内置的深拷贝操作符。你必须自己实现。

实现深拷贝通常有两种方式：

1. 自定义copy()或clone()方法：这是最标准、最推荐的做法，尤其是在UVM框架中。
2. 重载new构造函数：在构造函数中接收源对象并完成深度复制。

我们重点看第一种。通常我们会定义一个copy(MyClass src)函数，或者像UVM那样定义一个do_copy(uvm_object rhs)虚函数。

4.1 实现一个深拷贝函数

接上面的Transaction和Packet例子，我们来实现深拷贝。

class Packet; int id; int data_q[$]; // Packet类的深拷贝函数 function Packet copy(); Packet p = new(); p.id = this.id; // 拷贝基本类型 p.data_q = this.data_q; // 动态数组赋值是值拷贝，自动创建独立副本 return p; endfunction endclass class Transaction; int addr; Packet pkt; // Transaction类的深拷贝函数 function Transaction copy(); Transaction t = new(); t.addr = this.addr; // 拷贝基本类型 if (this.pkt != null) begin t.pkt = this.pkt.copy(); // 关键！调用子对象的copy()，创建新的Packet对象 end else begin t.pkt = null; end return t; endfunction endclass

现在，当我们调用dst = src.copy();时，内存模型如下：

源对象 src 深拷贝生成的目标对象 dst +------------------+ +------------------+ | addr: 0x1000 | | addr: 0x1000 | +------------------+ +------------------+ | pkt: ---------+ | pkt: ---------+ +------------------+ +------------------+ | | | | v v | +------------------+ +------------------+ | | Packet对象 A | | Packet对象 B | | // 全新的对象！ | id: 1 | | id: 1 | | | data_q: {10,20,30}| | data_q: {10,20,30}| | // 动态数组也是独立副本 +------------------+ +------------------+ |

关键点分析：

1. dst是一个全新的Transaction对象。
2. dst.addr复制了值。
3. dst.pkt指向了一个全新的Packet对象（对象B），它是通过调用src.pkt.copy()创建的。这个新的Packet对象B拥有独立的内存，其id和data_q都是对象A对应值的副本。
4. 此时，修改dst.pkt.id只会影响对象B，完全不影响源对象src及其子对象A。

Transaction src = new(); src.addr = 32‘h1000; src.pkt = new(); src.pkt.id = 1; Transaction dst; dst = src.copy(); // 深拷贝！ dst.addr = 32’h2000; dst.pkt.id = 99; $display(“src.addr=%h, src.pkt.id=%0d”, src.addr, src.pkt.id); // 1000, 1 $display(“dst.addr=%h, dst.pkt.id=%0d”, dst.addr, dst.pkt.id); // 2000, 99

完美隔离！这才是我们通常想要的“复制”效果。

4.2 处理更复杂的嵌套和循环引用

现实中的类可能更复杂，包含关联数组、对象数组、甚至循环引用（A中有B的句柄，B中又有A的句柄）。实现一个健壮的深拷贝需要仔细处理这些情况。

• 对象数组/队列：需要遍历数组，对每个元素调用其copy()方法。

  class ComplexObj; Packet pkt_list[$]; function ComplexObj copy(); ComplexObj c = new(); foreach (this.pkt_list[i]) begin c.pkt_list.push_back(this.pkt_list[i].copy()); end // ... 拷贝其他成员 return c; endfunction endclass

• 关联数组：同样需要遍历并复制值。如果值是对象，则需要深拷贝。

  int obj_map [string]; // 对于int等基本类型，直接赋值即可（值拷贝） copy_obj_map = this.obj_map; // 如果值是对象句柄 MyClass obj_map [string]; foreach (this.obj_map[key]) begin copy_obj_map[key] = this.obj_map[key].copy(); end

• 循环引用：这是深拷贝的难点。简单的递归copy()会导致无限循环。通常的解决方案是使用“映射表”（例如uvm_coreservice_t中的全局表或自定义的static关联数组），记录已经拷贝过的原始对象到新对象的映射。当再次遇到同一个原始对象时，直接返回映射表中对应的新对象句柄，而不是再次拷贝。UVM的copy()方法在底层通过uvm_coreservice_t在一定程度上处理了这个问题，但对于特别复杂的自定义结构，仍需注意。

5. UVM中的拷贝实践：copy()、clone()与do_copy()

在UVM验证方法学中，所有继承自uvm_object的类（如uvm_sequence_item,uvm_transaction）都自带拷贝机制。理解并正确使用它是构建可重用验证环境的关键。

5.1copy()与clone()的区别

• copy(dst_rhs)：这是一个虚函数，用于将当前对象（this）的内容复制到一个已存在的目标对象中。目标对象必须已经通过new创建。

  MyTransaction src = new(“src”); MyTransaction dst = new(“dst”); src.copy(dst); // 将src的内容拷贝到已存在的dst中

  它的内部流程是：检查类型兼容性 -> 调用do_copy(rhs)-> 调用子类重载的do_copy执行实际拷贝。

• clone()：这是一个函数，它会创建一个新的对象，并将当前对象的内容拷贝到这个新对象中，最后返回这个新对象的句柄。你不需要预先创建目标对象。

  MyTransaction src = new(“src”); MyTransaction dst; dst = src.clone(); // dst被赋值了一个全新的、内容与src相同的对象 $cast(dst, src.clone()); // 更安全的做法，因为clone()返回uvm_object句柄

  clone()的内部实现大致是：obj = create(...); obj.copy(this); return obj;。它结合了create和copy。

实操心得：在UVM验证中，clone()用得更频繁，特别是在monitor将事务传递给scoreboard或reference model时。为了确保数据的独立性，必须克隆事务，而不是传递引用。文章开头的那个bug，正确的修复方法就是：

monitor2scb.get(tr); exp_q.push_back(tr.clone()); // 关键！克隆一个副本存起来

5.2 如何重写do_copy()：实现深拷贝

UVM将拷贝的实际工作交给了do_copy(uvm_object rhs)虚函数。当你需要自定义拷贝行为（尤其是实现深拷贝）时，必须重写这个函数。

步骤：

1. 首先调用super.do_copy(rhs);以确保父类的属性被正确拷贝。
2. 将参数rhs通过$cast转换为你的具体类型。
3. 逐一拷贝你的类中定义的成员变量。对于基本类型和动态数组，直接赋值。对于嵌套的uvm_object，调用其copy()或clone()方法。

class MyTransaction extends uvm_sequence_item; `uvm_object_utils(MyTransaction) int addr; int data; Packet pkt; // 自定义子对象 int dyn_arr[$]; function new(string name = “MyTransaction”); super.new(name); endfunction // 重写do_copy实现深拷贝 virtual function void do_copy(uvm_object rhs); MyTransaction rhs_; super.do_copy(rhs); // 拷贝父类属性 if (!$cast(rhs_, rhs)) begin `uvm_error(“DO_COPY”, “Cast failed”) return; end // 拷贝基本类型 this.addr = rhs_.addr; this.data = rhs_.data; // 拷贝动态数组（值拷贝） this.dyn_arr = rhs_.dyn_arr; // 深拷贝嵌套对象 if (rhs_.pkt != null) begin // 方法1: 如果目标pkt已存在，用copy if (this.pkt == null) this.pkt = new(); rhs_.pkt.copy(this.pkt); // 方法2: 更简洁，直接用clone创建新对象 // this.pkt = rhs_.pkt.clone(); end else begin this.pkt = null; end endfunction endclass

注意事项：在do_copy中，this是目标对象，rhs_是源对象。方向是rhs_ -> this。务必不要搞反。UVM的copy(dst)函数内部调用dst.do_copy(this)，所以do_copy中的rhs参数实际上是源对象。

5.3 `uvm_field_* 宏与自动拷贝

UVM提供了uvm_field_*系列宏（如uvm_field_int,uvm_field_object）在uvm_object_utils_begin/end块中注册成员，这些宏会自动实现copy、compare、print等操作。

`uvm_object_utils_begin(MyTransaction) `uvm_field_int(addr, UVM_ALL_ON) `uvm_field_int(data, UVM_ALL_ON) `uvm_field_object(pkt, UVM_ALL_ON) // 对于对象，默认是浅拷贝！ `uvm_field_queue_int(dyn_arr, UVM_ALL_ON) `uvm_object_utils_end

重要警告：uvm_field_object宏默认实现的是浅拷贝！这意味着如果你用宏注册了对象成员，调用自动生成的copy()时，嵌套的对象不会被深拷贝。这常常是另一个隐蔽的Bug来源。

最佳实践建议：

1. 对于需要深拷贝的嵌套对象，不要使用uvm_field_object宏注册它。
2. 手动重写do_copy()函数来实现深拷贝逻辑，如上节所示。
3. 或者，如果你坚持使用宏，并且希望深拷贝，需要设置宏的标记（flag）。uvm_field_object有一个UVM_DEEP标志，但它的行为可能不符合所有深拷贝场景（特别是循环引用），且文档不清晰，不推荐依赖。
4. 最稳妥、最可控的方式就是手动实现do_copy。

6. 实战场景与避坑指南

理解了原理，我们来看看在哪些具体场景下必须谨慎处理拷贝问题，以及如何避开常见的坑。

6.1 场景一：Monitor到Scoreboard的数据传递

这是最经典的场景，也是开篇案例的所在。Monitor捕获到总线事务，需要送给Scoreboard做比对。

错误做法（传递引用）：

// 在Scoreboard的run_phase中 forever begin MyTransaction tr; mon_aport.get(tr); // 从analysis port获取 exp_fifo.push(tr); // 直接存入FIFO end

问题：tr是monitor内部的一个对象，每次get拿到的是它的引用。monitor在下一个周期会重用这个对象（填充新数据），导致exp_fifo里存的所有“旧事务”实际上都变成了最新的数据。

正确做法（深拷贝/克隆）：

forever begin MyTransaction tr, tr_clone; mon_aport.get(tr); $cast(tr_clone, tr.clone()); // 克隆一个独立副本 exp_fifo.push(tr_clone); // 存入副本 end

或者，如果事务类正确实现了do_copy，也可以：

forever begin MyTransaction tr; MyTransaction tr_copy = new(); mon_aport.get(tr); tr.copy(tr_copy); // 拷贝到新创建的对象中 exp_fifo.push(tr_copy); end

6.2 场景二：Sequence Item的随机化与发送

在Sequence中生成并随机化事务，然后发送给Driver。

task body(); MyTransaction tr = new(“tr”); repeat(10) begin assert(tr.randomize()); // 随机化 `uvm_send(tr) // 发送给driver end endtask

这里有问题吗？uvm_send或start_item/finish_item机制内部，UVM Sequencer会负责在将事务交给Driver之前，调用clone()方法创建副本。所以，即使你在循环中重用同一个tr对象，Driver收到的是克隆体，因此是安全的。但是，这依赖于UVM框架的行为。如果你在自己的通信机制中（比如直接通过mailbox传递），就必须自己处理克隆。

6.3 场景三：配置对象（uvm_object）的共享与隔离

配置对象（如env_cfg）通常在整个环境中共享。但有时，某个组件（如某个agent）需要基于全局配置进行一些本地修改，而不希望影响其他组件。

错误做法（直接赋值）：

class MyAgent extends uvm_agent; MyConfig global_cfg; MyConfig local_cfg; function void build_phase(uvm_phase phase); super.build_phase(phase); // 获取全局配置 if (!uvm_config_db#(MyConfig)::get(this, “”, “cfg”, global_cfg)) ... // 想基于全局配置做一些本地调整 local_cfg = global_cfg; // 危险！这只是句柄拷贝 local_cfg.some_setting = SPECIAL_VALUE; // 这会修改全局配置！ endfunction endclass

正确做法（深拷贝配置）：

function void build_phase(uvm_phase phase); super.build_phase(phase); if (!uvm_config_db#(MyConfig)::get(this, “”, “cfg”, global_cfg)) ... // 创建本地配置副本 local_cfg = MyConfig::type_id::create(“local_cfg”); global_cfg.copy(local_cfg); // 将全局配置拷贝到本地副本 // 现在可以安全修改本地副本了 local_cfg.some_setting = SPECIAL_VALUE; endfunction

6.4 常见陷阱总结

1. 误以为new操作是深拷贝：new src是浅拷贝，这是很多错误的根源。
2. 忘记拷贝动态数组/队列中的对象：如果你的动态数组里存的是对象句柄，arr = src_arr只会复制句柄数组，数组内的对象仍然是共享的。需要遍历数组进行深拷贝。
3. 在do_copy中忘记调用super.do_copy(rhs)：导致父类的属性没有被拷贝。
4. uvm_field_object宏的浅拷贝陷阱：如前所述，这是UVM新手常踩的大坑。
5. 循环引用导致栈溢出：在实现自定义深拷贝时，如果对象图中有环（A引用B，B引用A），递归拷贝会无限循环。必须引入“已拷贝对象映射表”来检测环。
6. 拷贝性能：深拷贝涉及递归创建对象和复制数据，对于大型、复杂的对象树（比如一个包含大量数据包的链表），频繁深拷贝可能有性能开销。在设计数据结构时需权衡。有时，使用“不可变对象”（immutable object）模式，一旦创建就不修改，只传递引用，是更好的选择。

7. 数据类型转换与拷贝的微妙关系

搜索热词中提到了“sv中的数据类型转换”，这与拷贝也有关联。$cast是SV中用于类型安全转换的操作，它经常与拷贝/克隆配合使用。

当clone()一个父类句柄时，返回的是uvm_object基类句柄。为了将其赋值给子类句柄，必须使用$cast进行动态类型检查。

uvm_object obj_h; MyTransaction src = new(), dst; src.addr = 100; obj_h = src.clone(); // clone()返回uvm_object句柄 // dst = obj_h; // 直接赋值编译会报错，类型不兼容 if (!$cast(dst, obj_h)) begin // 必须使用$cast `uvm_error(“CAST”, “Type cast failed”) end

$cast在这里执行了两个动作：1) 检查obj_h指向的对象是否与MyTransaction类型兼容（即是否是MyTransaction或其子类）；2) 如果兼容，将句柄赋值给dst。$cast本身不执行任何拷贝操作，它只是安全地转换了句柄的类型。

另一个相关的概念是“打包（packing）”与“解包（unpacking）”，即将对象序列化为比特流（pack）或从比特流恢复为对象（unpack）。这个过程本质上也是一种深“拷贝”（通过中间格式），常用于将事务通过物理接口发送出去，或者存储到文件。UVM的uvm_field_*宏也支持pack/unpack操作。

8. 仿真调度与对象操作的时序

“sv仿真调度”虽然不直接等同于拷贝，但理解调度区域对理解对象在何时被修改、何时被拷贝至关重要。SV的仿真区域（Preponed, Active, Inactive, NBA, Observed, Reactive, Postponed）决定了赋值语句的效果何时可见。

考虑一个多线程操作同一对象的场景：

class Shared; int val; endclass Shared s = new(); initial begin s.val = 10; end initial begin #1; Shared s_copy = new s; // 浅拷贝 s.val = 20; #0; // 进入NBA区域 $display(s_copy.val); // 输出多少？ end

由于#1延迟，第一个initial块在new s之前就已经执行完毕，s.val=10。浅拷贝s_copy获得了s在时刻1的状态。然后s.val被改为20。这个修改发生在Active区域，而$display在下一个仿真时间片（time slot）的Active区域（因为#0会重新调度到当前时间片的末尾）。所以，s_copy.val显示的是拷贝时的值10。但如果拷贝和修改发生在同一个仿真区域，且没有时序控制，结果就可能不同。

核心要点：在多线程环境中，如果你希望某个时刻的对象状态快照，并且后续修改不影响这个快照，那么在那个时刻进行深拷贝是必要的。同时，要注意拷贝操作本身发生的仿真区域，它决定了你捕获到的是哪个“瞬间”的状态。

理解浅拷贝与深拷贝，是掌握SystemVerilog面向对象编程和构建健壮UVM验证环境的基石。它关乎数据的生命线——独立性与正确性。下次当你需要在组件间传递事务、复制配置或者保存状态时，先停下来想一想：我需要的是另一个“遥控器”，还是另一台独立的“电视机”？想清楚这个问题，就能避开大多数因拷贝不当引发的诡异Bug。在实践中，对于需要独立性的数据，默认使用深拷贝（通过clone()或正确实现的copy()）是一个更安全的选择，虽然会牺牲一点性能，但换来的是代码的清晰和数据的可靠。