O Parâmetro Self

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

Quando um método precisa acessar os dados armazenados em uma instância de struct, ele usa o parâmetro &self. Este parâmetro especial é sempre o primeiro argumento em um método e representa uma referência à instância na qual o método é chamado.

O símbolo & significa que estamos pegando a instância emprestada em vez de assumir a posse (ownership) dela. Isso permite que o método leia os campos da struct sem consumir a instância:

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
    
    fn is_square(&self) -> bool {
        self.width == self.height
    }
}

Dentro do corpo do método, self fornece acesso a todos os campos da struct usando a notação de ponto. O método area lê tanto width quanto height para calcular e retornar o resultado.

Como o &self apenas empresta a instância, você pode chamar múltiplos métodos na mesma struct sem problemas:

fn main() {
    let rect = Rectangle { width: 10, height: 5 };
    
    println!("Area: {}", rect.area());      // 50
    println!("Square? {}", rect.is_square()); // false
}

Métodos que usam &self são de apenas leitura—eles podem examinar os dados da struct, mas não podem alterá-los. Na próxima lição, você aprenderá como criar métodos que podem modificar a instância.

Desafio

Fácil

Crie uma struct Circle com um único campo: radius (f64).

Adicione um bloco de implementação para Circle com dois métodos que usam &self:

circumference — retorna a circunferência como f64 (fórmula: 2.0 * 3.14159 * radius)
diameter — retorna o diâmetro como f64 (fórmula: 2.0 * radius)

Você receberá uma entrada:

O raio do círculo (f64)

Crie uma instância de Circle com o raio fornecido, então imprima a circunferência e o diâmetro em linhas separadas.

Formato de saída esperado:

{circumference}
{diameter}

Folha de consulta

Os métodos acessam os dados da struct usando o parâmetro &self, que deve ser o primeiro argumento. O símbolo & significa que o método empresta a instância em vez de assumir a posse (ownership):

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
    
    fn is_square(&self) -> bool {
        self.width == self.height
    }
}

Dentro do método, use self com a notação de ponto para acessar os campos da struct. Métodos com &self são apenas de leitura e podem examinar os dados, mas não modificá-los.

Como o &self apenas empresta a instância, você pode chamar múltiplos métodos na mesma struct:

let rect = Rectangle { width: 10, height: 5 };
println!("Area: {}", rect.area());      // 50
println!("Square? {}", rect.is_square()); // false

Experimente você mesmo

use std::io;

// TODO: Defina a struct Circle aqui


// TODO: Adicione o bloco de implementação para Circle com os métodos circumference e diameter


fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let radius: f64 = input.trim().parse().expect("Invalid number");
    
    // TODO: Crie uma instância de Circle e imprima a circunferência e o diâmetro
    
}