appendix/derive

[giscus[bot]]

appendix/derive

https://course.rs/appendix/derive.html

[Trevorngc]

derive is attribute

[fjchen7]

我看文档，说Clone是Copy的父trait，而Copy里面是没有方法的。

然后这里又说，实现Copy时，只要让Clone的方法clone(&self)返回*self就可以。

这里有点困惑：

1. 如果自己实现Clone特征，会对Copy的行为造成什么影响吗？
2. 可以自己实现Copy特征吗？我在文档里看到，Copy是没法自己实现的，只能用默认行为。

[small-white0-0]

1. 自己实现Clone,不会对Copy产生影响。

#[derive(Debug)]
struct O {
    a: i32,
}

impl Copy for O {}
impl Clone for O {
    fn clone(&self) -> Self {
        Self { a: 123 }
    }
}

fn main() {
    let b = O { a: 1 };
    let c = b;
    let d = b.clone();
    println!("b:{b:?},c:{c:?},d:{d:?}");
}

显示b:O { a: 1 },c:O { a: 1 },d:O { a: 123 }

2. 可以，但没必有。因为Copy只是一个标记trait,使用宏和手动实现，结果都是一样的。只是手动要写的更多。

// 使用宏
#[derive(Clone,Copy)]
struct O {
    a: i32,
}

// 手动
struct O {
    a: i32,
}

impl Copy for O {
    // 什么也不用写，毕竟是一个标记trait
}
impl Clone for O {
    fn clone(&self) -> Self {
        // * self 还是 Self {..} 或者其他的实现方式。
        // 随便，不会对Copy行为产生影响，但是必须实现Clone,才能实现Copy。
    }
}

个人的进一步理解

move：
所有权转移，其实就是在赋值的时候，将原本的变量状态标记为失去所有权，这个变量在栈上面依旧存在，直到离开作用域，才会从栈上删除变量。（以前看过的一篇文章讲rust和类型状态，里面是这么解释的）

let a = Box::new(1);
let b = a;

这里通过rust-gdb可以发现，a和b的地址不一样，说明a和b是两个变量。rust做的只是在执行let b = a;后将a的状态变为失去所有权的状态。
let b = a; 我把他理解为两步：

1. 把a的值赋值给b（仅限栈里面的数据，可类比c的赋值）
2. 改变a的状态，改为失去所有权的状态。

Copy:
这个只是一个标记 trait ,看copy的模块路径就可以看到“core::marker::Copy”，它只是一个给编译器看的标记，没有其他任何作用。 它告诉编译器，这个类型的数据只会在栈，不可能在堆，让编译器不要执行 move 中的第二步。

PS： 如何保证会在栈？rust 本身只给基本类型实现了 Copy。Copy又要求实现该trait 的结构体内部元素需要实现Copy。所以能实现了Copy的结构体，里面就只有基本类型或者只基本类型的复杂类型，那么这个结构体就不会在堆上面存在数据。

#[derive(Debug, Clone, Copy)]
struct O {
    a: i32,
    b: Box<i32>,
}
// 这个就会报错，说Box没有实现Copy,
// 然后由于孤儿规则，我们不能去为Box实现Copy
// newtype也由于 Copy 要求结构体属性的类型也实现Copy,而无法为Box实现Copy

Clone：
就是返回一个新变量，不导致原变量会失去所有权。对于实现了Copy trait 的结构体为何返回*self就可以了。因为

let a = b.clone(); // b.clone()就是直接返回的*self
//上面的等价于下面的
let a = b;   //因为实现了`Copy`所以不会有所有权转移。

至于为何要实现了Clone，才能实现Copy。我不太清楚原因，可能是能Copy的变量不能Clone会很奇怪？

个人理解，没有详细的查rust的源码和文档，可能有理解错的地方,请斧正。

[zy010101]

Differs from Copy in that Copy is implicit and an inexpensive bit-wise copy, while Clone is always explicit and may or may not be expensive. In order to enforce these characteristics, Rust does not allow you to reimplement Copy, but you may reimplement Clone and run arbitrary code.

Since Clone is more general than Copy, you can automatically make anything Copy be Clone as well.

与 Copy 不同，Copy 是隐式的且成本低廉的位拷贝，而 Clone 总是显式的，并且可能是昂贵的。为了确保这些特性，Rust 不允许重新实现 Copy，但你可以重新实现 Clone 并运行任意代码。

由于 Clone 比 Copy 更通用，你可以自动将任何“copy”设置为“clone”。

[tjw123hh]

翻译：
Copy 的不同之处在于它是隐式的且一定成本低廉的逐位拷贝（bit-wise copy），而 Clone 总是显式的，成本可能昂贵也可能不昂贵。为了确保这些特性，Rust 不允许重新实现 Copy，但你可以重新实现 Clone 来运行任意代码。

由于 Clone 比 Copy 更加通用，你也可以把所有能 Copy 的东西 Clone。

[lfod1997]

官方文档用辞很准确了：

• Clone：“A common trait for the ability to explicitly duplicate an object.”
• Copy：“Types whose values can be duplicated simply by copying bits.”

Rust 的 Copy 类似 C++ 的 std::is_trivially_copyable，表示标准拷贝过程没有副作用，可以通过简单的内存拷贝完成（拷贝是廉价的）；Rust 的 Clone 类似 C++ 的 std::is_copy_constructible，只表示我们对该类型定义了标准拷贝行为（拷贝是可能的）。

那通过字面上的逻辑关系，我们很容易发现 Clone 的约束力比 Copy 弱，因此实现了 Copy 的类型必定实现了 Clone。

个人理解。

[jockchou]

Copy只是一个标识，从概念上区分罢了。你可以理解为Copy只是Clone的一个特例，Clone是超集。一个只需clone方法返回*self的特例，不需要有堆内存分配等实现。

就像Eq和PartialEq这两个Trait一样的设计思想，Eq继承自PartialEq，Eq标识比较关系还具备自反性，而PartialEq只具备传递性和对称性。

[pejaz]

Clone 和 Copy 那里，实现 Copy 就必须实现 Clone 了。这里怎么还说 实际上 Copy 特征并不阻止你在实现时使用了深拷贝，只是，我们不应该这么做，毕竟遵循一个语言的惯例是很重要的。当用户看到 Copy 时，潜意识就应该知道这是浅拷贝，复制一个值会非常快。 难道实现 Clone 特征过程中还能避免使用深拷贝吗? 我理解其实所有的拷贝其实都是深拷贝，区别只是实现 Copy 特征的（如 i32）发生于栈上的拷贝。以及实现了 Clone 特征的(如 String)发生于堆上数据(实际 value)和栈上的(String 指针) 同时拷贝。