C++ OperaSobrecarga tor com exemplos

Sintaxe

Para sobrecarregar um C++ operador, 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.
• A seguir, você menciona a palavra-chave do operador.
• O símbolo indica que o símbolo do operador está sobrecarregado. Por exemplo, +, -, <, ++.
• O(s) argumento(s) pode(m) ser passado(s) 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. Incluindo 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 estará 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 contador 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. A operadora 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() for chamada. O } marca o fim 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 nesta 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 valor após a conclusão bem-sucedida.
19. Fim do corpo da função main().

Diferentes abordagens para Operator Sobrecarga 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 do operador pode ser uma função membro quando um operando Esquerdo é um objeto da Classe.
• Quando o operando esquerdo é diferente, o OperaA função de sobrecarga do tor 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 da classe privada e protegida.

Pode tudo C++ Operators estar sobrecarregado?

Não. Existem C++ operadores 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 para lembrar

1. Com a sobrecarga do operador, você pode redefinir a forma como um operador funciona apenas para os tipos definidos pelo usuário (objetos, estruturas). Você não pode usá-lo para tipos integrados (float, char, int, etc.).
2. O = e & C++ operadores são sobrecarregados por padrão. Por exemplo, você pode copiar os objetos da mesma Classe diretamente usando o operador =.
3. Operaa precedência de tor não altera a associatividade e a precedência de operadores. No entanto, você pode alterar a ordem de avaliação usando parênteses.
4. Existem 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 Operasobrecarga

Aqui estão as regras para OperaSobrecarga:

• 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 amiga. No entanto, esses operadores podem ser sobrecarregados usando funções de membro.

Como sobrecarregar Operator

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. Incluindo 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 Operasobrecarga.
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 estará 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 como 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. A operadora 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 nesta função.
16. Crie uma instância do OperaClasse torOverload chamada ov.
17. Isso chamará a função do operador void ++().
18. Utilize a postura de Operaclasse torOverload para chamar a função Print().
19. A função deve retornar 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. Incluindo 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 dentro da Classe.
5. Defina duas variáveis ​​inteiras, reais e superiores.
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 da classe e inicializando o variáveis.
8. Inicialize o valor da variável real.
9. Inicialize o valor da variável.
10. Fim do corpo do construtor.
11. Substitua o significado do operador +.
12. Crie o tipo de dados resultado 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. Esta 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 resultado 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 somadas. A primeira parte de c1 será somada à primeira parte de c2, ou seja, 9+4. A segunda parte de c1 será somada à 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 C++ operador em um escopo.
• Isso é chamado de sobrecarga do operador.
• OperaA sobrecarga do operador fornece um significado especial de um operador para um tipo de dados definido pelo usuário.
• Você pode redefinir a maioria C++ operadores por sobrecarga de operadores.
• Nem todos C++ os operadores podem ficar sobrecarregados.
• Para que um operador fique 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.