Trait std::clone::Clone1.0.0[−][src]

pub trait Clone {
    #[must_use = "cloning is often expensive and is not expected to have side effects"]
    fn clone(&self) -> Self;

    fn clone_from(&mut self, source: &Self) { ... }
}
Expand description

通用的 trait，用于显式复制对象。

与 Copy 的不同之处在于 Copy 是隐式的并且是廉价的按位复制，而 Clone 始终是显式的并且可能昂贵也可能不昂贵。 为了强制执行这些特性，Rust 不允许您重新实现 Copy，但是您可以重新实现 Clone 并运行任意代码。

由于 Clone 比 Copy 更通用，因此您可以自动将 Copy 设为 Clone。

Derivable

如果所有字段均为 Clone，则此 trait 可以与 #[derive] 一起使用。Clone 的 derived 实现在每个字段上调用 clone。

对于泛型结构体，#[derive] 通过在泛型参数上添加绑定的 Clone 有条件地实现 Clone。

// `derive` T 为 Clone 时，为 Reading<T> 实现 Clone。
#[derive(Clone)]
struct Reading<T> {
    frequency: T,
}
Run

如何实现 Clone?

Copy 类型应该实现 Clone 的简单实现。更正式地: 如果 T: Copy，x: T 和 y: &T，则 let x = y.clone(); 等效于 let x = *y;。 手动执行时应注意保持不变。但是，不安全的代码一定不能依靠它来确保内存安全。

一个示例是持有函数指针的泛型结构体。在这种情况下，不能对 Clone 的实现进行派生操作，而可以将其实现为:

struct Generate<T>(fn() -> T);

impl<T> Copy for Generate<T> {}

impl<T> Clone for Generate<T> {
    fn clone(&self) -> Self {
        *self
    }
}
Run

其他实现者

除了下面列出的 实现者 外，以下类型还实现了 Clone:

  • 函数项类型 (即，为每个函数定义的不同类型)
  • 函数指针类型 (例如 fn() -> i32)
  • 如果项类型也实现 Clone (例如 [i32; 123456])，则所有大小的数组类型
  • 如果每个组件还实现 Clone (例如 ()，(i32, bool))，则为元组类型
  • 闭包类型，如果它们没有从环境中捕获任何值，或者所有此类捕获的值本身都实现了 Clone。 请注意，由共享引用捕获的变量始终实现 Clone (即使引用对象没有实现)，而由变量引用捕获的变量从不实现 Clone。

Required methods

返回值的副本。

Examples

let hello = "Hello"; // &str 实现克隆

assert_eq!("Hello", hello.clone());
Run

Provided methods

从 source 执行复制分配。

a.clone_from(&b) 在功能上等效于 a = b.clone()，但是可以重写以重用 a 的资源，以避免不必要的分配。

Implementations on Foreign Types

impl Clone for __m512d

[src]

impl Clone for __m512i

[src]

impl Clone for __m128

[src]

impl Clone for __m256i

[src]

impl Clone for __m128i

[src]

impl Clone for __m256bh

[src]

impl Clone for __m256d

[src]

impl Clone for __m512

[src]

impl Clone for __m512bh

[src]

impl Clone for __m256

[src]

impl Clone for __m128d

[src]

impl Clone for __m128bh

[src]

Implementors

This is supported on Linux only.
This is supported on Unix only.
This is supported on (Android or DragonFly BSD or Emscripten or FreeBSD or Linux or NetBSD or OpenBSD) and Unix only.

共享的引用可以被克隆，但是可变引用 不能!

共享的引用可以被克隆，但是可变引用 不能!

Panics

如果值当前是可变借用的，则出现 panic。

Panics

如果当前 other 是可变借用的，则会 panic。

克隆 Rc 指针。

这将创建另一个指向相同分配的指针，从而增加了强引用计数。

Examples

use std::rc::Rc;

let five = Rc::new(5);

let _ = Rc::clone(&five);
Run

克隆 Weak 指针，该指针指向相同的分配。

Examples

use std::rc::{Rc, Weak};

let weak_five = Rc::downgrade(&Rc::new(5));

let _ = Weak::clone(&weak_five);
Run

克隆发送者以发送到其他线程。

请注意，请注意发送方的生命周期，因为所有发送方 (包括原始发送方) 都需要丢弃，以便 Receiver::recv 停止阻塞。

克隆 Arc 指针。

这将创建另一个指向相同分配的指针，从而增加了强引用计数。

Examples

use std::sync::Arc;

let five = Arc::new(5);

let _ = Arc::clone(&five);
Run

克隆 Weak 指针，该指针指向相同的分配。

Examples

use std::sync::{Arc, Weak};

let weak_five = Arc::downgrade(&Arc::new(5));

let _ = Weak::clone(&weak_five);
Run

返回带有此 box 的 内容的 clone() 的新 box。

Examples

let x = Box::new(5);
let y = x.clone();

// 值是一样的
assert_eq!(x, y);

// 但是它们是独特的对象
assert_ne!(&*x as *const i32, &*y as *const i32);
Run

将 source 的内容复制到 self，而不创建新的分配。

Examples

let x = Box::new(5);
let mut y = Box::new(10);
let yp: *const i32 = &*y;

y.clone_from(&x);

// 值是一样的
assert_eq!(x, y);

// 没有分配发生
assert_eq!(yp, &*y);
Run