Struct std::cell::UnsafeCell 1.0.0
[−]
[src]
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.
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
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>
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() };
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
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();
Trait Implementations
impl<T> !Sync for UnsafeCell<T> where T: ?Sized
impl<T> Default for UnsafeCell<T> where T: Default
1.9.0
fn default() -> UnsafeCell<T>
Returns the "default value" for a type. Read more
impl<T> From<T> for UnsafeCell<T>
1.12.0
fn from(t: T) -> UnsafeCell<T>
Performs the conversion.