Polimorfismo C ++

Neste tutorial, aprenderemos sobre polimorfismo em C ++ com a ajuda de exemplos.

O polimorfismo é um conceito importante de programação orientada a objetos. Simplesmente significa mais de um formulário. Ou seja, a mesma entidade (função ou operador) se comporta de maneira diferente em diferentes cenários. Por exemplo,

O +operador em C ++ é usado para executar duas funções específicas. Quando usado com números (inteiros e números de ponto flutuante), realiza a adição.

 int a = 5; int b = 6; int sum = a + b; // sum = 11

E quando usamos o +operador com strings, ele executa a concatenação de strings. Por exemplo,

 string firstName = "abc "; string lastName = "xyz"; // name = "abc xyz" string name = firstName + lastName;

Podemos implementar polimorfismo em C ++ usando as seguintes maneiras:

  1. Sobrecarga de função
  2. Sobrecarga do operador
  3. Substituição de função
  4. Funções virtuais

Sobrecarga de função C ++

Em C ++, podemos usar duas funções com o mesmo nome se tiverem parâmetros diferentes (ou tipos ou número de argumentos).

E, dependendo do número / tipo de argumentos, diferentes funções são chamadas. Por exemplo,

 // C++ program to overload sum() function #include using namespace std; // Function with 2 int parameters int sum(int num1, int num2) ( return num1 + num2; ) // Function with 2 double parameters double sum(double num1, double num2) ( return num1 + num2; ) // Function with 3 int parameters int sum(int num1, int num2, int num3) ( return num1 + num2 + num3; ) int main() ( // Call function with 2 int parameters cout << "Sum 1 = " << sum(5, 6) << endl; // Call function with 2 double parameters cout << "Sum 2 = " << sum(5.5, 6.6) << endl; // Call function with 3 int parameters cout << "Sum 3 = " << sum(5, 6, 7) << endl; return 0; )

Resultado

 Soma 1 = 11 Soma 2 = 12,1 Soma 3 = 18

Aqui, criamos 3 sum()funções diferentes com parâmetros diferentes (número / tipo de parâmetros). E, com base nos argumentos passados ​​durante uma chamada de função, um particular sum()é chamado.

É um polimorfismo de tempo de compilação porque o compilador sabe qual função executar antes de o programa ser compilado.

Para saber mais sobre, visite nosso tutorial de sobrecarga de função C ++.

Sobrecarga de operador C ++

Em C ++, podemos sobrecarregar um operador, desde que estejamos operando em tipos definidos pelo usuário, como objetos ou estruturas.

Nós não podemos usar o operador sobrecarga para tipos básicos, tais como int, double, etc.

A sobrecarga do operador é basicamente uma sobrecarga de função, em que diferentes funções de operador têm o mesmo símbolo, mas operandos diferentes.

E, dependendo dos operandos, diferentes funções de operador são executadas. Por exemplo,

 // C++ program to overload ++ when used as prefix #include 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 = value + 1; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++()" function ++count1; count1.display(); return 0; )

Resultado

 Contagem: 6

Aqui, sobrecarregamos o ++operador, que opera em objetos da Countclasse (objeto contagem1 neste caso).

Usamos esse operador sobrecarregado para incrementar diretamente a variável de valor do objeto count1 por 1.

Este também é um polimorfismo de tempo de compilação .

Para saber mais, visite nosso tutorial C ++ Operator Overloading.

Substituição de função C ++

Na herança de C ++, podemos ter a mesma função na classe base, bem como em suas classes derivadas.

Quando chamamos a função usando um objeto da classe derivada, a função da classe derivada é executada em vez daquela da classe base.

Portanto, diferentes funções são executadas dependendo do objeto que está chamando a função.

Isso é conhecido como substituição de função em C ++. Por exemplo,

 // C++ program to demonstrate function overriding #include using namespace std; class Base ( public: virtual void print() ( cout << "Base Function" << endl; ) ); class Derived : public Base ( public: void print() ( cout << "Derived Function" << endl; ) ); int main() ( Derived derived1; // Call print() function of Derived class derived1.print(); return 0; )

Resultado

 Função Derivada

Aqui, usamos uma print()função na Baseclasse e a mesma função na Derivedclasse

Quando chamamos print()usando o Derivedobjeto derivado1, ele substitui a print()função de Baseexecutando a print()função da Derivedclasse.

É um polimorfismo de tempo de execução porque a chamada de função não é resolvida pelo compilador, mas sim no tempo de execução.

Para saber mais, visite nosso tutorial de Substituição de funções C ++.

Funções virtuais C ++

Em C ++, podemos não ser capazes de substituir funções se usarmos um ponteiro da classe base para apontar para um objeto da classe derivada.

O uso de funções virtuais na classe base garante que a função possa ser substituída nesses casos.

Assim, as funções virtuais realmente se enquadram na sobreposição de funções . Por exemplo,

 // C++ program to demonstrate the use of virtual functions #include using namespace std; class Base ( public: virtual void print() ( cout << "Base Function" << endl; ) ); class Derived : public Base ( public: void print() ( cout << "Derived Function"

Output

 Derived Function

Here, we have used a virtual function print() in the Base class to ensure that it is overridden by the function in the Derived class.

Virtual functions are runtime polymorphism.

To learn more, visit our C++ Virtual Functions tutorial.

Why Polymorphism?

Polymorphism allows us to create consistent code. For example,

Suppose we need to calculate the area of a circle and a square. To do so, we can create a Shape class and derive two classes Circle and Square from it.

In this case, it makes sense to create a function having the same name calculateArea() in both the derived classes rather than creating functions with different names, thus making our code more consistent.

Artigos interessantes...