Sobrecarga do operador C++ com exemplos

O que é sobrecarga do operador?

Usando sobrecarga de operador em C++, você pode especificar mais de um significado para um operador em um escopo. A finalidade da sobrecarga de operadores é fornecer um significado especial de um operador para um tipo de dados definido pelo usuário.

Com a ajuda da sobrecarga de operadores, você pode redefinir a maioria dos operadores de C++. Você também pode usar a sobrecarga de operador para executar diferentes operações usando um operador.

Neste tutorial de C++, você aprenderá:

• O que é sobrecarga do operador?
• Sintaxe
• Diferentes abordagens para sobrecarga de operador em C++
• Todos os operadores C++ podem ser sobrecarregados?
• Lembranças:
• Regras para sobrecarga do operador:
• Como sobrecarregar o operador:

Sintaxe

Para sobrecarregar um operador C++, você deve definir uma função especial dentro da classe da seguinte forma:

class class_name
{
    ... .. ...
    public
       return_type operator symbol (argument(s))
       {
           ... .. ...
       } 
    ... .. ...
};

Aqui está uma explicação para a sintaxe acima:

• O return_type é o tipo de retorno da função.
• Em seguida, você menciona a palavra-chave do operador.
• O símbolo denota o símbolo do operador a ser sobrecarregado. Por exemplo, +, -, <, ++.
• Os argumentos podem ser passados ​​para a função do operador da mesma forma que as funções.

Exemplo 1:

#include <iostream>
using namespace std;
class TestClass {
private:
	int count;
public:
	TestClass() : count(5) {}
	void operator --() {
		count = count - 3;
	}
	void Display() { 

		cout << "Count: " << count; }
};

int main() {
	TestClass tc;
	--tc;
	tc.Display();
	return 0;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

1. Incluir o arquivo de cabeçalho iostream em nosso código para usar suas funções.
2. Inclua o namespace std em nosso programa para usar suas classes sem chamá-lo.
3. Crie uma classe chamada TestClass.
4. Use o modificador de acesso privado, que marca um membro da classe como acessível de forma privada.
5. Crie uma contagem de variável inteira. Esta variável será acessível de forma privada.
6. Use o modificador de acesso público, que marca um membro da classe como acessível de forma privada.
7. Use um construtor de classe para inicializar o contador de variável para 5.
8. Sobrecarregue o significado do operador —.
9. O operador diminuirá o valor da variável x em 1.
10. Fim da seção de sobrecarga do operador. O operador recebeu um novo nome.
11. Definindo uma função chamada função Display().
12. Imprima o valor da variável count junto com outro texto no console quando a função Display() é chamada. O } marca o final do corpo da função Display().
13. Fim do corpo da classe.
14. Chame a função main(). A lógica do programa deve ser adicionada dentro desta função.
15. Crie uma instância da classe TestClass e dê a ela o nome tc.
16. Isso chamará a função do operador void –().
17. Use a postura da classe TestClass para chamar a função Display().
18. A função deve retornar o valor após a conclusão bem-sucedida.
19. Fim do corpo da função main().

Diferentes abordagens para sobrecarga de operador em C++

Você pode realizar a sobrecarga do operador implementando qualquer um dos seguintes tipos de funções:

1. Função de membro
2. Função de não membro
3. Função de amigo

• A função de sobrecarga de operador pode ser uma função de membro quando um operando esquerdo é um objeto da classe.
• Quando o operando esquerdo é diferente, a função de sobrecarga do operador deve ser uma função não membro.

Você pode tornar a função de sobrecarga do operador uma função amiga se ela precisar acessar os membros de classe privados e protegidos.

Todos os operadores C++ podem ser sobrecarregados?

Não. Existem operadores C++ que não podem ser sobrecarregados.

Eles incluem:

• ::-Operador de resolução de escopo
• ?:-operador ternário.
• . -seletor de membros
• Operador Sizeof
• * -seletor de ponteiro de membro

Coisas a serem lembradas:

1. Com a sobrecarga de operadores, você pode redefinir a maneira como um operador funciona apenas para os tipos definidos pelo usuário (objetos, estruturas). Você não pode usá-lo para tipos internos (float, char, int, etc.).
2. Os operadores =e &C++ são sobrecarregados por padrão. Por exemplo, você pode copiar os objetos da mesma classe diretamente usando o operador =.
3. A precedência do operador não altera a associatividade e a precedência dos operadores. No entanto, você pode alterar a ordem de avaliação usando parênteses.
4. Há quatro operadores que você não pode sobrecarregar em C++. Eles incluem o operador de resolução de escopo (::), o operador de seleção de membro (.), a seleção de membro por meio de um ponteiro para o operador de função (.*) e o operador ternário (?:).

Regras para sobrecarga do operador:

Aqui estão as regras para sobrecarga do operador:

• Para que funcione, pelo menos um operando deve ser um objeto de classe definido pelo usuário.
• Você só pode sobrecarregar os operadores existentes. Você não pode sobrecarregar novos operadores.
• Alguns operadores não podem ser sobrecarregados usando uma função de amigo. No entanto, esses operadores podem ser sobrecarregados usando a função de membro.

Como sobrecarregar o operador:

Exemplo 1:

#include <iostream>   
using namespace std;
class OperatorOverload {
private:
	int x;

public:
	OperatorOverload() : x(10) {}
	void operator ++() {
		x = x + 2;
	}
	void Print() {
		cout << "The Count is: " << x;
		}
};
int main() {
	OperatorOverload ov;
	++ov;   
	ov.Print();
	return 0;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

1. Incluir o arquivo de cabeçalho iostream em nosso código para usar suas funções.
2. Inclua o namespace std em nosso programa para usar suas classes sem chamá-lo.
3. Crie uma classe chamada OperatorOverload.
4. Use o modificador de acesso privado, que marca um membro da classe como acessível de forma privada.
5. Crie uma variável inteira x. Esta variável será acessível de forma privada.
6. Use o modificador de acesso público, que marca um membro da classe como acessível de forma privada.
7. Use um construtor de classe para inicializar a variável x para 10.
8. Sobrecarregue o significado do operador ++.
9. O operador incrementará o valor da variável x com 2.
10. Fim da seção de sobrecarga do operador. O operador recebeu um novo nome.
11. Chamando a função Print().
12. Imprima o valor da variável x junto com outro texto no console quando a função Print() for chamada.
13. Fim do corpo da função Print().
14. Fim do corpo da classe.
15. Chame a função main(). A lógica do programa deve ser adicionada dentro desta função.
16. Crie uma instância da classe OperatorOverload chamada ov.
17. Isso chamará a função ++() do operador void.
18. Use a postura da classe OperatorOverload para chamar a função Print().
19. A função deve retornar o valor após a conclusão bem-sucedida.
20. Fim do corpo da função main().

Exemplo 2:

#include<iostream> 
using namespace std;

class TestClass {
private:
	int real, over;
public:
	TestClass(int rl = 0, int ov = 0) {
		real = rl;
		over = ov;
	}

	TestClass operator + (TestClass const &obj) {
		TestClass result;
		result.real = real + obj.real;
		result.over = over + obj.over;
		return result;
	}
	void print() {
		cout << real << " + i" << over << endl;
	}
};
int main()
{
	TestClass c1(9, 5), c2(4, 3);
	TestClass c3 = c1 + c2;
	c3.print();
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

1. Incluir o arquivo de cabeçalho iostream em nosso programa para usar suas funções.
2. Inclua o namespace std em nosso programa para usar suas classes sem chamá-lo.
3. Crie uma classe chamada TestClass. O { marca o início do corpo da classe.
4. Use o modificador de acesso privado para marcar variáveis ​​como privadas, o que significa que elas só podem ser acessadas de dentro da classe.
5. Defina duas variáveis ​​inteiras, real e over.
6. Use o modificador de acesso público para marcar o construtor como público, o que significa que ele estará acessível mesmo fora da classe.
7. Criando o construtor de classe e inicializando as variáveis.
8. Inicie o valor da variável real.
9. Inicialize o valor da variável.
10. Fim do corpo do construtor.
11. Substituir o significado do operador +.
12. Crie o resultado do tipo de dados do tipo TestClass.
13. Use o operador + com números complexos. Esta linha adicionará a parte real de um número à parte real de outro número.
14. Use o operador + com números complexos. Essa linha adicionará a parte imaginária de um número à parte imaginária de outro número.
15. O programa retornará o valor da variável result após a execução bem-sucedida.
16. Fim da definição do novo significado do operador +, ou seja, sobrecarga.
17. Chame o método print().
18. Imprima o novo número complexo após a adição no console.
19. Fim do corpo da função print().
20. Fim do corpo da classe TestClass.
21. Chamando a função main().
22. Passando os valores das partes reais e complexas a serem adicionadas. A primeira parte de c1 será adicionada à primeira parte de c2, ou seja, 9+4. A segunda parte de c1 será adicionada à segunda parte de c, ou seja, 5+3.
23. Executando uma operação usando o operador + sobrecarregado e armazenando o resultado na variável c3.
24. Imprimindo o valor da variável c3 no console.
25. Fim do corpo da função main().

Resumo:

• Você pode especificar mais de um significado para um operador C++ em um escopo.
• Isso é chamado de sobrecarga de operadores.
• A sobrecarga de operador fornece um significado especial de um operador para um tipo de dados definido pelo usuário.
• Você pode redefinir a maioria dos operadores C++ por meio da sobrecarga de operadores.
• Nem todos os operadores C++ podem ser sobrecarregados.
• Para que um operador seja sobrecarregado, pelo menos um dos operandos deve ser um objeto definido pelo usuário.
• Somente os operadores existentes podem ser sobrecarregados. Você não pode sobrecarregar novos operadores.