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

Usando Structs

Siguiente ►
►

En este tema, aprenderemos cómo utilizar structs en Rust para organizar y manejar datos de manera eficiente. Los structs son una forma de agrupar datos relacionados bajo un mismo nombre, permitiendo un acceso más estructurado y seguro a la información.

Contenido

  1. Definición de Structs
  2. Instanciación de Structs
  3. Acceso a los Campos de un Struct
  4. Actualización de Structs
  5. Métodos en Structs
  6. Ejercicios Prácticos
  7. Conclusión

Definición de Structs

Un struct en Rust se define utilizando la palabra clave struct, seguida del nombre del struct y una lista de campos. Cada campo tiene un nombre y un tipo.

struct Usuario {
    nombre: String,
    edad: u32,
    email: String,
}

En este ejemplo, hemos definido un struct llamado Usuario con tres campos: nombre, edad y email.

Instanciación de Structs

Para crear una instancia de un struct, se especifican los valores de cada campo.

fn main() {
    let usuario1 = Usuario {
        nombre: String::from("Alice"),
        edad: 30,
        email: String::from("[email protected]"),
    };

    println!("Nombre: {}, Edad: {}, Email: {}", usuario1.nombre, usuario1.edad, usuario1.email);
}

En este ejemplo, hemos creado una instancia de Usuario llamada usuario1 y hemos impreso sus campos.

Acceso a los Campos de un Struct

Podemos acceder a los campos de un struct utilizando la notación de punto (.).

fn main() {
    let usuario1 = Usuario {
        nombre: String::from("Alice"),
        edad: 30,
        email: String::from("[email protected]"),
    };

    println!("Nombre: {}", usuario1.nombre);
    println!("Edad: {}", usuario1.edad);
    println!("Email: {}", usuario1.email);
}

Actualización de Structs

Podemos actualizar los campos de un struct utilizando la notación de punto (.). Sin embargo, los structs en Rust son inmutables por defecto. Para actualizar un campo, debemos declarar el struct como mutable utilizando la palabra clave mut.

fn main() {
    let mut usuario1 = Usuario {
        nombre: String::from("Alice"),
        edad: 30,
        email: String::from("[email protected]"),
    };

    usuario1.edad = 31;
    println!("Edad actualizada: {}", usuario1.edad);
}

Métodos en Structs

Podemos definir métodos para un struct utilizando la palabra clave impl. Los métodos permiten encapsular el comportamiento relacionado con el struct.

struct Usuario {
    nombre: String,
    edad: u32,
    email: String,
}

impl Usuario {
    fn descripcion(&self) -> String {
        format!("{} tiene {} años y su email es {}", self.nombre, self.edad, self.email)
    }
}

fn main() {
    let usuario1 = Usuario {
        nombre: String::from("Alice"),
        edad: 30,
        email: String::from("[email protected]"),
    };

    println!("{}", usuario1.descripcion());
}

En este ejemplo, hemos definido un método descripcion para el struct Usuario que devuelve una cadena con la descripción del usuario.

Ejercicios Prácticos

Ejercicio 1: Crear y Usar un Struct

  1. Define un struct llamado Libro con los campos titulo, autor y paginas.
  2. Crea una instancia de Libro y asigna valores a sus campos.
  3. Imprime los valores de los campos del Libro.
struct Libro {
    titulo: String,
    autor: String,
    paginas: u32,
}

fn main() {
    let libro1 = Libro {
        titulo: String::from("Rust Programming"),
        autor: String::from("Steve Klabnik"),
        paginas: 500,
    };

    println!("Título: {}", libro1.titulo);
    println!("Autor: {}", libro1.autor);
    println!("Páginas: {}", libro1.paginas);
}

Ejercicio 2: Actualizar un Campo de un Struct

  1. Define un struct llamado Carro con los campos marca, modelo y año.
  2. Crea una instancia mutable de Carro y asigna valores a sus campos.
  3. Actualiza el campo año y luego imprime los valores actualizados.
struct Carro {
    marca: String,
    modelo: String,
    año: u32,
}

fn main() {
    let mut carro1 = Carro {
        marca: String::from("Toyota"),
        modelo: String::from("Corolla"),
        año: 2020,
    };

    carro1.año = 2021;
    println!("Marca: {}", carro1.marca);
    println!("Modelo: {}", carro1.modelo);
    println!("Año: {}", carro1.año);
}

Ejercicio 3: Definir y Usar un Método en un Struct

  1. Define un struct llamado Persona con los campos nombre y edad.
  2. Implementa un método llamado saludo que devuelva una cadena de saludo.
  3. Crea una instancia de Persona y llama al método saludo.
struct Persona {
    nombre: String,
    edad: u32,
}

impl Persona {
    fn saludo(&self) -> String {
        format!("Hola, mi nombre es {} y tengo {} años.", self.nombre, self.edad)
    }
}

fn main() {
    let persona1 = Persona {
        nombre: String::from("Carlos"),
        edad: 25,
    };

    println!("{}", persona1.saludo());
}

Conclusión

En esta sección, hemos aprendido cómo definir y usar structs en Rust. Hemos cubierto la definición de structs, la instanciación, el acceso y la actualización de campos, así como la implementación de métodos. Los structs son una herramienta poderosa para organizar y manejar datos en Rust, y su uso adecuado puede mejorar significativamente la claridad y la eficiencia de tu código.

En el próximo tema, exploraremos los enums y la coincidencia de patrones, que son fundamentales para manejar diferentes tipos de datos y comportamientos en Rust.

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