Polimorfismo é uma oportunidade para diferentes classes de objetos, relacionadas através de herança, de responder de várias formas quando o mesmo elemento de função for chamado. Isso ajuda a criar um mecanismo universal descrevendo o comportamento não apenas da classe base, mas também das classes descendentes.
Vamos continuar a desenvolver uma classe base CShape, e definir uma função membro GetArea(), destinado a calcular a área de uma forma. Em todas as classes descendentes, produzidas por herança a partir da classe base, nós redefinimos esta função de acordo com as regras de cálculo de área de uma forma (shape) particular.
Para um quadrado (classe CSquare), a área é calculada através de seu lado, para um círculo (classe CCircle), a área é expressa através de seu raio, etc. Nós podemos criar um array para armazenas objetos do tipo CShape, no qual tanto objetos da classe base como todos os objetos de classes descendentes podem ser armazenados. Mais adiante, podemos chamar a mesma função para cada elemento do array.
Exemplo:
//--- Classe Base
class CShape
{
protected:
int m_type; // tipo da forma
int m_xpos; // X - coordenada do ponto base
int m_ypos; // Y - coordenada do ponto de base
public:
void CShape(){m_type=0;}; // construtor, tipo=0
int GetType(){return(m_type);};// retorna o tipo da forma
virtual
double GetArea(){return (0); }// retorna a área da forma
};
Agora, todas as classes derivadas têm uma função membro getArea(), que retorna o valor zero. A implementação desta função em cada descendente não será a mesma.
//--- A classe derivada Circle
class CCircle : public CShape // Depois do dois pontos definimos a classe base
{ // a partir do qual a herança é feita
private:
double m_radius; // raio do círculo
public:
void CCircle(){m_type=1;}; // construtor, tipo=1
void SetRadius(double r){m_radius=r;};
virtual double GetArea(){return (3.14*m_radius*m_radius);}// área do círculo
};
Para a classe Square, a declaração é a mesma:
//--- A classe derivada Square
class CSquare : public CShape // Depois do dois pontos definimos a classe base
{ // a partir do qual a herança é feita
private:
double m_square_side; // lado do quadrado
Para calcular a área do quadrado e círculo, precisamos dos correspondentes valores de m_radius e m_square_side, por isso nós adicionamos as funções SetRadius() e SetSide() na declaração da correspondente classe.
Assumimos que objetos de diferentes tipos (CCircle e CSquare) derivados do tipo base CShape são usados em nosso programa. Polimorfismo permite criar um array de objetos da classe base CShape, mas ao declarar este array, estes objetos são desconhecidos e o tipo deles é indefinido.
A decisão sobre que tipo de objeto estará contido em cada elemento do array será tomada diretamente durante a execução do programa. Isso envolve a criação dinâmica de objetos das classes apropriadas, e portanto a necessidade do uso de ponteiros de objeto ao invés de objetos.
O operador new é usado para criação dinâmica de objetos. Cada um destes objetos devem ser individualmente e explicitamente excluídos usando o operador delete. Portanto declararemos um array de ponteiros do tipo CShape, e criaremos um objeto de um tipo apropriado para cada elemento (new Class_Name), como mostrado no exemplo de script seguinte:
//+------------------------------------------------------------------+
//| Programa Script da função start (iniciar) |
//+------------------------------------------------------------------+
void OnStart()
{
//--- Declararmos um array de ponteiros de objeto do tipo base
CShape *shapes[5]; // Um array de ponteiros para objetos CShape
//--- Aqui preenchemos o array com objetos derivados
//--- Declaramos um ponteiro para o objeto de tipo CCircle
CCircle *circle=new CCircle();
//--- Definimos propriedades do objeto usando o ponteiro do círculo
circle.SetRadius(2.5);
//--- Colocamos o valor do ponteiro em shapes[0]
shapes[0]=circle;
//--- Criamos um outro objeto CCircle e escrevemos seu ponteiro em shapes[1]
circle=new CCircle();
shapes[1]=circle;
circle.SetRadius(5);
//--- Aqui nós intencionalmente "esquecemos" de definir um valor para shapes[2]
//circle=new CCircle();
//circle.SetRadius(10);
//shapes[2]=circle;
//--- Definimos NULL para o elemento que não é usado
shapes[2]=NULL;
//--- Criamos um objeto CSquare e escrevemos seu ponteiro em shapes[3]
CSquare *square=new CSquare();
square.SetSide(5);
shapes[3]=square;
//--- Criamos um objeto CSquare e escrevemos seu ponteiro em shapes[4]
square=new CSquare();
square.SetSide(10);
shapes[4]=square;
//--- Temos um array de ponteiros, obtemos seu tamanho
int total=ArraySize(shapes);
//--- Passamos em um loop através de todos os ponteiros no array
for(int i=0; i<5;i++)
{
//--- Se o ponteiro no índice especificado é válido
if(CheckPointer(shapes[i])!=POINTER_INVALID)
{
//--- Imprimi o tipo e área da forma
PrintFormat("O objeto do tipo %d tem a área %G",
shapes[i].GetType(),
shapes[i].GetArea());
}
//--- Se o ponteiro tem o tipo POINTER_INVALID
else
{
//--- Notificamos um erro
PrintFormat("Objeto shapes[%d] não foi inicializado! Seu ponteiro pe %s",
i,EnumToString(CheckPointer(shapes[i])));
}
}
//--- Devemos excluir todos os objetos criados dinamicamente
for(int i=0;i<total;i++)
{
//--- Nós podemos excluir somente objetos com ponteiros do tipo POINTER_DYNAMIC
if(CheckPointer(shapes[i])==POINTER_DYNAMIC)
{
//--- Notificação de exclusão
PrintFormat("Excluindo shapes[%d]",i);
//--- Excluímos um objeto por meio de seu ponteiro
delete shapes[i];
}
}
}
Favor notar que ao excluir um objeto usando o operador delete, o tipo de seu ponteiro deve ser verificado. Somente objetos com ponteiro do tipo POINTER_DYNAMIC podem ser excluídos usando delete. Para ponteiros de outros tipos, um erro será retornado.
Além da redefinição de funções durante herança, o polimorfismo também inclui a implementação de uma mesma função com diferentes conjuntos de parâmetros dentro de uma classe. Isso significa que a classe pode ter várias funções com o mesmo nome, mas com um tipo e/ou conjunto de parâmetros diferentes. Neste caso, o polimorfismo é implementado através de sobrecarga de função.
