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

pub struct Shared<T> where T: ?Sized { /* fields omitted */ }
Unstable (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

Unstable (shared #27730)

Creates a new Shared.

Safety

ptr must be non-null.

Methods from Deref<Target=*mut T>

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());Run

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

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

Trait Implementations

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

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

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

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

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

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

impl<T> Pointer for Shared<T>

Formats the value using the given formatter.

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

The resulting type after dereferencing

The method called to dereference a value

impl<T: RefUnwindSafe + ?Sized> UnwindSafe for Shared<T>
1.9.0
[src]