std::cell::UnsafeCell - Rust
Description: API documentation for the Rust `UnsafeCell` struct in crate `std`.
Keywords: rust, rustlang, rust-lang, UnsafeCell

# 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 unsafe fn into_inner(self) -> T`
[src]

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

### `impl<T> UnsafeCell<T> where
T: ?Sized,`
[src]

#### `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> From<T> for UnsafeCell<T>`
1.12.0
[src]

#### `fn from(t: T) -> UnsafeCell<T>`
[src]

Performs the conversion.

### `impl<T, U> CoerceUnsized<UnsafeCell<U>> for UnsafeCell<T> where
T: CoerceUnsized<U>,`
[src]

### `impl<T> !Sync for UnsafeCell<T> where
T: ?Sized,`
[src]

### `impl<T> Debug for UnsafeCell<T> where
T: Debug + ?Sized,`
1.9.0
[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`
[src]

Formats the value using the given formatter. Read more

### `impl<T> Default for UnsafeCell<T> where
T: Default,`
1.10.0
[src]

#### `fn default() -> UnsafeCell<T>`
[src]

Creates an `UnsafeCell`, with the `Default` value for T.

### `impl<T: ?Sized> !RefUnwindSafe for UnsafeCell<T>`
1.9.0
[src]

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
↑
  Move up in search results
↓
  Move down in search results
↹
  Switch tab
⏎
  Go to active search result
+ / -
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)