Punteros inteligentes en Rust: ¿Cómo funcionan?

La gestión de la memoria es uno de los puntos de venta de Rust, especialmente porque la seguridad no se ve comprometida. El sistema de propiedad de Rust permite que el compilador garantice la seguridad del código y la ausencia de errores de memoria, como punteros colgantes y fugas de memoria.

Rust también proporciona punteros inteligentes con metadatos y capacidades adicionales más allá de los punteros tradicionales. Los punteros inteligentes son útiles para abordar las fugas de memoria.

¿Qué son los punteros inteligentes en Rust?

Los punteros inteligentes son uno de Tipos de datos de Rust que amplía las capacidades de los punteros regulares al ofrecer funcionalidades adicionales como operadores sobrecargados, destructores y administración automática de memoria.

Rust utiliza estructuras para ejecutar punteros inteligentes; por lo tanto, los punteros inteligentes también tienen capacidades de propiedad.

Cuando vincula la memoria que contiene datos asignados dinámicamente con punteros inteligentes, se desasignan automáticamente. Los punteros inteligentes brindan funcionalidad para controlar el Vida útil del objeto de Rust, lo que los hace útiles para evitar errores como la desreferenciación de puntero nulo y las fugas de memoria que son populares en otros lenguajes de bajo nivel como C y C++.

Beneficios de usar punteros inteligentes

Estos son algunos de los beneficios de usar punteros inteligentes:

1. Gestión automática de memoria: Los punteros inteligentes proporcionan una gestión automática de la memoria, incluida la asignación y desasignación, en contraste con la gestión manual de la memoria con punteros normales.
2. Seguridad mejorada: Los punteros inteligentes hacen cumplir la semántica de propiedad, lo que garantiza que solo un propietario pueda acceder a los recursos por vez, lo que evita el seguimiento de datos y los errores relacionados con la concurrencia.
3. Flexibilidad: Rust proporciona múltiples punteros inteligentes, cada uno con su conjunto de semántica de propiedad para escribir código seguro de forma flexible.
4. Administracion de recursos: puede usar punteros inteligentes para administrar otros recursos, como controladores de archivos y sockets de red, encapsulando los recursos dentro de un puntero inteligente que facilita la gestión de su ciclo de vida y garantiza que se cierren y liberen correctamente después usar.
5. Desempeño mejorado: Los punteros inteligentes ayudan a mejorar el rendimiento al reducir la copia y las asignaciones de memoria: la reducción del espacio de memoria por el uso de punteros inteligentes da como resultado un mayor rendimiento.

Los punteros inteligentes son adecuados para aplicaciones de tamaño mediano a grande, especialmente en los casos en que la gestión de la memoria es fundamental.

Tipos de punteros inteligentes

Rust proporciona varios tipos de punteros inteligentes, incluidos Caja, RC, RefCelda, y exclusión mutua.

1. El puntero inteligente Box

El Caja Smart Pointer es el puntero inteligente más simple y común de Rust. El Caja El puntero inteligente ayuda a asignar valores en el montón y crea un puntero en caja para la accesibilidad.

El Caja Smart Pointer es útil para la asignación de memoria dinámica cuando necesita asegurarse de que la memoria se desasigne automáticamente cuando los punteros están fuera del alcance.

Así es como puede declarar y usar un Caja puntero:

fnprincipal(){
// nueva instancia del puntero inteligente de la caja 
dejar x = Caja::nuevo(5);
imprimir!(X)
}

El Caja type es parte del preludio de Rust, por lo que no tendrá que importar el tipo, a diferencia de otros punteros inteligentes.

El X la variable es una Caja puntero que apunta al valor entero 5. Rust asigna la memoria para el valor en el montón y la desasigna automáticamente cuando la variable está fuera del alcance.

2. El puntero inteligente Rc

El RC El puntero inteligente (referencia contada) proporciona funcionalidad para crear valores de propiedad compartida. El RC los punteros inteligentes rastrean el número de referencias a un valor y desasignan el valor cuando la última referencia está fuera del alcance.

El RC El puntero inteligente es útil cuando necesita compartir la propiedad de un valor de accesibilidad en varias partes de su programa.

para declarar un RC puntero inteligente, importará el RC estructura de la biblioteca estándar, declarar una nueva RC puntero con el nuevo y clone la variable de puntero con el clon variable.

usar estándar:: rc:: Rc;
fnprincipal() {
// nueva instancia del puntero inteligente RC 
dejar x = Rc:: nuevo(5);
dejar y = Rc:: clon(&x);
imprimir!("x = {}, y = {}", x, y);
}

El X variable es la RC variable puntero, y la y variable es un clon con acceso al valor en memoria. El recuento de referencia es dos y el valor se desasigna de la memoria cuando las variables están fuera del alcance.

3. El puntero inteligente RefCell

El RefCelda El puntero inteligente proporciona mutabilidad interior que permite que las referencias inmutables y mutables coexistan siempre que haya una referencia mutable por tiempo determinado.

El RefCelda El puntero inteligente es útil cuando se mutan valores pertenecientes a referencias mutables.

El Ref. celda La función no es parte del preludio de Rust, por lo que deberá importar la estructura de la biblioteca estándar para usar el puntero inteligente.

usar std:: celda:: RefCell;
fnprincipal(){
// nueva instancia del puntero inteligente Refcell 
dejar x = RefCell:: nuevo(5);
dejar y = x.prestar();
dejar z = x.borrow_mut();
imprimir!("y = {}", *y);
imprimir!("z = {}", *z);
} 

El Ref. celda puntero inteligente contiene el valor, y el y variable es la referencia inmutable al valor. El prestamos_mut La función crea una referencia mutable del valor.

El programa es seguro si solo hay una referencia mutable a la vez.

4. El puntero inteligente Mutex

El exclusión mutua puntero inteligente proporciona exclusiones mutuas. El exclusión mutua El puntero inteligente es útil para sincronizar el acceso a los valores a través de múltiples subprocesos en programas concurrentes.

El exclusión mutua El puntero inteligente proporciona exclusión mutua para garantizar que solo un subproceso pueda acceder al valor y evitar el seguimiento de datos.

Tendrás que importar el exclusión mutua estructurar y crear una nueva instancia con el nuevo función a utilizar exclusión mutua Puntero inteligente en Rust.

usar estándar:: sincronización:: Mutex;
fnprincipal() {
// nueva instancia del puntero mutex 
dejar contador = exclusión mutua:: nuevo (0);
 {
dejarmudo num = contador.bloquear().desenvolver();
 *numero += 1;
 }
imprimir!("Resultado: {}", *contador.bloquear().desenvolver());
}

El encimera la variable es la nueva exclusión mutua instancia. El principal La función adquiere un bloqueo en el mutex con el cerrar metodo de la exclusión mutua instancia. El bloqueo permite la modificación segura del valor del contador antes de liberar el bloqueo e imprimir el valor.

El exclusión mutua tipo garantiza que solo un subproceso puede acceder a los recursos compartidos (en este caso, el encimera variable) y modificar su valor a la vez. La exclusión mutua garantiza que el acceso simultáneo a los recursos compartidos se serialice para evitar el seguimiento de datos y otros problemas de simultaneidad.

El modelo de propiedad de Rust garantiza la seguridad de la memoria

Los punteros inteligentes son uno de los enfoques de Rust para la seguridad y flexibilidad de la memoria. El modelo de propiedad de Rust garantiza que los programas utilicen la memoria de forma segura con el comprobador de préstamo en tiempo de compilación.

El verificador de préstamos es una característica crucial del modelo de propiedad de Rust que aplica reglas estrictas para la accesibilidad y modificación de la memoria.