复制 Copy Trait ​

什么是 Copy Trait ​

Copy 是 Rust 标准库中的一个标记 trait(marker trait)。实现了 Copy 的类型在赋值、传参时不会发生所有权转移,而是自动进行按位复制——原变量和新变量各自拥有独立的一份数据,互不影响。

rust
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 ​

rust
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 的。

rust
// 所有字段都是 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 的情况 ​

rust
// 包含 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)。并且必须满足:

rust
// 规则: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 类型实现一个二维向量运算库:

rust
#[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 中所有的数据复制需求。