Struct std::ptr::Unique

pub struct Unique<T> where T: ?Sized {
    // some fields omitted
}

Unstable (unique #27730)

: needs an RFC to flesh out design

A wrapper around a raw non-null *mut T that indicates that the possessor of this wrapper owns the referent. This in turn implies that the Unique<T> is Send/Sync if T is Send/Sync, unlike a raw *mut T (which conveys no particular ownership semantics). It also implies that the referent of the pointer should not be modified without a unique path to the Unique reference. Useful for building abstractions like Vec<T> or Box<T>, which internally use raw pointers to manage the memory that they own.

Methods

impl<T> Unique<T> where T: ?Sized

const unsafe fn new(ptr: *mut T) -> Unique<T>

Unstable (unique #27730)

Creates a new Unique.

Safety

ptr must be non-null.

unsafe fn get(&self) -> &T

Unstable (unique #27730)

Dereferences the content.

unsafe fn get_mut(&mut self) -> &mut T

Unstable (unique #27730)

Mutably dereferences the content.

Methods from Deref<Target=*mut T>

fn is_null(self) -> bool

Returns true if the pointer is null.

Examples

Basic usage:

fn main() { let mut s = [1, 2, 3]; let ptr: *mut u32 = s.as_mut_ptr(); assert!(!ptr.is_null()); }

let mut s = [1, 2, 3];
let ptr: *mut u32 = s.as_mut_ptr();
assert!(!ptr.is_null());

unsafe fn as_ref(self) -> Option<&'a T>

Returns None if the pointer is null, or else returns a reference to the value wrapped in Some.

Safety

While this method and its mutable counterpart are useful for null-safety, it is important to note that this is still an unsafe operation because the returned value could be pointing to invalid memory.

Additionally, the lifetime 'a returned is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.

Examples

Basic usage:

fn main() { let val: *mut u8 = &mut 10u8 as *mut u8; unsafe { if let Some(val_back) = val.as_ref() { println!("We got back the value: {}!", val_back); } } }

let val: *mut u8 = &mut 10u8 as *mut u8;

unsafe {
    if let Some(val_back) = val.as_ref() {
        println!("We got back the value: {}!", val_back);
    }
}

unsafe fn offset(self, count: isize) -> *mut T

Calculates the offset from a pointer. count is in units of T; e.g. a count of 3 represents a pointer offset of 3 * sizeof::<T>() bytes.

Safety

The offset must be in-bounds of the object, or one-byte-past-the-end. Otherwise offset invokes Undefined Behavior, regardless of whether the pointer is used.

Examples

Basic usage:

fn main() { let mut s = [1, 2, 3]; let ptr: *mut u32 = s.as_mut_ptr(); unsafe { println!("{}", *ptr.offset(1)); println!("{}", *ptr.offset(2)); } }

let mut s = [1, 2, 3];
let ptr: *mut u32 = s.as_mut_ptr();

unsafe {
    println!("{}", *ptr.offset(1));
    println!("{}", *ptr.offset(2));
}

unsafe fn as_mut(self) -> Option<&'a mut T>

Returns None if the pointer is null, or else returns a mutable reference to the value wrapped in Some.

Safety

As with as_ref, this is unsafe because it cannot verify the validity of the returned pointer, nor can it ensure that the lifetime 'a returned is indeed a valid lifetime for the contained data.

Examples

Basic usage:

fn main() { let mut s = [1, 2, 3]; let ptr: *mut u32 = s.as_mut_ptr(); }

let mut s = [1, 2, 3];
let ptr: *mut u32 = s.as_mut_ptr();

fn is_null(self) -> bool

Returns true if the pointer is null.

Examples

Basic usage:

fn main() { let s: &str = "Follow the rabbit"; let ptr: *const u8 = s.as_ptr(); assert!(!ptr.is_null()); }

let s: &str = "Follow the rabbit";
let ptr: *const u8 = s.as_ptr();
assert!(!ptr.is_null());

unsafe fn as_ref(self) -> Option<&'a T>

Returns None if the pointer is null, or else returns a reference to the value wrapped in Some.

Safety

While this method and its mutable counterpart are useful for null-safety, it is important to note that this is still an unsafe operation because the returned value could be pointing to invalid memory.

Additionally, the lifetime 'a returned is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.

Examples

Basic usage:

fn main() { let val: *const u8 = &10u8 as *const u8; unsafe { if let Some(val_back) = val.as_ref() { println!("We got back the value: {}!", val_back); } } }

let val: *const u8 = &10u8 as *const u8;

unsafe {
    if let Some(val_back) = val.as_ref() {
        println!("We got back the value: {}!", val_back);
    }
}

unsafe fn offset(self, count: isize) -> *const T

Calculates the offset from a pointer. count is in units of T; e.g. a count of 3 represents a pointer offset of 3 * sizeof::<T>() bytes.

Safety

Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object. If either pointer is out of bounds or arithmetic overflow occurs then any further use of the returned value will result in undefined behavior.

Examples

Basic usage:

fn main() { let s: &str = "123"; let ptr: *const u8 = s.as_ptr(); unsafe { println!("{}", *ptr.offset(1) as char); println!("{}", *ptr.offset(2) as char); } }

let s: &str = "123";
let ptr: *const u8 = s.as_ptr();

unsafe {
    println!("{}", *ptr.offset(1) as char);
    println!("{}", *ptr.offset(2) as char);
}

Trait Implementations

impl<T> Pointer for Unique<T>

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

impl<T> Deref for Unique<T> where T: ?Sized

type Target = *mut T

Unstable (unique #27730)

fn deref(&self) -> &*mut T

Unstable (unique #27730)

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

impl<T> Sync for Unique<T> where T: Sync + ?Sized

Unique pointers are Sync if T is Sync because the data they reference is unaliased. Note that this aliasing invariant is unenforced by the type system; the abstraction using the Unique must enforce it.

impl<T> Send for Unique<T> where T: Send + ?Sized

Unique pointers are Send if T is Send because the data they reference is unaliased. Note that this aliasing invariant is unenforced by the type system; the abstraction using the Unique must enforce it.

impl<T: UnwindSafe> UnwindSafe for Unique<T>