Las referencias Weak rompen ciclos en Rust

Un hijo que apunta a su padre debe hacerlo débilmente, o nada se libera jamás.

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

struct Node {
    name: String,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

fn main() {
    let root = Rc::new(Node {
        name: "tours".to_string(),
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(Vec::new()),
    });

    let leaf = Rc::new(Node {
        name: "basics".to_string(),
        parent: RefCell::new(Rc::downgrade(&root)),
        children: RefCell::new(Vec::new()),
    });

    root.children.borrow_mut().push(Rc::clone(&leaf));

    if let Some(parent) = leaf.parent.borrow().upgrade() {
        println!("{} is under {}", leaf.name, parent.name);
    }
    println!("strong {} weak {}", Rc::strong_count(&root),
             Rc::weak_count(&root));
}

Cómo funciona

1. Rc::downgrade crea un handle Weak que no posee.
2. upgrade devuelve None cuando el destino ya no está.
3. Dos referencias fuertes en un ciclo fugan el ciclo completo.

Palabras clave y builtins usados aquí

• Some
• String
• Vec
• fn
• if
• let
• struct
• use

El intento, en números

Líneas

30

Caracteres a escribir

665

Tokens

231

Ritmo de tres estrellas

110 tpm

Al ritmo de tres estrellas de 110 tokens por minuto, este intento toma unos 126 segundos.

Escribe este fragmento

Paso 3 de 3 en Mutabilidad interior; paso 9 de 11 en Lifetimes y mutabilidad interior.

← Anterior Siguiente →