# Struct std::ptr::Shared [−] [src]

    pub struct Shared<T> where
        T: ?Sized,  { /* fields omitted */ }

🔬 This is a nightly-only experimental API. (`shared` #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 has shared ownership of the referent. Useful for building abstractions like `Rc<T>` or `Arc<T>`, which internally use raw pointers to manage the memory that they own.

## Methods

### `impl<T> Shared<T> where
T: ?Sized,`
[src]

#### `unsafe fn new(ptr: *const T) -> Shared<T>`

🔬 This is a nightly-only experimental API. (`shared` #27730)

Creates a new `Shared`.

# Safety

`ptr` must be non-null.

### `impl<T> Shared<T> where
T: ?Sized,`
[src]

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

🔬 This is a nightly-only experimental API. (`shared` #27730)

Acquires the underlying pointer as a `*mut` pointer.

## Methods from Deref<Target = *const 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<'a>(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 * 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

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

🔬 This is a nightly-only experimental API. (`offset_to` #41079)

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

#### `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<'a>(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 * 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

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

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

🔬 This is a nightly-only experimental API. (`offset_to` #41079)

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<Shared<U>> for Shared<T> where
T: Unsize<U> + ?Sized,
U: ?Sized,`
[src]

### `impl<T> Copy for Shared<T> where
T: ?Sized,`
[src]

### `impl<T> !Send for Shared<T> where
T: ?Sized,`
[src]

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

### `impl<T> Pointer for Shared<T>`
[src]

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

Formats the value using the given formatter.

### `impl<T> !Sync for Shared<T> where
T: ?Sized,`
[src]

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

### `impl<T> Clone for Shared<T> where
T: ?Sized,`
[src]

#### `fn clone(&self) -> Shared<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> Deref for Shared<T> where
T: ?Sized,`
[src]

#### `type Target = *const T`

The resulting type after dereferencing

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

The method called to dereference a value

### `impl<T: RefUnwindSafe + ?Sized> UnwindSafe for Shared<T>`
[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`)