Introdução à Sobrecarga de Operadores

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 40 de 104.

Sobrecarregamento de operadores permite definir como operadores como +, - ou == se comportam quando usados com suas classes personalizadas. Em vez de chamar métodos como a.add(b), você pode escrever a forma mais intuitiva a + b.

Em C++, os operadores são essencialmente funções com nomes especiais. Para fazer a sobrecarga de um operador, você define uma função usando a palavra-chave operator seguida pelo símbolo:

class Vector2D {
    double x, y;
    
public:
    Vector2D(double x, double y) : x(x), y(y) {}
    
    // Sobrecarregar o operador +
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }
};

Agora você pode adicionar dois vetores naturalmente:

Vector2D v1(1.0, 2.0);
Vector2D v2(3.0, 4.0);
Vector2D v3 = v1 + v2;    // Chama v1.operator+(v2)

Nem todos os operadores podem ser sobrecarregados. O operador de resolução de escopo ::, o acesso a member ., o operador ternário ?: e sizeof não podem ser sobrecarregados. Além disso, você não pode criar novos operadores nem alterar a precedência de um operador — * sempre será avaliado antes de +.

Os operadores podem ser implementados como funções membro (como acima) ou como funções não membro. Nas próximas lições, você aprenderá quando usar cada abordagem e como sobrecarregar categorias específicas de operadores.

Desafio

Fácil

Vamos criar uma classe Point que representa uma coordenada 2D e permite somar dois pontos usando o operador +. Este é o seu primeiro passo no uso de sobrecarga de operadores, fazendo com que suas classes personalizadas funcionem com operadores familiares.

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

Point.h: defina uma classe Point que armazena as coordenadas x e y (ambas do tipo int). Sua classe deve ter:
- Membros privados para as coordenadas x e y
- Um construtor que receba os valores de x e y
- Os getters getX() e getY() (ambos const)
- Um operador + sobrecarregado que some dois pontos e retorne um novo Point com as coordenadas combinadas
O operador + deve ser implementado como uma função membro que receba outro Point por referência const e retorne um novo Point. Marque-o como const, pois ele não modifica nenhum dos operandos.
main.cpp: leia quatro inteiros da entrada (x1, y1, x2, y2 em linhas separadas) representando dois pontos. Crie dois objetos Point, some-os usando o operador + e exiba os resultados.
Formato da saída:
```
Point 1: (<x1>, <y1>)
Point 2: (<x2>, <y2>)
Sum: (<sum_x>, <sum_y>)
```

A ideia principal aqui é que p1 + p2 na verdade chama p1.operator+(p2) nos bastidores. Seu operador sobrecarregado permite escrever um código intuitivo como Point p3 = p1 + p2; em vez de algo como Point p3 = p1.add(p2);.

Converta as strings de entrada em inteiros usando std::stoi(). Não se esqueça das guardas de inclusão no seu arquivo de cabeçalho.

Experimente você mesmo

#include <iostream>
#include <string>
#include "Point.h"

using namespace std;

int main() {
    // Ler entrada
    string line1, line2, line3, line4;
    getline(cin, line1);
    getline(cin, line2);
    getline(cin, line3);
    getline(cin, line4);

    int x1 = stoi(line1);
    int y1 = stoi(line2);
    int x2 = stoi(line3);
    int y2 = stoi(line4);

    // TODO: Crie dois objetos Point usando os valores de entrada

    // TODO: Some os dois pontos usando o operador +

    // TODO: Exiba os resultados no formato exigido:
    // Ponto 1: (<x1>, <y1>)
    // Ponto 2: (<x2>, <y2>)
    // Soma: (<sum_x>, <sum_y>)

    return 0;
}