Prof.: José Eustáquio Rangel de Queiroz rangel@dsc.ufcg.br rangeldequeiroz@gmail

1. Técnicas de Programação Classes e Abstração de Dados Prof.:José Eustáquio Rangel de Queiroz rangel@dsc.ufcg.edu.br rangeldequeiroz@gmail.com Carga Horária:60 horas

2. Classes e Abstração de Dados Tópicos 6.1 Introdução 6.2 Definições de Estruturas 6.3 Acesso a Membros de Estruturas 6.4 Implementação de Tipos Definidos pelo Usuário com uma struct 6.5 Implementação de Tipos Abstratos de Dados com uma class 6.6 Escopo de Classes e Acessoa Membros deClasses 6.7 Separação da Interface da Implementação 6.8 Controle de Acesso a Membros 6.9 Funções de Acesso e Funções Utilitárias

3. Classes e Abstração de Dados Tópicos 6.10 Inicialização de Objetos de uma Classe: Construtores 6.11 Uso de Argumentos Default com Construtores 6.12 Destrutores 6.13 Chamada de Construtores e Destrutores 6.14 Uso de Funções de Alteração (set functions) e de Retorno (get functions) de Dados 6.15 Retorno de uma Referência para Membros de Dados private 6.16 Atribuição Default de Membro 6.17 Reusabilidade de Software

4. 6.1 Introdução • Programação Orientada a Objetos (POO) • Encapsulação de dados (atributos) e funções (comportamento) em “pacotes” denominados classes • Ocultação da Informação • Comunicação entre Objetos de Classes através de interfaces bem definidas • Implementação de detalhes ocultos nas próprias classes

5. 6.1 Introdução • Tipos definidos pelo programador: Classes • Dados (membros de dados) • Funções (funções-membros ou métodos) • Similares a fotocópias  Reusáveis • Instâncias de Classe  Objetos

6. 6.2 Definições de Estruturas • Estrutura • Agregação de variáveis do mesmo tipo ou de tipos diferentes em uma única entidade • Conceito comum no quotidiano • Exemplos • Cadastro de clientes de uma loja • Arquivo de receitas culinárias • Listagem de uma pasta (diretório) em um sistema computacional • Estruturas em C/C++  Definição a partir do uso da palavra-chave struct

7. 6.2 Definições de Estruturas • Estruturas em C/C++ • Sintaxe struct tipo{ tipo1 var1; tipo1 var2; tipo2 var3; . . . tipo3 varn; }; Rótulo ou Etiqueta da Estrutura Membros da Estrutura (mesmo tipo ou tipos variados)

8. 6.2 Definições de Estruturas • Estruturas • Exemplos struct Automovel{ char fabricante[20]; char modelo[15]; char chassi[20]; int ano; long int km; float preco; }; struct Horario{ int hora; int minuto; int segundo; };

9. 6.2 Definições de Estruturas • Denominação de membros de estruturas • Na mesma struct Nomes únicos • Em structs diferentes  Possibilidade de compartilhamento do nome • Encerramento da definição de uma struct  Obrigatoriedade do uso de ponto-e-vírgula (;)

10. 6.2 Definições de Estruturas • Estruturas Auto-referentes • Membros de estruturas não podem ser instâncias da struct que os contém • Membros de estruturas podem ser apontadores para instâncias da struct que os contém  Estruturas Auto-referentes • Uso em listas encadeadas, filas, pilhas e árvores

11. 6.2 Definições de Estruturas • Definição de struct • Criação de novos tipos de dados  Uso na declaração de variáveis • Declaração de variáveis do tipo estrutura do mesmo modo que variáveis de outros tipos • Exemplos • Horario horarioObj; • Horario horarioArray[10]; • Horario *horarioApont; • Horario &horarioRef = horarioObj;

12. 6.3 Acesso a Membros de Estruturas • Operadores de Acesso a Membros • Operador Ponto (.)  Membros de estrutura e classe • Operador Seta (->)  Membros de estrutura e classe via apontador para objeto

13. 6.3 Acesso a Membros de Estruturas • Operadores de Acesso a Membros • Exemplo • Impressão do membro segundo de tempObj • cout << tempObj.segundo; ou • tempApont = &tempObj; cout << tempApont->segundo; • tempApont->segundoequivalente a (*tempApont). segundo • Uso dos parênteses  Prioridade de * inferior a .

14. 6.4 Implementação de Tipos Definidos pelo Usuário com uma struct • Passagem Default de Estruturas  Por valor • Passagem de estruturas por referência • Evita overhead de cópia da estrutura • Estruturas no estilo da linguagem C • Ausência de “interfaceamento” • Se a implementação for alterada, todos os programas que usam a struct deverão ser convenientemente alterados

15. 6.4 Implementação de Tipos Definidos pelo Usuário com uma struct • Estruturas no estilo da linguagem C • Impossibilidade de impressão como um todo (manutenção da unidade) • Impressão/ formatação membro a membro • Impossibilidade de comparação na íntegra • Comparação membro a membro

16. 6.4 Implementação de Tipos Definidos pelo Usuário - structHorario(1/4) 01 //Criação de uma estrutura, declaração de seus membros e impressão 02da estrutura. 03#include <iostream> 04 05using std::cout; 06using std::endl; 07 08#include <iomanip> 09 10using std::setfill; 11using std::setw; 12// definição da estrutura 13 14struct Horario { 15int hora; // 0-23 (formato de 24 horas) 16int minuto; // 0-59 17int segundo; // 0-59 18 19 }; // fim da estrutura Horario 20 21void imprUniv( const Horario & ); // protótipo 22 void imprPadrao( const Horario & ); // protótipo 23 Definição do tipo de estrutura Horario com três membros inteiros Passagem de referências para objetos constantes tipo Horario, a fim de eliminar overhead de cópia

17. Uso do operador . na inicialização dos membros da estrutura Possibilidade de atribuição de valores inválidos às variáveis, devido ao acesso direto aos dados 6.4 Implementação de Tipos Definidos pelo Usuário -structHorario(2/4) 24int main() 25 { 26 Horario Jantar; // variável do tipo Horario 27 28 Jantar.hora = 18; //inicialização do membro hora de Jantar 29 Jantar.minuto = 30; //inicialização do membro minuto de Jantar 30 Jantar.segundo = 0; //inicialização do membro segundo de Jantar 31 cout << “ O jantar será servido às”; 32 imprUniv( Jantar ); 33 cout << “ (horário universal),\n que corresponde a ”; 34 imprPadrao( Jantar ); 35 cout << “ no horário padrão.\n ”; 36 Jantar.hora = 29; //inicialização do membro hora com valor inválido 37 Jantar.minuto = 73; //inicialização do membro minuto com valor 38 //inválido 39 Jantar.segundo = 90; //inicialização do membro segundo com 40 //valor inválido 41 cout << “ \n Horário com valores inválidos ”; 42 imprUniv(Jantar); 43 cout << endl; 44return0; 45 } // final de main 46

18. Uso de setfill, um manipulador parametrizado de streams Uso do operador . para o acesso a membros de dados 6.4 Implementação de Tipos Definidos pelo Usuário -structHorario(3/4) 49// Impressão do horário no formato universal (hh:mm:ss) 50void imprUniv( const Horario &t ) 51 { 52 cout << setfill( '0' ) << setw( 2 ) << t.hora << ":" 53 << setw( 2 ) << t.minuto << ":" 54 << setw( 2 ) << t.segundo; 55 56 } // fim da função imprUniv 57 58// Impressão do horário no formato padrão (hh:mm:ss AM/PM) 59voidimprPadrao( const Horario &t ) 60 { 61 cout << ( (t.hora == 0 || t.hora == 12 ) ? 6212 : t.hora % 12 ) << ":" << setfill( '0' ) 63 << setw( 2 ) << t.minuto << ":" 64 << setw( 2 ) << t.segundo 65 << ( t.hora < 12 ? " AM" : " PM" ); 66 67 } // fim da função imprPadrao

19. 6.4 Implementação de Tipos Definidos pelo Usuário -structHorario(4/4) • Resultado da execução do programa O jantar será servido às 18:30:00 (horário universal), que corresponde a 6:30:00 PM no horário padrão. Horário com valores inválidos: 29:73:90

20. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Classes e Objetos • Objetos do Modelo • Atributos (membros de dados) • Comportamentos (membros de funções) • Definição a partir do uso da palavra-chave class • Membro de funções • Métodos • Invocação em resposta a mensagens

21. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Objeto • Abstração de algo no domínio do problema modelado a partir de OO • Reflexo da capacidade do sistema de retenção de informações sobre o elemento abstraído, de interação com tal elemento ou ambos • Continência de dados (atributos) e procedimentos (serviços) exclusivos

22. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Classe • Descrição de um conjunto de objetos semelhantes, i.e. detentores do mesmo conjunto de características • Continência das características dos atributos e métodos que representarão as particularidades dos vários objetos que a compõem

23. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Classe em C++ • C++ trouxe valiosas melhorias de sintaxe à linguagem C • Maior motivação no estudo de C++ POO • Melhor modo implementação do paradigma da OO  Através do tipo de dado class • Evolução linear do C ao C++ De arrays, estruturas e uniões (C) até classes (C++) • Principal evolução apresentada pelo tipo class Possibilidade de encapsulação de dados e funções, com acesso controlado

24. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • struct x class structCliente{ charnomeCliente[31]; charfimereco[51]; floatvalorCompra; }; classCliente{ charnomeCliente[31]; char fimereco[51]; float valorCompra; void zerarValor(); void verValor(); }; Cliente vcliente; vcliente.valorCompra = 1957.86; strcpy(vcliente.nomeCliente, “Joseana”); . . . Cliente vcliente; vcliente.valorCompra = 189.32; strcpy(vcliente.nomeCliente, “Eustaquio”); . . .

25. Atributos que conterão as informações de status dos objetos. Manutenção do conceito de protótipo de função. 6.5 Implementação de Tipos Abstratos de Dados com umaclass Declaração de um novo tipo para o compilador. • Sintaxe de class classNomeClasse { tipo_de_acesso : tipo_1 nomeAtributo1; . . . tipo_n nomeAtributon; protótipo_função1; . . . protótipo_funçãon; } ; Definição da acessibilidade aos membros da classe: private, public ou protected.

26. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Especificadores de Acesso a Membros • public: • Acesso a membros em qualquer lugar dentro do escopo dos objetos (default de struct) • private: • Acesso apenas por funções-membros da classe (default de class) • protected: • Acesso por funções-membros da classe e por funções-membros de classes derivadas desta classe.

27. Atributos Funções Privadas Funções Públicas 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Especificadores de Acesso a Membros

28. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Construtores • Função-membro especial • Inicialização dos membros de dados • Mesmo nome da classe class NomeClasse { . . . public : NomeClasse (tipo(s) parâmetro(s)); }; • Chamada no ato da instanciação do objeto (quando ocorre a alocação de memória)

29. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Construtores • Possibilidade da existência de vários construtores • Possibilidade de sobrecarga de funções • Inexistência de tipo de retorno • Construtores com parâmetros  Reconhecimento no ato da declaração de instâncias • Regra da passagem de parâmetros semelhante a funções NomeClasse ObjetoClasse(parâmetro(s));

30. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Construtores • Tarefas passíveis de vinculação • Alocação dinâmica • Abertura de arquivo • Regra geral • Não é aconselhável vincular ao construtor funções que não estejam associadas ao processo de inicialização

31. Construtor 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Construtores - Exemplo classPonto { floatx, y; public: Ponto(floata,floatb) {x = a; y= b;} }; Ponto(void); voidmain{ Ponto meuPonto(2.9, 8); } Ponto outroPonto; Ponto :: Ponto(void) { cout << “Digite os valores de x e y”; cin >> x >> y; }

32. 6.5 Implementação de Tipos Abstratos de Dados com umaclass 01 // Circulo.h - Definição da classe Circulo 02 03 #include <iostream.h> 04class circulo 05 { 06int coordx; 07int coordy; 08int raio; char * cor; 16 }; // fim da classe Horario

33. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Objetos de classes • Após a definição da classe • Especificador do novo tipo  Nome da Classe • C++  Linguagem extensível • Declarações de objeto, array, apontador e referência

34. Nome da classe (Horario) torna-se novo tipo de especificador. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Objetos de classes - Exemplo Horario noite; // objeto do tipo Horario Horario arraydeHorarios[ 5 ]; // array de objetos do tipo Horario Horario *apontHorario; // apontador para objeto do tipo Horario Horario &Jantar = noite; // referência a um objeto do tipo Horario

35. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Funções-membros definidas fora da classe • Operador Binário de Resolução de Escopo (::) • “Amarração” do nome do membro ao nome da classe • Identificação exclusiva de funções de uma classe específica • Possibilidade de atribuição do mesmo nome a funções-membros de classes distintas

36. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Funções-membros definidas fora da classe • Formato para definição de funções-membros Tipo_de_Retorno Nome_da_Classe::Nome_da_FuncaoMembro( ){ … } • Formato inalterado, independentemente de tratar-se de uma função pública (public) ou privada (private)

37. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Funções-membros definidas fora da classe • Isenção do operador de resolução de escopo (::) e do nome da classe • Busca de funções em linha (inline)pelo compilador • Funções inline do C++ Similares às macros do C • Codificação para funções inline copiada no ato das chamadas às funções no programa

38. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Funções-membros definidas fora da classe • Busca de funções inlinepelo compilador • Fora da classe  Uso explícito de funções em linha (inline) a partir do uso da palavra-chave inline • Uso da palavra-chave inline  Economia de em casos nos quais funções pequenas são chamadas muitas vezes dentro de um programa • No caso de funções-membros de classe  Isenção do uso da palavra-chave inline

39. 6.5 Implementação de Tipos Abstratos de Dados -class Horario(1/5) 01// Horario.cpp - Definição da classe Horario. 02#include <iostream> 03 04using std::cout; 05using std::endl; 06 07#include <iomanip> 08 09using std::setfill; 10using std::setw; 11 12// definição de tipos abstratos de dados (TAD) Horario 13class Horario { 14 15public: 16Horario(); // construtor 17void alteraHorario( int, int, int ); //alteração do horario 18void imprUniv(); // impressão no formato universal 19void imprPadrao(); // impressão no formato padrão 20 Definição da classe Horario

40. Inicialização dos membros de dados privados (private) com 0 pelo construtor, assegurando um estado inicial consistente para todos os objetos do tipo Horario 6.5 Implementação de Tipos Abstratos de Dados -class Horario(2/5) 21private: 22int hora; // 0 - 23 (formato de 24 horas) 23int minuto; // 0 - 59 24int segundo; // 0 - 59 25 26 }; // fim da classe Horario 27 28 Horario::Horario() 29 { 30 hora = minuto = segundo = 0; 31 } // fim do construtor Horario 32 33 // apresentação do novo valor de Horariono formato universal, 34// validação e verificação dos valores dos dados e ajuste dos valores 35 // inválidos para zero 36void Horario::alteraHorario( int h, int m, int s ) 37 { 38 hora = ( h >= 0 && h < 24 ) ? h : 0; 39 minuto = ( m >= 0&& m < 60 ) ? m : 0; 40 segundo = ( s >= 0 && s < 60 ) ? s : 0; 41 42 } // fim da função alteraHorario

41. Inexistência de argumentos (“conhecimento” implícito de que o propósito é a impressão de membros de dados); chamadas mais concisas às funções-membros Declaração da variável t como objeto da classe Horario 6.5 Implementação de Tipos Abstratos de Dados -class Horario(3/5) 43// impressão do horário no formato universal 44void Horario::imprUniv() 45 { 46 cout << setfill( '0' ) << setw( 2 ) << hora << ":" 47 << setw( 2 ) << minuto << ":" 48 << setw( 2 ) << segundo; 49 50 } // fim da função imprUniv 51 52// impressão do horário no formato padrão 53void Horario::imprPadrao() 54 { 55 cout << ( ( hora == 0 || hora == 12 ) ? 12 : hora % 12 ) 56 << ":" << setfill( '0' ) << setw( 2 ) << minuto 57 << ":" << setw( 2 ) << segundo 58 << ( hora < 12 ? " AM" : " PM" ); 59 } // fim da funçãoimprPadrao 60 61int main() 62 { 63Horario t; // instanciação do objeto t da classe Horario 64

42. Invocação de funções-membros públicas para a impressão do horário Alteração de membros de dados via uso de função-membro pública 6.5 Implementação de Tipos Abstratos de Dados -class Horario(4/5) 65// valores iniciais de saída dos t objetos Horario 66 cout << " O horario universal inicial eh "; 67 t.imprUniv(); // 00:00:00 68 69 cout << "\nO horario padrao inicial eh "; 70 t.imprPadrao(); // 12:00:00 AM 71 72 t.alteraHorario( 13, 27, 6 ); // alteração de Horario 73 74// novos valores de saída dos t objetos Horario 75 cout << "\n\nO horario universal apos alteraHorario eh "; 76 t.imprUniv(); // 13:27:06 77 78 cout << "\nO horario padrao apos alteraHorario eh "; 79 t.imprPadrao(); // 1:27:06 PM 80 81 t.alteraHorario( 99, 99, 99 ); // verificação de valores inválidos 82// a partir do uso de função-membro pública 83// valores de saída t apos a especifição de valores inválidos 84 cout << "\n\nApos verificacao de valores invalidos: " 85 << "\nHorario universal: "; 86 t.imprUniv(); // 00:00:00 87

43. 6.5 Implementação de Tipos Abstratos de Dados -class Horario(5/5) 88 cout << "\nHorario padrao : "; 89 t.imprPadrao(); // 12:00:00 AM 90 cout << endl; 91 92return0; 93 94 } // fim de main O horario universal inicial eh 00:00:00 O horario padrao inicial eh 12:00:00 AM O horario universal apos alteraHorario eh 13:27:06 O horario padrao apos alteraHorario eh 1:27:06 PM Apos verificacao de valores invalidos: Horario universal : 00:00:00 Horario padrao : 12:00:00 AM

44. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Destrutores • Funções complementares aos construtores • Necessidade de criação  Liberação da memória alocada dinamicamente • Chamados quando o escopo de declaração da variável é encerrado  “Limpeza de finalização” • Mesmo nome da classe precedido de um til (~) • Inexistência de argumentos, retorno e sobrecarga

45. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Destrutores • Sintaxe class NomeClasse { . . . public : ~ Nome_tipo_classe (); } • Sintaxe na definição da função destrutora NomeClasse :: ~ NomeClasse () { // código da função destrutora }

46. 6.5 Implementação de Tipos Abstratos de Dados com umaclass class Org { char *razãoSocial; public: Org(); ~Org(); }; Org :: Org() { char aux[80]; cout << “Digite o nome da Organização”; cin.get(aux, 80); razãoSocial = newchar(strlen(aux)+1); strcpy(razãoSocial, aux); } Org :: ~Org() { delete razãoSocial; } • Exemplo Alocação de memória heap Liberação de memória heap Início de um bloco de código Chamada do construtor { Org objOrg; } Final do bloco de código

47. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Construtores e Destrutores • Variáveis dinamicamente alocadas • Liberação de memória de forma explícita  Mecanismo diferente daquele apontado para variáveis auto • Uso de destrutores para tal fim essencial em POO • Ambos extremamente úteis no processo de gestão de objetos dinâmicos em C++

48. 6.5 Implementação de Tipos Abstratos de Dados com umaclass • Vantagens do uso de classes • Simplificação da Programação • Interfaceamento • Ocultação da complexidade da implementação do usuário • Reuso de Software • Composição (agregação) • Objetos de uma classe incluídos como membros de outras classes • Herança • Novas classes derivadas de classes já implementadas

49. 6.6 Escopo de Classe e Acesso a Membros de uma Classe • Escopo de Classes • Dados-membros e funções-membros • No escopo da classe • Membros da Classe • Imediatamente acessíveis por todos as funções-membros • Referência pelo nome • Fora do escopo da classe • Referência via manipulações (handles) • Nome do objeto, referência ao objeto, apontador para o objeto

50. 6.6 Escopo de Classe e Acesso a Membros de uma Classe • Escopo de Arquivos • Funções Não-membros • Escopo de Funções • Variáveis declaradas na função-membro • Reconhecimento apenas para a função • Variáveis com mesmo nome como variáveis de escopo de classe • Variável de escopo de classe “oculta” • Acesso via operador de resolução de escopo (::) Nome_da_classe::Nome_da_variável_da_classe