Getters

Parte da seção Object Oriented Programming do Journey de Rust da Coddy — lição 11 de 61.

Com campos privados, o código externo não pode acessar os dados da sua struct diretamente. Mas às vezes você precisa permitir que outros leiam os dados sem dar a eles a capacidade de alterá-los. É aqui 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 de apenas leitura) e retorna o valor do campo privado. Em Rust, os getters são tipicamente nomeados com o nome do próprio campo — nenhum prefixo get_ é necessário.

Agora o código externo pode ler o saldo através 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 de propriedade como String, você frequentemente retornará uma referência para evitar cópias desnecessárias:

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

Getters fornecem acesso de leitura controlado enquanto mantêm o próprio campo protegido. A struct permanece no controle de seus dados — o código externo pode olhar, mas não pode tocar.

Desafio

Fácil

Vamos construir um sistema de perfil de usuário que demonstra como os métodos getter fornecem acesso de leitura 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 struct em si deve ser pública, mas os campos devem permanecer privados. Implemente um construtor new público que receba um username e uma age. Em seguida, adicione dois métodos getter:
- username — retorna uma referência ao username (&String)
- age — retorna o valor da age (u32)
main.rs: Importe seu módulo profile, 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 são normalmente nomeados com o próprio nome do campo — nenhum prefixo get_ é necessário. 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 username "alice" e age 25, a saída seria:

Username: alice
Age: 25

Você receberá duas entradas: o username e a age.

Folha de consulta

Um método getter é um método público que fornece acesso de apenas leitura a um campo privado.

Getters permitem que o código externo visualize os dados sem poder modificá-los diretamente:

pub struct Wallet {
    balance: f64,
}

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

Em Rust, os getters são nomeados com o próprio nome do campo — nenhum prefixo get_ é necessário.

Para campos que contêm dados de propriedade (owned data) como String, retorne uma referência para evitar cópias desnecessárias:

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

Usando um método getter:

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

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: Criar um UserProfile usando o construtor

    // TODO: Usar os métodos getter para imprimir o nome de usuário e a idade
    // Formato:
    // Username: {username}
    // Age: {age}
}