Operadores em C++ como mágica: regras de sobrecarga para iniciantes

Introdução: por que seu código não parece mágica?

Imagine que você está escrevendo um programa em C++ e precisa comparar dois números complexos. Você escreve if (a > b) — e o compilador dá um erro. "Por quê?", você se pergunta. E a resposta é porque o compilador não sabe o que significa "maior que" para o seu próprio tipo de dado.

Em C++, operadores não são apenas rabiscos no teclado. Eles são uma ferramenta poderosa que permite que seu código pareça natural, como em matemática ou em Python. A sobrecarga de operadores (operator overloading) é uma forma de ensinar o compilador a trabalhar com suas classes de forma tão intuitiva quanto com tipos nativos. Hoje, vamos abordar as regras e expressões idiomáticas básicas que transformarão seu código de um conjunto chato de funções em uma "linguagem de programação" elegante dentro do C++.

Este material é baseado em uma pergunta real do Stack Overflow que reuniu milhares de visualizações. Nós o adaptamos para iniciantes, para que você não apenas copie exemplos, mas entenda por que deve fazer de um jeito e não de outro.

Regra nº 1: "Não invente a roda" — quando a sobrecarga é justificada

A primeira coisa a aprender: sobrecarga de operadores não é uma festa para a qual você precisa convidar todo mundo. Sobrecarregue operadores apenas quando isso tornar o código mais óbvio. Se você está criando uma classe Vetor — a sobrecarga de + para somar vetores é totalmente lógica. Já para uma classe BancoDeDados, o operador + pareceria estranho e enganoso.

A regra de ouro: a semântica do operador deve ser intuitivamente clara. O usuário da sua classe (ou você mesmo daqui a um mês) deve entender à primeira vista o que a + b faz.

Quando não sobrecarregar

\n
• Se o operador não tiver um significado óbvio para o seu tipo (por exemplo, operator+ para uma classe "Pessoa").
\n
• Se você puder usar uma função comum com um nome descritivo (adicionar(), mesclar()).
\n
• Se você não pretende manter a semântica padrão (o operador + não deve modificar seus argumentos).
\n

Regra nº 2: Operador de atribuição — o rei das expressões idiomáticas

O operador mais comum e mais traiçoeiro é o operador de atribuição (operator=). Sem ele, sua classe funcionará, mas apenas até você começar a copiar objetos. E é aí que a coisa fica interessante.

A principal expressão idiomática para operator= é o copy-and-swap (cópia e troca). Por que ela é tão boa? Porque resolve três problemas de uma vez:

\n
• Proteção contra auto-atribuição (a = a).
\n
• Segurança contra exceções (se a cópia lançar uma exceção, o objeto original permanece intacto).
\n
• Simplicidade e legibilidade do código.
\n

Veja como fica na prática:

class MyString {\nprivate:\n    char* data;\n    size_t size;\n\npublic:\n    // Construtor de cópia\n    MyString(const MyString& other) : size(other.size) {\n        data = new char[size + 1];\n        std::copy(other.data, other.data + size + 1, data);\n    }\n\n    // Destrutor\n    ~MyString() { delete[] data; }\n\n    // Operador de atribuição via copy-and-swap\n    MyString& operator=(MyString other) { // 1. Recebe por valor\n        std::swap(data, other.data);       // 2. Troca os dados\n        std::swap(size, other.size);\n        return *this;                      // 3. Retorna a referência\n    } // 4. O objeto antigo é destruído no destrutor de other\n};

Observe: other é passado por valor, não por referência. Este é o ponto-chave: o construtor de cópia cria uma cópia temporária, e nós apenas trocamos os dados com ela. Os dados antigos são liberados automaticamente quando o objeto temporário é