Polimorfismo C++ com Exemplo

O que é polimorfismo em C++?

Em C++, o polimorfismo faz com que uma função de membro se comporte de maneira diferente com base no objeto que a chama/chama. Polimorfismo é uma palavra grega que significa ter muitas formas. Ocorre quando você tem uma hierarquia de classes relacionadas por herança.

Por exemplo, suponha que temos a função makeSound(). Quando um gato chama essa função, ele produzirá o som de miado. Quando uma vaca invoca a mesma função, ela fornecerá o som de moow.

Embora tenhamos uma função, ela se comporta de maneira diferente em diferentes circunstâncias. A função tem muitas formas; portanto, atingimos o polimorfismo.

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

• O que é polimorfismo?
• Tipos de polimorfismo
• Polimorfismo de tempo de compilação
• Sobrecarga de funções
• Sobrecarga do operador
• Polimorfismo de tempo de execução
• Substituição de função
• Função virtual C++
• Polimorfismo em tempo de compilação vs. Polimorfismo em tempo de execução

Tipos de polimorfismo

C++ suporta dois tipos de polimorfismo:

• Polimorfismo em tempo de compilação e
• Polimorfismo em tempo de execução.

Polimorfismo de tempo de compilação

Você invoca as funções sobrecarregadas combinando o número e o tipo de argumentos. A informação está presente durante o tempo de compilação. Isso significa que o compilador C++ selecionará a função correta em tempo de compilação.

O polimorfismo em tempo de compilação é obtido por meio de sobrecarga de função e sobrecarga de operador.

Sobrecarga de funções

A sobrecarga de funções ocorre quando temos muitas funções com nomes semelhantes, mas argumentos diferentes. Os argumentos podem diferir em termos de número ou tipo.

Exemplo 1:

#include <iostream> 
using namespace std;

void test(int i) {
	cout << " The int is " << i << endl;
}
void test(double  f) {
	cout << " The float is " << f << endl;
}
void test(char const *ch) {
	cout << " The char* is " << ch << endl;
}

int main() {
	test(5);
	test(5.5);
	test("five");
	return 0;
}

Saída:

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

Explicação do código:

1. Inclua o arquivo de cabeçalho iostream em nosso código. Seremos capazes de usar suas funções.
2. Inclua o namespace std em nosso código. Seremos capazes de usar suas classes sem chamá-lo.
3. Crie uma função chamada test que receba um parâmetro inteiro i. O { marca o início do corpo do teste de função.
4. Instrução a ser executada se o teste de função acima for invocado/chamado.
5. Fim do corpo do teste de função acima.
6. Crie uma função chamada test que receba um parâmetro float f. O { marca o início do corpo do teste de função.
7. Instrução a ser executada se o teste de função acima for invocado/chamado.
8. Fim do corpo do teste de função acima.
9. Crie uma função chamada test que receba um parâmetro de caractere ch. O { marca o início do corpo do teste de função.
10. Instrução a ser executada se o teste de função acima for invocado/chamado.
11. Fim do corpo do teste de função acima.
12. Chame a função main(). O { marca o início do corpo da função.
13. Chame a função test e passe 5 para ela como o valor do argumento. Isso invoca a função de teste que aceita um argumento inteiro, ou seja, a primeira função de teste.
14. Chame a função test e passe 5.5 para ela como o valor do argumento. Isso invocará a função de teste que aceita um argumento float, ou seja, a segunda função de teste.
15. Chame a função test e passe cinco para ela como o valor do argumento. Isso invocará a função de teste que aceita um argumento de caractere, ou seja, a terceira função de teste.
16. O programa deve retornar um valor se for executado com sucesso.
17. O final do corpo da função main().

Temos três funções com o mesmo nome, mas diferentes tipos de argumentos. Conseguimos o polimorfismo.

Sobrecarga do operador

Em Sobrecarga de Operador, definimos um novo significado para um operador C++. Também altera a forma como o operador funciona. Por exemplo, podemos definir o operador + para concatenar duas strings. Nós o conhecemos como o operador de adição para adicionar valores numéricos. Após nossa definição, quando colocado entre inteiros, ele os adicionará. Quando colocado entre as strings, ele as concatenará.

Exemplo 2:

#include<iostream> 
using namespace std;

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

	ComplexNum operator + (ComplexNum const &obj) {
		ComplexNum result;
		result.real = real + obj.real;
		result.over = over + obj.over;
		return result;
	}
	void print() { 
		cout << real << " + i" << over << endl; 
	}
};
int main()
{
	ComplexNum c1(10, 2), c2(3, 7);
	ComplexNum c3 = c1+c2;
	c3.print();
}

Saída:

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

Explicação do código:

1. Inclua 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 ComplexNum. 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 será acessível mesmo de fora da classe.
7. Crie o construtor da classe e inicialize 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. Precisamos substituir o significado do operador +.
12. Crie o resultado do tipo de dados do tipo ComplexNum.
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 ComplexNum.
21. Chame a função main().
22. Passe os valores das partes reais e complexas a serem adicionadas. A primeira parte de c1 será adicionada à primeira parte de c2, ou seja, 10+3. A segunda parte de c1 será adicionada à segunda parte de c, ou seja, 2+7.
23. Execute uma operação usando o operador + sobrecarregado e armazenando o resultado na variável c3.
24. Imprima o valor da variável c3 no console.
25. Fim do corpo da função main().

Polimorfismo de tempo de execução

Isso acontece quando o método de um objeto é invocado/chamado durante o tempo de execução e não durante o tempo de compilação. O polimorfismo de tempo de execução é obtido por meio da substituição de função. A função a ser chamada/invocada é estabelecida durante o tempo de execução.

Substituição de função

A substituição de função ocorre quando uma função da classe base recebe uma nova definição em uma classe derivada. Nesse momento, podemos dizer que a função base foi substituída.

Por exemplo:

#include <iostream>
using namespace std;
class Mammal {

public:
	void eat() {

		cout << "Mammals eat...";
	}

};

class Cow: public Mammal {

public:
	void eat() {

		cout << "Cows eat grass...";
	}
};
int main(void) {

	Cow c = Cow();

	c.eat();

	return 0;

}

Saída:

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

Explicação do código:

1. Importe 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 Mamífero. O { marca o início do corpo da classe.
4. Use o modificador de acesso público para definir a função que estamos prestes a criar como acessível publicamente. Ele será acessível de fora desta classe.
5. Crie uma função pública chamada eat. O { marca o início do corpo da função.
6. Imprima a instrução adicionada à função cout quando a função eat() é invocada.
7. Fim do corpo da função eat().
8. Fim do corpo da classe Mamífero.
9. Crie uma classe chamada Vaca que herde a classe Mamífero. Vaca é a classe derivada, enquanto Mamífero é a classe base. O { marca o início desta classe.
10. Use o modificador de acesso público para marcar a função que estamos prestes a criar como acessível publicamente. Será acessível de fora desta classe.
11. Substitui a função eat() que foi definida na classe base. O { marca o início do corpo da função.
12. A instrução a ser impressa no console quando esta função é invocada.
13. Fim do corpo da função eat().
14. Fim do corpo da classe Vaca.
15. Chame a função main(). O { marca o início do corpo desta função.
16. Crie uma instância da classe Cow e dê a ela o nome c.
17. Chame a função eat() definida na classe Cow.
18. O programa deve retornar um valor após a conclusão bem-sucedida.
19. Fim da função main().

Função virtual C++

Uma função virtual é outra maneira de implementar polimorfismo em tempo de execução em C++. É uma função especial definida em uma classe base e redefinida na classe derivada. Para declarar uma função virtual, você deve usar a palavra-chave virtual. A palavra-chave deve preceder a declaração da função na classe base.

Se uma classe de função virtual for herdada, a classe virtual redefine a função virtual para atender às suas necessidades. Por exemplo:

#include <iostream>  
using namespace std;
class ClassA {
		public:
		virtual void show() {
			cout << "The show() function in base class invoked..." << endl;
		}
	};
	class ClassB :public ClassA {
	public:
		void show() 	{
			cout << "The show() function in derived class invoked...";
		}
	};
	int main() {
		ClassA* a;   
		ClassB b;
		a = &b;
		a->show();      
	}

Saída:

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

Explicação do código:

1. Inclua o arquivo de cabeçalho iostream no código para usar suas funções.
2. Inclua o namespace std em nosso código para usar suas classes sem chamá-lo.
3. Crie uma classe chamada ClassA.
4. Use o modificador de acesso público para marcar um membro de classe como acessível publicamente.
5. Crie uma função virtual chamada show(). Será uma função pública.
6. O texto a ser impresso quando o show() invocado é invocado. O endl é uma palavra-chave C++, que significa linha final. Move o cursor do mouse para a próxima linha.
7. Fim do corpo da função virtual show().
8. Fim do corpo da classe ClassA.
9. Criando uma nova classe chamada ClassB que herda a classe ClassA. ClassA se torna a classe base enquanto ClassB se torna a classe derivada.
10. Use o modificador de acesso público para marcar um membro de classe como acessível publicamente.
11. Redefina a função virtual show() derivada na classe base.
12. O texto a ser impresso no console quando a função show() definida na classe derivada é invocada.
13. Fim do corpo da função show().
14. Fim do corpo da classe derivada, ClassB.
15. Chame a função main(). A lógica do programa deve ser adicionada ao seu corpo.
16. Crie uma variável de ponteiro chamada a. Ele aponta para a classe chamada ClassA.
17. Crie uma instância da classe chamada ClassB. A instância recebe o nome b.
18. Atribua os valores armazenados no endereço b na variável a.
19. Chame a função show() definida na classe derivada. A vinculação tardia foi implementada.
20. Fim do corpo da função main().

Polimorfismo em tempo de compilação vs. Polimorfismo em tempo de execução

Aqui estão as principais diferenças entre os dois:
Polimorfismo em tempo de compilação Polimorfismo em tempo de execução Também é chamado de ligação antecipada ou polimorfismo estáticoTambém é chamado de ligação tardia/dinâmica ou polimorfismo dinâmicoO método é chamado/chamado durante o tempo de compilaçãoO método é chamado/chamado durante o tempo de execuçãoImplementado via sobrecarga de função e sobrecarga de operadorImplementado via substituição de método e funções virtuaisExemplo, sobrecarga de método. Muitos métodos podem ter nomes semelhantes, mas diferentes números ou tipos de argumentosExemplo, substituição de método. Muitos métodos podem ter um nome semelhante e o mesmo protótipo. Execução mais rápida, pois a descoberta de métodos é feita durante o tempo de compilação. Execução mais lenta, pois o descobridor de métodos é feito durante o tempo de execução. é fornecido para resolver problemas complexos, pois os métodos são descobertos durante o tempo de execução.

Resumo:

• Polimorfismo significa ter muitas formas.
• Ocorre quando há uma hierarquia de classes relacionadas por herança.
• Com o polimorfismo, uma função pode se comportar de maneira diferente com base no objeto que a invoca/chama.
• No polimorfismo de tempo de compilação, a função a ser invocada é estabelecida durante o tempo de compilação.
• No polimorfismo de tempo de execução, a função a ser invocada é estabelecida durante o tempo de execução.
• O polimorfismo em tempo de compilação é determinado por meio de sobrecarga de função e sobrecarga de operador.
• Na sobrecarga de funções, existem muitas funções com nomes semelhantes, mas argumentos diferentes.
• Os parâmetros podem diferir em número ou tipo.
• Na sobrecarga de operadores, um novo significado é definido para operadores C++.
• O polimorfismo de tempo de execução é obtido por meio da substituição de função.
• Na substituição de função, uma classe derivada fornece uma nova definição para uma função definida na classe base.