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.

## Implementations

### `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.

#### `pub unsafe fn as_uninit_ref(&self) -> &MaybeUninit<T>`[src]

🔬 This is a nightly-only experimental API. (`ptr_as_uninit` #75402)

Returns a shared references to the value. In contrast to `as_ref`, this does not require that the value has to be initialized.

For the mutable counterpart see `as_uninit_mut`.

# Safety

When calling this method, you have to ensure that all of the following is true:

- The pointer must be properly aligned.

- It must be "dereferencable" in the sense defined in the module documentation.

- You must enforce Rust's aliasing rules, since the returned lifetime `'a` is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, for the duration of this lifetime, the memory the pointer points to must not get mutated (except inside `UnsafeCell`).

This applies even if the result of this method is unused!

#### `pub unsafe fn as_uninit_mut(&mut self) -> &mut MaybeUninit<T>`[src]

🔬 This is a nightly-only experimental API. (`ptr_as_uninit` #75402)

Returns a unique references to the value. In contrast to `as_mut`, this does not require that the value has to be initialized.

For the shared counterpart see `as_uninit_ref`.

# Safety

When calling this method, you have to ensure that all of the following is true:

- The pointer must be properly aligned.

- It must be "dereferencable" in the sense defined in the module documentation.

- You must enforce Rust's aliasing rules, since the returned lifetime `'a` is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, for the duration of this lifetime, the memory the pointer points to must not get accessed (read or written) through any other pointer.

This applies even if the result of this method is unused!

### `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.

#### `pub unsafe fn as_ref(&self) -> &Tⓘ

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

Returns a shared reference to the value. If the value may be uninitialized, `as_uninit_ref` must be used instead.

For the mutable counterpart see `as_mut`.

# Safety

When calling this method, you have to ensure that all of the following is true:

- The pointer must be properly aligned.

- It must be "dereferencable" in the sense defined in the module documentation.

- The pointer must point to an initialized instance of `T`.

- You must enforce Rust's aliasing rules, since the returned lifetime `'a` is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, for the duration of this lifetime, the memory the pointer points to must not get mutated (except inside `UnsafeCell`).

This applies even if the result of this method is unused! (The part about being initialized is not yet fully decided, but until it is, the only safe approach is to ensure that they are indeed initialized.)

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

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

Returns a unique reference to the value. If the value may be uninitialized, `as_uninit_mut` must be used instead.

For the shared counterpart see `as_ref`.

# Safety

When calling this method, you have to ensure that all of the following is true:

- The pointer must be properly aligned.

- It must be "dereferencable" in the sense defined in the module documentation.

- The pointer must point to an initialized instance of `T`.

- You must enforce Rust's aliasing rules, since the returned lifetime `'a` is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, for the duration of this lifetime, the memory the pointer points to must not get accessed (read or written) through any other pointer.

This applies even if the result of this method is unused! (The part about being initialized is not yet fully decided, but until it is, the only safe approach is to ensure that they are indeed initialized.)

#### `pub const fn cast<U>(self) -> NonNull<U>`1.27.0[src]

Casts to a pointer of another type.

### `impl<T> NonNull<[T]>`[src]

#### `pub fn slice_from_raw_parts(data: NonNull<T>, len: usize) -> NonNull<[T]>`[src]

🔬 This is a nightly-only experimental API. (`nonnull_slice_from_raw_parts` #71941)

Creates a non-null raw slice from a thin pointer and a length.

The `len` argument is the number of elements, not the number of bytes.

This function is safe, but dereferencing the return value is unsafe. See the documentation of `slice::from_raw_parts` for slice safety requirements.

# Examples

    #![feature(nonnull_slice_from_raw_parts)]

    use std::ptr::NonNull;

    // create a slice pointer when starting out with a pointer to the first element
    let mut x = [5, 6, 7];
    let nonnull_pointer = NonNull::new(x.as_mut_ptr()).unwrap();
    let slice = NonNull::slice_from_raw_parts(nonnull_pointer, 3);
    assert_eq!(unsafe { slice.as_ref()[2] }, 7);

Run

(Note that this example artificially demonstrates a use of this method, but `let slice = NonNull::from(&x[..]);` would be a better way to write code like this.)

#### `pub fn len(self) -> usize`[src]

🔬 This is a nightly-only experimental API. (`slice_ptr_len` #71146)

Returns the length of a non-null raw slice.

The returned value is the number of elements, not the number of bytes.

This function is safe, even when the non-null raw slice cannot be dereferenced to a slice because the pointer does not have a valid address.

# Examples

    #![feature(slice_ptr_len, nonnull_slice_from_raw_parts)]
    use std::ptr::NonNull;

    let slice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(), 3);
    assert_eq!(slice.len(), 3);

Run

#### `pub fn as_non_null_ptr(self) -> NonNull<T>`[src]

🔬 This is a nightly-only experimental API. (`slice_ptr_get` #74265)

Returns a non-null pointer to the slice's buffer.

# Examples

    #![feature(slice_ptr_get, nonnull_slice_from_raw_parts)]
    use std::ptr::NonNull;

    let slice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(), 3);
    assert_eq!(slice.as_non_null_ptr(), NonNull::new(1 as *mut i8).unwrap());

Run

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

🔬 This is a nightly-only experimental API. (`slice_ptr_get` #74265)

Returns a raw pointer to the slice's buffer.

# Examples

    #![feature(slice_ptr_get, nonnull_slice_from_raw_parts)]
    use std::ptr::NonNull;

    let slice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(), 3);
    assert_eq!(slice.as_mut_ptr(), 1 as *mut i8);

Run

#### `pub unsafe fn as_uninit_slice(&self) -> &[MaybeUninit<T>]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
`[src]

🔬 This is a nightly-only experimental API. (`ptr_as_uninit` #75402)

Returns a shared reference to a slice of possibly uninitialized values. In contrast to `as_ref`, this does not require that the value has to be initialized.

For the mutable counterpart see `as_uninit_slice_mut`.

# Safety

When calling this method, you have to ensure that all of the following is true:

- The pointer must be valid for reads for `ptr.len() * mem::size_of::<T>()` many bytes, and it must be properly aligned. This means in particular:

  - The entire memory range of this slice must be contained within a single allocated object! Slices can never span across multiple allocated objects.

  - The pointer must be aligned even for zero-length slices. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as `data` for zero-length slices using `NonNull::dangling()`.

- The total size `ptr.len() * mem::size_of::<T>()` of the slice must be no larger than `isize::MAX`. See the safety documentation of `pointer::offset`.

- You must enforce Rust's aliasing rules, since the returned lifetime `'a` is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, for the duration of this lifetime, the memory the pointer points to must not get mutated (except inside `UnsafeCell`).

This applies even if the result of this method is unused!

See also `slice::from_raw_parts`.

#### `pub unsafe fn as_uninit_slice_mut(&self) -> &mut [MaybeUninit<T>]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
`[src]

🔬 This is a nightly-only experimental API. (`ptr_as_uninit` #75402)

Returns a unique reference to a slice of possibly uninitialized values. In contrast to `as_mut`, this does not require that the value has to be initialized.

For the shared counterpart see `as_uninit_slice`.

# Safety

When calling this method, you have to ensure that all of the following is true:

- The pointer must be valid for reads and writes for `ptr.len() * mem::size_of::<T>()` many bytes, and it must be properly aligned. This means in particular:

  - The entire memory range of this slice must be contained within a single allocated object! Slices can never span across multiple allocated objects.

  - The pointer must be aligned even for zero-length slices. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as `data` for zero-length slices using `NonNull::dangling()`.

- The total size `ptr.len() * mem::size_of::<T>()` of the slice must be no larger than `isize::MAX`. See the safety documentation of `pointer::offset`.

- You must enforce Rust's aliasing rules, since the returned lifetime `'a` is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, for the duration of this lifetime, the memory the pointer points to must not get accessed (read or written) through any other pointer.

This applies even if the result of this method is unused!

See also `slice::from_raw_parts_mut`.

# Examples

    #![feature(allocator_api, ptr_as_uninit)]

    use std::alloc::{AllocRef, Layout, Global};
    use std::mem::MaybeUninit;
    use std::ptr::NonNull;

    let memory: NonNull<[u8]> = Global.alloc(Layout::new::<[u8; 32]>())?;
    // This is safe as `memory` is valid for reads and writes for `memory.len()` many bytes.
    // Note that calling `memory.as_mut()` is not allowed here as the content may be uninitialized.
    let slice: &mut [MaybeUninit<u8>] = unsafe { memory.as_uninit_slice_mut() };

Run

#### `pub unsafe fn get_unchecked_mut<I>(
self,
index: I
) -> NonNull<<I as SliceIndex<[T]>>::Output> where
I: SliceIndex<[T]>,` [src]

🔬 This is a nightly-only experimental API. (`slice_ptr_get` #74265)

Returns a raw pointer to an element or subslice, without doing bounds checking.

Calling this method with an out-of-bounds index or when `self` is not dereferencable is undefined behavior even if the resulting pointer is not used.

# Examples

    #![feature(slice_ptr_get, nonnull_slice_from_raw_parts)]
    use std::ptr::NonNull;

    let x = &mut [1, 2, 4];
    let x = NonNull::slice_from_raw_parts(NonNull::new(x.as_mut_ptr()).unwrap(), x.len());

    unsafe {
        assert_eq!(x.get_unchecked_mut(1).as_ptr(), x.as_non_null_ptr().as_ptr().add(1));
    }

Run

## Trait Implementations

### `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, 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> 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, U> DispatchFromDyn<NonNull<U>> for NonNull<T> where
T: Unsize<U> + ?Sized,
U: ?Sized,` [src]

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

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

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

Performs the conversion.

### `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> 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

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

Compares and returns the maximum of two values. Read more

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

Compares and returns the minimum of two values. Read more

#### `#[must_use]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> 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> 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> 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> !Send for NonNull<T> where
T: ?Sized,` [src]

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

### `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: 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> Any for T where
T: 'static + ?Sized,` [src]

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

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

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

#### `fn borrow(&self) -> &Tⓘ

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

Immutably borrows from an owned value. Read more

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

#### `fn borrow_mut(&mut self) -> &mut Tⓘ

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

Mutably borrows from an owned value. Read more

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

#### `fn from(t: T) -> T`[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> 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

### `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> 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.