Struct std::cell::UnsafeCell

pub struct UnsafeCell<T> where T: ?Sized {
    // some 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.

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

Examples

fn main() { use std::cell::UnsafeCell; use std::marker::Sync; #[allow(dead_code)] 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> {}

Methods

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

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();

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

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

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

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() };

Trait Implementations

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

fn default() -> UnsafeCell<T>

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

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

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

impl<T: ?Sized> !RefUnwindSafe for UnsafeCell<T>