Polimorfismo. BCC Programação Orientada a Objectos(POO) Departamento de Computação - UFOP Baseado nos slides do Prof. Marco Antônio Carvalho

Transcrição

1 Polimorfismo BCC Programação Orientada a Objectos(POO) Guillermo Cámara-Chávez Departamento de Computação - UFOP Baseado nos slides do Prof. Marco Antônio Carvalho

2 Introdução O Polimorfismo é um recurso que nos permite programar em geral ao invés de programar específicamente ; Vamos supor um programa que simula o movimento de vários animais. 1/104

3 Introdução Três classes representam os animais pesquisados: Peixe; Sapo; Pássaro Todos herdam da classe Animal Contém um método mover e a posição do animal. 2/104

4 Introdução (cont.) Cada classe derivada implementa o método mover(); O programa mantém um vetor de ponteiros para objetos das classes derivadas da classe Animal Para simular o movimento do animal, envia-se a mesma mensagem (mover()) para cada objeto; 3/104

5 Introdução (cont.) Cada objeto responderá de uma maneira diferente; A mensagem é enviada genericamente Cada objeto sabe como modificar sua posição de acordo com seu tipo de movimento. 4/104

6 Introdução (cont.) 5/104

7 Introdução (cont.) Através do polimorfismo pode-se projetar e implementar sistemas que sejam facilmente extensíveis Novas classes podem ser adicionadas com pouca ou mesmo nenhuma modificação às partes gerais do programa As novas classes devem fazer parte da hierarquia de herança. 6/104

8 Introdução (cont.) Por exemplo, se criarmos uma classe Tartaruga somente precisamos implementar: a classe e, a parte da simulação que instância o objeto As partes que processam a classe Animal genericamente não seriam alteradas. 7/104

9 Outro Exemplo Vamos imaginar que temos um programa que controla um jogo que contém as seguintes classes/objetos/elementos Marciano; Plutoniano; RaioLaser; NaveEspacial. Todos estes objetos são derivados de uma classe ObjetoEspacial 8/104

10 Polimorfismo Para gerenciar os elementos presentes na tela, mantemos um vetor com ponteiros para objetos da classe ObjetoEspacial Cada objeto possui um método desenhar(), que o imprime na tela. 9/104

11 Polimorfismo (cont.) Para atualizar a tela do jogo, é necessário redesenhar todos os seus elementos. Enviar a mesma mensagem para cada objeto do vetor Método desenhar(); 10/104

12 Polimorfismo (cont.) Método desenhar(): Cada objeto redefine este método para suas especificidades; A classe ObjetoEspacial determina que as classes derivadas o implementem. Podem ser criadas novas classes para outros elementos do jogo O processo de atualizar a tela continuaria o mesmo. 11/104

13 Outro Exemplo 12/104

14 Outro Exemplo (cont.) Vamos supor um programa que simula diversos animais emitindo sons. Cada personagem emite seu próprio som Cada personagem é um objeto que invoca seu próprio método emitirsom(); A classe derivada sabe como deve ser implementado. Em uma hierarquia de herança, podemos criar uma classe Mamifero, a partir dela derivam Boi, cachorro, gato, bode, etc. 13/104

15 Implementações c l a s s Mamifero { p u b l i c : v o i d emitirsom ( ) { cout << "\nsom de mamifero " ; } ; } ; c l a s s Cachorro : p u b l i c Mamifero { p u b l i c : v o i d emitirsom ( ) { cout << "\n woof woof" ; } ; } ; c l a s s Vaca : p u b l i c Mamifero { p u b l i c : v o i d emitirsom ( ) { cout << "\n moo moo" ; } ; } ; c l a s s Bode : p u b l i c Mamifero { p u b l i c : v o i d emitirsom ( ) { cout << "\n baa baa" ; } ; } ; c l a s s Gato : p u b l i c Mamifero { p u b l i c : v o i d emitirsom ( ) { cout << "\n meow meow" ; } ; } ; 14/104

16 Sem Polimorfismo i n t main ( ) { Cachorro c a c h o r r o ; Vaca vaca ; Bode bode ; Gato gato ; c a c h o r r o. emitirsom ( ) ; vaca. emitirsom ( ) ; bode. emitirsom ( ) ; gato. emitirsom ( ) ; r e t u r n 0 ; } 15/104

17 Sem Polimorfismo (cont.) woof woof moo moo baa baa meow meow 16/104

18 Polimorfismo c l a s s Mamifero { p u b l i c : v i r t u a l v o i d emitirsom ( ) { cout << "\nsom de mamifero " ; } ; } ; c l a s s Cachorro : p u b l i c Mamifero { p u b l i c : v o i d emitirsom ( ) { cout << "\n woof woof" ; } ; } ; c l a s s Vaca : p u b l i c Mamifero { p u b l i c : v o i d emitirsom ( ) { cout << "\n moo moo" ; } ; } ; c l a s s Bode : p u b l i c Mamifero { p u b l i c : v o i d emitirsom ( ) { cout << "\n baa baa" ; } ; } ; c l a s s Gato : p u b l i c Mamifero { p u b l i c : v o i d emitirsom ( ) { cout << "\n meow meow" ; } ; } ; 17/104

19 Polimorfismo (cont.) i n t main ( ) { Mamifero p [ 5 ] = { new Cachorro ( ), new Vaca ( ), new Bode ( ), new Gato ( ) } ; } } f o r ( i n t i = 0 ; i < 5 ; i ++) { p [ i ] >emitirsom ( ) ; } r e t u r n 0 ; 18/104

20 Polimorfismo (cont.) woof woof moo moo baa baa meow meow 19/104

21 Polimorfismo (cont.) Como vimos na aula anterior, é possível realizar a conversão de tipo entre classe base e derivada Um objeto da classe base pode receber um objeto da classe derivada O contrário não vale 20/104

22 Polimorfismo (cont.) Também é possível fazer o mesmo com ponteiros Um ponteiro para a classe base pode apontar para um objeto da classe derivada O contrário não vale. 21/104

23 Polimorfismo (cont.) Note que a classe Derivada redefine o método print(); O método original imprime os atributos a, b e c; O método redefinido acrescenta a impressão dos atributos d, e e f. Derivada d: int e: int f: int +Derivada() +getdef() +setdef() +print() Base a: int b: int c: int +Base() +getabc() +setabc() +print() 22/104

24 Polimorfismo (cont.) c l a s s Base { i n t a, b, c ; p u b l i c : Base ( i n t a=0, i n t b=0, i n t c =0): a ( a ), b ( b ), c ( c ){} v o i d p r i n t ( ) { cout << "\n Base: " << a << ","<< b << "," <<c ; } } ; c l a s s D e r i v a d a : p u b l i c Base { i n t d, e, f ; p u b l i c : D e r i v a d a ( i n t d=0, i n t e =0, i n t f =0): d ( d ), e ( e ), f ( f ){} v o i d p r i n t ( ) { cout << "\n Derivada " << d << ","<< e << "," <<f ; } } ; 23/104

25 Polimorfismo (cont.) #i n c l u d e <i o s t r e a m > #i n c l u d e "base.h" u s i n g namespace s t d ; i n t main ( ) { Base objb ( 1, 2, 3 ), p objb=n u l l p t r ; D e r i v a d a objd ( 4, 5, 6 ), p objd=n u l l p t r ; } p objb = &objb ; p objb >p r i n t ( ) ; p objd = &objd ; P objd >p r i n t ( ) ; p objb = &objd ; p objb >p r i n t ( ) ; 24/104

26 Polimorfismo (cont.) #i n c l u d e <i o s t r e a m > #i n c l u d e "base.h" u s i n g namespace s t d ; i n t main ( ) { Base objb ( 1, 2, 3 ), p objb=n u l l p t r ; D e r i v a d a objd ( 4, 5, 6 ), p objd=n u l l p t r ; } p objb = &objb ; // aponta para objeto da classe Base p objb >p r i n t ( ) ; // invoca método da classe Base p objd = &objd ; // aponta para objeto da classe Derivada P objd >p r i n t ( ) ; // invoca método da classe Derivada p objb = &objd ; // aponta para objeto da classe Derivada p objb >p r i n t ( ) ; // invoca método da classe Base r e t u r n 0 ; 25/104

27 Polimorfismo (cont.) Base D e r i v a d a Base 26/104

28 Polimorfismo (cont.) Este tipo de construção é permitido pelo compilador por conta do relacionamento de herança Um objeto da classe derivada é um objeto da classe base. 27/104

29 Polimorfismo (cont.) A funcionalidade invocada depende do handle (tipo do ponteiro ou referência) utilizado para invocá-la Não depende do tipo do objeto apontado pelo handle. Utilizando um tipo especial de método podemos fazer com que este comportamento seja invertido O que é crucial para o polimorfismo. 28/104

30 Polimorfismo (cont.) #i n c l u d e <i o s t r e a m > #i n c l u d e "base.h" u s i n g namespace s t d ; i n t main ( ) { Base objb ( 1, 2, 3 ), p objb=n u l l p t r ; D e r i v a d a objd ( 4, 5, 6 ), p objd=n u l l p t r ; p objb = &objb ; // aponta para objeto da classe Base p objb >p r i n t ( ) ; // invoca método da classe Base } // ERRO! não é possível apontar para objeto da classe Base p objd = &objb ; // Erro! Um objeto da classe base não // é um objeto da classe derivada p objd >p r i n t ( ) ; r e t u r n 0 ; 29/104

31 Funções Virtuais O tipo do handle determina a versão de um método que será invocada Não o tipo do objeto apontado Base p objb=n u l l p t r ; D e r i v a d a objd ( 4, 5, 6 ) ; p objb = &objd ; // aponta para objeto da classe Derivada p objb >p r i n t ( ) ; // invoca método da classe Base 30/104

32 Funções Virtuais (cont.) Com funções virtuais, ocorre o contrário O tipo do objeto apontado determina qual será a versão do método a ser invocado 31/104

33 Funções Virtuais (cont.) Voltando ao exemplo do jogo espacial, cada classe derivada da classe ObjetoEspacial define um objeto de formato geométrico diferente Cada classe define seu próprio método desenhar() Podemos através de um ponteiro para classe base invocar o método desenhar(); Porém, seria útil se o programa determinasse dinamicamente (tempo de execução) qual método deve ser utilizado para desenhar cada forma, baseado no tipo do objeto. 32/104

34 Funções Virtuais (cont.) Para permitir este tipo de comportamento dinâmico, declaramos na classe base o método desenhar() como uma função virtual O redefinimos nas classes derivadas; O método sobrescrito possui o mesmo protótipo do original (assinatura e tipo de retorno). 33/104

35 Funções Virtuais (cont.) Para declararmos um método como virtual, adicionamos a palavra chave virtual antes de seu protótipo v i r t u a l v o i d d e s e n h a r ( ) Se uma classe não sobrescrever um método virtual, ela herda a implementação original; 34/104

36 Funções Virtuais (cont.) Definindo o método como virtual na classe base, ele permanecerá assim por toda a hierarquia de herança Mesmo que as classes derivadas a sobrescrevam e não a declarem como virtual novamente; É uma boa prática declarar o método como virtual por toda a hierarquia de classes. 35/104

37 Resolução Estática e Dinâmica As instruções de chamada a métodos não virtuais são resolvidas em tempo de compilação E traduzidas em chamadas a funções de endereço fixo; Isso faz com que a instrução seja vinculada à função antes de sua execução; 36/104

38 Resolução Estática e Dinâmica (cont.) Resolução Estática Acontece quando invocamos um método através de um objeto, usando o operador. Não se trata de comportamento polimórfico 37/104

39 Resolução Dinâmica Quando uma instrução de chamada a um método virtual é encontrada pelo compilador, ele não tem como identificar qual é o método associado em tempo de compilação. Quando utilizamos ponteiros (ou referências) para objetos, o compilador não conhece qual é a classe do endereço contido no ponteiro antes de o programa ser executado; A instrução é avaliada em tempo de execução; Isto é chamado de Resolução Dinâmica, ou Resolução Tardia (Comportamento polimórfico). 38/104

40 Exemplo Poligono base altura +setvalores() +calculaarea() Retangulo Triangulo +calculaarea() +calculaarea() 39/104

41 Exemplo (cont.) c l a s s P o l i g o n o { p r o t e c t e d : d o u b l e base, a l t u r a ; p u b l i c : } v o i d s e t V a l o r e s ( d o u b l e a, d o u b l e b ){ base=a ; a l t u r a=b ; } v i r t u a l d o u b l e a r e a ( v o i d ) { r e t u r n 0 ; } 40/104

42 Exemplo (cont.) c l a s s Retangulo : p u b l i c P o l i g o n o { p u b l i c : d o u b l e a r e a ( v o i d ){ r e t u r n ( base a l t u r a ) ; } } ; c l a s s T r i a n g u l o : p u b l i c P o l i g o n o { p u b l i c : d o u b l e a r e a ( v o i d ){ r e t u r n ( base a l t u r a / 2 ) ; } } ; 41/104

43 Exemplo (cont.) i n t main ( ) { Retangulo r e c t ; T r i a n g u l o t r g l ; P o l i g o n o p o l y ; } P o l i g o n o p p o l y 1 = &r e c t ; P o l i g o n o p p o l y 2 = &t r g l ; P o l i g o n o p p o l y 3 = &p o l y ; ppoly1 >s e t V a l o r e s ( 4, 5 ) ; ppoly2 >s e t V a l o r e s ( 4, 5 ) ; ppoly3 >s e t V a l o r e s ( 4, 5 ) ; cout << ppoly1 >a r e a ( ) << e n d l ; cout << ppoly2 >a r e a ( ) << e n d l ; cout << ppoly3 >a r e a ( ) << e n d l ; r e t u r n 0 ; 42/104

44 Exemplo (cont.) As três classes (Poligono, Retangulo e Triangulo) possuem os mesmos membros: base, altura, setvalores() e area(). area() foi definida como virtual porque é redefinida depois nas classes derivadas. 43/104

45 Outro Exemplo Considere uma classe Veículo com duas classes derivadas Automóvel e Bicicleta Essas classes têm três métodos, definidos para veículos de forma geral e redefinidas mais especificamente para automóveis e bicicletas; 44/104

46 Outro Exemplo (cont.) As funções são: VerificaLista(): para verificar o que precisa ser analisado no veículo; Reparar(): para realizar os reparos e a manutenção necessária Limpa(): para realizar procedimentos de limpeza do veículo A aplicação Oficina define um objeto que recebe objetos da classe Veículos. Para cada veículo recebido, a oficina executa na sequencia os três métodos da classe Veículo. 45/104

47 Outro Exemplo (cont.) c l a s s V e i c u l o { p u b l i c : v i r t u a l v o i d v e r i f i c a L i s t a ( ) { cout<<"\n Verifica Veiculo " ; } ; v i r t u a l v o i d r e p a r a r ( ) { cout<<"\n Repara Veiculo " ; } ; v i r t u a l v o i d l i m p a ( ) { cout<<"\n Limpa Veiculo " ; } ; } ; 46/104

48 Outro Exemplo (cont.) c l a s s Automovel : p u b l i c V e i c u l o { p u b l i c : v o i d v e r i f i c a L i s t a ( ) { cout<<"\n Verifica Automovel " ; } ; v o i d r e p a r a r ( ) { cout<<"\n Repara Automovel " ; } ; v o i d l i m p a ( ) { cout<<"\n Limpa Automovel " ; } ; } ; c l a s s B i c i c l e t a : p u b l i c V e i c u l o { p u b l i c : v o i d v e r i f i c a L i s t a ( ) { cout<<"\n Verifica Bicicleta " ; } ; v o i d r e p a r a r ( ) { cout<<"\n Repara Bicicleta " ; } ; v o i d l i m p a ( ) { cout<<"\n Limpa Bicicleta " ; } ; } ; 47/104

49 Outro Exemplo (cont.) Não há como saber no momento de programação se a Oficina estará recebendo um automóvel ou uma bicicleta O momento de decisão sobre qual método será aplicado só ocorrerá durante a execução do programa. 48/104

50 Outro Exemplo (cont.) c l a s s O f i c i n a { i n t R ; p u b l i c : V e i c u l o proximo ( ) ; v o i d manter ( V e i c u l o v ) ; i n t getr ( ) ; } ; 49/104

51 Outro Exemplo (cont.) V e i c u l o O f i c i n a : : proximo ( ) { V e i c u l o v ; R = rand ( ) ; i f (R % 2 == 0) v = new Automovel ( ) ; e l s e v = new B i c i c l e t a ( ) ; r e t u r n v ; } v o i d O f i c i n a : : manter ( V e i c u l o v ){ v >V e r i f i c a L i s t a ( ) ; v >Reparar ( ) ; v >Limpa ( ) ; } i n t O f i c i n a : : getr ( ) { r e t u r n R ; } 50/104

52 Outro Exemplo (cont.) i n t main ( ) { O f i c i n a Of ; V e i c u l o pv ; i n t n = 0 ; w h i l e ( n < 6) { pv = Of. proximo ( ) ; cout<<endl <<Of. getr()<< e n d l ; Of. manter ( pv ) ; n++; d e l e t e pv ; } r e t u r n 0 ; } 51/104

53 Outro Exemplo (cont.) Na tela é mostrado 41 V e r i f i c a B i c i c l e t a Repara B i c i c l e t a Limpa B i c i c l e t a V e r i f i c a B i c i c l e t a Repara B i c i c l e t a Limpa B i c i c l e t a 6334 V e r i f i c a Automovel Repara Automovel Limpa Automovel V e r i f i c a Automovel Repara Automovel Limpa Automovel V e r i f i c a B i c i c l e t a Repara B i c i c l e t a Limpa B i c i c l e t a V e r i f i c a Automovel Repara Automovel Limpa Automovel 52/104

54 Outro Exemplo (cont.) O método Of.proximo() realiza uma atribuição de um objeto Automóvel à variável R quando o valor do número aleatório gerado é par. um objeto Bicicleta à variável R quando o valor do número aleatório gerado é ímpar. 53/104

55 Sumário das Atribuções permitidas entre Ponteiros de Classe Base e Derivada Apesar de um objeto de uma classe derivada ser um objeto da classe base, temos dois tipos de objetos completamente diferentes. um objeto de uma classe derivada pode ser tratado como um objeto da classe base Ele contém todos os membros da classe base. 54/104

56 Sumário das Atribuções permitidas entre Ponteiros de Classe Base e Derivada (cont.) O contrário não é válido (objeto da classe Base ser tratado como da classe Derivada) Os membros da classe derivada são indefinidos para objetos da classe base; É possível realizar um downcasting; No entanto, não é seguro 55/104

57 Sumário das Atribuções Permitidas Considere o seguinte caso: c l a s s Base { p u b l i c : Base ( ) {} v o i d p r i n t ( ) { cout << "\n Base" ; } } ; c l a s s D e r i v a d a : p u b l i c Base { p u b l i c : D e r i v a d a ( ) { } v o i d p r i n t ( ) { cout << "\n Derivada " ; } v o i d p r i n t 2 {}{ cout << "\n Interno " ; " } }; i n t main ( ) { Base objb, p objb=n u l l p t r ; D e r i v a d a objd, p objd=n u l l p t r ;... r e t u r n 0 ; } 56/104

58 Sumário das Atribuções Permitidas (cont.) Apontar um ponteiro base para um objeto base é simples p objb = &objb ; Apontar um ponteiro derivado para um objeto derivado é simples p objd = &objd ; 57/104

59 Sumário das Atribuções Permitidas (cont.) Apontar um ponteiro base para um objeto derivado é seguro p objb = &objd ; O ponteiro deve ser utilizado apenas para realizar chamadas da classe base; Base p objb >p r i n t 2 ( ) ; // ERRO não é membro da classe Chamadas da classe derivada gerarão erros, a não ser que seja utilizado downcasting, o que não é seguro 58/104

60 Sumário das Atribuções Permitidas (cont.) Apontar um ponteiro derivado para um objeto base gera um erro de compilação p objd = &objb ; // ERRO de compilação A relação é um se dá de cima para baixo na hierarquia 59/104

61 Classes Abstratas e Métodos Virtuais Puros Quando pensamos em classes, podemos pensar que os programas as instanciarão, criando objetos daquele tipo Porém, existem casos em que é útil definir classes que não serão instanciadas nunca. 60/104

62 Classes Abstratas e Métodos Virtuais Puros (cont.) Tais classes são denominadas classes abstratas Como são normalmente utilizadas como base em hierarquias de herança, também são conhecidas como classes base abstratas. São classes incompletas, que devem ser completadas por classes derivadas; Por isso não podem ser instanciadas. 61/104

63 Classes Abstratas Classes que podem ser instanciadas são chamadas de classes concretas Providenciam implementação para todos os métodos que definem. O propósito de uma classe base abstrata é exatamente prover um base apropriada para que outras classes herdem 62/104

64 Classes Abstratas (cont.) Classes base abstratas são genéricas demais para definirem com precisão objetos reais e serem instanciadas As classes concretas cuidam das especificidades necessárias para que objetos sejam bem modelados e instanciados 63/104

65 Classes Abstratas (cont.) Em uma hierarquia de herança, não é obrigatória a existência de uma base abstrata Porém, bons projetos de engenharia de software possuem hierarquias de herança cujo topo é formado por classes abstratas; 64/104

66 Classes Abstratas (cont.) Em alguns casos, classes abstratas constituem completamente os primeiros níveis de uma hierarquia de herança. Uma classe é determinada abstrata automaticamente quando um ou mais de seus métodos virtuais são declarados como puros. 65/104

67 Métodos Virtuais Puros Para declararmos um método como virtual puro, utilizamos a seguinte sintaxe: v i r t u a l v o i d p r i n t ( ) = 0 ; O =0 é conhecido como especificador puro Não se trata de atribuição; Métodos virtuais não possuem implementação; Toda classe derivada concreta deve sobrescrevê-lo com uma implementação concreta 66/104

68 Métodos Virtuais Puros (cont.) A diferença entre um método virtual e um método virtual puro é que o primeiro opcionalmente possui implementação na classe base O segundo requer obrigatoriamente uma implementação nas classes derivadas. 67/104

69 Métodos Virtuais Puros (cont.) Um método virtual puro nunca será executada na classe base Deve ser sobrescrita nas classes derivadas; Serve para fornecer uma interface polimórfica para classes derivadas. 68/104

70 Métodos Virtuais Puros (cont.) Novamente, uma classe que possui um método virtual puro não pode ser instanciada Invocar um método virtual puro geraria erro. Pode-se declarar ponteiros para uma classe base abstrata e apontá-los para objetos de classes derivadas. 69/104

71 Exemplo de Polimorfismo A utilização de polimorfismo é particularmente eficiente na implementação de sistemas de software em camadas Como um sistema operacional; Cada tipo de dispositivo físico opera de uma forma diferente No entanto, operações como escrita e leitura são básicas. 70/104

72 Exemplo de Polimorfismo (cont.) Uma classe base abstrata pode ser utilizada para gerar uma interface para todos os dispositivos Todo o comportamento necessário pode ser implementado como métodos virtuais puros; Cada dispositivo sobrescreve os métodos em suas próprias classes, derividas da classe base abstrata. Para cada novo dispositivo, instala-se o driver, que contém implementações concretas para a classe base abstrata. 71/104

73 Outro Exemplo de Polimorfismo Outro aplicação útil do polimorfismo é na criação de classes de iteradores Iteradores são utilizados para percorrer estruturas de dados ou (coleções) Vetores, listas, árvores, etc; Percorrem os objetos de uma agregação sem expôr sua implementação interna A STL fornece uma grande variedade de iteradores para estruturas de dados 72/104

74 Exemplo: Funcionarios Pagamento de funcionários: 4 tipos de funcionários 1. Salário fixo semanal; 2. Horistas (hora extra depois de 40 horas); 3. Comissionados; 4. Assalariados Comissionados A idéia é realizar o cálculo dos pagamentos utilizando comportamento polimórfico. Na aula sobre herança, tínhamos apenas os dois últimos tipos de funcionários, em uma hierarquia de herança. 73/104

75 Exemplo: Funcionarios (cont.) 74/104

76 Exemplo: Funcionarios (cont.) Neste exemplo, não há uma classe que absorva o comportamento das outras Será necessário criar uma outra classe que sirva de base para os outras Representará um funcionário genérico Nome, sobrenome e documento são os atributos; Getters e setters para cada um dos atributos. Um print para todos os atributos. Será uma classe base abstrata. 75/104

77 Exemplo: Funcionarios (cont.) Teremos quatro classes derivadas, cada uma representando um tipo de funcionário A diferença se dá basicamente pela forma em que o pagamento é calculado (método earnings()). 76/104

78 Exemplo: Funcionarios (cont.) 77/104

79 Exemplo: Funcionarios (cont.) Dada a hierarquia estabelecida e a necessidade de polimorfismo: Os getters e setters da classe base serão métodos concretos; O método print será um método virtual Terá implementação, mas opcionalmente poderá ser sobrescrito pelas classes derivadas. O método earnings será um método virtual puro Não terá implementação e obrigatoriamente será sobrescrito pelas classes derivadas. As classes derivadas definem seus próprios atributos e respectivos getters e setters. 78/104

80 Exemplo: Funcionarios (cont.) 79/104

81 Exemplo: Funcionarios (cont.) 80/104

82 Employee.h #i f n d e f EMPLOYEE H #d e f i n e EMPLOYEE H #i n c l u d e <s t r i n g > // classe string padrão C++ u s i n g s t d : : s t r i n g ; c l a s s Employee { s t r i n g f i r s t N a m e ; s t r i n g lastname ; s t r i n g s o c i a l S e c u r i t y N u m b e r ; p u b l i c : Employee ( c o n s t s t r i n g="", c o n s t s t r i n g&="", c o n s t s t r i n g&="" ) ; v o i d s e t F i r s t N a m e ( c o n s t s t r i n g& ) ; s t r i n g getfirstname ( ) c o n s t ; v o i d setlastname ( c o n s t s t r i n g& ) ; s t r i n g getlastname ( ) c o n s t ;... 81/104

83 Employee.h (cont.)... v o i d s e t S o c i a l S e c u r i t y N u m b e r ( c o n s t s t r i n g& ) ; s t r i n g g e t S o c i a l S e c u r i t y N u m b e r ( ) c o n s t ; // a função virtual pura cria a classe básica abstrata Employee v i r t u a l d o u b l e e a r n i n g s ( ) c o n s t = 0 ; // virtual pura v i r t u a l v o i d p r i n t ( ) c o n s t ; // virtual } ; // fim da classe Employee #e n d i f 82/104

84 Employee.cpp #i n c l u d e <i o s t r e a m > u s i n g s t d : : cout ; #i n c l u d e " Employee.h" // Definição da classe Employee // construtor Employee : : Employee ( c o n s t s t r i n g &f i r s t, c o n s t s t r i n g &l a s t, c o n s t s t r i n g &s s n ) : f i r s t N a m e ( f i r s t ), lastname ( l a s t ), s o c i a l S e c u r i t y N u m b e r ( s s n ) {} } // fim do construtor Employee 83/104

85 Employee.cpp // imprime informações de Employee (virtual, mas não virtual pura) v o i d Employee : : p r i n t ( ) c o n s t { cout << getfirstname ( ) << << getlastname ( ) << "\ nsocial security number : " << g e t S o c i a l S e c u r i t y N u m b e r ( ) ; } // fim da função print 84/104

86 HourlyEmployee.h #i f n d e f HOURLY H #d e f i n e HOURLY H #i n c l u d e " Employee.h" // Definição da classe Employee c l a s s HourlyEmployee : p u b l i c Employee { d o u b l e wage ; // salário por hora d o u b l e h o u r s ; // horas trabalhadas durante a semana p u b l i c : HourlyEmployee ( c o n s t s t r i n g &="", c o n s t s t r i n g &="", c o n s t s t r i n g &="", d o u b l e = 0. 0, d o u b l e = 0. 0 ) ; v o i d setwage ( d o u b l e ) ; d o u b l e getwage ( ) c o n s t ; v o i d s e t H o u r s ( d o u b l e ) ; d o u b l e gethours ( ) c o n s t ; // palavra-chave virtual assinala intenção de sobrescrever v i r t u a l d o u b l e e a r n i n g s ( ) c o n s t ; // calcula os rendimentos v i r t u a l v o i d p r i n t ( ) c o n s t ; // imprime HourlyEmployee } ; #e n d i f 85/104

87 HourlyEmployee.cpp u s i n g s t d : : cout ; #i n c l u d e " HourlyEmployee.h" // Definição da classe HourlyEmployee // construtor HourlyEmployee : : HourlyEmployee ( c o n s t s t r i n g &f i r s t, c o n s t s t r i n g &l a s t, c o n s t s t r i n g &ssn, d o u b l e hourlywage, d o u b l e hoursworked ) : Employee ( f i r s t, l a s t, s s n ) { setwage ( hourlywage ) ; // valida a remuneração por hora s e t H o u r s ( hoursworked ) ; // valida as horas trabalhadas } // fim do construtor HourlyEmployee 86/104

88 HourlyEmployee.cpp (cont.) // calcula os rendimentos; // sobrescreve a função virtual pura earnings em Employee d o u b l e HourlyEmployee : : e a r n i n g s ( ) c o n s t { i f ( gethours ( ) <= 40 ) // nenhuma hora extra r e t u r n getwage ( ) gethours ( ) ; e l s e r e t u r n 40 getwage ( ) + ( ( gethours ( ) 40 ) getwage ( ) 1. 5 ) ; } // fim da função earnings 87/104

89 HourlyEmployee.cpp (cont.) // imprime informações do HourlyEmployee v o i d HourlyEmployee : : p r i n t ( ) c o n s t { cout << "hourly employee : " ; Employee : : p r i n t ( ) ; // reutilização de código cout << "\ nhourly wage: " << getwage ( ) << "; hours worked: " << gethours ( ) ; } // fim da função print 88/104

90 SalariedEmployee.h #i f n d e f SALARIED H #d e f i n e SALARIED H #i n c l u d e " Employee.h" // Definição da classe Employee c l a s s S a l a r i e d E m p l o y e e : p u b l i c Employee { d o u b l e w e e k l y S a l a r y ; // salário por semana p u b l i c : S a l a r i e d E m p l o y e e ( c o n s t s t r i n g &="", c o n s t s t r i n g &="", c o n s t s t r i n g &="", d o u b l e = 0. 0 ) ; v o i d s e t W e e k l y S a l a r y ( d o u b l e ) ; d o u b l e g e t W e e k l y S a l a r y ( ) c o n s t ; // palavra-chave virtual assinala intenção de sobrescrever v i r t u a l d o u b l e e a r n i n g s ( ) c o n s t ; // calcula os rendimentos v i r t u a l v o i d p r i n t ( ) c o n s t ; // imprime SalariedEmployee } ; // fim da classe SalariedEmployee #e n d i f 89/104

91 SalariedEmployee.h #i n c l u d e <i o s t r e a m > u s i n g s t d : : cout ; #i n c l u d e " SalariedEmployee.h" // construtor S a l a r i e d E m p l o y e e : : S a l a r i e d E m p l o y e e ( c o n s t s t r i n g &f i r s t, c o n s t s t r i n g &l a s t, c o n s t s t r i n g &ssn, d o u b l e s a l a r y ) : Employee ( f i r s t, l a s t, s s n ) { s e t W e e k l y S a l a r y ( s a l a r y ) ; } // fim do construtor SalariedEmployee 90/104

92 SalariedEmployee.h (cont.) // calcula os rendimentos; // sobrescreve a função virtual pura earnings em Employee d o u b l e S a l a r i e d E m p l o y e e : : e a r n i n g s ( ) c o n s t { r e t u r n g e t W e e k l y S a l a r y ( ) ; } // fim da função earnings // imprime informações de SalariedEmployee v o i d S a l a r i e d E m p l o y e e : : p r i n t ( ) c o n s t { cout << " salaried employee : " ; Employee : : p r i n t ( ) ; cout << "\ nweekly salary : " << g e t W e e k l y S a l a r y ( ) ; } // fim da função print 91/104

93 ComissionEmployee.h #i f n d e f COMMISSION H #d e f i n e COMMISSION H #i n c l u d e " Employee.h" // Definição da classe Employee c l a s s CommissionEmployee : p u b l i c Employee { d o u b l e g r o s s S a l e s ; // vendas brutas semanais d o u b l e commissionrate ; // porcentagem da comissão p u b l i c : CommissionEmployee ( c o n s t s t r i n g &="", c o n s t s t r i n g &="", c o n s t s t r i n g &="", d o u b l e = 0. 0, d o u b l e = 0. 0 ) ; v o i d setcommissionrate ( d o u b l e ) ; d o u b l e getcommissionrate ( ) c o n s t ; v o i d s e t G r o s s S a l e s ( d o u b l e ) ; d o u b l e g e t G r o s s S a l e s ( ) c o n s t ; // palavra-chave virtual assinala intenção de sobrescrever v i r t u a l d o u b l e e a r n i n g s ( ) c o n s t ; // calcula os rendimentos v i r t u a l v o i d p r i n t ( ) c o n s t ; // imprime o objeto CommissionEmployee } ; // fim da classe CommissionEmployee #e n d i f 92/104

94 ComissionEmployee.cpp #i n c l u d e <i o s t r e a m > u s i n g s t d : : cout ; #i n c l u d e " CommissionEmployee.h" // construtor CommissionEmployee : : CommissionEmployee ( c o n s t s t r i n g &f i r s t, c o n s t s t r i n g &l a s t, c o n s t s t r i n g &ssn, d o u b l e s a l e s, d o u b l e r a t e ) : Employee ( f i r s t, l a s t, s s n ) { s e t G r o s s S a l e s ( s a l e s ) ; setcommissionrate ( r a t e ) ; } // fim do construtor CommissionEmployee 93/104

95 ComissionEmployee.cpp (cont.) // calcula os rendimentos; // sobrescreve a função virtual pura earnings em Employee d o u b l e CommissionEmployee : : e a r n i n g s ( ) c o n s t { r e t u r n getcommissionrate ( ) g e t G r o s s S a l e s ( ) ; } // fim da função earnings // imprime informações do CommissionEmployee v o i d CommissionEmployee : : p r i n t ( ) c o n s t { cout << " commission employee : " ; Employee : : p r i n t ( ) ; // reutilização de código cout << "\ngross sales: " << g e t G r o s s S a l e s ( ) << "; commission rate: " << getcommissionrate ( ) ; } // fim da função print 94/104

96 BasePlusComissionEmployee.h #i f n d e f BASEPLUS H #d e f i n e BASEPLUS H #i n c l u d e " CommissionEmployee.h" c l a s s BasePlusCommissionEmployee : p u b l i c CommissionEmployee { d o u b l e b a s e S a l a r y ; // salário-base por semana p u b l i c : BasePlusCommissionEmployee ( c o n s t s t r i n g &="", c o n s t s t r i n g &="", c o n s t s t r i n g &="", d o u b l e = 0. 0, d o u b l e = 0. 0, d o u b l e = 0. 0 ) ; v o i d s e t B a s e S a l a r y ( d o u b l e ) ; // configura o salário-base d o u b l e g e t B a s e S a l a r y ( ) c o n s t ; // retorna o salário-base // palavra-chave virtual assinala intenção de sobrescrever v i r t u a l d o u b l e e a r n i n g s ( ) c o n s t ; // calcula os rendimentos v i r t u a l v o i d p r i n t ( ) c o n s t ; // imprime o objeto BasePlusCommissionEmployee } ; // fim da classe BasePlusCommissionEmployee #e n d i f 95/104

97 BasePlusComissionEmployee.cpp #i n c l u d e <i o s t r e a m > u s i n g s t d : : cout ; // Definição da classe BasePlusCommissionEmployee #i n c l u d e " BasePlusCommissionEmployee.h" // construtor BasePlusCommissionEmployee : : BasePlusCommissionEmployee ( c o n s t s t r i n g &f i r s t, c o n s t s t r i n g &l a s t, c o n s t s t r i n g &ssn, d o u b l e s a l e s, d o u b l e r a t e, d o u b l e s a l a r y ) : CommissionEmployee ( f i r s t, l a s t, ssn, s a l e s, r a t e ) { s e t B a s e S a l a r y ( s a l a r y ) ; // valida e armazena o salário-base } // fim do construtor BasePlusCommissionEmployee 96/104

98 BasePlusComissionEmployee.cpp (cont.) // calcula os rendimentos; // sobrescreve a função virtual pura earnings em Employee d o u b l e BasePlusCommissionEmployee : : e a r n i n g s ( ) c o n s t { r e t u r n g e t B a s e S a l a r y ( ) + CommissionEmployee : : e a r n i n g s ( ) ; } // fim da função earnings // imprime informações de BasePlusCommissionEmployee v o i d BasePlusCommissionEmployee : : p r i n t ( ) c o n s t { cout << "base - salaried " ; CommissionEmployee : : p r i n t ( ) ; // reutilização de código cout << "; base salary: " << g e t B a s e S a l a r y ( ) ; } // fim da função print 97/104

99 Main.cpp #i n c l u d e <i o s t r e a m > #i n c l u d e <iomanip> u s i n g namespace s t d ; #i n c l u d e <v e c t o r > // inclui definições de classes na hierarquia Employee #i n c l u d e " Employee.h" #i n c l u d e " SalariedEmployee.h" #i n c l u d e " HourlyEmployee.h" #i n c l u d e " CommissionEmployee.h" #i n c l u d e " BasePlusCommissionEmployee.h" v o i d v i r t u a l V i a P o i n t e r ( c o n s t Employee c o n s t ) ; // protótipo v o i d v i r t u a l V i a R e f e r e n c e ( c o n s t Employee &); // protótipo 98/104

100 Main.cpp (cont.) i n t main ( ) { // configura a formatação de saída de ponto flutuante cout << f i x e d << s e t p r e c i s i o n ( 2 ) ; // cria objetos da classe derivada S a l a r i e d E m p l o y e e s a l a r i e d E m p l o y e e ( "John", "Smith", " ", 800 ) ; HourlyEmployee h o u r l y E m p l o y e e ( "Karen", "Price", " ", , 40 ) ; CommissionEmployee commissionemployee ( "Sue", "Jones", " ", 10000,. 0 6 ) ; BasePlusCommissionEmployee basepluscommissionemployee ( "Bob", "Lewis", " ", 5000,. 0 4, 300 ) ;... 99/104

101 Main.cpp (cont.) c o u t << " Employees processed individually using static binding :\ n\n" ; // saída de info. e rendimentos dos Employees com vinculação estática s a l a r i e d E m p l o y e e. p r i n t ( ) ; cout << "\ nearned $" << s a l a r i e d E m p l o y e e. e a r n i n g s ( ) ; h o u r l y E m p l o y e e. p r i n t ( ) ; cout << "\ nearned $" << h ourlyemployee. e a r n i n g s ( ) ; commissionemployee. p r i n t ( ) ; cout << "\ nearned $" << commissionemployee. e a r n i n g s ( ) ; basepluscommissionemployee. p r i n t ( ) ; cout << "\ nearned $" << basepluscommissionemployee. earnings (); 100/104

102 Main.cpp (cont.) // cria um vector a partir dos quatro ponteiros da classe básica v e c t o r < Employee > employees ( 4 ) ; // inicializa o vector com Employees employees [ 0 ] = &s a l a r i e d E m p l o y e e ; employees [ 1 ] = &h o u r l y E m p l o y e e ; employees [ 2 ] = &commissionemployee ; employees [ 3 ] = &basepluscommissionemployee ; c o u t << " Employees processed polymorphically via dynamic binding :\ n\n" ; 101/104

103 Main.cpp (cont.) // chama virtualviapointer para imprimir informações e rendimentos // de cada Employee utilizando vinculação dinâmica c o u t << " Virtual function calls made off base -class pointers :\n\n" ; f o r ( s i z e t i = 0 ; i < employees. s i z e ( ) ; i++ ) v i r t u a l V i a P o i n t e r ( employees [ i ] ) ; // chama virtualviareference para imprimir informações // de cada Employee utilizando vinculação dinâmica c o u t << " Virtual function calls made off base - class references :\ n\n" ; f o r ( s i z e t i = 0 ; i < employees. s i z e ( ) ; i++ ) // observe o desreferenciamento v i r t u a l V i a R e f e r e n c e ( employees [ i ] ) ; r e t u r n 0 ; } // fim de main 102/104

104 Main.cpp (cont.) // chama funções print e earnings virtual de Employee a partir de um // ponteiro de classe básica utilizando vinculação dinâmica v o i d v i r t u a l V i a P o i n t e r ( c o n s t Employee c o n s t b a s e C l a s s P t r ) { b a s e C l a s s P t r >p r i n t ( ) ; cout << "\ nearned $" << b a s e C l a s s P t r >e a r n i n g s ( ) ; } // fim da função virtualviapointer // chama funções print e earnings virtual de Employee a partir de um // referência de classe básica utilizando vinculação dinâmica v o i d v i r t u a l V i a R e f e r e n c e ( c o n s t Employee &b a s e C l a s s R e f ) { b a s e C l a s s R e f. p r i n t ( ) ; cout << "\ nearned $" << b a s e C l a s s R e f. e a r n i n g s ( ) ; } // fim da função virtualviareference 103/104

105 FIM 104/104