AULA 14 - Programação II - Graduação
POLIMORFISMO
Polimorfismo em linguagens orientadas a objeto, é a capacidade de objetos se comportarem de forma diferenciada, em face de suas características ou do ambiente ao qual estejam submetidos, mesmo quando executando ação que detenha, semanticamente, a mesma designação.
Já vimos isto acontecer com os construtores sobrecarregados das classes, que executam diferentes códigos, para diferentes listas de parâmetros.
O polimorfismo em C++ se apresenta sob diversas formas diferentes, desde as mais simples, como operadores que têm múltiplos usos, funções com mesmo nome e lista de parâmetros diferentes, até as mais complexas como é o caso das funções virtuais, cujas formas de execução são dependentes da classe a qual o objeto pertence e são identificadas em tempo de execução.
Polimorfismo descreve a capacidade de um código de programação comportar-se de diversas formas dependendo do contexto;
- É um dos recursos mais poderosos de linguagens orientadas a objetos:
- Permite trabalhar em um nível alto de abstração;
- Facilita a incorporação de novos códigos em um sistema existente.
A herança nos permite reutilizar numa classe derivada um código escrito para uma classe base. Nesse processo, alguns métodos podem ser redefinidos e, embora tenham nomes idênticos, ter implementações completamente distintas.
FUNÇÕES VIRTUAIS
Em muitas situações, projeta-se uma classe base que vai gerar muitas classes derivadas, porém estas são muito diferentes entre si...
Se uma classe base A tem uma função virtual f() e sua classe derivada B também tem uma função f(), de mesmo nome e tipo, então uma chamada a f() a partir de um objeto da classe derivada deveria invocar B::f().
Nem sempre isto vai acontecer:
Exemplo 1
class Componente {
public:
void exibe() const { cout << "Componente::exibe()" << endl; }
};
/**************/
class Botao: public Componente {
public:
void exibe() const { cout << "Botao::exibe()" << endl; }
};
/**************/
class Janela: public Componente {
public:
void exibe() const { cout << "Janela::exibe()" << endl; }
};
/**************/
void manipula(const Componente &c)
{ c.exibe(); }
/**************/
int main()
{ Botao ok;
Janela ajuda;
manipula(ok); //objeto da classe derivada Botao
manipula(ajuda); //objeto da classe derivada Janela
return 0;
}
Executando o programa acima, veremos que a instrução c.exibe(), na função de manipulação, chamará o método exibe() da super=classe Componente!
A saída será:
Mas isso, na prática, seria um erro; pois a exibição de um botão é uma tarefa diferente da exibição de uma janela.
Como desenvolver, então, os métodos na super-classe, de forma bastante genérica, para que cada classe possa particularizá-los na medida do que seja necessário?
⇒ FUNÇÕES VIRTUAIS
Se na função de manipulação queremos chamar o método exibe() correspondente à classe a que pertence o objeto passado à função, então temos que definir, dentro da classe base, o método exibe() como virtual!!!
Para declarar uma função como sendo virtual, é preciso preceder sua declaração com a palavra chave virtual.
Uma função virtual é uma função que é declarada como virtual em uma classe base e redefinida pela classe derivada.
A redefinição da função na classe derivada sobrepõe a definição da função virtual na classe base!!!
Em outras palavras, a declaração da função virtual na classe base age como uma espécie de indicador que especifica uma linha geral de ação e estabelece uma interface de acesso.
A redefinição da função virtual pela classe derivada especifica as operações realmente executadas pelo método.
O problema acima então ficaria:
class Componente {
public:
virtual void exibe() const { cout << "Componente::exibe()" << endl; }
};
Para maior clareza, a palavra chave virtual pode ser repetida também na declaração do método exibe() nas classes derivadas. Isto, porém, não é obrigatório neste caso.
class Botao: public Componente {
public: virtual void exibe() const { cout << "Botao::exibe()" << endl; }
};
/*********/
class Janela: public Componente {
public: virtual void exibe() const { cout << "Janela::exibe()" << endl;}
};
Agora, a saída será:
Ao encontrar uma chamada a um método virtual, o compilador terá que aguardar até o momento da execução para decidir qual o método correto a ser chamado.
Exemplo 2
Temos que definir a superclasse FiguraGeometrica, a partir da qual serão derivadas as classes Circulo, Quadrado e Triangulo.
O método Desenha(), porém, certamente será bastante diferente para cada uma das subclasses.
Como proceder.....???
Definir o método como virtual na superclasse e redefinir o método em cada uma das subclasses!
Exemplo 3
Deseja-se criar um vetor de ponteiros para acessar objetos....
#include <iostream>
class base // Classe base
{ public: void print( ) { cout << "\nBASE";}
};
class deriv0: public base //Classe derivada de base
{ public: void print( ) { cout << "\nDERIV0";}
};
class deriv1: public base //Classe derivada de base
{ public: void print( ) { cout << "\nDERIV1";}
};
class deriv2: public base //Classe derivada de base
{ public: void print( ) { cout << "\nDERIV2";}
};
/*************/
int main()
{ base * ptr[3]; // cria vetor de ponteiros para classe base
deriv0 dv0; // cria objeto da subclasse deriv0
deriv1 dv1; // cria objeto da subclasse deriv1
deriv2 dv2; // cria objeto da subclasse deriv2
// preenche vetor de ponteiros:
ptr[0] = &dv0;
ptr[1] = &dv1;
ptr[2] = &dv2;
for(int i = 0; i < 3; i++)
ptr[i]->print( ); // chama método
return 0;
}
A saída será:
Para resolver o problema:....
#include <iostream>
class base // Classe base
{public: virtual void print( ) { cout << "\nBASE";} //MÉTODO VIRTUAL
}; //RESTANTE DO CÓDIGO INALTERADO:
class deriv0: public base //Classe derivada de base
{ public: void print( ) { cout << "\nDERIV0";}
};
class deriv1: public base //Classe derivada de base
{ public: void print( ) { cout << "\nDERIV1";}
};
class deriv2: public base //Classe derivada de base
{ public: void print( ) { cout << "\nDERIV2";}
};
/*************/
int main()
{ base * ptr[3]; // cria vetor de ponteiros para classe base
deriv0 dv0; // cria objeto da subclasse deriv0
deriv1 dv1; // cria objeto da subclasse deriv1
deriv2 dv2; // cria objeto da subclasse deriv2
// preenche vetor de ponteiros:
ptr[0] = &dv0;
ptr[1] = &dv1;
ptr[2] = &dv2;
for(int i = 0; i < 3; i++)
ptr[i]->print( ); // chama método
return 0;
}
O restante do código permanece exatamente igual e a saída agora fica:
Quando trabalhamos com ponteiros para objetos de classes derivadas, é importante que os destrutores também sejam declarados virtuais.
Se um objeto da classe derivada está sendo apontado por ponteiro da classe base, e os destrutores são virtuais, então, quando esse objeto é liberado, primeiro será executado o destrutor da classe derivada e só depois o da classe base.
class Componente {
public: virtual ~Componente()
{ cout << "Destrói componente" << endl; }
};
/*************/
class Botao: public Componente {
public:
~Botao() { cout << "Destrói botao" << endl; }
};
/*************/
void main(void) {
Botao *ok = new Botao;
Componente *c = ok;
delete c;
}
Ao ser executado o comando delete, no programa acima, serão exibidas as mensagens "Destrói botão" e "Destrói componente".
Porém, se o destrutor não tivesse sido declarado virtual, apenas o destrutor da classe Component, aquela a que pertence o ponteiro, seria chamado.
Nem construtores nem métodos estáticos podem ser declarados virtuais.
Além disso, a acessibilidade de um método virtual é conservada dentro de todas as classes derivadas, mesmo que ele seja redefinido com um status diferente.
Classes abstratas
Às vezes, um método virtual definido em uma classe base, serve como uma interface genérica, que deverá ser implementada nas classes derivadas.
Se não há implementação desse método na classe base, isto é, quando a função virtual não possui código próprio é chamada de função virtual pura, ou método virtual puro, ou seja, foi criado apenas para ser redefinido nas classes derivadas - INTERFACE POLIMÓRFICA PARA SUBCLASSES.
Para indicar que um método é virtual puro, adicionamos o sufixo = 0 ao seu protótipo.
virtual tipo nome_função (lista-args) = 0;
Exemplo 4
class base // Classe base
{ public: virtual void print( ) = 0; // função virtual pura
};
...
A classe que possui uma ou mais funções virtuais puras não pode gerar objetos diretamente e é chamada de classe ABSTRATA - só pode ser utilizada como superclasse!
Uma classe é abstrata se contém pelo menos um método virtual puro.
Não é possível criar uma instância de uma classe abstrata.
Exemplo 5
class Componente {
public:
virtual void exibe() const = 0; // método virtual puro
};
void main()
{
Componente c; // erro, não se pode instanciar uma classe abstrata!
...
}
- Uma classe abstrata não pode ser usada como tipo de argumento, nem como tipo de retorno de uma função.
- Um método virtual puro não precisa ter uma implementação.
- Além disso, uma classe abstrata somente pode ser usada a partir de um ponteiro ou de uma referência.
- Uma classe derivada que não redefine um método virtual é também considerada abstrata.
- Quando uma classe é abstrata, qualquer classe derivada deve fornecer sua própria definição. Caso contrário, um erro de compilação será acusado.
Exercícios
Crie a super-classe FormaGeometrica que contém métodos virtuais de cálculo de área e perímetro. Depois, crie as sub-classes Circulo, Retangulo e Quadrado, como heranças de FormaGeometrica e escreva implementações para os métodos de cálculo de cada sub-classe.
Solução Exercício Polimorfismo
| Funções Amigas << | AULA 14 - Funções Virtuais e Polimorfismo | Streams >> |
|---|