Sobrecarga de Operadores em C++: Guia Prático com Exemplos de Código

O que é Sobrecarga de Operadores?

Usando sobrecarga de operadores em C++, você pode atribuir múltiplos significados a um operador dentro do mesmo escopo. O objetivo é dar um comportamento personalizado a um operador para um tipo definido pelo usuário.

Com sobrecarga de operadores, você pode redefinir a maioria dos operadores C++ e realizar diferentes operações usando um único símbolo.

Neste tutorial você aprenderá:

• O que é sobrecarga de operadores
• Sintaxe
• Diferentes abordagens para sobrecarregar operadores em C++
• Quais operadores não podem ser sobrecarregados
• Considerações importantes
• Regras para sobrecarga de operadores
• Como sobrecarregar um operador na prática

Sintaxe

Para sobrecarregar um operador C++, defina uma função membro especial dentro de uma classe da seguinte forma:

class nome_classe {
    ...
public:
    tipo_retorno operator simbolo (argumento(s)) {
        ...
    }
    ...
};

Os componentes são:

• tipo_retorno – o tipo retornado pela função operador.
• operator – a palavra-chave que inicia a declaração.
• simbolo – o operador que você quer sobrecarregar, ex. +, -, <, ++.
• argumento(s) – parâmetros, como qualquer outra função.

Exemplo 1: Sobrecarga do Operador Decremento Prefixado

#include <iostream>
using namespace std;
class ClasseTeste {
private:
    int contador;
public:
    ClasseTeste() : contador(5) {}
    void operator --() {
        contador = contador - 3;
    }
    void Exibir() {
        cout << "Contador: " << contador;
    }
};
int main() {
    ClasseTeste ct;
    --ct;
    ct.Exibir();
    return 0;
}

Saída:

Contador: 2

Explicação do Código:

1. Inclui <iostream> para acessar facilidades de entrada/saída.
2. Usa namespace std para brevidade.
3. Define classe ClasseTeste.
4. Torna contador um membro de dado privado.
5. Fornece construtor público que inicializa contador com 5.
6. Sobrecarrega o operador prefixado -- para subtrair 3 de contador.
7. Implementa Exibir() para imprimir o valor atual.
8. Em main(), cria uma instância, aplica o operador sobrecarregado e exibe o resultado.

Diferentes Abordagens para Sobrecarga de Operadores em C++

A sobrecarga pode ser alcançada através de:

1. Funções membro
2. Funções não-membro (friend ou free functions)
3. Funções friend (quando acesso a dados privados é necessário)

• Se o operando esquerdo é um objeto da classe, uma função membro é tipicamente usada.
• Quando o operando esquerdo é de tipo diferente, uma função não-membro é requerida.
• Funções friend são úteis quando o operador precisa acessar membros privados ou protegidos.

Todos os Operadores C++ Podem Ser Sobrecarregados?

Não. Os seguintes operadores não são sobrecarregáveis:

• :: – resolução de escopo
• ?: – condicional ternário
• . – acesso a membro
• sizeof – consulta de tamanho
• * (seletor de ponteiro para membro)

Coisas para Lembrar

1. A sobrecarga afeta apenas tipos definidos pelo usuário; tipos built-in mantêm seu comportamento original.
2. Os operadores de atribuição (=) e endereço-de (&) são automaticamente sobrecarregados para classes que fornecem construtores de cópia ou operadores de atribuição.
3. A precedência de operadores permanece inalterada; você pode usar parênteses para forçar ordem de avaliação.
4. Três operadores—::, ., ?:—são explicitamente proibidos de sobrecarga.

Regras para Sobrecarga de Operadores

• Pelo menos um operando deve ser um tipo de classe definido pelo usuário.
• Apenas operadores existentes podem ser sobrecarregados; você não pode introduzir novos símbolos de operador.
• Alguns operadores (ex.: new, delete) não podem ser sobrecarregados como funções friend mas podem ser sobrecarregados como funções membro.

Como Sobrecarregar um Operador

Exemplo 1: Operador Incremento

#include <iostream>
using namespace std;
class SobrecargaOperador {
private:
    int x;
public:
    SobrecargaOperador() : x(10) {}
    void operator ++() {
        x += 2;
    }
    void Imprimir() {
        cout << "A Contagem é: " << x;
    }
};
int main() {
    SobrecargaOperador so;
    ++so;
    so.Imprimir();
    return 0;
}

Saída:

A Contagem é: 12

Exemplo 2: Adição de Números Complexos

#include <iostream>
using namespace std;
class ClasseTeste {
private:
    int real, imag;
public:
    ClasseTeste(int rl = 0, int im = 0) : real(rl), imag(im) {}
    ClasseTeste operator + (ClasseTeste const &obj) {
        ClasseTeste resultado;
        resultado.real = real + obj.real;
        resultado.imag = imag + obj.imag;
        return resultado;
    }
    void imprimir() {
        cout << real << " + i" << imag << endl;
    }
};
int main() {
    ClasseTeste c1(9, 5), c2(4, 3);
    ClasseTeste c3 = c1 + c2;
    c3.imprimir();
}

Saída:

13 + i8

Explicação do Código:

1. Inclui <iostream> e usa namespace std.
2. Define ClasseTeste com componentes real e imag.
3. Fornece construtor para inicialização.
4. Sobrecarrega operador + para realizar adição de números complexos.
5. Retorna nova instância ClasseTeste contendo a soma.
6. Implementa imprimir() para exibir o número complexo.
7. Em main(), cria duas instâncias, soma-as e imprime o resultado.

Resumo

• Sobrecarga de operadores permite múltiplos significados para um operador dentro de um escopo.
• Fornece comportamento personalizado para tipos definidos pelo usuário.
• A maioria dos operadores C++ pode ser sobrecarregada, mas alguns não podem.
• Pelo menos um operando deve ser um tipo definido pelo usuário.
• Apenas operadores existentes são sobrecarregáveis.