C++ POO Intermediário

Sobrecarga de operadores

A sobrecarga de operadores permite que objetos de classes personalizadas se comportem como tipos nativos, usando operadores como +, == ou <<. Em C++, isso é feito definindo funções especiais chamadas operator@, onde @ é o símbolo do operador. Assim, você pode escrever a + b em vez de a.somar(b), deixando o código mais expressivo e intuitivo.

Neste card, veremos como sobrecarregar operadores aritméticos (como +), operadores de comparação (incluindo o operador <=> da linguagem, que gera automaticamente ==, <, >, etc.) e o operador de saída << para imprimir objetos. Também abordaremos boas práticas, como manter a semântica esperada e evitar sobrecargas confusas.

A sobrecarga pode ser feita como função membro ou como função livre. Operadores que modificam o objeto à esquerda (como +=) geralmente são membros; operadores binários simétricos (como +) costumam ser funções livres para permitir conversões implícitas em ambos os lados. O operador << deve ser uma função livre, pois o operando à esquerda é um std::ostream.

Com a chegada do C++20, o operador <=> (three-way comparison) simplifica a implementação de todos os operadores relacionais: basta defini-lo e o compilador gera ==, !=, <, <=, >, >=. Isso reduz código repetitivo e erros.

Pontos-chave

Sobrecarregar operator+ permite somar objetos como se fossem tipos primitivos.
O operador <=> (C++20) gera automaticamente todos os operadores de comparação relacionais.
operator<< deve ser uma função livre que recebe std::ostream& e a classe, retornando std::ostream&.
Prefira funções livres para operadores binários simétricos e membros para operadores que modificam o objeto à esquerda.
Mantenha a semântica intuitiva: + não deve modificar operandos, == deve ser reflexivo e consistente.

operator_overload.cpp

#include <iostream>
#include <compare>

class Ponto {
public:
    int x, y;

    // Construtor
    Ponto(int x = 0, int y = 0) : x(x), y(y) {}

    // Operador de soma como membro (modifica o objeto à esquerda? não, retorna novo)
    Ponto operator+(const Ponto& outro) const {
        return Ponto(x + outro.x, y + outro.y);
    }

    // Operador de comparação three-way (C++20) - gera ==, !=, <, <=, >, >=
    auto operator<=>(const Ponto& outro) const = default;

    // Operador de saída como função amiga
    friend std::ostream& operator<<(std::ostream& os, const Ponto& p);
};

// Implementação do operador <<
std::ostream& operator<<(std::ostream& os, const Ponto& p) {
    os << "(" << p.x << ", " << p.y << ")";
    return os;
}

int main() {
    Ponto a(1, 2);
    Ponto b(3, 4);

    Ponto soma = a + b;  // usa operator+
    std::cout << "Soma: " << soma << '\n';

    // Comparações usando <=>
    std::cout << "a == b? " << (a == b) << '\n';
    std::cout << "a < b? " << (a < b) << '\n';
    std::cout << "a >= b? " << (a >= b) << '\n';

    return 0;
}

Sobrecarga de operadores

Pontos-chave

Exercícios

Sobrecarga de operador + para uma classe Vetor2D

Comparação com operador <=> (C++20)

Classe Fração com operadores aritméticos, comparação e saída

Continue estudando