Dominando Sobrecarga em C++: Funções e Operadores Explicados

C++ permite especificar mais de uma definição para um nome de função ou um operador no mesmo escopo, o que é chamado de sobrecarga de função e sobrecarga de operador, respectivamente.

Uma declaração sobrecarregada é uma declaração declarada com o mesmo nome de uma declaração previamente declarada no mesmo escopo, exceto que ambas as declarações têm argumentos diferentes e obviamente definição (implementação) diferente.

Quando você chama uma função ou operador sobrecarregado, o compilador determina a definição mais apropriada a usar, comparando os tipos de argumentos que você usou para chamar a função ou operador com os tipos de parâmetros especificados nas definições. O processo de seleção da função ou operador sobrecarregado mais apropriado é chamado de resolução de sobrecarga.

Sobrecarga de Função em C++

Você pode ter múltiplas definições para o mesmo nome de função no mesmo escopo. A definição da função deve diferir entre si pelos tipos e/ou número de argumentos na lista de argumentos. Você não pode sobrecarregar declarações de função que diferem apenas pelo tipo de retorno.

O exemplo a seguir mostra onde a mesma função print() é usada para imprimir diferentes tipos de dados:

#include <iostream>
using namespace std;
class printData {
public:
    void print(int i) {
        cout << "Printing int: " << i << endl;
    }
    void print(double f) {
        cout << "Printing float: " << f << endl;
    }
    void print(char* c) {
        cout << "Printing character: " << c << endl;
    }
};
int main(void) {
    printData pd;
    // Chama print para imprimir inteiro
    pd.print(5);
    // Chama print para imprimir float
    pd.print(500.263);
    // Chama print para imprimir caractere
    pd.print("Hello C++");
    return 0;
}

Quando o código acima é compilado e executado, produz o seguinte resultado:

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

Sobrecarga de Operadores em C++

Você pode redefinir ou sobrecarregar a maioria dos operadores embutidos disponíveis em C++. Assim, um programador pode usar operadores com tipos definidos pelo usuário também.

Operadores sobrecarregados são funções com nomes especiais: a palavra-chave "operator" seguida pelo símbolo do operador sendo definido. Como qualquer outra função, um operador sobrecarregado tem um tipo de retorno e uma lista de parâmetros.

Box operator+(const Box&);

declara o operador de adição que pode ser usado para adicionar dois objetos Box e retorna o objeto Box final. A maioria dos operadores sobrecarregados pode ser definida como funções não-membro ordinárias ou como funções membro de classe. No caso de definirmos a função acima como função não-membro de uma classe, teríamos que passar dois argumentos para cada operando da seguinte forma:

Box operator+(const Box&, const Box&);

O exemplo a seguir mostra o conceito de sobrecarga de operador usando uma função membro. Aqui um objeto é passado como argumento cujas propriedades serão acessadas usando este objeto; o objeto que chamará este operador pode ser acessado usando o operador this como explicado abaixo:

#include <iostream>
using namespace std;
class Box {
public:
    double getVolume(void) {
        return length * breadth * height;
    }
    void setLength(double len) { length = len; }
    void setBreadth(double bre) { breadth = bre; }
    void setHeight(double hei) { height = hei; }
    // Sobrecarga do operador + para adicionar dois objetos Box.
    Box operator+(const Box& b) {
        Box box;
        box.length = this->length + b.length;
        box.breadth = this->breadth + b.breadth;
        box.height = this->height + b.height;
        return box;
    }
private:
    double length;  // Comprimento de uma caixa
    double breadth; // Largura de uma caixa
    double height;  // Altura de uma caixa
};
// Função principal do programa
int main() {
    Box Box1; // Declara Box1 do tipo Box
    Box Box2; // Declara Box2 do tipo Box
    Box Box3; // Declara Box3 do tipo Box
    double volume = 0.0; // Armazena volume de uma caixa
    // especificação box 1
    Box1.setLength(6.0);
    Box1.setBreadth(7.0);
    Box1.setHeight(5.0);
    // especificação box 2
    Box2.setLength(12.0);
    Box2.setBreadth(13.0);
    Box2.setHeight(10.0);
    // volume da caixa 1
    volume = Box1.getVolume();
    cout << "Volume of Box1: " << volume << endl;
    // volume da caixa 2
    volume = Box2.getVolume();
    cout << "Volume of Box2: " << volume << endl;
    // Adiciona dois objetos:
    Box3 = Box1 + Box2;
    // volume da caixa 3
    volume = Box3.getVolume();
    cout << "Volume of Box3: " << volume << endl;
    return 0;
}

Quando o código acima é compilado e executado, produz o seguinte resultado:

Volume of Box1: 210
Volume of Box2: 1560
Volume of Box3: 5400

Operadores Sobrecarregáveis/Não-Sobrecarregáveis

A seguir está a lista de operadores que podem ser sobrecarregados:

A seguir está a lista de operadores que não podem ser sobrecarregados:

Exemplos de Sobrecarga de Operadores

Aqui estão vários exemplos de sobrecarga de operadores para ajudar no entendimento do conceito.