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

# 1.25.0[−][src]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>`[src]

#### `pub const fn dangling() -> NonNull<T>`[src]

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,` [src]

#### `pub const unsafe fn new_unchecked(ptr: *mut T) -> NonNull<T>`[src]

Creates a new `NonNull`.

# Safety

`ptr` must be non-null.

#### `pub fn new(ptr: *mut T) -> Option<NonNull<T>>`[src]

Creates a new `NonNull` if `ptr` is non-null.

#### `pub const fn as_ptr(self) -> *mut T`[src]

Acquires the underlying `*mut` pointer.

####
ⓘImportant traits for &'_ mut I

### Important traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W`
`pub unsafe fn as_ref(&self) -> &T`[src]

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 I

### Important traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W`
`pub unsafe fn as_mut(&mut self) -> &mut T`[src]

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>`1.27.0[src]

Casts to a pointer of another type.

## Trait Implementations

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

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

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

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

### `impl<T> Eq for NonNull<T> where
T: ?Sized,` [src]

### `impl<'_, T> From<&'_ mut T> for NonNull<T> where
T: ?Sized,` [src]

#### `fn from(reference: &mut T) -> NonNull<T>`[src]

Performs the conversion.

### `impl<T> From<Unique<T>> for NonNull<T> where
T: ?Sized,` [src]

#### `fn from(unique: Unique<T>) -> NonNull<T>`[src]

Performs the conversion.

### `impl<'_, T> From<&'_ T> for NonNull<T> where
T: ?Sized,` [src]

#### `fn from(reference: &T) -> NonNull<T>`[src]

Performs the conversion.

### `impl<T> PartialEq<NonNull<T>> for NonNull<T> where
T: ?Sized,` [src]

#### `fn eq(&self, other: &NonNull<T>) -> bool`[src]

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

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

This method tests for `!=`.

### `impl<T, U> DispatchFromDyn<NonNull<U>> for NonNull<T> where
T: Unsize<U> + ?Sized,
U: ?Sized,` [src]

### `impl<T> Hash for NonNull<T> where
T: ?Sized,` [src]

#### `fn hash<H>(&self, state: &mut H) where
H: Hasher,` [src]

Feeds this value into the given [`Hasher`]. Read more

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

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

### `impl<T> Ord for NonNull<T> where
T: ?Sized,` [src]

#### `fn cmp(&self, other: &NonNull<T>) -> Ordering`[src]

This method returns an `Ordering` between `self` and `other`. Read more

#### `fn max(self, other: Self) -> Self`1.21.0[src]

Compares and returns the maximum of two values. Read more

#### `fn min(self, other: Self) -> Self`1.21.0[src]

Compares and returns the minimum of two values. Read more

#### `fn clamp(self, min: Self, max: Self) -> Self`[src]

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

Restrict a value to a certain interval. Read more

### `impl<T> Pointer for NonNull<T> where
T: ?Sized,` [src]

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter. Read more

### `impl<T> Clone for NonNull<T> where
T: ?Sized,` [src]

#### `fn clone(&self) -> NonNull<T>`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from `source`. Read more

### `impl<T> PartialOrd<NonNull<T>> for NonNull<T> where
T: ?Sized,` [src]

#### `fn partial_cmp(&self, other: &NonNull<T>) -> Option<Ordering>`[src]

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

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

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

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

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

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

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

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

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

### `impl<T, U> CoerceUnsized<NonNull<U>> for NonNull<T> where
T: Unsize<U> + ?Sized,
U: ?Sized,` [src]

### `impl<T> Copy for NonNull<T> where
T: ?Sized,` [src]

### `impl<T: RefUnwindSafe + ?Sized> UnwindSafe for NonNull<T>`[src]

## Auto Trait Implementations

### `impl<T: ?Sized> RefUnwindSafe for NonNull<T> where
T: RefUnwindSafe,`

### `impl<T: ?Sized> Unpin for NonNull<T>`

## Blanket Implementations

### `impl<T> From<T> for T`[src]

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

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

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

####
ⓘImportant traits for &'_ mut I

### Important traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W`
`fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

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

####
ⓘImportant traits for &'_ mut I

### Important traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W`
`fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)`[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into` #41263)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more