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

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

Unstable (`shared` #27730)

: needs an RFC to flesh out design

A wrapper around a raw `*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`

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

Unstable (`shared` #27730)

Creates a new `Shared`.

## Methods from Deref<Target=*mut T>

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

Returns true if the pointer is null.

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

Unstable (`ptr_as_ref` #27780)

: Option is not clearly the right return type, and we may want to tie the return lifetime to a borrow of the raw pointer

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.

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

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

Returns true if the pointer is null.

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

Unstable (`ptr_as_ref` #27780)

: Option is not clearly the right return type, and we may want to tie the return lifetime to a borrow of the raw pointer

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.

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

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

Unstable (`ptr_as_ref` #27780)

: return value does not necessarily convey all possible information

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.

## Trait Implementations

### `impl<T> !Send for Shared<T> where T: ?Sized`

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

### `impl<T> !Sync for Shared<T> where T: ?Sized`

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

### `impl<T> Clone for Shared<T> where T: ?Sized`

#### `fn clone(&self) -> Shared<T>`

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

### `impl<T> Copy for Shared<T> where T: ?Sized`

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

### `impl<T> Deref for Shared<T> where T: ?Sized`

#### `type Target = *mut T`

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

### `impl<T> Pointer for Shared<T>`

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

### `impl<T: RefRecoverSafe + ?Sized> RecoverSafe for Shared<T>`

# 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

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