Getters

Parte da seção Programação Orientada a Objetos do Journey de Rust da Coddy. Lição 11 de 61.

Com campos privados, o código externo não pode acessar diretamente os dados da sua struct. Mas, às vezes, você precisa permitir que outras pessoas leiam os dados sem dar a elas a capacidade de alterá-los. É aí que entram os métodos getter.

Um getter é simplesmente um método público que retorna uma referência a um campo privado:

// wallet.rs
pub struct Wallet {
    balance: f64,
}

impl Wallet {
    pub fn new(initial: f64) -> Wallet {
        Wallet { balance: initial }
    }
    
    pub fn balance(&self) -> f64 {
        self.balance
    }
}

O método balance() recebe &self (acesso somente para leitura) e retorna o valor do campo privado. Em Rust, os getters normalmente recebem o mesmo nome do próprio campo: não é necessário usar o prefixo get_.

Agora, o código externo pode ler o saldo por meio do método:

// main.rs
mod wallet;
use wallet::Wallet;

fn main() {
    let w = Wallet::new(100.0);
    println!("Balance: {}", w.balance());  // Funciona!
}

Para campos que contêm dados próprios, como String, você frequentemente retornará uma referência para evitar cópias desnecessárias:

pub fn name(&self) -> &String {
    &self.name
}

Os getters fornecem acesso controlado de leitura, mantendo o próprio campo protegido. A struct continua responsável pelos próprios dados: o código externo pode consultar, mas não pode alterar.

Desafio

Fácil

Vamos criar um sistema de perfil de usuário que demonstra como os métodos getter fornecem acesso controlado a dados privados.

Você criará dois arquivos para organizar seu código:

profile.rs: Defina uma struct UserProfile com dois campos privados: username (String) e age (u32). A própria struct deve ser pública, mas os campos devem permanecer privados. Implemente um construtor público new que receba um nome de usuário e uma idade. Em seguida, adicione dois métodos getter:
- username: retorna uma referência ao nome de usuário (&String)
- age: retorna o valor da idade (u32)
main.rs: Inclua seu módulo de perfil, crie um UserProfile e use os métodos getter para imprimir as informações do usuário.

Lembre-se de que os getters em Rust normalmente recebem o mesmo nome do próprio campo: não é necessário o prefixo get_. Para campos String, retorne uma referência para evitar cópias desnecessárias.

Sua saída deve seguir este formato exato:

Username: {username}
Age: {age}

Por exemplo, se você criar um perfil com o nome de usuário "alice" e a idade 25, a saída será:

Username: alice
Age: 25

Você receberá duas entradas: o nome de usuário e a idade.

Experimente você mesmo

mod profile;

use profile::UserProfile;

fn main() {
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let username = input1.trim().to_string();

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let age: u32 = input2.trim().parse().expect("Failed to parse age");

    // TODO: Crie um UserProfile usando o construtor

    // TODO: Use os métodos getter para imprimir o username e a age
    // Formato:
    // Username: {username}
    // Age: {age}
}