El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Entendiendo la Propiedad

Siguiente ►
►

La propiedad es uno de los conceptos más importantes y únicos en Rust. Este concepto ayuda a gestionar la memoria de manera segura y eficiente sin necesidad de un recolector de basura. En esta sección, aprenderemos los principios básicos de la propiedad, cómo funciona y cómo afecta a la gestión de la memoria en Rust.

Conceptos Clave de la Propiedad

  1. Propietario (Owner): Cada valor en Rust tiene un propietario.
  2. Alcance (Scope): El alcance es el bloque de código en el que el propietario es válido.
  3. Transferencia de Propiedad (Move): La propiedad puede ser transferida de una variable a otra.
  4. Reglas de Propiedad:
    • Cada valor en Rust tiene un propietario.
    • Solo puede haber un propietario a la vez.
    • Cuando el propietario sale de su alcance, el valor se elimina.

Ejemplo Básico de Propiedad

Veamos un ejemplo simple para entender cómo funciona la propiedad en Rust:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;

    println!("{}", s1); // Esto causará un error
}

Explicación del Código

  1. let s1 = String::from("hello");: Aquí, s1 es el propietario del valor "hello".
  2. let s2 = s1;: La propiedad del valor "hello" se transfiere de s1 a s2. Ahora, s1 ya no es válido.
  3. println!("{}", s1);: Intentar usar s1 después de que su propiedad ha sido transferida causará un error de compilación.

Transferencia de Propiedad (Move)

Cuando asignamos s1 a s2, la propiedad del valor se mueve de s1 a s2. Esto significa que s1 ya no es válido y no puede ser usado.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 ya no es válido

    println!("{}", s2); // Esto funciona
}

Clonación de Datos

Si queremos que tanto s1 como s2 sean válidos, podemos clonar los datos en lugar de mover la propiedad.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // Clonamos el valor

    println!("s1 = {}, s2 = {}", s1, s2); // Ambos son válidos
}

Explicación del Código

  1. let s2 = s1.clone();: Aquí, en lugar de mover la propiedad, clonamos el valor. Ahora, tanto s1 como s2 son propietarios de sus propias copias del valor "hello".

Propiedad y Funciones

Cuando pasamos una variable a una función, la propiedad de esa variable se transfiere a la función.

fn main() {
    let s = String::from("hello");

    takes_ownership(s);

    println!("{}", s); // Esto causará un error
}

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}

Explicación del Código

  1. takes_ownership(s);: La propiedad de s se transfiere a la función takes_ownership.
  2. println!("{}", s);: Intentar usar s después de que su propiedad ha sido transferida causará un error de compilación.

Devolviendo Propiedad desde Funciones

Podemos devolver la propiedad desde una función para que el valor pueda ser usado después de la llamada a la función.

fn main() {
    let s1 = gives_ownership();
    let s2 = String::from("hello");
    let s3 = takes_and_gives_back(s2);

    println!("s1 = {}, s3 = {}", s1, s3);
}

fn gives_ownership() -> String {
    let some_string = String::from("hello");
    some_string
}

fn takes_and_gives_back(a_string: String) -> String {
    a_string
}

Explicación del Código

  1. gives_ownership() -> String: Esta función crea un String y devuelve su propiedad.
  2. takes_and_gives_back(a_string: String) -> String: Esta función toma un String y devuelve su propiedad.

Ejercicio Práctico

Ejercicio

Escribe un programa que:

  1. Cree una variable String.
  2. Pase la variable a una función que imprima el valor.
  3. Intente usar la variable después de la llamada a la función (esto debería causar un error).
  4. Modifica el programa para que la función devuelva la propiedad y la variable pueda ser usada después de la llamada a la función.

Solución

fn main() {
    let s = String::from("hello");

    let s = takes_and_gives_back(s);

    println!("{}", s);
}

fn takes_and_gives_back(a_string: String) -> String {
    println!("{}", a_string);
    a_string
}

Explicación del Código

  1. let s = takes_and_gives_back(s);: La propiedad de s se transfiere a la función takes_and_gives_back y luego se devuelve.
  2. println!("{}", s);: Ahora s es válido y puede ser usado después de la llamada a la función.

Conclusión

En esta sección, hemos aprendido los conceptos básicos de la propiedad en Rust, cómo se transfiere la propiedad y cómo afecta a la gestión de la memoria. La propiedad es fundamental para escribir programas seguros y eficientes en Rust. En la próxima sección, exploraremos las referencias y el préstamo, que nos permitirán trabajar con datos sin transferir la propiedad.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados