AULA 14 - Programação II - Graduação
FUNÇÕES VIRTUAIS E POLIMORFISMO: Em muitas situações, projeta-se uma classe base que vai gerar muitas classes derivadas, diferentes entre si... Como desenvolver os métodos na super-classe, de forma bastante genérica, para que cada classe possa particularizá-los na medida do que for necessário? FUNÇÕES VIRTUAIS
Exemplo: temos que definir a superclasse FormaGeometrica, a partir da qual serão derivadas as classes Circulo, Retangulo, Triangulo e Elipse. O método Desenha() certamente será bastante diferente, em cada uma das subclasses.....??? Definir o método como virtual na superclasse e redefinir o método em cada uma das subclasses!
Outro Exemplo: Deseja-se criar um vetor de ponteiros para acessar objetos....
- include <iostream.h>
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”;} };
void 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 }
Para resolver o problema:....
- include <iostream.h>
class base // Classe base {public: virtual void print( ) { cout << “\nBASE”;} //MÉTODO VIRTUAL }; ... O restante do código permanece exatamente igual e a saída agora fica:
Quando a função virtual não possui código próprio é chamada de função virtual pura, ou seja, foi criada apenas para ser redefinida nas classes derivadas - INTERFACE POLIMÓRFICA PARA SUBCLASSES.
Exemplo:
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!
Funções virtuais
Uma função virtual é uma função que é declarada como virtual em uma classe base e redefinida pela classe derivada. Para declarar uma função como sendo virtual, é preciso preceder sua declaração com a palavra chave virtual. A redefinição da função na classe derivada sobrepõe a definição da função na classe base. No fundo, 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.
Quando acessadas normalmente, funções virtuais se comportam como qualquer outro tipo de função membro da classe. Entretanto, o que torna funções virtuais importantes e capazes de suportar polimorfismo em tempode execução é o seu modo de comportamento quando acessado através de um apontador. Lembre-se que um apontador para a classe base pode ser usado para apontar para qualquer classe derivada daquela classe base. Quando um apontador base aponta para um objeto derivado que contém uma função virtual, C ++ determina qual versão daquela função chamar baseada no tipo do objeto apontado pelo apontador. Assim, quando objetos diferentes são apontados, versões diferentes da função virtual são executadas.
Considere o seguinte exemplo:
indentation
- include $<$iostream.h$>$
class base { public: virtual void vfunc() { cout $\ll$ "Esta e vfunc() de base$\backslash$n"; } };
class derived1 : public base { public: void vfunc() { cout $\ll$ "Esta e vfunc() de derived1$\backslash$n"; } };
class derived2 : public base { public: void vfunc() { cout $\ll$ "Esta e vfunc() de derived2$\backslash$n"; } };
main() { base $\ast$p, b; derived1 d1; derived2 d2;
// p aponta para base p = &b; p$\rightarrow$vfunc(); // p aponta para derived1 p = &d1; p$\rightarrow$vfunc(); // p aponta para derived2 p = &d2; p$\rightarrow$vfunc();
return(0); } O resultado da execução deste programa é:
Esta e vfunc() de base Esta e vfunc() de derived1 Esta e vfunc() de derived2
Observe que:
a declaração de vfunc() deve ser precedida pela palavra chave virtual; a palavra chave virtual não é necessária na declaração das funções vfunc() das classes derivadas; a definição de qual versão da função vfunc() é invocada só é obtida em tempo de execução: ela não é baseada no tipo declarado de p, mas sim para quem p aponta; polimorfismo em tempo de execução só é atingido através do uso de apontadores para classe base. Se vfunc() for chamada da maneira ``usual, isto é, usando o operador ponto, como em d2.vfunc(), então a função, mesmo sendo declarada como virtual, tem o mesmo comportamento de outras funções membro. A redefinição de uma função virtual por uma classe derivada é similar a sobrecarga de funções. Entretanto, este termo não é aplicado para a redefinição de funções virtuais porque há diversas diferenças. Talvez a mais importante é que o protótipo para uma função virtual deve combinar exatamente o protótipo especificado para a classe base. Caso o protótipo seja diferente, o comportamento será exatamente o mesmo de uma função sobrecarregada -- o comportamento virtual da função será perdido. Outra restrição importante é que funções virtuais devem ser membros da classe das quais elas fazem parte -- não podem simplesmente ser funções amigas. Por estes motivos, a redefinição de funções virtuais por classes derivadas é usualmente chamada de sobreposição, e não de sobrecarga.
Deve-se observar que a ``virtualidade é hereditária. Isto é, quando uma função virtual é herdada, sua natureza virtual também é herdada -- mesmo quando a palavra chave virtual não é explicitamente declarada no método da classe derivada. Assim, o caráter virtual da função é mantido, não importa qual o número de níveis na hierarquia de classes.
O uso da palavra chave virtual indica que a função pode ser sobreposta, mas não obriga a sobreposição. Caso a classe derivada não sobreponha uma função virtual, então o método correspondente da classe base será utilizado.
6.8. Herança virtual
Considere a derivação da classe D ilustrada a seguir:
Se a classe A possui um dado membro a, um objeto da classe D herdará duas cópias desse dado, uma vez da classe B e outra da classe C. Para acessar esses dados duplicados, será preciso empregar o operador de resolução de escopo.
Exemplo 6.15: void main(void) { D d; d.a = 0; // erro: ambíguo d.B::a = 1; // Ok, acessa cópia herdada de B d.C::a = 2; // Ok, acessa cópia herdade de C } A B D C Herança 41
Através da herança virtual, entretanto, é possível especificar que haja apenas uma ocorrência dos dados herdados da classe base. Para que a classe D herde apenas uma cópia dos dados da classe A, é preciso que as classes B e C herdem virtualmente de A. Exemplo 6.16: class B : virtual public A { ... }; class C : virtual public A { ... }; class D : public B, public C { ... }; void main() { D d; d.a = 0; // Ok, não há mais ambigüidade } É preciso não confundir esse status "virtual" da declaração de herança de classes com aquele dos membros virtuais que veremos mais adiante. Aqui, a palavra chave virtual apenas indica ao compilador que os dados herdados não deverão ser duplicados. 6.9. Polimorfismo e funções virtuais 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. Graças ao polimorfismo, podemos usar uma mesma instrução para chamar, dinamicamente, métodos completamente distintos numa hierarquia de classes. Em C++, o polimorfismo é obtido através de funções virtuais. Se uma classe base tem uma função virtual f() e sua classe derivada D também tem uma função f(), do mesmo tipo, então uma chamada a f() a partir de um objeto da classe derivada estará invocando D::f(); mesmo que o acesso seja feito através de um ponteiro ou de uma referência. A função da classe derivada sobrescreve a função da classe base; mas, se os tipos das funções forem diferentes, as funções são consideradas distintas e o mecanismo virtual não é empregado. Exemplo 6.17: 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(); } Herança 42 void main() { Botao ok; Janela ajuda; manipula(ok); manipula(ajuda); } Executando o programa acima, veremos que a instrução c.exibe(), na função de manipulação, chamará o método exibe() da classe Componente. 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. 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. Exemplo 6.18: 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. Exemplo 6.19: 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; } }; 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. 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. Exemplo 6.20: class Componente { public: virtual ~Componente() { cout << "Destrói componente" << endl; } }; class Botao: public Componente { public: ~Botao() { cout << "Destrói botao" << endl; } }; Herança 43 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 Componente, 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 . 6.10. 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, dizemos que tal método é virtual puro. Para indicar que um método é virtual puro, adicionamos o sufixo = 0 ao seu protótipo. Exemplo 6.21: 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 se contém pelo menos um método virtual puro. Não é possível criar uma instância de uma classe abstrata. Além disso, 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.
| Funções Amigas << | AULA 14 - Funções Virtuais e Polimorfismo | Streams >> |
|---|