Médio Rust

Tupla de produto e cálculo de total

Enunciado

Crie uma tupla chamada produto com os campos: nome (&str), preço unitário (f64) e quantidade (u32). Desestruture a tupla em três variáveis e calcule o valor total (preço * quantidade). Imprima o nome, a quantidade e o total formatado com duas casas decimais no formato: Produto: Caneta, Quantidade: 10, Total: R$ 25.00.

Requisitos

  • Declarar a tupla com os três tipos corretos.
  • Desestruturar a tupla em variáveis separadas.
  • Calcular o total como f64 e imprimir com duas casas decimais.
  • Seguir exatamente o formato de saída.

Código inicial

fn main() {
    // TODO: crie a tupla, desestruture e calcule o total
}

Saída esperada

Produto: Caneta, Quantidade: 10, Total: R$ 25.00
Ver dica

A desestruturação é feita com let (nome, preco, qtd) = produto;. Para formatar duas casas decimais, use {:.2}.

Mostrar solução 
fn main() {
    // Tupla com tipos heterogêneos: &str, f64, u32
    let produto: (&str, f64, u32) = ("Caneta", 2.50, 10);

    // Desestruturação em variáveis separadas
    let (nome, preco, quantidade) = produto;

    // Cálculo do total: preco é f64, quantidade é u32 -> converte para f64
    let total = preco * quantidade as f64;

    // Impressão formatada com duas casas decimais
    println!(
        "Produto: {}, Quantidade: {}, Total: R$ {:.2}",
        nome, quantidade, total
    );
}

Passo a passo

  1. Declaramos produto como uma tupla de três elementos com tipos &str, f64 e u32.
  2. Usamos let (nome, preco, quantidade) = produto; para desestruturar a tupla em três variáveis independentes.
  3. Para calcular o total, multiplicamos preco (f64) por quantidade convertida para f64 com as f64. Sem a conversão, o compilador daria erro de tipos incompatíveis.
  4. O resultado é armazenado em total, que é f64.
  5. No println!, usamos {:.2} para exibir o total com exatamente duas casas decimais.
  6. A saída segue o formato pedido, com R$ antes do valor.

Por que funciona

Tuplas em Rust permitem agrupar valores de tipos diferentes em uma única estrutura de tamanho fixo. A desestruturação com let (a, b, c) = tupla; é uma forma idiomática de extrair os campos. A conversão explícita com as f64 é necessária porque Rust não faz coerção implícita entre tipos numéricos — isso evita erros sutis de precisão. O formatador {:.2} garante a apresentação monetária.

Erros comuns

  • Esquecer o as f64: let total = preco * quantidade; gera erro de compilação (cannot multiply f64 by u32). Corrija com quantidade as f64.
  • Desestruturar na ordem errada: let (preco, nome, quantidade) = produto; faz preco receber a string e o código não compila. Mantenha a ordem dos tipos.
  • Usar {} em vez de {:.2}: o total sai como 25 em vez de 25.00.

Outra forma de resolver

Você pode acessar os campos pelo índice sem desestruturar:

let total = produto.1 * produto.2 as f64;
println!("Produto: {}, Quantidade: {}, Total: R$ {:.2}", produto.0, produto.2, total);

Útil quando você só precisa de um ou dois campos e não quer criar variáveis para todos.

Saída esperada

Produto: Caneta, Quantidade: 10, Total: R$ 25.00