Rust utiliza un verificador de préstamos para hacer cumplir sus reglas de propiedad y garantizar que los programas estén seguros en la memoria. Las reglas de propiedad dictan cómo Rust administra la memoria sobre la pila y el montón.
A medida que escribe programas Rust, deberá usar variables sin cambiar la propiedad del valor asociado. Rust proporciona un mecanismo de préstamo sólido para fomentar la flexibilidad y la reutilización del código.
¿Qué es el préstamo en Rust?
Tomar prestado es acceder al valor de una variable sin tomar posesión de la variable haciendo referencia al propietario. El comprobador de préstamos garantiza que la referencia sea válida y que los datos no se eliminen mediante una construcción denominada períodos de vigencia.
Una vida es el tiempo que existe una variable. Los tiempos de vida comienzan con la creación de variables y terminan con la destrucción de variables. Puede tomar prestada la propiedad de una variable y, cuando la referencia prestada está fuera del alcance, la propiedad vuelve a la variable propietaria. El préstamo es un poco como el
punteros que encontrará en lenguajes como C++ y Go. Pero el compilador de Rust usa el verificador de préstamos para garantizar que los programas estén seguros en la memoria.Un ejemplo de préstamo en Rust
Puede tomar prestada la propiedad de una variable haciendo referencia al propietario mediante el símbolo de y comercial (&).
fnprincipal() {
dejar x = Cuerda::desde("hola"); // x posee "hola"
dejar y = &x; // y hace referencia a x, toma prestado "hola"
imprimir!("{}", X);
imprimir!("{}", y)
}
Sin pedir prestado por referencia, el programa entraría en pánico. Violaría la regla de propiedad de que un valor puede tener un propietario y dos variables no pueden apuntar a la misma ubicación de memoria. El préstamo puede ser muy útil en las funciones. Aquí hay un ejemplo de préstamo en una función, para mantener la propiedad mientras se llama a otras funciones que toman variables locales como argumentos.
fnimprimir_incluso(vector: &Vec<i32>) {
por valores en vector {
si valores % 2 == 0 {
imprimir!("{}", valores);
}
}
}
los imprimir_incluso La función hace referencia a un vector de enteros de 32 bits como su argumento. Luego imprime líneas de valores que son múltiplos de dos en el vector usando un ciclo for y el comando println! macro.
fnprincipal() {
dejar número_vector = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
print_even(&number_vector); // la propiedad es prestada, no movida
imprimir!("La función principal conserva la propiedad del vector numérico{:?}", number_vector)
}
La función principal declara la variable number_vector y le asigna un vector de enteros de 32 bits. Luego llama a la función print_even y le pasa una referencia al número_vector variable usando el símbolo de ampersand.
La función principal conserva la propiedad de la número_vector variable puede continuar usando el valor en su ubicación de memoria.
Préstamo y mutación de referencias
Las funciones también pueden modificar variables prestadas usando referencias mutables a ellas, antes de devolverles la propiedad.
Sin embargo, a diferencia de las variables regulares que se pueden configurar como mutables usando la palabra clave mut, debe prefijar las referencias mutables con el símbolo ampersand.
Antes de hacer referencias mutables, la variable que desea modificar debe ser mutable.
fneliminar_valor(vector: &mudoVec<i32>) -> &Vec<i32> {
vectr.remove(4);
devolver vector
}
los eliminar_valor La función toma la referencia de un vector mutable de enteros de 32 bits. Devuelve un vector de enteros de 32 bits después de eliminar el valor del vector en el cuarto índice.
fnprincipal() {
dejarmudo números = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
eliminar_valor(&mudo números); // referencia mutable aquí
imprimir!("{:?}", números);
}
La función modifica la números vector llamando a remove_value y pasando la referencia mutable de un vector como argumento. Al imprimir el vector, el cuarto índice anterior del vector no existe.
Observe que el argumento es una referencia a un vector mutable.
Es importante entender la propiedad y el endeudamiento
Deberá comprender la propiedad y el préstamo para escribir un código Rust eficiente y seguro para la memoria que se compile y se ejecute. Si su código no sigue las reglas de propiedad, el verificador de préstamo lo detectará. Deberá hacer que su programa sea seguro para la memoria para que Rust lo compile.
El verificador de préstamos es molesto cuando eres nuevo en Rust. Pero, a medida que escriba más código Rust, se acostumbrará y adquirirá experiencia en la escritura de código Rust seguro para la memoria.
