Rust Ciclos de vida

El mecanismo de ciclos de vida en Rust es un mecanismo de gestión de recursos tan importante como el mecanismo de propiedad.

La razón por la que se introduce este concepto es principalmente para abordar los problemas de gestión de recursos en sistemas de tipos complejos.

Las referencias son un mecanismo esencial al tratar con tipos complejos, ya que los datos de tipos complejos no pueden copiarse ni procesarse fácilmente por el procesador.

Pero las referencias a menudo conducen a problemas extremadamente complejos de gestión de recursos. Primero conozcamos las referencias colgantes:

Ejemplo

{
    let r;

    {
        let x = 5;
        r = &x;
    }

    println!("r: {}", r);
}

Este código no pasará el compilador de Rust, porque el valor al que hace referencia r ya fue liberado antes de su uso.

En la figura anterior, el rango verde 'a representa el ciclo de vida de r, y el rango azul 'b representa el ciclo de vida de x. Es evidente que 'b es mucho más pequeño que 'a; una referencia debe estar dentro del ciclo de vida del valor para ser válida.

Siempre hemos usado String en las estructuras en lugar de &str; usemos un ejemplo para explicar la razón:

Ejemplo

fn longer(s1: &str, s2: &str) -> &str {
    if s2.len() > s1.len() {
        s2
    } else {
        s1
    }
}

La función longer toma dos segmentos de cadena, s1 y s2, y devuelve la referencia del más largo. Sin embargo, este código no pasará la compilación, porque la referencia devuelta podría ser una referencia expirada:

Ejemplo

fn main() {
    let r;
    {
        let s1 = "rust";
        let s2 = "ecmascript";
        r = longer(s1, s2);
    }
    println!("{} is longer", r);
}

En este programa, aunque se realiza la comparación, cuando se usa r, los valores originales s1 y s2 ya han dejado de ser válidos. Por supuesto, podemos mover el uso de r dentro del ámbito de los ciclos de vida de s1 y s2 para evitar este error, pero para la función, no puede saber qué sucede fuera de sí misma. Para garantizar que los valores que transmite son correctos, debe aplicar el principio de propiedad para eliminar todo peligro, por lo que la función longer no compila.

Anotaciones de ciclo de vida

Las anotaciones de ciclo de vida son una forma de describir el ciclo de vida de las referencias.

Aunque esto no puede cambiar el ciclo de vida de las referencias, permite declarar en lugares apropiados que dos referencias tienen el mismo ciclo de vida.

Las anotaciones de ciclo de vida comienzan con un apóstrofo, seguido de una palabra en minúsculas:

&i32        // 常规引用
&'a i32     // 含有生命周期注释的引用
&'a mut i32 // 可变型含有生命周期注释的引用

Transformemos la función longer con anotaciones de ciclo de vida:

Ejemplo

fn longer<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s2.len() > s1.len() {
        s2
    } else {
        s1
    }
}

Necesitamos usar la declaración de genéricos para especificar el nombre del ciclo de vida. Luego, el ciclo de vida del valor de retorno de la función será el mismo que el de los dos parámetros, por lo que al llamarla se puede escribir así:

Ejemplo

fn main() {
    let r;
    {
        let s1 = "rust";
        let s2 = "ecmascript";
        r = longer(s1, s2);
        println!("{} is longer", r);
    }
}

El resultado de ejecución de la combinación de los dos programas anteriores:

ecmascript is longer

Nota:No olvides el principio de inferencia automática de tipos.

Uso de referencias a segmentos de cadena en estructuras

Esta es la pregunta que quedó pendiente antes; aquí se responde:

Ejemplo

fn main() {
    struct Str<'a> {
        content: &'
a str
    }
    let s = Str {
        content: "string_slice"
    };
    println!("s.content = {}", s.content);
}

Resultado de ejecución:

s.content = string_slice

Si se define un método para la estructura Str:

Ejemplo

impl<'a> Str<'a> {
    fn get_content(&self) -> &str {
        self.content
    }
}

Aquí el valor de retorno no tiene anotación de ciclo de vida, pero no está de más añadirla. Esto es un problema histórico: las primeras versiones de Rust no soportaban la inferencia automática de ciclos de vida, y todos los ciclos de vida debían declararse estrictamente, pero las versiones estables principales de Rust ya soportan esta funcionalidad.

Ciclo de vida estático

Hay una anotación de ciclo de vida especial: 'static. El tipo de datos exacto representado por todas las constantes de cadena entre comillas dobles es &'static str. El ciclo de vida representado por 'static va desde el inicio de la ejecución del programa hasta el final de la misma.

Genéricos, traits y ciclos de vida trabajando juntos

Ejemplo

use std::fmt::Display;

fn longest_with_an_announcement<'a, T>(x: &'a str, y: &'a str, ann: T) -> &'a str
    where T: Display
{
    println!("Announcement! {}", ann);
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

Este programa proviene de la "Biblia de Rust", y utiliza a la vez genéricos, traits y mecanismos de ciclo de vida. No es obligatorio entenderlo por completo, pero puedes experimentarlo; tarde o temprano lo necesitarás.

Otras extensiones