Struct std::cell::UnsafeCell 1.0.0
[−]
[src]
#[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> {}Run
Methods
impl<T> UnsafeCell<T>
[src]
pub const fn new(value: T) -> UnsafeCell<T>
[src]
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);Run
pub fn into_inner(self) -> T
[src]
impl<T> UnsafeCell<T> where
T: ?Sized,
[src]
T: ?Sized,
pub fn get(&self) -> *mut T
[src]
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();Run
Trait Implementations
impl<T> Debug for UnsafeCell<T> where
T: Debug + ?Sized,
1.9.0[src]
T: Debug + ?Sized,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter. Read more
impl<T> !Sync for UnsafeCell<T> where
T: ?Sized,
[src]
T: ?Sized,
impl<T, U> CoerceUnsized<UnsafeCell<U>> for UnsafeCell<T> where
T: CoerceUnsized<U>,
[src]
T: CoerceUnsized<U>,
impl<T> Default for UnsafeCell<T> where
T: Default,
1.10.0[src]
T: Default,
fn default() -> UnsafeCell<T>
[src]
Creates an UnsafeCell
, with the Default
value for T.
impl<T> From<T> for UnsafeCell<T>
1.12.0[src]
fn from(t: T) -> UnsafeCell<T>
[src]
Performs the conversion.