# 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

`*mut T` but non-zero and covariant.

This is often the correct thing to use when building data structures using raw pointers, but is ultimately more dangerous to use because of its additional properties. If you're not sure if you should use `Shared<T>`, just use `*mut T`!

Unlike `*mut T`, the pointer must always be non-null, even if the pointer is never dereferenced. This is so that enums may use this forbidden value as a discriminant -- `Option<Shared<T>>` has the same size as `Shared<T>`. However the pointer may still dangle if it isn't dereferenced.

Unlike `*mut T`, `Shared<T>` is covariant over `T`. If this is incorrect for your use case, you should include some PhantomData in your type to provide invariance, such as `PhantomData<Cell<T>>` or `PhantomData<&'a mut T>`. Usually this won't be necessary; covariance is correct for most safe abstractions, such as Box, Rc, Arc, Vec, and LinkedList. This is the case because they provide a public API that follows the normal shared XOR mutable rules of Rust.

## Methods

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

#### `pub fn empty() -> Shared<T>`
[src]

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

Creates a new `Shared` that is dangling, but well-aligned.

This is useful for initializing types which lazily allocate, like `Vec::new` does.

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

#### `pub const unsafe fn new_unchecked(ptr: *mut T) -> Shared<T>`
[src]

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

Creates a new `Shared`.

# Safety

`ptr` must be non-null.

#### `pub fn new(ptr: *mut T) -> Option<Shared<T>>`
[src]

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

Creates a new `Shared` if `ptr` is non-null.

#### `pub fn as_ptr(self) -> *mut T`
[src]

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

Acquires the underlying `*mut` pointer.

####
ⓘImportant traits for &'a mut I

### Important traits for &'a mut I

`impl<'a, I> Iterator for &'a mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'a, R: Read + ?Sized> Read for &'a mut Rimpl<'a, W: Write + ?Sized> Write for &'a mut W`
`pub unsafe fn as_ref(&self) -> &T`
[src]

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

Dereferences the content.

The resulting lifetime is bound to self so this behaves "as if" it were actually an instance of T that is getting borrowed. If a longer (unbound) lifetime is needed, use `&*my_ptr.ptr()`.

####
ⓘImportant traits for &'a mut I

### Important traits for &'a mut I

`impl<'a, I> Iterator for &'a mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'a, R: Read + ?Sized> Read for &'a mut Rimpl<'a, W: Write + ?Sized> Write for &'a mut W`
`pub unsafe fn as_mut(&mut self) -> &mut T`
[src]

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

Mutably dereferences the content.

The resulting lifetime is bound to self so this behaves "as if" it were actually an instance of T that is getting borrowed. If a longer (unbound) lifetime is needed, use `&mut *my_ptr.ptr_mut()`.

#### `pub unsafe fn as_mut_ptr(&self) -> *mut T`
[src]

Deprecated since 1.19

: renamed to `as_ptr` for ergonomics/consistency

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

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

## Trait Implementations

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

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

Returns a copy of the value. Read more

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

Performs copy-assignment from `source`. Read more

### `impl<'a, T> From<&'a mut T> for Shared<T> where
T: ?Sized,`
[src]

#### `fn from(reference: &'a mut T) -> Shared<T>`
[src]

Performs the conversion.

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

#### `fn from(unique: Unique<T>) -> Shared<T>`
[src]

Performs the conversion.

### `impl<'a, T> From<&'a T> for Shared<T> where
T: ?Sized,`
[src]

#### `fn from(reference: &'a T) -> Shared<T>`
[src]

Performs the conversion.

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

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

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

Formats the value using the given formatter.

### `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
↹
  Switch tab
⏎
  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`)