Primero aclaro que no quise traducir Ownership a Propiedad o algo así porque normalmente en videos y eventos se habla de Ownership por lo tanto me parece lo más acertado seguir con esto.
Ownership es la característica más exclusiva de Rust, y le permite a Rust garantizar la seguridad de la memoria sin necesidad de un recolector de basura. Por lo tanto, es importante comprender cómo funciona el Ownership en Rust.
Todos los programas tienen que administrar la forma en que usan la memoria de una computadora mientras se ejecutan. Algunos lenguajes tienen un recolector de basura que constantemente busca memoria que ya no se usa mientras se ejecuta el programa como java; en otros lenguajes como C, el programador debe asignar explícitamente y liberar la memoria. Rust utiliza un tercer enfoque: la memoria se administra a través de un sistema de propiedad o Ownership con un conjunto de reglas que el compilador verifica en el momento de la compilación. Ninguna de las funciones de Ownership ralentiza su programa mientras se está ejecutando.
En muchos lenguajes de programación, no tiene que pensar en el stack y el heap con mucha frecuencia. Pero en un lenguaje de programación de sistemas como Rust, si un valor está en la stack o en el heap tiene efectos sobre cómo se comporta el lenguaje y por qué tiene que tomar ciertas decisiones.
Tanto el stack como el heap son partes de la memoria que están disponibles para que su código las use en tiempo de ejecución, pero están estructuradas de diferentes maneras. El stack almacena valores en el orden en que los obtiene y elimina los valores en el orden opuesto. Esto se conoce como último en entrar, primero en salir es una pila.
Todos los datos almacenados en la pila deben tener un tamaño fijo conocido. Los datos con un tamaño desconocido en el momento de la compilación o un tamaño que podría cambiar deben almacenarse en el heap. El heap está menos organizado: cuando coloca datos, solicita una cierta cantidad de espacio. El sistema operativo encuentra un lugar vacío que sea lo suficientemente grande, lo marca como en uso y devuelve un puntero, que es la dirección de la ubicación. Este proceso se denomina asignación en el heap y a veces se abrevia como asignación. Insertar valores en la pila no se considera asignación. Debido a que el puntero es un tamaño fijo conocido, puede almacenar el puntero en la pila, pero cuando desee los datos reales, se debe seguir el puntero.
Agregar datos a el stack es más rápido que asignar en el heap porque el sistema operativo nunca tiene que buscar un lugar para almacenar nuevos datos; esa ubicación siempre está en la parte superior de la pila. Comparativamente, la asignación de espacio en el heap requiere más trabajo, porque el sistema operativo primero debe encontrar un espacio lo suficientemente grande como para contener los datos y luego realizar la contabilidad para prepararse para la próxima asignación.
Acceder a los datos en el heap es más lento que acceder a los datos en el Stack porque tienes que seguir un puntero para llegar allí. Los procesadores son más rápidos si saltan menos en la memoria.
Cuando su código llama a una función, los valores pasados a la función (incluidos, potencialmente, punteros a los datos del heap) y las variables locales de la función se insertan en el Stack. Cuando termina la función, esos valores se sacan.
Realizar un seguimiento de qué partes del código están utilizando qué datos en el heap, minimizar la cantidad de datos duplicados en el heap y limpiar los datos no utilizados en el heap para que no se quede sin espacio son todos problemas que el Ownership aborda.
Primero, echemos un vistazo a las reglas de Ownership:
- Cada valor en Rust tiene una variable que se llama su propietario.
- Solo puede haber un propietario a la vez.
- Cuando el propietario sale del alcance, el valor se descartará.
Como primer ejemplo de Ownership, veremos el alcance de algunas variables. Un ámbito es el rango dentro de un programa para el cual un artículo es válido. Digamos que tenemos una variable que se ve así:
let s = "hello";
La variable s se refiere a un literal de cadena, donde el valor de la cadena está codificado en el texto de nuestro programa. La variable es válida desde el punto en el que se declara hasta el final del alcance actual. El listado 4-1 tiene comentarios que indican dónde la variable s es válida.
{ // s is not valid here, it’s not yet declared
let s = "hello"; // s is valid from this point forward
// do stuff with s
}
En otras palabras, hay dos puntos importantes en el tiempo aquí:
Cuando s entra en el alcance, es válido.
Sigue siendo válido hasta que se salga del alcance.
En este punto, la relación entre los ámbitos y cuando las variables son válidas es similar a la de otros lenguajes de programación. Ahora construiremos sobre esta comprensión introduciendo el tipo de cadena.
Ya me quedo muy largo seguimos en otro post...
Dejo link:
https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html
