Primitive Type pointer1.0.0 [−]
Raw, unsafe pointers, *const T
, and *mut T
.
Working with raw pointers in Rust is uncommon, typically limited to a few patterns.
Use the null
and null_mut
functions to create null pointers, and the
is_null
method of the *const T
and *mut T
types to check for null.
The *const T
and *mut T
types also define the offset
method, for
pointer math.
Common ways to create raw pointers
1. Coerce a reference (&T
) or mutable reference (&mut T
).
let my_num: i32 = 10; let my_num_ptr: *const i32 = &my_num; let mut my_speed: i32 = 88; let my_speed_ptr: *mut i32 = &mut my_speed;Run
To get a pointer to a boxed value, dereference the box:
let my_num: Box<i32> = Box::new(10); let my_num_ptr: *const i32 = &*my_num; let mut my_speed: Box<i32> = Box::new(88); let my_speed_ptr: *mut i32 = &mut *my_speed;Run
This does not take ownership of the original allocation and requires no resource management later, but you must not use the pointer after its lifetime.
2. Consume a box (Box<T>
).
The into_raw
function consumes a box and returns
the raw pointer. It doesn't destroy T
or deallocate any memory.
let my_speed: Box<i32> = Box::new(88); let my_speed: *mut i32 = Box::into_raw(my_speed); // By taking ownership of the original `Box<T>` though // we are obligated to put it together later to be destroyed. unsafe { drop(Box::from_raw(my_speed)); }Run
Note that here the call to drop
is for clarity - it indicates
that we are done with the given value and it should be destroyed.
3. Get it from C.
extern crate libc; use std::mem; fn main() { unsafe { let my_num: *mut i32 = libc::malloc(mem::size_of::<i32>()) as *mut i32; if my_num.is_null() { panic!("failed to allocate memory"); } libc::free(my_num as *mut libc::c_void); } }Run
Usually you wouldn't literally use malloc
and free
from Rust,
but C APIs hand out a lot of pointers generally, so are a common source
of raw pointers in Rust.
Methods
impl<T> *const T where
T: ?Sized,
[src]
T: ?Sized,
fn is_null(self) -> bool
[src]
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<'a>(self) -> Option<&'a T>
1.9.0[src]
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 ptr: *const u8 = &10u8 as *const u8; unsafe { if let Some(val_back) = ptr.as_ref() { println!("We got back the value: {}!", val_back); } }Run
unsafe fn offset(self, count: isize) -> *const T
[src]
Calculates the offset from a pointer. count
is in units of T; e.g. a
count
of 3 represents a pointer offset of 3 * size_of::<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
1.16.0[src]
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 * size_of::<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:
// 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 offset_to(self, other: *const T) -> Option<isize>
[src]
Calculates the distance between two pointers. The returned value is in
units of T: the distance in bytes is divided by mem::size_of::<T>()
.
If the address different between the two pointers ia not a multiple of
mem::size_of::<T>()
then the result of the division is rounded towards
zero.
This function returns None
if T
is a zero-sized typed.
Examples
Basic usage:
#![feature(offset_to)] fn main() { let a = [0; 5]; let ptr1: *const i32 = &a[1]; let ptr2: *const i32 = &a[3]; assert_eq!(ptr1.offset_to(ptr2), Some(2)); assert_eq!(ptr2.offset_to(ptr1), Some(-2)); assert_eq!(unsafe { ptr1.offset(2) }, ptr2); assert_eq!(unsafe { ptr2.offset(-2) }, ptr1); }Run
impl<T> *mut T where
T: ?Sized,
[src]
T: ?Sized,
fn is_null(self) -> bool
[src]
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<'a>(self) -> Option<&'a T>
1.9.0[src]
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 ptr: *mut u8 = &mut 10u8 as *mut u8; unsafe { if let Some(val_back) = ptr.as_ref() { println!("We got back the value: {}!", val_back); } }Run
unsafe fn offset(self, count: isize) -> *mut T
[src]
Calculates the offset from a pointer. count
is in units of T; e.g. a
count
of 3 represents a pointer offset of 3 * size_of::<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
1.16.0[src]
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 * size_of::<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:
// 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<'a>(self) -> Option<&'a mut T>
1.9.0[src]
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
fn offset_to(self, other: *const T) -> Option<isize>
[src]
Calculates the distance between two pointers. The returned value is in
units of T: the distance in bytes is divided by mem::size_of::<T>()
.
If the address different between the two pointers ia not a multiple of
mem::size_of::<T>()
then the result of the division is rounded towards
zero.
This function returns None
if T
is a zero-sized typed.
Examples
Basic usage:
#![feature(offset_to)] fn main() { let mut a = [0; 5]; let ptr1: *mut i32 = &mut a[1]; let ptr2: *mut i32 = &mut a[3]; assert_eq!(ptr1.offset_to(ptr2), Some(2)); assert_eq!(ptr2.offset_to(ptr1), Some(-2)); assert_eq!(unsafe { ptr1.offset(2) }, ptr2); assert_eq!(unsafe { ptr2.offset(-2) }, ptr1); }Run
Trait Implementations
impl<T, U> CoerceUnsized<*mut U> for *mut T where
T: Unsize<U> + ?Sized,
U: ?Sized,
[src]
T: Unsize<U> + ?Sized,
U: ?Sized,
impl<T, U> CoerceUnsized<*const U> for *mut T where
T: Unsize<U> + ?Sized,
U: ?Sized,
[src]
T: Unsize<U> + ?Sized,
U: ?Sized,
impl<T, U> CoerceUnsized<*const U> for *const T where
T: Unsize<U> + ?Sized,
U: ?Sized,
[src]
T: Unsize<U> + ?Sized,
U: ?Sized,
impl<T> PartialOrd<*mut T> for *mut T where
T: ?Sized,
[src]
T: ?Sized,
fn partial_cmp(&self, other: &*mut T) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &*mut T) -> bool
[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &*mut T) -> bool
[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &*mut T) -> bool
[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &*mut T) -> bool
[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl<T> PartialOrd<*const T> for *const T where
T: ?Sized,
[src]
T: ?Sized,
fn partial_cmp(&self, other: &*const T) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &*const T) -> bool
[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &*const T) -> bool
[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &*const T) -> bool
[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &*const T) -> bool
[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl<T> Eq for *mut T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Eq for *const T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Pointer for *mut T where
T: ?Sized,
[src]
T: ?Sized,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter.
impl<T> Pointer for *const T where
T: ?Sized,
[src]
T: ?Sized,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter.
impl<T> !Send for *mut T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> !Send for *const T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Debug for *const T where
T: ?Sized,
[src]
T: ?Sized,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter.
impl<T> Debug for *mut T where
T: ?Sized,
[src]
T: ?Sized,
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter.
impl<T> !Sync for *mut T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> !Sync for *const T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Ord for *const T where
T: ?Sized,
[src]
T: ?Sized,
fn cmp(&self, other: &*const 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
impl<T> Ord for *mut T where
T: ?Sized,
[src]
T: ?Sized,
fn cmp(&self, other: &*mut 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
impl<T> PartialEq<*mut T> for *mut T where
T: ?Sized,
[src]
T: ?Sized,
fn eq(&self, other: &*mut T) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
[src]
This method tests for !=
.
impl<T> PartialEq<*const T> for *const T where
T: ?Sized,
[src]
T: ?Sized,
fn eq(&self, other: &*const T) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
[src]
This method tests for !=
.
impl<T> Hash for *mut T
[src]
fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
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]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<T> Hash for *const T
[src]
fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
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]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<T> Zeroable for *const T where
T: ?Sized,
[src]
T: ?Sized,
For fat pointers to be considered "zero", only the "data" part needs to be null.
fn is_zero(&self) -> bool
[src]
🔬 This is a nightly-only experimental API. (nonzero
#27730)
needs an RFC to flesh out the design
impl<T> Zeroable for *mut T where
T: ?Sized,
[src]
T: ?Sized,
For fat pointers to be considered "zero", only the "data" part needs to be null.
fn is_zero(&self) -> bool
[src]
🔬 This is a nightly-only experimental API. (nonzero
#27730)
needs an RFC to flesh out the design