复制 Copy Trait
什么是 Copy Trait
Copy 是 Rust 标准库中的一个标记 trait(marker trait)。实现了 Copy 的类型在赋值、传参时不会发生所有权转移,而是自动进行按位复制——原变量和新变量各自拥有独立的一份数据,互不影响。
fn main() {
// i32 实现了 Copy
let x = 42;
let y = x; // 按位复制,不是移动
println!("x = {}, y = {}", x, y); // 两个都有效
// String 没有实现 Copy
let s1 = String::from("hello");
let s2 = s1; // 移动,不是复制
// println!("{}", s1); // 编译错误
println!("{}", s2);
}哪些类型实现了 Copy
fn main() {
// 所有整数类型
let a: i8 = 1;
let b = a;
println!("i8: a={}, b={}", a, b);
let c: u64 = 100;
let d = c;
println!("u64: c={}, d={}", c, d);
// 所有浮点类型
let e: f64 = 3.14;
let f = e;
println!("f64: e={}, f={}", e, f);
// bool
let g = true;
let h = g;
println!("bool: g={}, h={}", g, h);
// char
let i = 'R';
let j = i;
println!("char: i={}, j={}", i, j);
// 元组:当所有元素都是 Copy 时
let t1 = (1, 2.0, true);
let t2 = t1;
println!("tuple: t1={:?}, t2={:?}", t1, t2);
// 固定大小数组:当元素是 Copy 时
let arr1 = [1, 2, 3];
let arr2 = arr1;
println!("array: arr1={:?}, arr2={:?}", arr1, arr2);
// 引用也是 Copy 的(引用本身被复制,被引用的数据不受影响)
let s = String::from("hello");
let r1 = &s;
let r2 = r1; // 引用被复制
println!("refs: r1={}, r2={}", r1, r2);
}| 类型 | 是否 Copy | 原因 |
|---|---|---|
i8, i16, i32, i64, i128 | 是 | 栈上固定大小 |
u8, u16, u32, u64, u128 | 是 | 栈上固定大小 |
f32, f64 | 是 | 栈上固定大小 |
bool | 是 | 1 字节 |
char | 是 | 4 字节 |
isize, usize | 是 | 平台指针大小 |
&T(不可变引用) | 是 | 指针大小 |
fn 指针 | 是 | 指针大小 |
(T1, T2) 元组 | 当所有元素 Copy 时 | 取决于元素 |
[T; N] 数组 | 当元素 Copy 时 | 取决于元素 |
String | 否 | 拥有堆数据 |
Vec<T> | 否 | 拥有堆数据 |
Box<T> | 否 | 拥有堆数据 |
&mut T | 否 | 可变引用不能复制 |
为自定义类型实现 Copy
自定义类型可以通过 #[derive(Copy, Clone)] 来实现 Copy,但有一个硬性条件:所有字段都必须是 Copy 的。
// 所有字段都是 Copy 类型,可以 derive Copy
#[derive(Debug, Copy, Clone)]
struct Point {
x: f64,
y: f64,
}
#[derive(Debug, Copy, Clone)]
struct Color {
r: u8,
g: u8,
b: u8,
}
// 包含 Copy 字段的枚举也可以 Copy
#[derive(Debug, Copy, Clone)]
enum Direction {
North,
South,
East,
West,
}
fn main() {
let p1 = Point { x: 1.0, y: 2.0 };
let p2 = p1; // 复制,p1 仍然有效
println!("p1={:?}, p2={:?}", p1, p2);
let c1 = Color { r: 255, g: 128, b: 0 };
let c2 = c1; // 复制
println!("c1={:?}, c2={:?}", c1, c2);
let d1 = Direction::North;
let d2 = d1; // 复制
println!("d1={:?}, d2={:?}", d1, d2);
}不能实现 Copy 的情况
// 包含 String 字段 —— String 不是 Copy 的
// #[derive(Copy, Clone)] // 编译错误
#[derive(Debug, Clone)]
struct User {
name: String, // String 不是 Copy
age: u32, // u32 是 Copy
}
// 包含 Vec 字段
// #[derive(Copy, Clone)] // 编译错误
#[derive(Debug, Clone)]
struct DataSet {
values: Vec<f64>, // Vec 不是 Copy
}
fn main() {
let u1 = User { name: String::from("张三"), age: 28 };
// let u2 = u1; // 移动,u1 失效
let u2 = u1.clone(); // 需要显式克隆
println!("u1={:?}", u1); // clone 后 u1 仍然有效
println!("u2={:?}", u2);
}Copy 的限制条件
实现 Copy 必须同时实现 Clone(Copy 是 Clone 的子 trait)。并且必须满足:
// 规则:Copy 要求所有字段都是 Copy 的
// 可以 Copy
#[derive(Debug, Copy, Clone)]
struct Rectangle {
width: f64, // Copy
height: f64, // Copy
}
// 可以 Copy(枚举的所有变体的关联数据都是 Copy)
#[derive(Debug, Copy, Clone)]
enum Shape {
Circle(f64), // f64 是 Copy
Rect(f64, f64), // 都是 Copy
Point, // 无数据
}
// 不能 Copy(即使只有一个字段不是 Copy)
#[derive(Debug, Clone)]
struct NamedRect {
name: String, // String 不是 Copy —— 整个结构体不能 Copy
width: f64,
height: f64,
}
fn main() {
let r1 = Rectangle { width: 10.0, height: 5.0 };
let r2 = r1; // 复制
println!("r1={:?}, r2={:?}", r1, r2);
let s1 = Shape::Circle(3.0);
let s2 = s1; // 复制
println!("s1={:?}, s2={:?}", s1, s2);
}基本示例
用 Copy 类型实现一个二维向量运算库:
#[derive(Debug, Copy, Clone, PartialEq)]
struct Vec2 {
x: f64,
y: f64,
}
impl Vec2 {
fn new(x: f64, y: f64) -> Self {
Vec2 { x, y }
}
fn zero() -> Self {
Vec2 { x: 0.0, y: 0.0 }
}
// 因为 Vec2 是 Copy 的,方法可以按值接收 self 而不影响调用者
fn length(self) -> f64 {
(self.x * self.x + self.y * self.y).sqrt()
}
fn add(self, other: Vec2) -> Vec2 {
Vec2 {
x: self.x + other.x,
y: self.y + other.y,
}
}
fn scale(self, factor: f64) -> Vec2 {
Vec2 {
x: self.x * factor,
y: self.y * factor,
}
}
fn dot(self, other: Vec2) -> f64 {
self.x * other.x + self.y * other.y
}
fn normalize(self) -> Vec2 {
let len = self.length();
if len == 0.0 {
Vec2::zero()
} else {
self.scale(1.0 / len)
}
}
}
impl std::fmt::Display for Vec2 {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "({:.2}, {:.2})", self.x, self.y)
}
}
fn main() {
let a = Vec2::new(3.0, 4.0);
let b = Vec2::new(1.0, 2.0);
// 因为 Vec2 是 Copy 的,a 和 b 在每次操作后仍然可用
println!("a = {}", a);
println!("b = {}", b);
println!("a + b = {}", a.add(b));
println!("|a| = {:.2}", a.length());
println!("a · b = {:.2}", a.dot(b));
println!("a * 2 = {}", a.scale(2.0));
println!("normalize(a) = {}", a.normalize());
// a 和 b 仍然可用(Copy 语义)
println!("a 仍然是 {}", a);
println!("b 仍然是 {}", b);
}常见问题
问题一:Copy 和 Clone 有什么关系?
Copy 是 Clone 的子 trait——实现 Copy 必须同时实现 Clone。但 Clone 不要求 Copy。Copy 是隐式自动触发的(赋值时),Clone 需要显式调用 .clone()。
问题二:什么时候应该给自定义类型实现 Copy?
当类型满足以下条件时考虑实现 Copy:所有字段都是 Copy 类型、类型很小(通常不超过几十字节)、按位复制语义合理(复制后两份数据独立且等价)。
问题三:为什么 &mut T 不是 Copy 的?
如果可变引用能 Copy,就会出现同一时间有多个可变引用指向同一数据的情况,违反了 Rust 的借用规则(同时只能有一个可变引用)。
问题四:实现了 Copy 之后可以取消吗?
技术上可以移除 #[derive(Copy)],但这是一个破坏性变更——所有依赖 Copy 语义的代码都会编译失败。发布的库不应该随意移除 Copy 实现。
适用场景
- 小型值类型:坐标点、颜色、尺寸等小型数据
- 数字类型包装:对基本数字类型的封装
- 无数据枚举:状态标记、方向等枚举
- 配置选项:只包含基本类型的小型配置
注意事项
Copy类型赋值时自动复制,原变量不失效- 实现
Copy的前提是所有字段都是Copy的 Copy必须和Clone一起实现String、Vec、Box等拥有堆数据的类型不能实现Copy&T是 Copy 的,&mut T不是 Copy 的- 大型结构体不应该实现
Copy(复制开销大) - 已发布的库不要轻易移除
Copy实现
总结
Copy trait 让类型在赋值和传参时自动按位复制而不是移动,原变量保持有效。所有基本类型(整数、浮点数、布尔、字符)和不可变引用都实现了 Copy。自定义类型通过 #[derive(Copy, Clone)] 实现 Copy,前提是所有字段都是 Copy 的。Copy 适合小型、纯栈数据的值类型,拥有堆数据的类型(String、Vec 等)不能也不应该实现 Copy。Copy 是隐式触发的便捷语义,Clone 是显式调用的深拷贝操作,两者配合使用覆盖了 Rust 中所有的数据复制需求。