PCS3111. Laboratório de Programação Orientada a Objetos para Engenharia Elétrica. Aula 6: Polimorfismo

Transcrição

1 PCS3111 Laboratório de Programação Orientada a Objetos para Engenharia Elétrica Aula 6: Polimorfismo Escola Politécnica da Universidade de São Paulo

2 Conceito de polimorfismo 2

3 Polimorfismo A palavra vem do grego: πολύς, polys, muito μορφή, morphē, forma 3

4 Morfeu é o deus grego do sono e dos sonhos, que podia assumir qualquer forma. Imagem: Trustees of the British Museum, cedida mediante licença CC BY-NC-SA 4.0 4

5 Não é este Morfeu ;) 5

6 Definição Polimorfismo é a propriedade de um único nome ser usado com diversos significados. Na programação, isso significa que, dependendo do contexto, o comportamento pode ser feito diferente. Nome de quê? Comportamento de quem? R: de variáveis, de classes, mas principalmente de funções! Ao lado de encapsulamento, abstração e herança, polimorfismo é característica essencial da orientação a objetos! 6

7 Formas de polimorfismo Há quatro formas de polimorfismo nas linguagens de programação OO: Sobrecarga ou overloading: um mesmo nome é usado com diferentes comportamentos e diferentes argumentos; Redefinição ou overriding: uma classe derivada estabelece um comportamento diferente para um método herdado de sua classe base; Variáveis polimórficas: uma variável que pode assumir valores de diferentes tipos durante a execução. Templates: uma forma de criar modelos para classes parametrizando os tipos. (observação: essa última não será vista nesta aula!) 7

8 Sobrecarga (overloading) 8

9 O que é sobrecarga? Um termo sobrecarregado pode ser usado em diferentes contextos, com significados diferentes. O mesmo ocorre com a linguagem natural: A manga da camisa A fruta manga O contexto permite identificar o significado atribuído ao termo. 9

10 Com certeza você já percebeu que alguns operadores têm diferentes implementações! A sobrecarga é a forma já conhecida de polimorfismo! Seja o operador + Em C++, o mesmo operador pode ser usado em diferentes contextos: (adição de inteiros) (adição em ponto flutuante) cata + vento" (concatenação de strings!) Dá para imaginar que a implementação da função + é diferente para cada caso! 10

11 Sobrecarga A sobrecarga pode ser de operadores e também de funções. C++ permite que o programador faça mais de uma definição para um mesmo nome dentro do mesmo escopo desde que as declarações tenham: assinaturas diferentes e implementações diferentes (really?) 11

12 Como o compilador decide? Quando o compilador encontra uma função ou operador sobrecarregados, decide a implementação mais adequada com base na comparação das assinaturas dos métodos. Este processo é chamado de resolução da sobrecarga. 12

13 Assinatura Dentro do mesmo escopo, a assinatura dos métodos precisa ser diferente. A assinatura é uma combinação do número e tipo dos argumentos e do tipo do retorno. Não pode haver sobrecarga apenas variando o tipo de retorno. 13

14 Exemplo: Soma int soma (int a){ return a; int soma (int a, int b){ return a+b; int soma (int a, int b, int c) { return a+b+c; int main() { // testando a sobrecarga por assinatura cout << "6 = " << soma(6) << endl; cout << "6 + 6 = " << soma (6,6) << endl; cout << " = " << soma (6,6,6) << endl; return 0; 14

15 Construtores sobrecarregados É comum haver mais de um construtor para uma classe, variando-se o número de parâmetros. No exemplo seguinte, considere uma classe Relogio, cujos objetos podem ser construídos de 4 diferentes formas. 15

16 Exemplo: Relogio class Relogio { Há 4 diferentes construtores! public: Relogio(); Relogio (int hora); Relogio (int hora, int minuto); Relogio (int hora, int minuto, int segundo); void imprimir (); virtual ~Relogio(); protected: int hora; int minuto; int segundo; ; 16

17 Relogio::Relogio() { hora = minuto = segundo = 0; Relogio::Relogio(int hora) { this->hora = hora; this->minuto = this->segundo = 0; Relogio::Relogio(int hora, int minuto) { this->hora = hora; this->minuto = minuto; this->segundo = 0; Relogio::Relogio (int hora, int minuto, int segundo){ this->hora = hora; this->minuto = minuto; this->segundo = segundo; void Relogio::imprimir(){ cout << hora << ":" << minuto << ":" << segundo << endl; Relogio::~Relogio(){ 17

18 int main() { Relogio *r1, *r2, *r3, *r4; r1 = new Relogio (); r2 = new Relogio (1); r3 = new Relogio (1,30); r4 = new Relogio (1, 30, 45); r1->imprimir(); r2->imprimir(); r3->imprimir(); r4->imprimir(); 18

19 Redefinição (overriding) 19

20 Redefinição (overriding) A redefinição acontece quando uma classe derivada modifica um método que herdou da classe base. A função redefinida pela classe derivada tem a mesma declaração da classe base. Isto significa: O mesmo nome O mesmo tipo de retorno A mesma assinatura (lista de parâmetros) 20

21 Qual a diferença de sobrecarga? A redefinição só faz sentido no contexto da herança. A sobrecarga é numa mesma classe; As assinaturas precisam ser as mesmas; Os métodos redefinidos podem ser combinados com os que os redefinem; Em geral, é resolvida em tempo de execução e não em tempo de compilação.

22 Exemplo: Pássaros Seja a classe Passaro Suponha que todos os pássaros cantem, cada um de sua forma. 22

23 Passaro.h Exemplo 1: Pássaro class Passaro { protected: bool emextincao; string corpredominante; public: Passaro(); ~Passaro(); void canta(); bool getemextincao(); string getcorpredominante(); ; Construtor da classe base Método da classe base 23

24 Passaro.cpp #include "Passaro.h" Passaro::Passaro() { this->emextincao = false; this->corpredominante = "cinza"; Passaro::~Passaro() { void Passaro::canta() { cout << "Piu Piu Piu" << endl; bool Passaro::getEmExtincao () { return this->emextincao; string Passaro::getCorPredominante () { return this->corpredominante; 24

25 Arara.h class Arara: public Passaro { public: Arara(); ~Arara(); void canta (); Construtor da classe derivada Método da classe derivada 25

26 Arara.cpp Arara::Arara():Passaro(){ this->emextincao = true; this->corpredominante = "azul"; Arara::~Arara() { void Arara::canta() { cout << "A-RA-RA --- A-RA-RA" << endl; O método da classe derivada redefine o método da classe base: o mesmo nome, a mesma assinatura, mas funções diferentes! 26

27 main.cpp int main() { Passaro *p = new Passaro (); cout << "Passaro " << p->getcorpredominante() << " em extincao? R: " << p->getemextincao() <<endl; p->canta(); Arara *a = new Arara (); cout << "Arara " << a->getcorpredominante() << " em extincao? R: " << a->getemextincao() << endl; a->canta(); delete p; delete a; return 0; 27

28 Cuidado! Se uma arara é um pássaro também, o que deve acontecer neste caso? int main() { Passaro *p [3]; p[0] = new Passaro (); p[1] = new Arara (); p[2] = new Arara (); for (int i = 0; i < 3; i++) { p[i]->canta(); for (int i = 0; i < 3; i++) { delete p[i]; return 0; 28

29 Por quê? Porque o compilador escolhe qual método ele vai acionar a partir do tipo da variável no código fonte, e no comando p[i]->canta() p é do tipo Passaro! Isto é, o compilador decide qual método usar antes de executar o programa (em tempo de compilação) Isto é chamado de ligação estática (static binding)! Observe que a atribuição p[1] = new Arara (); é válida! 29

30 Virtual Para que o compilador adie a decisão de qual método usar até o momento da execução do programa, declaramos o método como virtual. Isso indica ao compilador que espere a execução do programa para então decidir o método a ser usado com base na classe a que pertence o objeto. Este efeito é chamado de ligação dinâmica (dynamic binding) 30

31 #ifndef PASSARO_H #define PASSARO_H #include <iostream> #include <cstring> using namespace std; class Passaro { protected: bool emextincao; string corpredominante; public: Passaro(); virtual ~Passaro(); virtual void canta(); bool getemextincao(); string getcorpredominante (); ; #endif // PA Haver pelo menos um método virtual sinaliza polimorfismo! Existe a possibilidade de que destrutor seja acionado objeto de classe derivada. Se o destrutor não for declarado virtual também, dá erro! Experimente! O método da classe base declarado como virtual indica que o compilador deve protelar a decisão de qual o método a ser usado! 31

32 #include "Arara.h" Arara::Arara():Passaro(){ this->emextincao = true; this->corpredominante = "azul"; Arara::~Arara() { cout << "Arara deletada!" << endl; void Arara::canta() { cout << "A-RA-RA --- A-RA-RA" << endl; Fizemos uma implementação diferente do destrutor para sinalizar esse efeito! 32

33 int main() { Passaro *p [3]; p[0] = new Passaro (); p[1] = new Arara (); p[2] = new Arara (); { { for (int i = 0; i < 3; i++) p[i]->canta(); for (int i = 0; i < 3; i++) delete p[i]; return 0; Observe que delete p[0] é o destrutor padrão de Passaro, portanto, não há saída na console correspondente! 33

34 Substituição x refinamento Quando um método é redefinido, o código no método da classe derivada pode: Substituir completamente o código do método da classe base (substituição) ou Chamar o método da classe base e acrescentar a ele o código específico da classe derivada (refinamento) 34

35 Construtores sempre usam refinamento O construtor da classe base é acionado quando construímos a classe derivada. Desta forma garante-se que toda inicialização da classe base acontece também para os objetos da classe derivada. 35

36 Exemplo de refinamento Arara::Arara():Passaro(){ this->emextincao = true; this->corpredominante = "azul"; Arara::~Arara() { O construtor da classe derivada refina o método da classe base, inicializando de forma diferente os parâmetros. void Arara::canta() { cout << "A-RA-RA --- A-RA-RA" << endl; 36

37 Variáveis polimórficas 37

38 Variáveis também podem ser polimórficas! #include <iostream> #include <cstring> using namespace std; class A { ; class B: public A { ; int main() { A *a = new A(); a = new B(); A variável a é polimórfica, pois recebe objetos de classes diferentes. 38

39 this this é a variável polimórfica mais comum! Ela pode receber diferentes classes! 39

40 Conclusão 40

41 Polimorfismo é importante porque Favorece a componentização e consequentemente, o reuso de software, na medida em que um comportamento básico pode ser estendido para atender às peculiaridades das classes derivadas. Favorece a abstração e o encapsulamento, na medida em que nomes iguais escondem a implementação diferente. 41

42 Bibliografia Budd, T. An Introduction to Object-Oriented Programming. Addison-Wesley, 3 rd ed Conceito de polimorfismo: Capítulo 14 Sobrecarga: Capítulo 15 Redefinição: Capítulo 16 Variáveis polimórficas: Capítulo 17 Lafore, R. Object Oriented Programming in C++. Sams Publishing, 4th. ed Sobrecarga de operadores: Capítulo 8 Herança: Capítulo 9 42