Sobrecarga do operador C++

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

Em C++, podemos alterar a maneira como os operadores funcionam 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 resultado de uma classe chamada Complex que representa números complexos.

Como a sobrecarga de operadores nos permite alterar como os operadores funcionam, podemos redefinir como o + operador funciona e use-o 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.

Observação: Não podemos usar sobrecarga de operador para tipos de dados fundamentais como int , float , char e assim por diante.

Sintaxe para sobrecarga de operador C++

Para sobrecarregar um operador, usamos um operator especial função. Definimos a função dentro da classe ou estrutura cujos objetos/variáveis queremos que o operador sobrecarregado trabalhe.

class className {
    ... .. ...
    public
       returnType operator symbol (arguments) {
           ... .. ...
       } 
    ... .. ...
};

Aqui,

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

Sobrecarga do operador em operadores unários

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

Example1:++ Operador (Operador Unário) Sobrecarga

// Overload ++ when used as prefix

#include <iostream>
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;
}

Saída

Count: 6

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

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

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

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

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

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

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

// Overload ++ when used as prefix and postfix

#include <iostream>
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;
}

Saída

Count: 6
Count: 7

O Exemplo 2 funciona quando ++ é usado como prefixo e 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 fazendo Count como o tipo de retorno da função do 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 de operador (operador ++)

#include <iostream>
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;
}

Saída

Count: 6
Count: 6

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;
}

O código para a sobrecarga do operador postfix também é semelhante. Observe que criamos um objeto temp e retornou seu valor para a função do operador.

Observe também o código

temp.value = ++value;

A variável valor pertence ao count1 objeto em main() porque conta1 está chamando a função, enquanto temp.value pertence ao temp objeto.

Sobrecarga de operadores em operadores binários

Operadores binários trabalham em dois operandos. Por exemplo,

result = num + 9;

Aqui, + é um operador binário que funciona nos operandos num e 9 .

Quando sobrecarregamos o operador binário para tipos definidos pelo usuário usando o código:

obj3 = obj1 + obj2;

A função do operador é chamada usando o obj1 objeto e obj2 é passado como um argumento para a função.

Exemplo 4:Sobrecarga do operador binário C++

// C++ program to overload the binary operator +
// This program adds two complex numbers

#include <iostream>
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 << "Enter real and imaginary parts respectively: ";
        cin >> 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:\n";
    complex1.input();

    cout << "Enter second complex number:\n";
    complex2.input();

   // complex1 calls the operator function
   // complex2 is passed as an argument to the function
    result = complex1 + complex2;
    result.output();

    return 0;
}

Saída

Enter first complex number:
Enter real and imaginary parts respectively: 9 5
Enter second complex number:
Enter real and imaginary parts respectively: 7 6
Output Complex number: 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
}

No entanto,

usando & torna nosso código eficiente referenciando o complex2 objeto em vez de fazer um objeto duplicado dentro da função do operador.
usando const é considerado uma boa prática porque impede que a função do operador modifique complex2 .

Coisas a serem lembradas na sobrecarga do 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 de operadores não pode alterar a precedência e a associatividade dos operadores. No entanto, se quisermos alterar a ordem de avaliação, os parênteses devem ser usados.
Existem 4 operadores que não podem ser sobrecarregados em C++. Eles são:
1. :: (resolução do escopo)
2. . (seleção de membros)
3. .* (seleção de membros através de ponteiro para função)
4. ?: (operador ternário)

Visite estas páginas para saber mais sobre:

Como sobrecarregar o operador de incremento da maneira correta?
Como sobrecarregar o operador binário - para subtrair números complexos?

Como passar e retornar objeto de funções C++? Ponteiros C++

Linguagem C