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.

Sobrecarga de operadores permite que você defina 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 o mais intuitivo a + b.

Em C++, operadores são essencialmente funções com nomes especiais. Para sobrecarregar 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) {}
    
    // Sobrecarga do 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 ::, acesso a membro ., ternário ?: e sizeof não podem ser sobrecarregados. Além disso, você não pode criar novos operadores ou alterar a precedência de um operador - * sempre será avaliado antes de +.

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

Desafio

Fácil

Vamos construir uma classe Point que representa uma coordenada 2D e suporta a adição de dois pontos usando o operador +. Este é o seu primeiro passo na 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 int). Sua classe deve ter:
- Membros privados para as coordenadas x e y
- Um construtor que recebe os valores x e y
- Getters getX() e getY() (ambos const)
- Um operador + sobrecarregado que soma dois pontos e retorna um novo Point com as coordenadas combinadas
O operador + deve ser implementado como uma função membro que recebe outro Point por referência constante e retorna 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 de saída:
```
Point 1: (<x1>, <y1>)
Point 2: (<x2>, <y2>)
Sum: (<sum_x>, <sum_y>)
```

A ideia principal aqui é que p1 + p2 está, na verdade, chamando p1.operator+(p2) nos bastidores. Seu operador sobrecarregado permite que você escreva códigos intuitivos 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 dos "header guards" em seu arquivo de cabeçalho.

Folha de consulta

A sobrecarga de operadores permite que você defina como operadores como +, - ou == se comportam com classes personalizadas, permitindo uma sintaxe intuitiva como a + b em vez de a.add(b).

Para sobrecarregar um operador, defina 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) {}
    
    // Sobrecarga do operador +
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }
};

Uso:

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

Alguns operadores não podem ser sobrecarregados: ::, ., ?: e sizeof. Você não pode criar novos operadores ou alterar a precedência dos operadores.

Os operadores podem ser implementados como funções membros ou funções não membros.

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: Criar dois objetos Point usando os valores de entrada

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

    // TODO: Exibir os resultados no formato exigido:
    // Point 1: (<x1>, <y1>)
    // Point 2: (<x2>, <y2>)
    // Sum: (<sum_x>, <sum_y>)

    return 0;
}