# Primitive Type pointer [−]

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` function to create null pointers, and the `is_null` method of the `*const T` type to check for null. The `*const T` type also defines the `offset` method, for pointer math.

# Common ways to create raw pointers

## 1. Coerce a reference (`&T`) or mutable reference (`&mut T`).

fn main() { 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; }

    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;

To get a pointer to a boxed value, dereference the box:

fn main() { 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; }

    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;

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.

fn main() { 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)); } }

    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));
    }

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.

#![feature(libc)] extern crate libc; use std::mem; fn main() { unsafe { let my_num: *mut i32 = libc::malloc(mem::size_of::<i32>() as libc::size_t) as *mut i32; if my_num.is_null() { panic!("failed to allocate memory"); } libc::free(my_num as *mut libc::c_void); } }

    extern crate libc;

    use std::mem;

    fn main() {
        unsafe {
            let my_num: *mut i32 = libc::malloc(mem::size_of::<i32>() as libc::size_t) as *mut i32;
            if my_num.is_null() {
                panic!("failed to allocate memory");
            }
            libc::free(my_num as *mut libc::c_void);
        }
    }

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.

See also the `std::ptr` module.

## Methods

### `impl<T> *const T where T: ?Sized`

#### `fn is_null(self) -> bool`
1.0.0

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

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

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);
    }

### `impl<T> *mut T where T: ?Sized`

#### `fn is_null(self) -> bool`
1.0.0

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

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

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

fn main() { 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]". }

    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]".

## Trait Implementations

### `impl<T> Zeroable for *const T where T: ?Sized`

### `impl<T> Zeroable for *mut T where T: ?Sized`

### `impl<T> PartialEq<*const T> for *const T where T: ?Sized`
1.0.0

#### `fn eq(&self, other: &*const T) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &Rhs) -> bool`
1.0.0

This method tests for `!=`.

### `impl<T> Eq for *const T where T: ?Sized`
1.0.0

### `impl<T> PartialEq<*mut T> for *mut T where T: ?Sized`
1.0.0

#### `fn eq(&self, other: &*mut T) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &Rhs) -> bool`
1.0.0

This method tests for `!=`.

### `impl<T> Eq for *mut T where T: ?Sized`
1.0.0

### `impl<T> Clone for *const T where T: ?Sized`
1.0.0

#### `fn clone(&self) -> *const T`

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`
1.0.0

Performs copy-assignment from `source`. Read more

### `impl<T> Clone for *mut T where T: ?Sized`
1.0.0

#### `fn clone(&self) -> *mut T`

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`
1.0.0

Performs copy-assignment from `source`. Read more

### `impl<T> Ord for *const T where T: ?Sized`
1.0.0

#### `fn cmp(&self, other: &*const T) -> Ordering`

This method returns an `Ordering` between `self` and `other`. Read more

### `impl<T> PartialOrd<*const T> for *const T where T: ?Sized`
1.0.0

#### `fn partial_cmp(&self, other: &*const T) -> Option<Ordering>`

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `fn lt(&self, other: &*const T) -> bool`

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `fn le(&self, other: &*const T) -> bool`

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`

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `fn ge(&self, other: &*const T) -> bool`

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<T> Ord for *mut T where T: ?Sized`
1.0.0

#### `fn cmp(&self, other: &*mut T) -> Ordering`

This method returns an `Ordering` between `self` and `other`. Read more

### `impl<T> PartialOrd<*mut T> for *mut T where T: ?Sized`
1.0.0

#### `fn partial_cmp(&self, other: &*mut T) -> Option<Ordering>`

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `fn lt(&self, other: &*mut T) -> bool`

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `fn le(&self, other: &*mut T) -> bool`

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`

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `fn ge(&self, other: &*mut T) -> bool`

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<T> !Send for *const T where T: ?Sized`
1.0.0

### `impl<T> !Send for *mut T where T: ?Sized`
1.0.0

### `impl<T> !Sync for *const T where T: ?Sized`
1.0.0

### `impl<T> !Sync for *mut T where T: ?Sized`
1.0.0

### `impl<T, U> CoerceUnsized<*mut U> for *mut T where T: Unsize<U> + ?Sized, U: ?Sized`

### `impl<T, U> CoerceUnsized<*const U> for *mut T where T: Unsize<U> + ?Sized, U: ?Sized`

### `impl<T, U> CoerceUnsized<*const U> for *const T where T: Unsize<U> + ?Sized, U: ?Sized`

### `impl<T> Hash for *const T`
1.0.0

#### `fn hash<H>(&self, state: &mut H) where H: Hasher`

Feeds this value into the state given, updating the hasher as necessary.

#### `fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher`
1.3.0

Feeds a slice of this type into the state provided.

### `impl<T> Hash for *mut T`
1.0.0

#### `fn hash<H>(&self, state: &mut H) where H: Hasher`

Feeds this value into the state given, updating the hasher as necessary.

#### `fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher`
1.3.0

Feeds a slice of this type into the state provided.

### `impl<T> Pointer for *const T where T: ?Sized`
1.0.0

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

Formats the value using the given formatter.

### `impl<T> Pointer for *mut T where T: ?Sized`
1.0.0

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

Formats the value using the given formatter.

### `impl<T> Debug for *const T`
1.0.0

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

Formats the value using the given formatter.

### `impl<T> Debug for *mut T`
1.0.0

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

Formats the value using the given formatter.

### `impl<T: RefUnwindSafe + ?Sized> UnwindSafe for *const T`
1.9.0
[src]

### `impl<T: RefUnwindSafe + ?Sized> UnwindSafe for *mut T`
1.9.0
[src]

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)