Cómo trabajar con la propiedad en Rust

En este artículo, exploraremos la propiedad de óxido y cómo funciona. El enfoque de propiedad y préstamo es una construcción relativamente nueva y viajes a los recién nacidos. En esta guía, intentaremos desmitificar cómo funciona la propiedad.

¿Qué es la propiedad??

Tradicionalmente, hay dos formas fundamentales de administrar recuerdos. El primero son los recolectores de basura; Se utiliza principalmente en lenguajes de alto nivel que abstractan el concepto de gestión de la memoria del programador.

El segundo es la gestión de memoria "manual", donde el programador define explícitamente el uso de la memoria. Aunque proporciona control, deja mucho espacio para dispararse en el pie.

El óxido adquiere un enfoque alternativo llamado propiedad y préstamo. La propiedad es una nueva "construcción" que define un valor tiene su propietario.

Las siguientes son las reglas de propiedad en Rust:

1. Cualquier valor definido en un programa de óxido tiene un propietario.
2. Un valor puede tener un propietario a la vez.
3. Un valor solo puede vivir mientras su dueño esté vivo. Lo que significa que el propietario no ha sido eliminado.

Para comprender mejor la propiedad del óxido, discutamos algunos conceptos y ejemplos.

Alcance

Podemos definir el alcance como un rango bajo el cual vive un valor específico. El alcance juega un papel importante en la propiedad y los préstamos.

Cada variable está sujeto a su alcance. En este caso, un alcance se refiere a un bloque como encerrado por un par de aparatos ortopédicos rizados.

Considere el siguiente programa de ejemplo:

fn main ()
// definido en el alcance de la función principal
Long_life = 100;

// definido en un bloque interno (nuevo alcance)
Let short_life = 10;
println!("Alcance interno: ", short_life);

// short_life no existe en este alcance
println!("Alcance externo: ", short_life);
println!("Long Life: ", long_life);

fn new_func ()
println!("Alcance de funciones: ", long_life);

En el programa de ejemplo anterior, tenemos dos funciones: la función principal y la función new_func.

Dentro de la función principal, declaramos una nueva variable llamada long_life. También creamos un nuevo alcance y declaramos una nueva variable llamada short_life.

Si ejecuta el código anterior, el compilador de óxido le dirá que las variables, short_life y long_life, no existen en ese alcance.

Esto se debe a que la variable short_life se declara en un nuevo alcance. Cuando termina ese alcance, se cae la variable. Esto significa que la variable short_life no existe fuera de las láminas rizadas.

El mismo caso se aplica a la variable Long_Life. Solo es accesible en la función principal. No está permitido acceder a él en otra función.

Sombreado

El sombreado variable es un caso típico. Se refiere a una característica donde la primera declaración variable está "sobrescribida" o sombreada por otra.

Tome el siguiente código de ejemplo:

fn main ()
Deje var1 = 10;
println!("Antes de la sombra: ", var1);
// después de la sombra
Deje var1 = 100;
println!("After Shadow: ", var1);

Aquí, tenemos una variable llamada var1 establecida en 10. Luego, lo sombreamos declarando la variable con el mismo nombre y la establecemos en un nuevo valor.

Esto debería imprimir:

Nota: No confunda el sombreado con mutabilidad. Consulte nuestro tutorial sobre la mutabilidad de Rust para obtener más información.

Transferir propiedad

El óxido nos permite transferir la propiedad del valor utilizando operaciones de copia o movimiento. Tome el siguiente código de ejemplo:

fn main ()
Deje var1 = 10;
Deje var2 = var1;
println!("var1: ", var1);
println!("var2: ", var2);

El ejemplo anterior declara una variable, VAR1 y le asigna el valor 10. También declaramos una nueva variable, VAR2, y la asignamos a VAR1.

Cuando esto sucede, Rust creará una nueva copia del valor y la asignará a VAR2. Esto significa que ambas variables no comparten el valor, y cada una ocupa su propio espacio de memoria.

¿Qué sucede cuando intentamos realizar la operación anterior con un valor con un tamaño de memoria no determinista??

Tome un tipo de cadena, por ejemplo. Dado que puede crecer o encogerse, no hay un tamaño de memoria predeterminado. Por lo tanto, no implementa el rasgo de copia:

dejar str1 = string :: de ("hola");
Str2 = str1;
println!("str1: ", str1);
println!("str1: ", str2);

Ejecutar la misma operación obliga al compilador de óxido a mover el valor de Str1 a STR2. Dado que un valor puede tener solo un propietario a la vez, la variable STR1 ya no es válida. Esto hará que el compilador devuelva un error si intentamos acceder a él:

Conclusión

Una razón por la cual los rustáceos aman el lenguaje de programación de óxido es la propiedad. Es una nueva característica que ofrece más flexibilidad y seguridad al mismo tiempo. Comprender cómo funciona puede ser beneficioso para crear aplicaciones rápidas y eficientes. Además, se discutieron las reglas de propiedad y los conceptos. Esperamos que hayas encontrado este artículo útil. Consulte los otros artículos de Sugerencia de Linux para obtener más consejos e información.