Consejos inteligentes de óxido

Los punteros no son algo nuevo para ningún programador. Son una característica que le permite usar variables para almacenar una dirección en la memoria. La dirección luego "señala", por lo tanto, puntero, a los datos almacenados en esa ubicación.

Los punteros inteligentes son punteros con capacidades extendidas, como cheques vinculados y gestión de memoria automática. Los punteros inteligentes también incluyen metadatos adicionales. Ahora, el concepto de punteros inteligentes no es nuevo, especialmente para los programadores de C ++.

Para este artículo, exploraremos varios consejos inteligentes como se define en la biblioteca de Rust Standard.

Puntos clave

En Rust, los punteros inteligentes son estructuras de datos, sin embargo, a diferencia de los punteros normales, los punteros inteligentes en realidad pueden poseer datos. Se implementan comúnmente utilizando estructuras pero difieren de las estructuras normales en el sentido de que implementan los rasgos Deref y caen.

Hay 5 consejos inteligentes que saber en Rust:

1. Caja
2. Desagüe
3. Gota
4. RC
5. Referencia

NOTA: En óxido se refiere al tipo de datos.

Tenga en cuenta que no cubrirá todos los consejos inteligentes en este artículo.

Caja

El cuadro Smart Pointer proporciona una forma de hacer referencia a los datos almacenados en la memoria del montón. Por defecto, Rust asigna todo en la memoria de la pila. Usando el puntero Smart Smart, podemos acceder a los datos en el montón, incurriendo en una sobrecarga de rendimiento.

El puntero inteligente de la caja también obedece las reglas de propiedad y préstamos. Por lo tanto, tiene un solo propietario de datos y puede tener solo una referencia mutable y cualquier número de referencias inmutables.

fn main ()
// Caja
dejar var = box :: nuevo (100);
println!("Valor: ", var)

En el ejemplo anterior, tenemos un puntero inteligente de caja que almacena el valor 5 en el montón. Tenga en cuenta que la caja en sí se almacena en la pila.

Una vez que se finaliza el programa, el cuadro se desacalta desde la memoria.

Desagüe

Como su nombre indica, el puntero inteligente Deref se usa para permitir la manipulación de la operación de deserencia. Usando el puntero inteligente Deref, puede crear una estructura que pueda funcionar con el puntero inteligente y las referencias.

Un código de ejemplo es como se muestra a continuación:

use std :: ops :: deref;
struct custbox
Datos: T,

suplicar Deref para Custbox
// Param de tipo genérico
Tipo Target = t;
Fn Deref (& Self) -> & t
&ser.datos


fn main ()
Sea x = custbox data: 100;
println!("Valor: ",*(x.deref ()))

Gota

El puntero Smart Smart se usa para la memoria libre que se asigna en el montón. El rasgo de caída en el óxido maneja la memoria cuando una variable sale del alcance. No necesitamos llamar a este rasgo manualmente, ya que Rust hará esto por nosotros. Sin embargo, podemos implementarlo para tipos personalizados como se muestra.

estructurar mystruct
X: i32,

Impl Drop for Mystruct
fn drop (& Mut self)
println!("Dropping: ", Self.X)


fn main ()
Sea _x = mystruct x: 100;
Sea _y = mystruct x: 200;

Lo anterior implementa el rasgo de caída para el rasgo personalizado. La salida es como se muestra:

Dropping: 200

Dropping: 100

Conclusión

En este artículo, cubrimos cómo crear y trabajar con consejos inteligentes comunes en el lenguaje de programación de óxido. Puede obtener más información sobre los punteros Smart Rust en el recurso a continuación:

https: // doc.lang óxido.org/book/ch15-00-smart-pointers.html