Médio Rust

Função que consome e devolve

Enunciado

Crie uma função adiciona_ponto que recebe uma String por valor, adiciona um ponto final e devolve a String modificada. No main, chame a função passando uma string, imprima o resultado e garanta que a variável original não seja usada após a chamada (pois foi movida).

Requisitos

  • A função deve ter a assinatura fn adiciona_ponto(s: String) -> String.
  • O main deve imprimir a string resultante.
  • O código deve compilar sem avisos de variável não utilizada.

Código inicial

fn main() {
    let texto = String::from("Olá mundo");
    // chame adiciona_ponto e imprima o resultado
}

fn adiciona_ponto(s: String) -> String {
    // implemente
}

Saída esperada

Olá mundo.
Ver dica

Dentro da função, use s + "." ou s.push('.') seguido de s. Lembre-se de retornar a String.

Mostrar solução 
fn main() {
    let texto = String::from("Olá mundo");
    let resultado = adiciona_ponto(texto); // texto movido para a função
    println!("{}", resultado);
}

fn adiciona_ponto(mut s: String) -> String {
    s.push('.'); // modifica a string local
    s // devolve a posse
}

Passo a passo

  1. String::from("Olá mundo") cria uma String e texto se torna dona.
  2. adiciona_ponto(texto) move a posse de texto para o parâmetro s da função.
  3. Dentro da função, s é declarado como mut para permitir modificação.
  4. s.push('.') adiciona o ponto final à string.
  5. A função retorna s, movendo a posse de volta para o chamador.
  6. O resultado é atribuído a resultado e impresso.

Por que funciona

A função toma posse do valor, modifica-o e devolve a posse. Isso segue as regras de ownership: em cada momento, há exatamente um dono. O compilador garante que texto não seja usado após o move, evitando use-after-free.

Erros comuns

  • Esquecer mut no parâmetro: s.push('.') gera erro cannot borrow as mutable.
  • Tentar usar texto após a chamada: error[E0382]: use of moved value: texto.
  • Retornar &s em vez de s: causaria erro de lifetime, pois s é local e seria liberado.

Outra forma de resolver

Se quiser evitar o move, passe uma referência mutável:

fn adiciona_ponto(s: &mut String) {
    s.push('.');
}

fn main() {
    let mut texto = String::from("Olá mundo");
    adiciona_ponto(&mut texto);
    println!("{}", texto);
}

Essa abordagem é preferível quando o chamador precisa continuar dono do valor.

Saída esperada

Olá mundo.