Rust – Concepto de propiedad

El lenguaje de programación Rust es conocido por su gestión de memoria. Este artículo explica cómo Rust usa su modelo de propiedad para una mejor gestión de la memoria. Si desea obtener un resumen de la sintaxis de Rust antes de leer este artículo, puede consultar los Archivos de Rust .

En general, hay 2 formas de administrar la memoria en un programa utilizando Garbage Collects (o) el programador tiene que definir explícitamente el uso de la memoria. Ambas opciones tienen sus ventajas y desventajas, como que la gestión explícita es más rápida, pero la recolección de basura es más fácil de implementar. Rust sigue un nuevo enfoque llamado «Propiedad» que promete ser más rápido y será más fácil cuando te acostumbres. El modelo de propiedad es nuevo para los programadores, pero cuando lo comprende y comienza a practicar, puede mejorar su uso.

¿Qué es la seguridad de la memoria?

La seguridad de la memoria es la propiedad de un programa en el que los punteros de memoria siempre apuntan a una memoria válida del tipo y tamaño correctos. Un programa que no es seguro para la memoria puede fallar o producir resultados y errores inesperados. También puede causar fugas de datos que a su vez reducen la seguridad del programa. Uno de los ejemplos que pueden causar problemas de seguridad de la memoria son los punteros colgantes (punteros que apuntan a datos no válidos (o) nulos).

Pila y montón

Rust almacena tipos de datos primitivos directamente en la memoria, pero los tipos de datos complejos generalmente se almacenan en Stack (o) Heap.

Stack almacena variables de tamaño en tiempo de compilación. Una pila sigue a un orden de último en entrar, primero en salir. Todos los tipos escalares se pueden almacenar en la pila ya que el tamaño es fijo. Si se desconoce el tamaño de la variable en el momento de la compilación, se almacenan en un montón que es adecuado para tipos de datos dinámicos. El montón se asigna para almacenar variables que pueden cambiar a lo largo del ciclo de vida del programa. Realizar operaciones en una pila es más rápido que en un montón debido al tamaño fijo y al acceso directo.

Reglas de propiedad de Rust

Las reglas de propiedad de Rust son las pautas (o) normas para el modelo de propiedad. Estos son

• Cada valor en Rust tiene una variable llamada propietario.
• Solo puede haber un propietario a la vez.
• Cuando el propietario queda fuera del alcance, el valor se eliminará.

Aquí hay un programa Rust simple que sigue las reglas anteriores

fn main() {
    print_gfg()
}
 
// gfg is not declared
fn print_gfg(){
   
   //gfg declared and its validity starts
    let gfg = "GeeksForGeeks"; 
   
    // gfg is in scope so valid
    println!("{}",gfg);
}

Producción:

GeekdForGeeks

Miremos el programa una vez. La función principal tiene solo una línea que llama a la función print_gfg() . La función print_gfg() imprime la string «GeeksForGeeks». Usamos la variable «gfg» para almacenar la string «GeeksForGeeks», por lo que gfg se convertirá en la string, y como se declara en la función print_gfg(), el alcance de la variable donde es el propietario y válido es hasta el final de la función.

propiedad de rust

Múltiples Variables y Datos

En el programa anterior, hemos visto cómo una variable puede acceder a los datos. Ahora veremos un ejemplo de cómo múltiples interactúan con los mismos datos.

fn main() {
    print_gfg()
}
 
// gfg is not declared
fn print_gfg(){
   
    //gfg declared and its validity starts
    let gfg = "Geeks";
   
    // gfg1 copies the data in variable gfg
    let gfg1 = gfg;    
   
    // gfg, gfg1 are in scope so valid
    println!("{} For {}",gfg, gfg1);
} //gfg, gfg1 both go out of scope

 
En este programa, la variable gfg1 copia datos en la variable gfg pero es válida porque el tamaño de la variable se conoce antes del tiempo de compilación, por lo que Rust almacena la variable en la pila.

programa valido

Ahora veamos un programa donde los datos se almacenan en el montón e intentemos copiar esos datos en otra variable. 

fn main() {
    print_gfg()
}
 
fn print_gfg(){
    let gfg = String::from("Geeks"); 
    let gfg1 = gfg;
    println!("{} For {}",gfg, gfg1);
}

Esto da un error porque el tamaño de la variable gfg es desconocido en tiempo de compilación y cuando referimos gfg1 a gfg , el puntero se mueve de gfg a gfg1 en lugar de copiar. Para hacer que copie los datos en lugar de moverlos cuando necesite usar el método de clonación 

fn main() {
    print_gfg()
}
 
fn print_gfg(){
    let gfg = String::from("Geeks"); 
    let gfg1 = gfg.clone();
    println!("{} For {}",gfg, gfg1);
}

clon

Puede obtener más información sobre cómo Rust maneja múltiples variables de datos en Referencias y Préstamos