Propiedad en Rust

Los programas de computadora deben administrar los recursos de memoria que utilizan en tiempo de ejecución.

La mayoría de los lenguajes de programación tienen funciones para administrar la memoria:

Lenguajes como C/C++ gestionan la memoria principalmente de forma manual; el desarrollador debe solicitar y liberar recursos de memoria manualmente. Sin embargo, para mejorar la eficiencia del desarrollo, muchos desarrolladores no tienen el hábito de liberar memoria a tiempo, siempre que no afecte la implementación de la funcionalidad del programa. Por lo tanto, la gestión manual de la memoria a menudo causa desperdicio de recursos.

Los programas escritos en Java se ejecutan en una máquina virtual (JVM). La JVM tiene la capacidad de reclamar automáticamente los recursos de memoria. Sin embargo, este método suele reducir la eficiencia en tiempo de ejecución, por lo que la JVM reclama recursos lo menos posible, lo que también hace que el programa ocupe una gran cantidad de memoria.

La propiedad es un concepto novedoso para la mayoría de los desarrolladores. Es un mecanismo sintáctico diseñado por el lenguaje Rust para usar la memoria de manera eficiente. El concepto de propiedad nació para permitir que Rust analice de forma más eficaz la utilidad de los recursos de memoria en la fase de compilación y así lograr la gestión de la memoria.

Reglas de propiedad

La propiedad tiene las siguientes tres reglas:

  • Cada valor en Rust tiene una variable llamada su propietario.
  • Solo puede haber un propietario a la vez.
  • Cuando el propietario sale del ámbito de ejecución del programa, el valor se elimina.

Estas tres reglas son la base del concepto de propiedad.

A continuación se presentarán los conceptos relacionados con la propiedad.

Ámbito de variables

Usamos el siguiente programa para describir el concepto de ámbito de variables:

{
    // 在声明以前,变量 s 无效
    let s = "ejemplo";
    // 这里是变量 s 的可用范围
}
// 变量范围已经结束,变量 s 无效

El ámbito de una variable es un atributo de la variable que representa su región válida. Por defecto, es válido desde la declaración de la variable hasta que finaliza el ámbito en el que se encuentra.


Memoria y asignación

Si definimos una variable y le asignamos un valor, el valor de esa variable existe en la memoria. Esta situación es muy común. Pero si la longitud de los datos que necesitamos almacenar es incierta (por ejemplo, una cadena ingresada por el usuario), no podemos determinar la longitud de los datos al definirla, ni podemos hacer que el programa asigne un espacio de memoria de longitud fija para el almacenamiento de datos en la fase de compilación. (Hay quien dice que asignar el mayor espacio posible puede resolver el problema, pero ese método no es elegante). Esto requiere un mecanismo por el cual el programa solicite memoria por sí mismo en tiempo de ejecución: el montón (heap). Todos los 'recursos de memoria' mencionados en este capítulo se refieren al espacio de memoria ocupado por el montón.

Donde hay asignación, hay liberación; un programa no puede ocupar un recurso de memoria para siempre. Por lo tanto, el factor clave que determina si los recursos se desperdician es si el recurso se libera a tiempo.

Escribimos el programa de ejemplo de la cadena de forma equivalente en C:

{
    char *s = strdup("ejemplo");
    free(s); // Liberar el recurso s
}

Obviamente, Rust no llama a la función free para liberar el recurso de la cadena s (sé que esto es incorrecto en C, porque "ejemplo" no está en el montón; aquí se supone que lo está). La razón por la que Rust no muestra explícitamente el paso de liberación es que, cuando finaliza el ámbito de la variable, el compilador de Rust añade automáticamente una llamada a la función de liberación de recursos.

Este mecanismo parece muy sencillo: no es más que ayudar al programador a añadir una llamada a una función de liberación de recursos en el lugar adecuado. Pero este mecanismo simple puede resolver eficazmente uno de los problemas de programación que más dolores de cabeza ha causado a los programadores en la historia.


Formas de interacción entre variables y datos

Las principales formas de interacción entre variables y datos son el movimiento (Move) y la clonación (Clone):

Movimiento

Múltiples variables pueden interactuar con los mismos datos de diferentes maneras en Rust:

let x = 5;
let y = x;

Este programa vincula el valor 5 a la variable x, luego copia el valor de x y lo asigna a la variable y. Ahora habrá dos valores 5 en la pila. En este caso, los datos son de tipo 'dato básico', que no necesitan almacenarse en el montón. La forma de 'movimiento' de los datos que solo están en la pila es la copia directa, lo que no requiere más tiempo ni más espacio de almacenamiento. Los tipos de 'dato básico' son estos:

  • Todos los tipos enteros, como i32, u32, i64, etc.
  • El tipo booleano bool, con valores true o false.
  • Todos los tipos de coma flotante, f32 y f64.
  • El tipo carácter char.
  • Tuplas que contienen solo datos de los tipos anteriores.

Pero si los datos que interactúan están en el montón, la situación es otra:

let s1 = String::from("hello");
let s2 = s1;

El primer paso crea un objeto String con el valor "hello". Aquí "hello" puede considerarse como datos de longitud indeterminada, que deben almacenarse en el montón.

El segundo paso es ligeramente diferente (Esto no es del todo cierto, solo sirve como referencia de comparación.):

Como se muestra en la figura: dos objetos String están en la pila, y cada objeto String tiene un puntero a la cadena "hello" en el montón. Al asignar a s2, solo se copian los datos de la pila; la cadena en el montón sigue siendo la cadena original.

Como dijimos antes, cuando una variable sale del ámbito, Rust llama automáticamente a la función de liberación de recursos y limpia la memoria del montón de esa variable. Pero si s1 y s2 se liberan, "hello" en el montón se liberaría dos veces, lo cual no está permitido por el sistema. Para garantizar la seguridad, s1 ya no es válido al asignar a s2. Así es: después de asignar el valor de s1 a s2, s1 no se puede volver a usar. El siguiente programa es incorrecto:

let s1 = String::from("hello");
let s2 = s1; 
println!("{}, world!", s1); // 错误!s1 已经失效

Así que la situación real es:

s1 solo existe nominalmente.


Clonación

Rust intenta reducir al máximo el costo de ejecución de los programas, por lo que, de forma predeterminada, los datos de mayor tamaño se almacenan en el montón y la interacción de datos se realiza mediante el movimiento. Pero si necesita copiar los datos simplemente para otro uso, puede usar el segundo método de interacción de datos: la clonación.

Ejemplo

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone();
    println!("s1 = {}, s2 = {}", s1, s2);
}

Resultado de la ejecución:

s1 = hello, s2 = hello

Aquí se copia realmente el "hello" del montón, por lo que s1 y s2 están vinculados cada uno a un valor, y al liberarse se tratan como dos recursos.

Por supuesto, la clonación solo se usa cuando es necesario copiar; después de todo, copiar datos lleva más tiempo.


Mecanismo de propiedad en funciones

Esta es la situación más compleja para las variables.

Si una variable se pasa como parámetro de una función a otra función, ¿cómo se puede gestionar la propiedad de forma segura?

El siguiente programa describe el principio de funcionamiento del mecanismo de propiedad en esta situación:

Ejemplo

fn main() {
    let s = String::from("hello");
    // s se declara válido

    takes_ownership(s);
    // el valor de s se pasa a la función como parámetro
    // por lo que se puede considerar que s se ha movido y no es válido desde aquí

    let x = 5;
    // x se declara válido

    makes_copy(x);
    // el valor de x se pasa a la función como parámetro
    // pero x es un tipo básico, sigue siendo válido
    // aquí todavía se puede usar x pero no s

} // fin de la función, x no es válido, luego s. Pero s se ha movido, por lo que no necesita ser liberado


fn takes_ownership(some_string: String) {
    // un parámetro String some_string se pasa, válido
    println!("{}", some_string);
} // fin de la función, el parámetro some_string se libera aquí

fn makes_copy(some_integer: i32) {
    // un parámetro i32 some_integer se pasa, válido
    println!("{}", some_integer);
} // fin de la función, el parámetro some_integer es de tipo básico, no necesita liberación

Si una variable se pasa como parámetro a una función, el efecto es el mismo que un movimiento.

Mecanismo de propiedad del valor de retorno de funciones

Ejemplo

fn main() {
    let s1 = gives_ownership();
    // gives_ownership mueve su valor de retorno a s1

    let s2 = String::from("hello");
    // s2 se declara válido

    let s3 = takes_and_gives_back(s2);
    // s2 se mueve como parámetro, s3 obtiene la propiedad del valor de retorno
} // s3 se libera al ser inválido, s2 se mueve, s1 se libera al ser inválido.

fn gives_ownership() -> String {
    let some_string = String::from("hello");
    // some_string se declara válido

    return some_string;
    // some_string se mueve fuera de la función como valor de retorno
}

fn takes_and_gives_back(a_string: String) -> String { 
    // a_string se declara válido

    a_string  // a_string se mueve fuera de la función como valor de retorno
}

La propiedad de una variable que se devuelve como valor de retorno de una función se moverá fuera de la función y regresará al lugar de llamada, en lugar de ser invalidada y liberada directamente.


Referencias y préstamo

Una referencia (Reference) es un concepto con el que los desarrolladores de C++ están bastante familiarizados.

Si conoces el concepto de punteros, puedes considerarla como un tipo de puntero.

En esencia, una 'referencia' es una forma de acceso indirecto a una variable.

Ejemplo

fn main() {
    let s1 = String::from("hello");
    let s2 = &s1;
    println!("s1 is {}, s2 is {}", s1, s2);
}

Resultado de la ejecución:

s1 is hello, s2 is hello

&El operador puede tomar una 'referencia' de la variable.

Cuando se referencia el valor de una variable, la variable en sí no se considera inválida. Porque la "referencia" no copia el valor de la variable en la pila:

El mismo principio aplica al pasar parámetros a funciones:

Ejemplo

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

Resultado de ejecución:

The length of 'hello' is 5.

Las referencias no obtienen la propiedad del valor.

Las referencias solo pueden tomar prestada (Borrow) la propiedad del valor.

Una referencia en sí misma también es un tipo y tiene un valor; este valor registra la ubicación de otro valor, pero la referencia no posee la propiedad del valor al que apunta:

Ejemplo

fn main() {
    let s1 = String::from("hello");
    let s2 = &s1;
    let s3 = s1;
    println!("{}", s2);
}

Este programa es incorrecto: porque el s1 que s2 tomó prestado ya ha movido la propiedad a s3, s2 no podrá seguir tomando prestado el uso de la propiedad de s1. Si se necesita usar s2 para usar ese valor, se debe volver a tomar prestado:

Ejemplo

fn main() {
    let s1 = String::from("hello");
    let mut s2 = &s1;
    let s3 = s1;
    s2 = &s3; // Volver a tomar prestada la propiedad desde s3
    println!("{}", s2);
}

Este programa es correcto.

Dado que las referencias no tienen propiedad, incluso si toman prestada la propiedad, solo disfrutan del derecho de uso (es lo mismo que alquilar una casa).

Si se intenta usar el derecho prestado para modificar datos, será bloqueado:

Ejemplo

fn main() {
    let s1 = String::from("run");
    let s2 = &s1;
    println!("{}", s2);
    s2.push_str("oob"); // Error: está prohibido modificar el valor prestado
    println!("{}", s2);
}

En este programa, s2 intenta modificar el valor de s1 y es bloqueado; la propiedad prestada no puede modificar el valor del propietario.

Por supuesto, también existe una forma de préstamo mutable. Es como alquilar una casa: si el reglamento de la administración de la propiedad permite que el propietario modifique la estructura de la casa, y el propietario declara en el contrato que te otorga este derecho durante el alquiler, entonces puedes reformar la casa:

Ejemplo

fn main() {
    let mut s1 = String::from("run");
    // s1 es mutable

    let s2 = &mut s1;
    // s2 es una referencia mutable

    s2.push_str("oob");
    println!("{}", s2);
}

Este programa ya no tiene problemas. Usamos &mut para marcar los tipos de referencia mutable.

En comparación con las referencias inmutables, además de tener diferentes permisos, las referencias mutables no permiten múltiples referencias, mientras que las inmutables sí:

Ejemplo

let mut s = String::from("hello");

let r1 = &mut s;
let r2 = &mut s;

println!("{}, {}", r1, r2);

Este programa es incorrecto porque hay múltiples referencias mutables a s.

El diseño de Rust para las referencias mutables se debe principalmente a la consideración de las colisiones de acceso a datos en estado de concurrencia, y evita que esto ocurra en la fase de compilación.

Debido a que una de las condiciones necesarias para que ocurra una colisión de acceso a datos es que los datos sean escritos por al menos un usuario y, al mismo tiempo, leídos o escritos por al menos otro usuario, cuando un valor tiene una referencia mutable no se permite que sea referenciado nuevamente por ninguna otra referencia.

Referencias colgantes (Dangling References)

Este es un concepto con otro nombre. Si se pone en un lenguaje de programación con punteros, se refiere a aquellos punteros que no apuntan realmente a datos accesibles (nota: no son necesariamente punteros nulos, también pueden ser recursos ya liberados). Son como una cuerda que ha perdido el objeto que sostenía, por eso se llaman "referencias colgantes".

Las "referencias colgantes" no están permitidas en Rust; si existen, el compilador las detectará.

A continuación se muestra un caso típico de referencia colgante:

Ejemplo

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s
}

Obviamente, al finalizar la función dangle, el valor de su variable local no se devuelve como valor de retorno, sino que se libera. Sin embargo, su referencia sí se devuelve; el valor al que apunta esta referencia ya no se puede garantizar que exista, por lo que no se permite que esto ocurra.

Otras extensiones