1.25.0[][src]Struct core::ptr::NonNull

#[repr(transparent)]pub struct NonNull<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: Sized> NonNull<T>[src]

pub const fn dangling() -> Self[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: ?Sized> NonNull<T>[src]

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

Creates a new NonNull.

Safety

ptr must be non-null.

pub fn new(ptr: *mut T) -> Option<Self>[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[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().

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.

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

pub const fn slice_from_raw_parts(data: NonNull<T>, len: usize) -> Self[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 artifically demonstrates a use of this method, but let slice = NonNull::from(&x[..]); would be a better way to write code like this.)

pub const 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

Trait Implementations

impl<T: ?Sized> Clone for NonNull<T>[src]

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

impl<T: ?Sized> Copy for NonNull<T>[src]

impl<T: ?Sized> Debug for NonNull<T>[src]

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

impl<T: ?Sized> Eq for NonNull<T>[src]

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

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

impl<T: ?Sized> Hash for NonNull<T>[src]

impl<T: ?Sized> Ord for NonNull<T>[src]

impl<T: ?Sized> PartialEq<NonNull<T>> for NonNull<T>[src]

impl<T: ?Sized> PartialOrd<NonNull<T>> for NonNull<T>[src]

impl<T: ?Sized> Pointer for NonNull<T>[src]

impl<T: ?Sized> !Send for NonNull<T>[src]

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

impl<T: ?Sized> !Sync for NonNull<T>[src]

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

Auto Trait Implementations

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

Blanket Implementations

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

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

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

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

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

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.

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.