Struct std::cell::UnsafeCell

#[lang = "unsafe_cell"]
pub struct UnsafeCell<T> where T: ?Sized { /* fields omitted */ }

The core primitive for interior mutability in Rust.

UnsafeCell<T> is a type that wraps some T and indicates unsafe interior operations on the wrapped type. Types with an UnsafeCell<T> field are considered to have an 'unsafe interior'. The UnsafeCell<T> type is the only legal way to obtain aliasable data that is considered mutable. In general, transmuting an &T type into an &mut T is considered undefined behavior.

The compiler makes optimizations based on the knowledge that &T is not mutably aliased or mutated, and that &mut T is unique. When building abstractions like Cell, RefCell, Mutex, etc, you need to turn these optimizations off. UnsafeCell is the only legal way to do this. When UnsafeCell<T> is immutably aliased, it is still safe to obtain a mutable reference to its interior and/or to mutate it. However, it is up to the abstraction designer to ensure that no two mutable references obtained this way are active at the same time, and that there are no active mutable references or mutations when an immutable reference is obtained from the cell. This is often done via runtime checks.

Note that while mutating or mutably aliasing the contents of an & UnsafeCell<T> is okay (provided you enforce the invariants some other way); it is still undefined behavior to have multiple &mut UnsafeCell<T> aliases.

Types like Cell<T> and RefCell<T> use this type to wrap their internal data.

Examples

use std::cell::UnsafeCell;
use std::marker::Sync;

struct NotThreadSafe<T> {
    value: UnsafeCell<T>,
}

unsafe impl<T> Sync for NotThreadSafe<T> {}

Methods

impl<T> UnsafeCell<T>

const fn new(value: T) -> UnsafeCell<T>

Constructs a new instance of UnsafeCell which will wrap the specified value.

All access to the inner value through methods is unsafe.

Examples

use std::cell::UnsafeCell;

let uc = UnsafeCell::new(5);

unsafe fn into_inner(self) -> T

Unwraps the value.

Safety

This function is unsafe because this thread or another thread may currently be inspecting the inner value.

Examples

use std::cell::UnsafeCell;

let uc = UnsafeCell::new(5);

let five = unsafe { uc.into_inner() };

impl<T> UnsafeCell<T> where T: ?Sized

fn get(&self) -> *mut T

Gets a mutable pointer to the wrapped value.

This can be cast to a pointer of any kind. Ensure that the access is unique when casting to &mut T, and ensure that there are no mutations or mutable aliases going on when casting to &T

Examples

use std::cell::UnsafeCell;

let uc = UnsafeCell::new(5);

let five = uc.get();

Trait Implementations

impl<T> !Sync for UnsafeCell<T> where T: ?Sized

impl<T> Default for UnsafeCell<T> where T: Default

fn default() -> UnsafeCell<T>

Creates an UnsafeCell, with the Default value for T.

impl<T, U> CoerceUnsized<UnsafeCell<U>> for UnsafeCell<T> where T: CoerceUnsized<U>

impl<T> From<T> for UnsafeCell<T>

fn from(t: T) -> UnsafeCell<T>

Performs the conversion.

impl<T> Debug for UnsafeCell<T> where T: Debug + ?Sized

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.