Struct std::ptr::Unique
[−]
[src]
pub struct Unique<T> where T: ?Sized { /* fields omitted */ }
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
[src]
unsafe fn new(ptr: *mut T) -> Unique<T>
unique
#27730)unsafe fn get(&self) -> &T
unique
#27730)Dereferences the content.
unsafe fn get_mut(&mut self) -> &mut T
unique
#27730)Mutably dereferences the content.
Methods from Deref<Target=*mut T>
fn is_null(self) -> bool
1.0.0
Returns true if the pointer is null.
Examples
Basic usage:
let s: &str = "Follow the rabbit"; let ptr: *const u8 = s.as_ptr(); assert!(!ptr.is_null());Run
unsafe fn as_ref(self) -> Option<&'a T>
1.9.0
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:
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); } }Run
unsafe fn offset(self, count: isize) -> *const T
1.0.0
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:
let s: &str = "123"; let ptr: *const u8 = s.as_ptr(); unsafe { println!("{}", *ptr.offset(1) as char); println!("{}", *ptr.offset(2) as char); }Run
fn wrapping_offset(self, count: isize) -> *const T
ptr_wrapping_offset
#37570)Calculates the offset from a pointer using wrapping arithmetic.
count
is in units of T; e.g. a count
of 3 represents a pointer
offset of 3 * sizeof::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .offset(count)
instead when possible, because offset
allows the compiler to optimize better.
Examples
Basic usage:
#![feature(ptr_wrapping_offset)] // Iterate using a raw pointer in increments of two elements let data = [1u8, 2, 3, 4, 5]; let mut ptr: *const u8 = data.as_ptr(); let step = 2; let end_rounded_up = ptr.wrapping_offset(6); // This loop prints "1, 3, 5, " while ptr != end_rounded_up { unsafe { print!("{}, ", *ptr); } ptr = ptr.wrapping_offset(step); }Run
fn is_null(self) -> bool
1.0.0
Returns true if the pointer is null.
Examples
Basic usage:
let mut s = [1, 2, 3]; let ptr: *mut u32 = s.as_mut_ptr(); assert!(!ptr.is_null());Run
unsafe fn as_ref(self) -> Option<&'a T>
1.9.0
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:
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); } }Run
unsafe fn offset(self, count: isize) -> *mut T
1.0.0
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:
let mut s = [1, 2, 3]; let ptr: *mut u32 = s.as_mut_ptr(); unsafe { println!("{}", *ptr.offset(1)); println!("{}", *ptr.offset(2)); }Run
fn wrapping_offset(self, count: isize) -> *mut T
ptr_wrapping_offset
#37570)Calculates the offset from a pointer using wrapping arithmetic.
count
is in units of T; e.g. a count
of 3 represents a pointer
offset of 3 * sizeof::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .offset(count)
instead when possible, because offset
allows the compiler to optimize better.
Examples
Basic usage:
#![feature(ptr_wrapping_offset)] // Iterate using a raw pointer in increments of two elements let mut data = [1u8, 2, 3, 4, 5]; let mut ptr: *mut u8 = data.as_mut_ptr(); let step = 2; let end_rounded_up = ptr.wrapping_offset(6); while ptr != end_rounded_up { unsafe { *ptr = 0; } ptr = ptr.wrapping_offset(step); } assert_eq!(&data, &[0, 2, 0, 4, 0]);Run
unsafe fn as_mut(self) -> Option<&'a mut T>
1.9.0
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:
let mut s = [1, 2, 3]; let ptr: *mut u32 = s.as_mut_ptr(); let first_value = unsafe { ptr.as_mut().unwrap() }; *first_value = 4; println!("{:?}", s); // It'll print: "[4, 2, 3]".Run
Trait Implementations
impl<T> Pointer for Unique<T>
[src]
impl<T> Deref for Unique<T> where T: ?Sized
[src]
type Target = *mut T
The resulting type after dereferencing
fn deref(&self) -> &*mut T
The method called to dereference a value
impl<T> Sync for Unique<T> where T: Sync + ?Sized
[src]
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
[src]
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.