# Trait std::marker::Copy [−] [src]

    pub trait Copy: Clone { }

Types that can be copied by simply copying bits (i.e. `memcpy`).

By default, variable bindings have 'move semantics.' In other words:

fn main() { #[derive(Debug)] struct Foo; let x = Foo; let y = x; // `x` has moved into `y`, and so cannot be used // println!("{:?}", x); // error: use of moved value }

    #[derive(Debug)]
    struct Foo;

    let x = Foo;

    let y = x;

    // `x` has moved into `y`, and so cannot be used

    // println!("{:?}", x); // error: use of moved value

However, if a type implements `Copy`, it instead has 'copy semantics':

fn main() { // we can just derive a `Copy` implementation #[derive(Debug, Copy, Clone)] struct Foo; let x = Foo; let y = x; // `y` is a copy of `x` println!("{:?}", x); // A-OK! }

    // we can just derive a `Copy` implementation
    #[derive(Debug, Copy, Clone)]
    struct Foo;

    let x = Foo;

    let y = x;

    // `y` is a copy of `x`

    println!("{:?}", x); // A-OK!

It's important to note that in these two examples, the only difference is if you are allowed to access `x` after the assignment: a move is also a bitwise copy under the hood.

## When can my type be `Copy`?

A type can implement `Copy` if all of its components implement `Copy`. For example, this `struct` can be `Copy`:

fn main() { #[allow(dead_code)] struct Point { x: i32, y: i32, } }

    struct Point {
       x: i32,
       y: i32,
    }

A `struct` can be `Copy`, and `i32` is `Copy`, so therefore, `Point` is eligible to be `Copy`.

fn main() { #![allow(dead_code)] struct Point; struct PointList { points: Vec<Point>, } }

    struct PointList {
        points: Vec<Point>,
    }

The `PointList` `struct` cannot implement `Copy`, because `Vec<T>` is not `Copy`. If we attempt to derive a `Copy` implementation, we'll get an error:

    the trait `Copy` may not be implemented for this type; field `points` does not implement `Copy`

## How can I implement `Copy`?

There are two ways to implement `Copy` on your type:

fn main() { #[derive(Copy, Clone)] struct MyStruct; }

    #[derive(Copy, Clone)]
    struct MyStruct;

and

fn main() { struct MyStruct; impl Copy for MyStruct {} impl Clone for MyStruct { fn clone(&self) -> MyStruct { *self } } }

    struct MyStruct;
    impl Copy for MyStruct {}
    impl Clone for MyStruct { fn clone(&self) -> MyStruct { *self } }

There is a small difference between the two: the `derive` strategy will also place a `Copy` bound on type parameters, which isn't always desired.

## When can my type not be `Copy`?

Some types can't be copied safely. For example, copying `&mut T` would create an aliased mutable reference, and copying `String` would result in two attempts to free the same buffer.

Generalizing the latter case, any type implementing `Drop` can't be `Copy`, because it's managing some resource besides its own `size_of::<T>()` bytes.

## When should my type be `Copy`?

Generally speaking, if your type can implement `Copy`, it should. There's one important thing to consider though: if you think your type may not be able to implement `Copy` in the future, then it might be prudent to not implement `Copy`. This is because removing `Copy` is a breaking change: that second example would fail to compile if we made `Foo` non-`Copy`.

# Derivable

This trait can be used with `#[derive]`.

## Implementors

- `impl<T> Copy for Wrapping<T> where T: Copy`
- `impl Copy for Decoded`
- `impl Copy for FullDecoded`
- `impl<'a> Copy for Part<'a>`
- `impl Copy for Sign`
- `impl Copy for Unpacked`
- `impl Copy for Fp`
- `impl Copy for FpCategory`
- `impl<T> Copy for NonZero<T> where T: Copy + Zeroable`
- `impl<T> Copy for Shared<T> where T: ?Sized`
- `impl<T> Copy for PhantomData<T> where T: ?Sized`
- `impl Copy for RangeFull`
- `impl<Idx> Copy for RangeTo<Idx> where Idx: Copy`
- `impl Copy for Ordering`
- `impl Copy for TypeId`
- `impl Copy for Ordering`
- `impl Copy for BorrowState`
- `impl<T> Copy for Option<T> where T: Copy`
- `impl<T> Copy for Slice<T>`
- `impl Copy for TraitObject`
- `impl<T, E> Copy for Result<T, E> where E: Copy, T: Copy`
- `impl Copy for SearchStep`
- `impl Copy for Utf8Error`
- `impl Copy for CharRange`
- `impl Copy for Radix`
- `impl<T, R> Copy for RadixFmt<T, R> where T: Copy, R: Copy`
- `impl Copy for Argument`
- `impl Copy for FormatSpec`
- `impl Copy for Alignment`
- `impl Copy for Count`
- `impl Copy for Position`
- `impl Copy for Error`
- `impl Copy for FlagV1`
- `impl<'a> Copy for Arguments<'a>`
- `impl Copy for ExchangeHeapSingleton`
- `impl<'a, K, V, Type> Copy for NodeRef<Immut<'a>, K, V, Type> where K: 'a, V: 'a`
- `impl<Node, Type> Copy for Handle<Node, Type> where Node: Copy`
- `impl<E> Copy for EnumSet<E>`
- `impl<T> Copy for Rawlink<T>`
- `impl Copy for ParseError`
- `impl<T> Copy for Bound<T> where T: Copy`
- `impl Copy for LocalKeyState`
- `impl Copy for FileType`
- `impl Copy for ErrorKind`
- `impl Copy for SeekFrom`
- `impl Copy for IpAddr`
- `impl Copy for Ipv4Addr`
- `impl Copy for Ipv6Addr`
- `impl Copy for Ipv6MulticastScope`
- `impl Copy for SocketAddr`
- `impl Copy for SocketAddrV4`
- `impl Copy for SocketAddrV6`
- `impl Copy for Shutdown`
- `impl<'a> Copy for Prefix<'a>`
- `impl<'a> Copy for PrefixComponent<'a>`
- `impl<'a> Copy for Component<'a>`
- `impl Copy for ExitStatus`
- `impl<T: Copy> Copy for SendError<T>`
- `impl Copy for RecvError`
- `impl Copy for TryRecvError`
- `impl<T: Copy> Copy for TrySendError<T>`
- `impl Copy for WaitTimeoutResult`
- `impl Copy for Duration`
- `impl Copy for Instant`
- `impl Copy for SystemTime`
- `impl Copy for utimbuf`
- `impl Copy for timeval`
- `impl Copy for timespec`
- `impl Copy for rlimit`
- `impl Copy for rusage`
- `impl Copy for in_addr`
- `impl Copy for in6_addr`
- `impl Copy for ip_mreq`
- `impl Copy for ipv6_mreq`
- `impl Copy for hostent`
- `impl Copy for iovec`
- `impl Copy for pollfd`
- `impl Copy for sockaddr`
- `impl Copy for sockaddr_in`
- `impl Copy for sockaddr_in6`
- `impl Copy for sockaddr_un`
- `impl Copy for sockaddr_storage`
- `impl Copy for addrinfo`
- `impl Copy for sockaddr_ll`
- `impl Copy for fd_set`
- `impl Copy for tm`
- `impl Copy for sched_param`
- `impl Copy for Dl_info`
- `impl Copy for epoll_event`
- `impl Copy for utsname`
- `impl Copy for dirent`
- `impl Copy for dirent64`
- `impl Copy for rlimit64`
- `impl Copy for glob_t`
- `impl Copy for ifaddrs`
- `impl Copy for pthread_mutex_t`
- `impl Copy for pthread_rwlock_t`
- `impl Copy for pthread_mutexattr_t`
- `impl Copy for pthread_cond_t`
- `impl Copy for passwd`
- `impl Copy for statvfs`
- `impl Copy for sockaddr_nl`
- `impl Copy for dqblk`
- `impl Copy for signalfd_siginfo`
- `impl Copy for fsid_t`
- `impl Copy for mq_attr`
- `impl Copy for cpu_set_t`
- `impl Copy for sigaction`
- `impl Copy for stack_t`
- `impl Copy for siginfo_t`
- `impl Copy for glob64_t`
- `impl Copy for ucred`
- `impl Copy for statfs`
- `impl Copy for msghdr`
- `impl Copy for termios`
- `impl Copy for flock`
- `impl Copy for sigset_t`
- `impl Copy for stat`
- `impl Copy for stat64`
- `impl Copy for pthread_attr_t`
- `impl Copy for ipc_perm`
- `impl Copy for shmid_ds`
- `impl Copy for StandardNormal`
- `impl Copy for Normal`
- `impl Copy for LogNormal`
- `impl Copy for Exp1`
- `impl Copy for Exp`
- `impl Copy for IsaacRng`
- `impl Copy for Isaac64Rng`
- `impl Copy for ChaChaRng`
- `impl Copy for ReseedWithDefault`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize`)