Ejercicio: Escritura de una función para crear un automóvil

6 minutos

En este ejercicio, usará enumeraciones, estructuras y funciones para procesar pedidos de automóviles nuevos. El desafío consiste en corregir el código de ejemplo para que se compile y se ejecute.

Para trabajar en el código de ejemplo de este ejercicio, tiene dos opciones:

Copiar el código y editarlo en el entorno de desarrollo local.
Abrir el código en un Área de juegos de Rust preparada.

Nota:

En el código de ejemplo, busque la macro todo!. Esta macro indica el código que se debe completar o actualizar.

Definición de una enumeración

La primera tarea consiste en corregir problemas de sintaxis en la definición de enumeración para que el código se compile.

Abra el primer bloque del código de ejemplo.

Copie el código siguiente y edítelo en el entorno de desarrollo local, o bien abra el código en esta Área de juegos de Rust preparada.

// Declare Car struct to describe vehicle with four named fields
struct Car {
    color: String,
    transmission: Transmission,
    convertible: bool,
    mileage: u32,
}

#[derive(PartialEq, Debug)]
// Declare enum for Car transmission type
enum Transmission {
    // todo!("Fix enum definition so code compiles");
    Manual;
    SemiAuto;
    Automatic;
}

Corrija el error de sintaxis de la enumeración Transmission para que el programa se compile con éxito.

Asegúrese de que el código se compila antes de continuar con la sección siguiente. El código aún no muestra ninguna salida, pero debe compilarse sin errores.

Los mensajes de advertencia del compilador se pueden omitir. Las advertencias se deben a que ha declarado definiciones de enumeración y estructuras, pero aún no las ha usado.

Creación de una instancia de una estructura

Después, agregue código para que la función car_factory cree una instancia de una estructura Car. Usaremos los valores de los argumentos de entrada para asignar las características del automóvil.

Agregue el bloque de código siguiente al código existente. El código nuevo se puede agregar en la parte superior o inferior del archivo.

// Build a "Car" by using values from the input arguments
// - Color of car (String)
// - Transmission type (enum value)
// - Convertible (boolean, true if car is a convertible)
fn car_factory(color: String, transmission: Transmission, convertible: bool) {

    // Use the values of the input arguments
    // All new cars always have zero mileage
    let car: Car = todo!("Create an instance of a `Car` struct");
}

Recompile el código y asegúrese de que se compila. De nuevo, los mensajes de advertencia se pueden ignorar.
Complete la declaración de la variable car para que cree una instancia de una estructura "Car". El automóvil nuevo debe usar los valores de los argumentos de entrada pasados a la función. Todos los automóviles nuevos tienen cero kilómetros conducidos.

Sugerencia

Deberá cambiar la instrucción de una declaración de tipo let car: Car a una creación de una instancia let car = Car { ... }.
Recompile el código y asegúrese de que se compila.

Devolución de un valor de una función

Ahora, actualice la función car_factory para devolver la estructura Car creada. Para devolver un valor, la firma de función debe declarar el tipo de valor y el cuerpo de la función debe proporcionar el valor.

Modifique la firma de función para declarar el tipo de valor devuelto como una estructura Car. Cambiará la línea de código siguiente en el archivo:
```
fn car_factory(color: String, transmission: Transmission, convertible: bool) = todo!("Return a `Car` struct") {
```
Sugerencia

Observe la distinción entre mayúsculas y minúsculas. No intente compilar el código todavía.
Para devolver el automóvil recién creado, ajuste la instrucción en la que ha creado una instancia de la estructura Car.
```
    let car: Car = todo!("An instance of a `Car` struct", "Set the function return value");
}
```
Sugerencia

En la sección anterior, ha cambiado la instrucción let car: Car = para crear correctamente una instancia de la estructura Car. Para completar este paso, puede simplificar este código. Puede crear la estructura Car y devolver el automóvil recién creado en una sola instrucción. No tendrá que usar las palabras clave leto return.
Recompile el código y asegúrese de que se compila sin errores.

Llamada a una función

Ya está a punto para llamar a la función y construir algunos automóviles.

Agregue la función main al código existente. El código nuevo se puede agregar en la parte superior o inferior del archivo.

fn main() {
    // We have orders for three new cars!
    // We'll declare a mutable car variable and reuse it for all the cars
    let mut car = car_factory(String::from("Red"), Transmission::Manual, false);
    println!("Car 1 = {}, {:?} transmission, convertible: {}, mileage: {}", car.color, car.transmission, car.convertible, car.mileage);

    car = car_factory(String::from("Silver"), Transmission::Automatic, true);
    println!("Car 2 = {}, {:?} transmission, convertible: {}, mileage: {}", car.color, car.transmission, car.convertible, car.mileage);

    car = car_factory(String::from("Yellow"), Transmission::SemiAuto, false);
    println!("Car 3 = {}, {:?} transmission, convertible: {}, mileage: {}", car.color, car.transmission, car.convertible, car.mileage);    
}

Recompile el código. Ahora se usan todos los elementos declarados, por lo que el compilador no debe emitir errores ni advertencias. Debería ver la siguiente salida:

Car 1 = Red, Manual transmission, convertible: false, mileage: 0
Car 2 = Silver, Automatic transmission, convertible: true, mileage: 0
Car 3 = Yellow, SemiAuto transmission, convertible: false, mileage: 0

Solución

Puede comparar el código con la solución preparada en esta Área de juegos de Rust.

Continuar