# 1.0.0[−][src]Function std::ptr::write_bytes

    pub unsafe extern "rust-intrinsic" fn write_bytes<T>(
        dst: *mut T,
        val: u8,
        count: usize
    )

Sets `count * size_of::<T>()` bytes of memory starting at `dst` to `val`.

`write_bytes` is similar to C's `memset`, but sets `count * size_of::<T>()` bytes to `val`.

# Safety

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

- `dst` must be valid for writes of `count * size_of::<T>()` bytes.

- `dst` must be properly aligned.

Additionally, the caller must ensure that writing `count * size_of::<T>()` bytes to the given region of memory results in a valid value of `T`. Using a region of memory typed as a `T` that contains an invalid value of `T` is undefined behavior.

Note that even if the effectively copied size (`count * size_of::<T>()`) is `0`, the pointer must be non-NULL and properly aligned.

# Examples

Basic usage:

    use std::ptr;

    let mut vec = vec![0u32; 4];
    unsafe {
        let vec_ptr = vec.as_mut_ptr();
        ptr::write_bytes(vec_ptr, 0xfe, 2);
    }
    assert_eq!(vec, [0xfefefefe, 0xfefefefe, 0, 0]);Run

Creating an invalid value:

    use std::ptr;

    let mut v = Box::new(0i32);

    unsafe {
        // Leaks the previously held value by overwriting the `Box<T>` with
        // a null pointer.
        ptr::write_bytes(&mut v as *mut Box<i32>, 0, 1);
    }

    // At this point, using or dropping `v` results in undefined behavior.
    // drop(v); // ERROR

    // Even leaking `v` "uses" it, and hence is undefined behavior.
    // mem::forget(v); // ERROR

    // In fact, `v` is invalid according to basic type layout invariants, so *any*
    // operation touching it is undefined behavior.
    // let v2 = v; // ERROR

    unsafe {
        // Let us instead put in a valid value
        ptr::write(&mut v as *mut Box<i32>, Box::new(42i32));
    }

    // Now the box is fine
    assert_eq!(*v, 42);Run

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## 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` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)