Function core::intrinsics::copy_nonoverlapping1.0.0[−][src]

pub unsafe extern "rust-intrinsic" fn copy_nonoverlapping<T>(
    src: *const T, 
    dst: *mut T, 
    count: usize
)

Copies count * size_of::<T>() bytes from src to dst. The source and destination must not overlap.

For regions of memory which might overlap, use copy instead.

copy_nonoverlapping is semantically equivalent to C's memcpy.

Safety

Behavior is undefined if any of the following conditions are violated:

Both src and dst must be valid.
Both src and dst must be properly aligned.
src.offset(count) must be valid. In other words, the region of memory which begins at src and has a length of count * size_of::<T>() bytes must belong to a single, live allocation.
dst.offset(count) must be valid. In other words, the region of memory which begins at dst and has a length of count * size_of::<T>() bytes must belong to a single, live allocation.
The two regions of memory must not overlap.

Like read, copy creates a bitwise copy of T, regardless of whether T is Copy. If T is not Copy, using both the values in the region beginning at *src and the region beginning at *dst can violate memory safety.

Examples

Manually implement Vec::append:

use std::ptr;

/// Moves all the elements of `src` into `dst`, leaving `src` empty.
fn append<T>(dst: &mut Vec<T>, src: &mut Vec<T>) {
    let src_len = src.len();
    let dst_len = dst.len();

    // Ensure that `dst` has enough capacity to hold all of `src`.
    dst.reserve(src_len);

    unsafe {
        // The call to offset is always safe because `Vec` will never
        // allocate more than `isize::MAX` bytes.
        let dst = dst.as_mut_ptr().offset(dst_len as isize);
        let src = src.as_ptr();

        // The two regions cannot overlap becuase mutable references do
        // not alias, and two different vectors cannot own the same
        // memory.
        ptr::copy_nonoverlapping(src, dst, src_len);
    }

    unsafe {
        // Truncate `src` without dropping its contents.
        src.set_len(0);

        // Notify `dst` that it now holds the contents of `src`.
        dst.set_len(dst_len + src_len);
    }
}

let mut a = vec!['r'];
let mut b = vec!['u', 's', 't'];

append(&mut a, &mut b);

assert_eq!(a, &['r', 'u', 's', 't']);
assert!(b.is_empty());Run