Fácil C++

Sobrecarga de operador + para uma classe Vetor2D

Enunciado

Crie uma classe Vetor2D que armazena coordenadas x e y (doubles). Sobrecarregue o operador + para somar dois vetores e o operador << para imprimir no formato (x, y). No main, crie dois vetores, some-os e imprima o resultado.

Requisitos

  • A classe Vetor2D deve ter membros públicos x e y do tipo double.
  • O operator+ deve ser uma função membro ou livre que retorna um novo Vetor2D com a soma componente a componente.
  • O operator<< deve ser uma função livre que imprime no formato (x, y).
  • O programa deve compilar e exibir a soma dos dois vetores.

Código inicial

#include <iostream>

class Vetor2D {
public:
    double x, y;
    Vetor2D(double x = 0, double y = 0) : x(x), y(y) {}
    // TODO: sobrecarregar operator+
};

// TODO: sobrecarregar operator<<

int main() {
    Vetor2D a(1.5, 2.5);
    Vetor2D b(3.0, 4.0);
    Vetor2D soma = a + b;
    std::cout << soma << '\n';
    return 0;
}

Saída esperada

(4.5, 6.5)
Ver dica

O operator+ pode ser membro: Vetor2D operator+(const Vetor2D& outro) const { ... }. O operator<< deve receber std::ostream& e retorná-lo.

Mostrar solução 
#include <iostream>

class Vetor2D {
public:
    double x, y;
    Vetor2D(double x = 0, double y = 0) : x(x), y(y) {}

    // Operador de soma como membro: retorna novo Vetor2D
    Vetor2D operator+(const Vetor2D& outro) const {
        return Vetor2D(x + outro.x, y + outro.y);
    }
};

// Operador de saída como função livre
std::ostream& operator<<(std::ostream& os, const Vetor2D& v) {
    os << '(' << v.x << ", " << v.y << ')';
    return os;
}

int main() {
    Vetor2D a(1.5, 2.5);
    Vetor2D b(3.0, 4.0);
    Vetor2D soma = a + b;
    std::cout << soma << '\n';
    return 0;
}

Passo a passo

  1. Definimos a classe Vetor2D com dois membros double e um construtor padrão que inicializa com zero.
  2. Sobrecarregamos operator+ como função membro constante: ela cria e retorna um novo Vetor2D com a soma das coordenadas. O const indica que o objeto atual não é modificado.
  3. Sobrecarregamos operator<< como função livre (fora da classe). Ela recebe std::ostream& e o vetor, imprime no formato (x, y) e retorna o stream para permitir encadeamento.
  4. No main, criamos dois vetores, usamos + para somá-los e << para imprimir o resultado.

Por que funciona

A sobrecarga de operadores permite que tipos definidos pelo usuário participem de expressões com a mesma sintaxe dos tipos nativos. O compilador traduz a + b para a.operator+(b) e std::cout << soma para operator<<(std::cout, soma). Assim, o código fica mais legível e expressivo.

Erros comuns

  • Esquecer de retornar std::ostream& no operator<<: isso quebra o encadeamento (std::cout << a << b).
  • Declarar operator+ sem const: se você tentar somar um objeto constante, o compilador reclama.
  • Tentar acessar membros privados no operator<< sem ser amigo: se os membros fossem privados, precisaria declarar friend.

Outra forma de resolver

Implementar operator+ como função livre:

Vetor2D operator+(const Vetor2D& a, const Vetor2D& b) {
    return Vetor2D(a.x + b.x, a.y + b.y);
}

Essa forma é preferível quando se deseja permitir conversões implícitas em ambos os operandos.

Saída esperada

(4.5, 6.5)