Copy 与 Clone 本质区别
面试题
请解释 Rust 中 Copy trait 和 Clone trait 的本质区别,什么类型可以实现 Copy,什么类型不能?
考察意图
考察候选人对 Rust 值语义和类型系统的理解。Copy 和 Clone 直接关系到所有权转移行为,是理解 Rust 内存模型的关键。面试官希望候选人能说清楚两者在语义、实现、性能和适用类型上的差异。
答题要点
Copy 与 Clone 对比
| 特性 | Copy | Clone |
|---|---|---|
| 行为 | 隐式按位复制 | 显式调用 .clone() |
| 触发方式 | 赋值、传参时自动触发 | 必须手动调用 |
| 实现方式 | 标记 trait(无方法体) | 有 clone() 方法 |
| 深浅拷贝 | 始终是按位浅拷贝 | 可以自定义(通常深拷贝) |
| 前置条件 | 所有字段必须是 Copy 的 | 所有字段必须是 Clone 的 |
| 关系 | Copy: Clone(Copy 是 Clone 的子 trait) | Clone 不要求 Copy |
| 堆分配 | 不能有堆分配 | 可以有堆分配 |
fn main() {
// === Copy 行为:隐式、自动 ===
let a: i32 = 42;
let b = a; // 按位复制,a 仍然有效
println!("a={}, b={}", a, b); // 都可以使用
// === Clone 行为:显式、手动 ===
let s1 = String::from("hello");
// let s2 = s1; // 移动!s1 无效
let s2 = s1.clone(); // 显式深拷贝,s1 仍然有效
println!("s1={}, s2={}", s1, s2);
}可以实现 Copy 的类型
// 以下类型实现了 Copy:
// - 所有整数类型:i8, i16, i32, i64, i128, isize, u8...u128, usize
// - 浮点类型:f32, f64
// - 布尔类型:bool
// - 字符类型:char
// - 不可变引用:&T
// - 元组(所有元素都是 Copy 的):(i32, f64, bool)
// - 数组(元素是 Copy 的):[i32; 5]
// - 函数指针:fn(i32) -> i32
// 自定义 Copy 类型
#[derive(Debug, Clone, Copy)] // Copy 要求同时实现 Clone
struct Point {
x: f64, // f64 是 Copy
y: f64, // f64 是 Copy
}
fn main() {
let p1 = Point { x: 1.0, y: 2.0 };
let p2 = p1; // 自动复制,p1 仍然有效
println!("p1={:?}, p2={:?}", p1, p2);
// 元组中全是 Copy 类型
let t1 = (1, 2.0, true);
let t2 = t1;
println!("t1={:?}, t2={:?}", t1, t2);
}不能实现 Copy 的类型
// 以下类型不能实现 Copy:
// - String(包含堆分配的缓冲区)
// - Vec<T>(包含堆分配的缓冲区)
// - Box<T>(堆分配的智能指针)
// - 包含上述类型字段的结构体
// - 实现了 Drop trait 的类型
// 原因:Copy 是按位复制,如果两个变量指向同一块堆内存,
// 当两者都被 drop 时会 double free
// 这个结构体不能 Copy,因为 String 不是 Copy
// #[derive(Copy, Clone)] // 编译错误
struct User {
name: String, // String 不是 Copy
age: u32, // u32 是 Copy
}
// 实现了 Drop 的类型也不能 Copy
// 因为 Copy 意味着"可以安全地按位复制"
// 而 Drop 意味着"析构时有自定义逻辑"
// 两者语义冲突
struct FileHandle {
fd: i32,
}
impl Drop for FileHandle {
fn drop(&mut self) {
println!("关闭文件描述符: {}", self.fd);
}
}
// #[derive(Copy, Clone)] // 编译错误:Drop 和 Copy 不能共存
fn main() {
let u1 = User { name: "Alice".to_string(), age: 30 };
let u2 = u1.clone(); // 只能 clone,不能 copy
// println!("{}", u1.name); // 如果没有 clone,u1 已被移走
println!("u2: {} {}", u2.name, u2.age);
}Clone 的自定义实现
#[derive(Debug)]
struct Matrix {
data: Vec<Vec<f64>>,
rows: usize,
cols: usize,
}
// 自定义 Clone 实现
impl Clone for Matrix {
fn clone(&self) -> Self {
// 深拷贝所有数据
Matrix {
data: self.data.clone(), // Vec 的 clone 是深拷贝
rows: self.rows,
cols: self.cols,
}
}
}
fn main() {
let m1 = Matrix {
data: vec![vec![1.0, 2.0], vec![3.0, 4.0]],
rows: 2,
cols: 2,
};
let m2 = m1.clone(); // 深拷贝
println!("m1: {:?}", m1);
println!("m2: {:?}", m2);
// m1 和 m2 是完全独立的副本
}常见追问
追问一:Copy 为什么要求同时实现 Clone?
因为 Copy: Clone,Copy 是 Clone 的子 trait。语义上来说,如果一个类型可以隐式复制(Copy),那它也应该可以显式复制(Clone)。对于 Copy 类型,clone() 的默认实现就是按位复制。
追问二:&mut T 为什么不是 Copy?
因为可变引用的借用规则要求同一时刻只能有一个可变借用。如果 &mut T 是 Copy 的,赋值就会自动复制出第二个可变引用,违反借用规则。不可变引用 &T 是 Copy 的,因为多个不可变引用可以共存。
追问三:clone() 的性能代价是什么?
取决于类型。Clone String 需要分配新堆内存并复制内容,Clone Vec 需要分配并复制所有元素。对于包含大量数据的类型,clone 可能很昂贵。应该尽量使用借用而非 clone。
基本示例
#[derive(Debug, Clone, Copy)]
struct Color {
r: u8,
g: u8,
b: u8,
}
#[derive(Debug, Clone)]
struct Palette {
name: String,
colors: Vec<Color>,
}
fn use_color(c: Color) {
// Color 是 Copy 的,传参时自动复制
println!("使用颜色: {:?}", c);
}
fn use_palette(p: &Palette) {
// Palette 不是 Copy 的,用借用避免移动
println!("调色板: {} ({} 种颜色)", p.name, p.colors.len());
}
fn main() {
let red = Color { r: 255, g: 0, b: 0 };
use_color(red);
use_color(red); // red 仍然有效,因为 Copy
let palette = Palette {
name: "暖色系".to_string(),
colors: vec![
Color { r: 255, g: 0, b: 0 },
Color { r: 255, g: 165, b: 0 },
],
};
use_palette(&palette); // 借用
let palette2 = palette.clone(); // 显式克隆
println!("{:?}", palette2);
}常见问题
问题一:什么时候用 derive(Copy) vs derive(Clone)?
如果所有字段都是 Copy 且类型语义上适合按位复制(小的值类型),用 derive(Copy, Clone)。如果类型包含堆分配或有自定义析构逻辑,只用 derive(Clone)。
问题二:Rc 和 Arc 的 clone 是深拷贝吗?
不是。Rc::clone() 和 Arc::clone() 只增加引用计数,不复制底层数据。这是一个 O(1) 操作。
适用场景
- Copy:小的值类型(坐标、颜色、配置标志)
- Clone:需要显式复制的复杂类型(含堆分配的结构体)
- 借用:只需要读取数据时优先使用,避免拷贝
注意事项
- Copy 和 Drop 不能同时实现
- Copy 要求所有字段都是 Copy 的
- &T 是 Copy 的,&mut T 不是
- clone() 的开销取决于数据大小
- Rc/Arc 的 clone 只增加引用计数
- 优先使用借用而非 clone
总结
Copy 是隐式的按位浅复制,赋值和传参时自动触发,适用于栈上的小值类型(整数、浮点、布尔、不可变引用等),不能有堆分配和 Drop。Clone 是显式的深拷贝,需要手动调用 .clone(),可以自定义复制行为。Copy 是 Clone 的子 trait(Copy: Clone)。不能 Copy 的类型包括 String、Vec、Box 以及实现了 Drop 的类型。&mut T 不是 Copy 的(可变借用唯一性)。应优先使用借用来避免不必要的拷贝。