# Struct std::rc::Weak 1.4.0[−][src]

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

`Weak` is a version of `Rc` that holds a non-owning reference to the managed value. The value is accessed by calling `upgrade` on the `Weak` pointer, which returns an `Option``<``Rc``<T>>`.

Since a `Weak` reference does not count towards ownership, it will not prevent the inner value from being dropped, and `Weak` itself makes no guarantees about the value still being present and may return `None` when `upgrade`d.

A `Weak` pointer is useful for keeping a temporary reference to the value within `Rc` without extending its lifetime. It is also used to prevent circular references between `Rc` pointers, since mutual owning references would never allow either `Rc` to be dropped. For example, a tree could have strong `Rc` pointers from parent nodes to children, and `Weak` pointers from children back to their parents.

The typical way to obtain a `Weak` pointer is to call `Rc::downgrade`.

## Methods

###

`impl<T> Weak<T>`

[src]

####

`pub fn new() -> Weak<T>`

1.10.0
[src]

Constructs a new `Weak<T>`, without allocating any memory. Calling `upgrade` on the return value always gives `None`.

# Examples

    use std::rc::Weak;

    let empty: Weak<i64> = Weak::new();
    assert!(empty.upgrade().is_none());Run

###

`impl<T> Weak<T> where T: ?Sized,`

[src]

####

`pub fn upgrade(&self) -> Option<Rc<T>>`

[src]

Attempts to upgrade the `Weak` pointer to an `Rc`, extending the lifetime of the value if successful.

Returns `None` if the value has since been dropped.

# Examples

    use std::rc::Rc;

    let five = Rc::new(5);

    let weak_five = Rc::downgrade(&five);

    let strong_five: Option<Rc<_>> = weak_five.upgrade();
    assert!(strong_five.is_some());

    // Destroy all strong pointers.
    drop(strong_five);
    drop(five);

    assert!(weak_five.upgrade().is_none());Run

## Trait Implementations

###

`impl<T> !Send for Weak<T> where T: ?Sized,`

[src]

###

`impl<T> Debug for Weak<T> where T: Debug + ?Sized,`

[src]

####

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

[src]

Formats the value using the given formatter. Read more

###

`impl<T> Clone for Weak<T> where T: ?Sized,`

[src]

####

`fn clone(&self) -> Weak<T>`

[src]

Makes a clone of the `Weak` pointer that points to the same value.

# Examples

    use std::rc::{Rc, Weak};

    let weak_five = Rc::downgrade(&Rc::new(5));

    Weak::clone(&weak_five);Run

####

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

1.0.0
[src]

Performs copy-assignment from `source`. Read more

###

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

[src]

###

`impl<T> !Sync for Weak<T> where T: ?Sized,`

[src]

###

`impl<T> Default for Weak<T>`

1.10.0
[src]

####

`fn default() -> Weak<T>`

[src]

Constructs a new `Weak<T>`, allocating memory for `T` without initializing it. Calling `upgrade` on the return value always gives `None`.

# Examples

    use std::rc::Weak;

    let empty: Weak<i64> = Default::default();
    assert!(empty.upgrade().is_none());Run

###

`impl<T> Drop for Weak<T> where T: ?Sized,`

[src]

####

`fn drop(&mut self)`

[src]

Drops the `Weak` pointer.

# Examples

    use std::rc::{Rc, Weak};

    struct Foo;

    impl Drop for Foo {
        fn drop(&mut self) {
            println!("dropped!");
        }
    }

    let foo = Rc::new(Foo);
    let weak_foo = Rc::downgrade(&foo);
    let other_weak_foo = Weak::clone(&weak_foo);

    drop(weak_foo);   // Doesn't print anything
    drop(foo);        // Prints "dropped!"

    assert!(other_weak_foo.upgrade().is_none());Run

# 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
`+`
  Expand all sections
`-`
  Collapse 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`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)