Sobrecarga de operador C ++ (com exemplos)

Neste tutorial, aprenderemos sobre sobrecarga de operador com a ajuda de exemplos.

Em C ++, podemos mudar a maneira como os operadores trabalham para tipos definidos pelo usuário, como objetos e estruturas. Isso é conhecido como sobrecarga do operador . Por exemplo,

Suponha que criamos três objetos c1, c2 e resultam de uma classe chamada Complexque representa números complexos.

Uma vez que a sobrecarga do operador nos permite mudar como os operadores funcionam, podemos redefinir como o +operador funciona e usá-lo para adicionar os números complexos de c1 e c2 escrevendo o seguinte código:

 result = c1 + c2;

em vez de algo como

 result = c1.addNumbers(c2);

Isso torna nosso código intuitivo e fácil de entender.

Nota: Nós não podemos usar o operador sobrecarga para tipos de dados fundamentais, como int, float, chare assim por diante.

Sintaxe para sobrecarga de operador C ++

Para sobrecarregar um operador, usamos uma operatorfunção especial .

 class className (… public returnType operator symbol (arguments) (… )… );

Aqui,

returnType é o tipo de retorno da função.
operador é uma palavra-chave.
symbolé o operador que queremos sobrecarregar. Como: +, <, -, ++, etc.
arguments são os argumentos passados para a função.

Sobrecarga de operador em operadores unários

Operadores unários operam em apenas um operando. O operador de incremento ++e o operador de decremento --são exemplos de operadores unários.

Exemplo 1: Sobrecarga do Operador ++ (Operador Unário)

 // Overload ++ when used as prefix #include using namespace std; class Count ( private: int value; public: // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix void operator ++ () ( ++value; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++ ()" function ++count1; count1.display(); return 0; )

Resultado

 Contagem: 6

Aqui, quando usamos ++count1;, o void operator ++ ()é chamado. Isso aumenta o atributo de valor para o objeto count1 em 1.

Nota: Quando sobrecarregamos os operadores, podemos usá-lo para trabalhar da maneira que quisermos. Por exemplo, poderíamos ter usado ++para aumentar o valor em 100.

No entanto, isso torna nosso código confuso e difícil de entender. É nosso trabalho como programador usar a sobrecarga do operador de maneira adequada e consistente e intuitiva.

O exemplo acima funciona apenas quando ++é usado como um prefixo. Para fazer ++funcionar como um postfix, usamos esta sintaxe.

 void operator ++ (int) ( // code )

Observe o intinterior dos parênteses. É a sintaxe usada para usar operadores unários como postfix; não é um parâmetro de função.

Exemplo 2: Sobrecarga do Operador ++ (Operador Unário)

 // Overload ++ when used as prefix and postfix #include using namespace std; class Count ( private: int value; public: // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix void operator ++ () ( ++value; ) // Overload ++ when used as postfix void operator ++ (int) ( ++value; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++ (int)" function count1++; count1.display(); // Call the "void operator ++ ()" function ++ count1; count1.display(); return 0; )

Resultado

 Contagem: 6 Contagem: 7

O Exemplo 2 funciona quando ++é usado tanto como prefixo quanto como posfixo. No entanto, não funciona se tentarmos fazer algo assim:

 Count count1, result; // Error result = ++count1;

Isso ocorre porque o tipo de retorno de nossa função de operador é void. Podemos resolver esse problema tornando Counto tipo de retorno da função de operador.

 // return Count when ++ used as prefix Count operator ++ () ( // code ) // return Count when ++ used as postfix Count operator ++ (int) ( // code )

Exemplo 3: valor de retorno da função do operador (operador ++)

 #include using namespace std; class Count ( private: int value; public : // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix Count operator ++ () ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; ) // Overload ++ when used as postfix Count operator ++ (int) ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1, result; // Call the "Count operator ++ ()" function result = ++count1; result.display(); // Call the "Count operator ++ (int)" function result = count1++; result.display(); return 0; )

Resultado

 Contagem: 6 Contagem: 7

Aqui, usamos o seguinte código para sobrecarga de operador de prefixo:

 // Overload ++ when used as prefix Count operator ++ () ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; )

The code for the postfix operator overloading is the same as well. Notice that we have created an object temp and returned its value to the operator function.

Also notice the code

 temp.value = ++value;

The variable value belongs to the count1 object in main() because count1 is calling the function, while temp.value belongs to the temp object.

Operator Overloading in Binary Operators

Binary operators work on two operands. For example,

 result = num + 9;

Here, + is a binary operator that works on the operands num and 9.

When we overload the binary operator for user-defined types by using the code:

 obj3 = obj1 + obj2;

The operator function is called using the obj1 object and obj2 is passed as an argument to the function.

Example 4: C++ Binary Operator Overloading

 // C++ program to overload the binary operator + // This program adds two complex numbers #include using namespace std; class Complex ( private: float real; float imag; public: // Constructor to initialize real and imag to 0 Complex() : real(0), imag(0) () void input() ( cout <> real; cin>> imag; ) // Overload the + operator Complex operator + (const Complex& obj) ( Complex temp; temp.real = real + obj.real; temp.imag = imag + obj.imag; return temp; ) void output() ( if (imag < 0) cout << "Output Complex number: " << real << imag << "i"; else cout << "Output Complex number: " << real << "+" << imag << "i"; ) ); int main() ( Complex complex1, complex2, result; cout << "Enter first complex number:"; complex1.input(); cout << "Enter second complex number:"; complex2.input(); // complex1 calls the operator function // complex2 is passed as an argument to the function result = complex1 + complex2; result.output(); return 0; )

Output

 Insira o primeiro número complexo: Insira as partes reais e imaginárias respectivamente: 9 5 Insira o segundo número complexo: Insira as partes reais e imaginárias respectivamente: 7 6 Número complexo de saída: 16 + 11i

Neste programa, a função do operador é:

 Complex operator + (const Complex& obj) ( // code )

Em vez disso, também poderíamos ter escrito esta função como:

 Complex operator + (Complex obj) ( // code )

Contudo,

o uso &torna nosso código eficiente ao fazer referência ao objeto complex2 em vez de tornar um objeto duplicado dentro da função do operador.
usar consté considerado uma boa prática porque evita que a função de operador modifique complex2.

Sobrecarregando operadores binários em C ++

Coisas para lembrar na sobrecarga de operador C ++

Dois operadores =e &já estão sobrecarregados por padrão em C ++. Por exemplo, para copiar objetos da mesma classe, podemos usar diretamente o =operador. Não precisamos criar uma função de operador.
A sobrecarga do operador não pode alterar a precedência e a associatividade dos operadores. No entanto, se quisermos alterar a ordem de avaliação, devem ser usados parênteses.
Existem 4 operadores que não podem ser sobrecarregados em C ++. Eles são:
1. :: (resolução de escopo)
2. . (seleção de membros)
3. .* (seleção de membro por meio de ponteiro para função)
4. ?: (operador ternário)