Struct ptr::Shared

pub struct Shared<T: ?Sized> { /* fields omitted */ }

*mut T but non-zero and covariant.

This is often the correct thing to use when building data structures using raw pointers, but is ultimately more dangerous to use because of its additional properties. If you're not sure if you should use Shared<T>, just use *mut T!

Unlike *mut T, the pointer must always be non-null, even if the pointer is never dereferenced. This is so that enums may use this forbidden value as a discriminant -- Option<Shared<T>> has the same size as Shared<T>. However the pointer may still dangle if it isn't dereferenced.

Unlike *mut T, Shared<T> is covariant over T. If this is incorrect for your use case, you should include some PhantomData in your type to provide invariance, such as PhantomData<Cell<T>> or PhantomData<&'a mut T>. Usually this won't be necessary; covariance is correct for most safe abstractions, such as Box, Rc, Arc, Vec, and LinkedList. This is the case because they provide a public API that follows the normal shared XOR mutable rules of Rust.

Implementations

impl<T: Sized> Shared<T>

pub const fn empty() -> Self

Creates a new Shared that is dangling, but well-aligned.

This is useful for initializing types which lazily allocate, like Vec::new does.

impl<T: ?Sized> Shared<T>

pub const unsafe fn new_unchecked(ptr: *mut T) -> Self

Creates a new Shared.

Safety

ptr must be non-null.

pub fn new(ptr: *mut T) -> Option<Self>

Creates a new Shared if ptr is non-null.

pub const fn as_ptr(self) -> NonNull<T>

Acquires the underlying *mut pointer.

pub unsafe fn as_ref(&self) -> &T

Dereferences the content.

The resulting lifetime is bound to self so this behaves "as if" it were actually an instance of T that is getting borrowed. If a longer (unbound) lifetime is needed, use &*my_ptr.ptr().

pub unsafe fn as_mut(&mut self) -> &mut T

Mutably dereferences the content.

The resulting lifetime is bound to self so this behaves "as if" it were actually an instance of T that is getting borrowed. If a longer (unbound) lifetime is needed, use &mut *my_ptr.ptr_mut().

Trait Implementations

impl<T: ?Sized> Clone for Shared<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: ?Sized + Unsize<T>, T: ?Sized> CoerceUnsized<Shared<T>> for Shared<S>

impl<T: ?Sized> Copy for Shared<T>

impl<'a, T: ?Sized> From<&'a T> for Shared<T>

fn from(reference: &'a T) -> Self

Performs the conversion.

impl<'a, T: ?Sized> From<&'a mut T> for Shared<T>

fn from(reference: &'a mut T) -> Self

Performs the conversion.

impl<T: ?Sized> From<NonNull<T>> for Shared<T>

fn from(ptr: NonNull<T>) -> Self

Performs the conversion.

impl<T: ?Sized> From<Unique<T>> for Shared<T>

fn from(unique: Unique<T>) -> Self

Performs the conversion.

impl<T: ?Sized> Pointer for Shared<T>

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

Formats the value using the given formatter.