Struct std::cell::UnsafeCellStable

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

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.

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

UnsafeCell<T> doesn't opt-out from any marker traits, instead, types with an UnsafeCell<T> interior are expected to opt-out from those traits themselves.

Examples

fn main() { use std::cell::UnsafeCell; use std::marker::Sync; struct NotThreadSafe<T> { value: UnsafeCell<T>, } unsafe impl<T> Sync for NotThreadSafe<T> {} }

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

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

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

NOTE: UnsafeCell<T>'s fields are public to allow static initializers. It is not recommended to access its fields directly, get should be used instead.

Fields

value

Wrapped value This field should not be accessed directly, it is made public for static initializers.

Methods

impl<T> UnsafeCell<T>

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

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

All access to the inner value through methods is unsafe, and it is highly discouraged to access the fields directly.

Examples

fn main() { use std::cell::UnsafeCell; let uc = UnsafeCell::new(5); }

use std::cell::UnsafeCell;

let uc = UnsafeCell::new(5);

fn get(&self) -> *mut T

Gets a mutable pointer to the wrapped value.

Examples

fn main() { use std::cell::UnsafeCell; let uc = UnsafeCell::new(5); let five = uc.get(); }

use std::cell::UnsafeCell;

let uc = UnsafeCell::new(5);

let five = uc.get();

unsafe fn into_inner(self) -> T

Unwraps the value

Unsafety

This function is unsafe because there is no guarantee that this or other threads are currently inspecting the inner value.

Examples

fn main() { use std::cell::UnsafeCell; let uc = UnsafeCell::new(5); let five = unsafe { uc.into_inner() }; }

use std::cell::UnsafeCell;

let uc = UnsafeCell::new(5);

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