Desafio Rust

Tuple struct e métodos

Enunciado

Defina uma tuple struct Ponto3D que armazena três coordenadas f64. Implemente uma função associada new e um método distancia_origem que retorna a distância euclidiana à origem. No main, crie dois pontos, imprima a distância de cada um à origem e a distância entre eles.

Requisitos

  • A tuple struct Ponto3D deve ter três campos f64.
  • A função associada new deve criar um Ponto3D.
  • O método distancia_origem deve retornar a distância à origem.
  • O programa deve imprimir as distâncias à origem e entre os pontos, com duas casas decimais.

Código inicial

struct Ponto3D(f64, f64, f64);

impl Ponto3D {
    // Implemente new, distancia_origem e distancia_entre
}

fn main() {
    // Crie dois pontos e imprima as distâncias
}

Saída esperada

Distância do ponto A à origem: 3.74
Distância do ponto B à origem: 7.07
Distância entre A e B: 5.92
Ver dica

Para a distância entre dois pontos, use a fórmula da distância euclidiana: ((x2-x1)^2 + (y2-y1)^2 + (z2-z1)^2).sqrt(). Acesse os campos com .0, .1, .2.

Mostrar solução 
struct Ponto3D(f64, f64, f64);

impl Ponto3D {
    // Função associada
    fn new(x: f64, y: f64, z: f64) -> Self {
        Ponto3D(x, y, z)
    }

    // Distância à origem
    fn distancia_origem(&self) -> f64 {
        (self.0 * self.0 + self.1 * self.1 + self.2 * self.2).sqrt()
    }

    // Distância entre dois pontos
    fn distancia_entre(&self, outro: &Ponto3D) -> f64 {
        let dx = self.0 - outro.0;
        let dy = self.1 - outro.1;
        let dz = self.2 - outro.2;
        (dx * dx + dy * dy + dz * dz).sqrt()
    }
}

fn main() {
    let a = Ponto3D::new(1.0, 2.0, 3.0);
    let b = Ponto3D::new(4.0, 5.0, 6.0);

    println!("Distância do ponto A à origem: {:.2}", a.distancia_origem());
    println!("Distância do ponto B à origem: {:.2}", b.distancia_origem());
    println!("Distância entre A e B: {:.2}", a.distancia_entre(&b));
}

Passo a passo

  1. Definimos a tuple struct Ponto3D com três campos f64 acessíveis por .0, .1, .2.
  2. No impl, a função new recebe três coordenadas e devolve Ponto3D(x, y, z).
  3. O método distancia_origem calcula a raiz da soma dos quadrados das coordenadas.
  4. O método distancia_entre recebe uma referência a outro Ponto3D e calcula a diferença em cada eixo.
  5. No main, criamos dois pontos com Ponto3D::new.
  6. Imprimimos as distâncias formatando com {:.2}.

Por que funciona

Tuple structs são úteis quando queremos um tipo distinto sem nomear campos. O acesso posicional (.0, .1) é direto. Métodos podem receber referências a outros pontos para cálculos relativos.

Erros comuns

  • Tentar acessar campos por nome: p.x não existe em tuple struct; use p.0.
  • Esquecer de passar a referência em distancia_entre(&b): se passar b diretamente, o método consumiria o valor (se fosse self), mas aqui é &self e outro: &Ponto3D, então &b é necessário.
  • Confundir a ordem dos campos: Ponto3D(z, y, x) inverteria os eixos.

Outra forma de resolver

Usar uma struct com campos nomeados (struct Ponto3D { x: f64, y: f64, z: f64 }) para maior clareza, especialmente se os campos tiverem significados distintos.

Saída esperada

Distância do ponto A à origem: 3.74
Distância do ponto B à origem: 7.07
Distância entre A e B: 5.92