Polimorfismo em C ++: Compreendendo os conceitos | Simplilearn

//myFunction com o mesmo nome, mas 1 parâmetro duplo

void myFunc (double a)

{

//myFunction com o mesmo nome e 2 parâmetros internos

void myFunc (int a, int b)

{

};

int main () {

functionOverloadingExample obj;

//Qual myFunction é chamado dependerá dos parâmetros passados ​​

//O primeiro’myFunc’é chamado

obj.myFunc (10);

//O segundo’myFunc’é chamado

obj.myFunc (10.20);

//O terceiro’myFunc’é chamado

obj.myFunc (100, 200);

return 0;

}

No programa acima, existem três funções com o mesmo nome myFunc, mas com argumentos diferentes. Quando uma chamada de função é feita, o compilador decide a função que deve ser chamada combinando os parâmetros passados. Portanto, quando você passa um valor inteiro 10, ele chama a função mFunc (int a).

• Sobrecarga do operador

A sobrecarga do operador às vezes também é chamada de polimorfismo ad-hoc. Na sobrecarga do operador, diferentes operadores exibem diferentes implementações com base em seus parâmetros ou assinaturas. A linguagem de programação C ++ permite criar operadores que podem servir a propósitos específicos com funções definidas pelo usuário. Essa capacidade do C ++ de criar operadores com um significado específico para tipos de dados é chamada de sobrecarga de operador.

Um exemplo simples e comum de sobrecarga de operador é quando você usa o operador “+” entre duas ou mais strings. É usado para uni-los ou concatená-los. Alguns outros casos de uso de sobrecarga de operador estão trabalhando com números fracionais, números complexos, inteiros grandes, etc.

Sintaxe

class class_name {

público

símbolo do operador return_type (argumentos) {

//defina a função

}

};

O programa a seguir ilustra o polimorfismo em tempo de compilação usando sobrecarga de operador:

#include

usando namespace std;

//definir uma classe

classe operatorOverlaodingExample

{

privado:

int myVar;

público:

operatorOverlaodingExample (): myVar (8) {}

operador void ++ () {

minhaVar=minhaVar + 20;

}

void display () {

cout <<"O valor atualizado é:"<

cout <<"\ n \ n";

}

};

int main ()

{

operatorOverlaodingExample obj;

//chame a função”operador viod +++ ()”

++ obj;

obj.display ();

return 0;

}

A principal diferença entre as funções normais e as funções do operador é que o nome das funções do operador é seguido pela palavra-chave “operador” junto com o símbolo do operador que você deseja sobrecarregar. Essas funções de operador são invocadas quando seus operadores correspondentes são usados ​​no programa.

Você pode sobrecarregar quase todos os operadores suportados pelo C ++, mas existem algumas exceções. Esses operadores de exceção são:

• . (operador de ponto)
• :: (operador de escopo)
• ?: (operador ternário)
• tamanho de

Alguns pontos-chave sobre sobrecarga do operador:

• Para sobrecarregar um operador, é necessário que pelo menos um operando seja um objeto de uma classe definida pelo usuário.
• Na sobrecarga do operador, um operador de atribuição padrão é criado com cada classe automaticamente pelo compilador.
• C ++ permite que você crie operadores de conversão que podem converter um tipo de operador em outro tipo.

#include

usando namespace std;

//define uma classe para converter inteiros em flutuantes

classe convertFloat

{

dividendo int, divisor;

público:

//construtor

convertFloat (int D, int d)

{

dividendo=D;

divisor=d;

}

//este é um operador de conversão

//converterá um número inteiro em flutuante

//e devolva

operador float () const {

return float (dividendo)/float (divisor);

}

};

int main () {

//chame a operadora

convertFloat f (5, 9);

float result=f;

//imprimir o resultado

cout <

cout <<"\ n \ n";

return 0;

}

• Os construtores que têm um único argumento também atuam como um operador de conversão.

#include

usando namespace std;

//definir uma classe

coordenadas de classe

{

privado:

int x1, y1;

público:

//construtor da classe

coordenadas (int x_coord=0, int y_coord=0) {

x1=x_coord;

y1=y_coord;

}

void displayCoordinates () {

cout <<"\ n";

cout <<"A coordenada x="<

}

};

int main () {

ponto de coordenadas (100, 100);

point.displayCoordinates ();

//x será 30 e y será 0

ponto=30;

point.displayCoordinates ();

return 0;

}

Maneiras de implementar polimorfismo em tempo de execução em C ++

Em C ++, você pode implementar o polimorfismo em tempo de execução de duas maneiras. Nesta seção, você verá os dois em detalhes.

• Substituição de função

A substituição da função ocorre quando a classe derivada e a classe base contêm uma função com o mesmo nome. Junto com o mesmo nome, ambas as funções devem ter o mesmo número de argumentos, bem como o mesmo tipo de retorno. A classe derivada herda as funções de membro e membros de dados de sua classe base. Portanto, para substituir uma determinada funcionalidade, você deve executar a substituição de função. Isso é alcançado durante o tempo de execução.

As funções que são substituídas adquirem escopos diferentes. Para anular a função, a herança é uma necessidade. Isso só pode acontecer em uma classe derivada. Se uma classe não for herdada de outra classe, você não poderá obter a substituição de função. Para resumir, uma função é substituída quando você deseja realizar uma tarefa complementar à função da classe base.

O programa a seguir ilustra o polimorfismo do tempo de execução usando a substituição de função:

#include

usando namespace std;

//definir uma classe base

pássaro da classe

{

público:

//exibe a função da classe base

void display ()

{

cout <<"Eu sou a função de exibição da classe base";

cout <<"\ n \ n";

}

};

papagaio de classe: pássaro público

{

público:

//exibir função da classe servida

//esta função exibirá ()

//da substituição da classe base em tempo de execução

void display ()

{

cout <<"Eu sou a função de exibição da classe derivada";

cout <<"\ n \ n";

}

};

int main ()

{

//criar objetos de classes base e filho

pássaro b;

papagaio p;

//chame a função diplay ()

b.display ();

p.display ();

}

• Funções virtuais

As funções virtuais são as funções de membro da classe base que são substituídas em uma classe derivada. Quando você faz uma chamada para essa função usando um ponteiro ou referência à classe base, a função virtual é chamada e a versão da classe derivada da função é chamada.

Alguns pontos-chave sobre funções virtuais

• As funções virtuais são apenas dinâmicas
• Eles são declarados dentro de uma classe base usando a palavra-chave “virtual”
• Essas funções são chamadas durante o tempo de execução
• As funções virtuais são sempre declaradas com uma classe base e substituídas em uma classe filha
• As funções virtuais podem existir na ausência de herança. Nesse caso, a versão da classe base da função será chamada

O programa a seguir ilustra o polimorfismo em tempo de execução usando uma função virtual:

#include

usando namespace std;

//define um pássaro da classe base

pássaro da classe {

público:

//função virtual

display vazio virtual ()

{

cout <<"Isso é exibido na classe de pássaros."<<"\ n \ n";

}

void print ()

{

cout <<"Isso é mostrado na classe de pássaros."<<"\ n \ n";

}

};

//definir um papagaio de classe infantil

papagaio de classe: pássaro público {

público:

void display ()

{

cout <<"Esta é a exibição na classe de papagaios."<<"\ n \ n";

}

void print ()

{

cout <<"Isso é mostrado na aula de papagaios."<<"\ n \ n";

}

};

int main ()

{

//cria uma referência para a classe bird

bird * brd;

papagaio p;

brd=& p;

//isso irá chamar a função virtual

brd-> display ();

//isso irá chamar a função não virtual

brd-> print ();

}