Rust de los fundamentos al dominio — Lección 8

Los artículos escritos en este blog fueron creados con el objetivo de enseñar. Además, la información del artículo puede ser incorrecta, así que tenga cuidado.

La mayoría de los valores solo pueden ser propiedad de colecciones y variables locales. Cuando necesite ceñirse al montón o compartirlo entre varios propietarios, elija un puntero inteligente que se adapte a su propósito.

Box

enum Node {
    Value(i32, Box<Node>),
    End,
}

let list = Node::Value(
    10,
    Box::new(Node::Value(20, Box::new(Node::End))),
);

Para los tipos recursivos, el tamaño del siguiente valor no se puede conocer inmediatamente en el momento de la compilación. Box coloca el valor en el montón y almacena un puntero de tamaño fijo en el tipo actual.

Box no se comparte automáticamente y todavía hay un solo propietario principal.

Rc y Arco

use std::rc::Rc;

let data = Rc::new(String::from("ItemTable"));
let ui_data = Rc::clone(&data);
let game_data = Rc::clone(&data);

Rc permite que varios lugares posean el mismo valor en un solo hilo. Los valores se limpian cuando desaparece el último Rc.

Compartir entre varios subprocesos requiere Arc, que utiliza recuento de referencias atómicas. Rc y Arc no hacen que sus valores internos se puedan cambiar de forma predeterminada.

variabilidad interna

use std::cell::RefCell;
use std::rc::Rc;

let score = Rc::new(RefCell::new(0));
*score.borrow_mut() += 10;

RefCell verifica las reglas de préstamo en tiempo de ejecución, no en tiempo de compilación. Al mismo tiempo, si se toma prestado incorrectamente, el programa entra en pánico, por lo que la verificación de compilación no desaparece.

El acceso a cambios generalmente se sincroniza entre subprocesos mediante una combinación de Arc y Mutex.

Si se superponen muchos consejos inteligentes, resulta difícil comprender la estructura de propiedad. Primero debe verificar el propósito de que Box sea propietario del montón, Rc lo comparta con un solo hilo y Arc lo comparta entre hilos, y seleccione el tipo más simple.