C++ operador de overload e função de overload

C++ Overload de função

Dentro do mesmo escopo, pode-se declarar várias funções com o mesmo nome que têm funcionalidades semelhantes, mas os parâmetros formais dessas funções iguais (referindo-se ao número, tipo ou ordem dos parâmetros) devem ser diferentes. Você não pode sobrecarregar funções apenas diferenciando-se pelo tipo de retorno.

O exemplo a seguir mostra funções com o mesmo nome print() usado para imprimir diferentes tipos de dados:

#include <iostream>
using namespace std;
　
class printData
{
　　　public:
　　　　　　void print(int i)
　　　　　　　　cout << "Os números inteiros são: " << i << endl;
　　　　　　}
　
　　　　　　void print(double f)
　　　　　　　　cout << "Os números de ponto flutuante são: " << f << endl;
　　　　　　}
　
　　　　　　void print(char c[])
　　　　　　　　cout << "A string é: " << c << endl;
　　　　　　}
};
　
int main(void)
{
　　　printData pd;
　
　　　//　Imprimir número inteiro
　　　pd.print(5);
　　　//　Imprimir número de ponto flutuante
　　　pd.print(500.263);
　　　//　Imprimir string
　　　char c[] = "Hello C++";
　　　pd.print(c);
　
　　　return 0;
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Os números inteiros são:　5
Os números de ponto flutuante são:　500.263
A string é: Hello C++

C++ de sobrecarga de operadores

Você pode redefinir ou sobrecarregar a maioria dos operadores C++ operadores integrados. Dessa forma, você pode usar operadores personalizados de tipos personalizados.

Os operadores sobrecarregados são funções com nomes especiais, cujo nome é composto pelo keyword operator seguido do símbolo do operador a ser sobrecarregado. Como outras funções, os operadores sobrecarregados têm um tipo de retorno e uma lista de parâmetros.

Box operador+(const Caixa&);

declara o operador de adição para somar dois objetos Caixa, retornando o objeto Caixa final. A maioria dos operadores sobrecarregados pode ser definida como função não membro comum ou como função membro da classe. Se definirmos a função acima como função não membro da classe, precisaremos passar dois parâmetros para cada operação, conforme mostrado a seguir:

Box operador+(const Caixa&, const Caixa&);

O exemplo a seguir usa funções de membros para demonstrar o conceito de sobrecarga de operadores. Aqui, o objeto é passado como parâmetro e suas propriedades são usadas this operadores para acessar, conforme mostrado a seguir:

#include <iostream>
using namespace std;
　
class Caixa
{
　　　public:
　
　　　　　　double getVolume(void)
　　　　　　{
　　　　　　　　　return comprimento　*　largura　*　altura;
　　　　　　}
　　　　　　void setComprimento(double len)
　　　　　　{
　　　　　　　　　　comprimento = len;
　　　　　　}
　
　　　　　　void setLargura(double bre)
　　　　　　{
　　　　　　　　　　largura = bre;
　　　　　　}
　
　　　　　　void setHeight(double hei)
　　　　　　{
　　　　　　　　　　height = hei;
　　　　　　}
　　　　　　//　sobre carga　+　usado para somar dois objetos Box
　　　　　　Box operador+(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
　　　　　　double breadth;　　　　　//　largura
　　　　　　double height;　　　　　　//　altura
};
//　função principal do programa
int main( )
{
　　　Box Box1;　　　　　　　　　　　　　　　　//　declaração Box1tipo de Box
　　　Box Box2;　　　　　　　　　　　　　　　　//　declaração Box2tipo de Box
　　　Box Box3;　　　　　　　　　　　　　　　　//　declaração Box3tipo de Box
　　　double volume = 0.0;　　　　　//　armazenar volume na variável
　
　　　//　Box1　detalhamento
　　　Box1.setLength(6.0);　
　　　Box1.setBreadth(7.0);　
　　　Box1.setHeight(5.0);
　
　　　//　Box2　detalhamento
　　　Box2.setLength(12.0);　
　　　Box2.setBreadth(13.0);　
　　　Box2.setHeight(10.0);
　
　　　//　Box1　volume
　　　volume = Box1.getVolume();
　　　cout << "Box1volume: " << volume << endl;
　
　　　//　Box2　volume
　　　volume = Box2.getVolume();
　　　cout << "Box2volume: " << volume << endl;
　
　　　//　somar dois objetos, obter Box3
　　　Box3　= Box1　+　Box2;
　
　　　//　Box3　volume
　　　volume = Box3.getVolume();
　　　cout << "Box3volume: " << volume << endl;
　
　　　return 0;
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Box1volume: 　210
Box2volume: 　1560
Box3volume: 　5400

operadores sobrecarregáveis/operadores não sobrecarregáveis

A lista de operadores sobrecarregáveis é a seguinte:

A lista de operadores não sobrecarregáveis é a seguinte:

• .: Operador de Acesso a Membros

• .*, ->*:: Operador de Acesso a Ponto de Membros

• ::: Operador de Domínio

• sizeof: Operador de Tamanho

• ?:: Operador de Condição

• #: Símbolo de Pré-processamento

Exemplo de Sobrecarga de Operadores

A seguir são fornecidos exemplos de sobrecarga de operadores de variedades, para ajudar você a entender melhor o conceito de sobrecarga.