Struct std::ptr::NonNull

#[repr(transparent)]
pub struct NonNull<T> where
    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 NonNull<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<NonNull<T>> has the same size as *mut T. However the pointer may still dangle if it isn't dereferenced.

Unlike *mut T, NonNull<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.

Notice that NonNull<T> has a From instance for &T. However, this does not change the fact that mutating through a (pointer derived from a) shared reference is undefined behavior unless the mutation happens inside an UnsafeCell<T>. The same goes for creating a mutable reference from a shared reference. When using this From instance without an UnsafeCell<T>, it is your responsibility to ensure that as_mut is never called, and as_ptr is never used for mutation.

Methods

impl<T> NonNull<T>

pub const fn dangling() -> NonNull<T>

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

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

Note that the pointer value may potentially represent a valid pointer to a T, which means this must not be used as a "not yet initialized" sentinel value. Types that lazily allocate must track initialization by some other means.

impl<T> NonNull<T> where
    T: ?Sized, 

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

Creates a new NonNull.

Safety

ptr must be non-null.

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

Creates a new NonNull if ptr is non-null.

pub const fn as_ptr(self) -> *mut T

Acquires the underlying *mut pointer.

Important traits for &'_ mut F

impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W

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.as_ptr().

Important traits for &'_ mut F

impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W

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.as_ptr().

pub const fn cast<U>(self) -> NonNull<U>

Cast to a pointer of another type

Trait Implementations

impl<'_, T> From<&'_ T> for NonNull<T> where
    T: ?Sized, 

fn from(reference: &T) -> NonNull<T>

Performs the conversion.

impl<'_, T> From<&'_ mut T> for NonNull<T> where
    T: ?Sized, 

fn from(reference: &mut T) -> NonNull<T>

Performs the conversion.

impl<T> From<Unique<T>> for NonNull<T> where
    T: ?Sized, 

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

Performs the conversion.

impl<T> PartialOrd<NonNull<T>> for NonNull<T> where
    T: ?Sized, 

fn partial_cmp(&self, other: &NonNull<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Hash for NonNull<T> where
    T: ?Sized, 

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T> !Send for NonNull<T> where
    T: ?Sized, 

NonNull pointers are not Send because the data they reference may be aliased.

impl<T> Eq for NonNull<T> where
    T: ?Sized, 

impl<T> Clone for NonNull<T> where
    T: ?Sized, 

fn clone(&self) -> NonNull<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Pointer for NonNull<T> where
    T: ?Sized, 

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

Formats the value using the given formatter.

impl<T> Debug for NonNull<T> where
    T: ?Sized, 

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

Formats the value using the given formatter.

impl<T> Copy for NonNull<T> where
    T: ?Sized, 

impl<T> Ord for NonNull<T> where
    T: ?Sized, 

fn cmp(&self, other: &NonNull<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp #44095)

Restrict a value to a certain interval.

impl<T> PartialEq<NonNull<T>> for NonNull<T> where
    T: ?Sized, 

fn eq(&self, other: &NonNull<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> !Sync for NonNull<T> where
    T: ?Sized, 

NonNull pointers are not Sync because the data they reference may be aliased.

impl<T, U> CoerceUnsized<NonNull<U>> for NonNull<T> where
    T: Unsize<U> + ?Sized,
    U: ?Sized, 

impl<T, U> DispatchFromDyn<NonNull<U>> for NonNull<T> where
    T: Unsize<U> + ?Sized,
    U: ?Sized, 

impl<T: RefUnwindSafe + ?Sized> UnwindSafe for NonNull<T>