Técnicas de Programação

Técnicas de Programação
Classes e Abstração de Dados Prof.: José Eustáquio Rangel de Queiroz Carga Horária: 60 horas

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 Acesso a Membros de Classes 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

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

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

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.2 Definições de Estruturas
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

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)

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;

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 (;)

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

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;

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

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->segundo equivalente a (*tempApont). segundo Uso dos parênteses  Prioridade de * inferior a .

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

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

6.4 Implementação de Tipos Definidos pelo Usuário - struct Horario (1/4)
01 //Criação de uma estrutura, declaração de seus membros e impressão 02 da estrutura. 03 #include <iostream> 04 05 using std::cout; 06 using std::endl; 07 08 #include <iomanip> 09 10 using std::setfill; 11 using std::setw; 12 // definição da estrutura 13 14 struct Horario { int hora; // 0-23 (formato de 24 horas) int minuto; // 0-59 int segundo; // 0-59 18 19 }; // fim da estrutura Horario 20 21 void 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

24 int main() 25 { Horario Jantar; // variável do tipo Horario 27 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 cout << “ O jantar será servido às ”; imprUniv( Jantar ); cout << “ (horário universal),\n que corresponde a ”; imprPadrao( Jantar ); 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); cout << endl; return 0; 45 } // final de main 46 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

49 // Impressão do horário no formato universal (hh:mm:ss) 50 void imprUniv( const Horario &t ) 51 { cout << setfill( '0' ) << setw( 2 ) << t.hora << ":" << setw( 2 ) << t.minuto << ":" << 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) 59 void imprPadrao( const Horario &t ) 60 { cout << ( (t.hora == 0 || t.hora == 12 ) ? : t.hora % 12 ) << ":" << setfill( '0' ) << setw( 2 ) << t.minuto << ":" << setw( 2 ) << t.segundo << ( t.hora < 12 ? " AM" : " PM" ); 66 67 } // fim da função imprPadrao Uso de setfill, um manipulador parametrizado de streams Uso do operador . para o acesso a membros de dados

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

6.5 Implementação de Tipos Abstratos de Dados com uma class
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

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

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

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

struct x class struct Cliente { char nomeCliente[31]; char fimereco[51]; float valorCompra; }; class Cliente { char nomeCliente[31]; char fimereco[51]; float valorCompra; void zerarValor(); void verValor(); }; Cliente vcliente; vcliente.valorCompra = ; strcpy(vcliente.nomeCliente, “Joseana”); . Cliente vcliente; vcliente.valorCompra = ; strcpy(vcliente.nomeCliente, “Eustaquio”); .

Sintaxe de class Declaração de um novo tipo para o compilador. class NomeClasse { 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. Atributos que conterão as informações de status dos objetos. Manutenção do conceito de protótipo de função.

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.

Especificadores de Acesso a Membros Atributos Funções Privadas Funções Públicas

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)

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));

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

Construtores - Exemplo class Ponto { float x, y; public : Ponto(float a, float b) {x = a; y= b;} }; Ponto(void); void main{ Ponto meuPonto(2.9, 8); } Ponto outroPonto; Ponto :: Ponto(void) { cout << “Digite os valores de x e y”; cin >> x >> y; Construtor

01 // Horario.h - Definição da classe Horario 02 03 class Horario { 04 05 public: 06 Horario(); // construtor 07 void alteraHorario(int, int, int); // ajuste do horário 08 void imprUniv(); // impressão no formato universal 09 void imprPadrao(); // impressão no formato padrão 10 11 private: 12 int hora; // (formato de 24 horas) 13 int minuto; // 14 int segundo; // 15 16 }; // fim da classe Horario Definição de classe a partir do uso da palavra-chave class. Construtor com o mesmo nome da classe (Horario) e sem tipo de retorno. Início do corpo da classe com chave esquerda ({). Especificadores de acesso a membros Protótipos de funções-membros públicas (public). Membros de dados privados (private), acessíveis apenas a funções-membros Finalização da definição da classe com um ponto-e-vírgula (;). Finalização do corpo da classe com chave direita (}).

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

Objetos de classes - Exemplo Nome da classe (Horario) torna-se novo tipo de especificador. 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

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

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)

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

Funções-membros definidas fora da classe Busca de funções inline pelo 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

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

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

43 // impressão do horário no formato universal 44 void Horario::imprUniv() 45 { cout << setfill( '0' ) << setw( 2 ) << hora << ":" << setw( 2 ) << minuto << ":" << setw( 2 ) << segundo; 49 50 } // fim da função imprUniv 51 52 // impressão do horário no formato padrão 53 void Horario::imprPadrao() 54 { cout << ( ( hora == 0 || hora == 12 ) ? 12 : hora % 12 ) << ":" << setfill( '0' ) << setw( 2 ) << minuto << ":" << setw( 2 ) << segundo << ( hora < 12 ? " AM" : " PM" ); 59 } // fim da função imprPadrao 60 61 int main() 62 { Horario t; // instanciação do objeto t da classe Horario 64 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

// valores iniciais de saída dos t objetos Horario cout << " O horario universal inicial eh "; t.imprUniv(); // 00:00:00 68 cout << "\nO horario padrao inicial eh "; t.imprPadrao(); // 12:00:00 AM 71 t.alteraHorario( 13, 27, 6 ); // alteração de Horario 73 // novos valores de saída dos t objetos Horario cout << "\n\nO horario universal apos alteraHorario eh "; t.imprUniv(); // 13:27:06 77 cout << "\nO horario padrao apos alteraHorario eh "; t.imprPadrao(); // 1:27:06 PM 80 t.alteraHorario( 99, 99, 99 ); // verificação de valores inválidos 82 // a partir do uso de função-membro pública // valores de saída t apos a especifição de valores inválidos cout << "\n\nApos verificacao de valores invalidos: " << "\nHorario universal: "; t.imprUniv(); // 00:00:00 87 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

cout << "\nHorario padrao : "; t.imprPadrao(); // 12:00:00 AM cout << endl; 91 return 0; 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

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

Destrutores Sintaxe class NomeClasse { . public : ~ Nome_tipo_classe (); } Sintaxe na definição da função destrutora NomeClasse :: ~ NomeClasse () { // código da função destrutora

Exemplo 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 = new char(strlen(aux)+1); strcpy(razãoSocial, aux); } Org :: ~Org() { delete razãoSocial; 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

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++

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

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

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

Escopo de Funções Reconhecimento das variáveis apenas pela função na qual foram definidas Destruição das variáveis após execução da função Operadores para acesso a membros de uma classe Similaridade àqueles usados em struct

Operadores para acesso a membros de uma classe Operador de seleção de membro Ponto (.) Objeto Referência ao objeto Operador de seleção de membro Seta (->) Apontadores

6.6 Escopo de Classe e Acesso a Membros de uma Classe (1/3)
Exemplo 01 // Cont.cpp - Demonstração dos operadores de acesso a membros de 02 // classes. ATENÇÃO: NOS PRÓXIMOS EXEMPLOS SERÁ EVITADO O 03 // USO DE DADOS PÚBLICOS (public)! 04 #include <iostream> 05 06 using std::cout; 07 using std::endl; 08 09 // definição da classe Cont 10 class Cont { 11 12 public: int x; 14 void impr() { cout << x << endl; } 19 }; // fim da classe Cont Membro de dados públicos (public) x para ilustração de operadores de acesso a membros de classe; tipicamente, membros de dados privados (private)

Exemplo 20 int main() 21 { Cont cont; // criação do objeto contador Cont *contApont = &cont; // criação do apontador para contador Cont &contRef = cont; // criação de referência para contador 25 cout << “Atribuicao de 1 a x e impressão via nome do 27 objeto: "; cont.x = 1; // atribuição de 1 ao membro de dados x cont.impr(); // chamada de função-membro impr cout << "Atribuicao de 2 a x e impressão via referencia 31 do objeto: "; contRef.x = 2; // atribuição de 2 ao membro de dados x contRef.impr(); // chamada de função-membro impr cout << "Atribuicao de 3 a x e impressão via apontador 35 do objeto: "; contApont->x = 3; // atribuição de 3 ao membro de dados x contApont->impr(); // chamada de função-membro impr return 0; 39 } // fim do main

Resultado da Execução do Programa Atribuição de 1 a x e impressão via nome do objeto: 1 Atribuição de 2 a x e impressão via referencia: 2 Atribuição de 2 a x e impressão via apontador: 3

6.7 Interface x Implementação
Separação da interface da implementação Vantagem Maior facilidade de modificação dos programas Desvantagens Necessidade de arquivos de cabeçalho Porções de implementação Funções-membros inline Hints about outra implementação Membros privados Possibilidade de maior ocultação com classe proxy

Arquivos de Cabeçalho Definições de classes e protótipos de funções Extensão do arquivo  .h Incluso em cada arquivo que usa a classe #include “caminho_do_arquivo.h” Exemplo Horario.h #include “C:/usr/rangel/Horario.h”

Arquivos de código-fonte Definições de funções-membros Mesmo nome-base Convenção Compilados e “linkados” Extensão do arquivo  .cpp Exemplo Horario.cpp

6.7 Interface x Implementação - Exemplo de Arquivo-Cabeçalho (1/1)
01 // Exemplo de arquivo de cabeçalho – Horario1.h 02 // Declaração da classe Horario. Funções-membros definidas em 03 // Horario1.cpp. Prevenção de inclusões múltiplas de cabeçalhos. 04 #ifndef Horario1_H 05 #define Horario1_H 06 07 // definição de tipos abstratos de dados (TAD) Horario 08 class Horario { 09 10 public: 11 Horario(); // construtor 12 void alteraHorario( int, int, int ); //alteração do horário 13 void imprUniv(); // impressão do horário no formato universal 14 void imprPadrao(); // impressão do horário no formato padrão 15 16 private: 17 int hora; // (formato de 24 horas) 18 int minuto; // 19 int segundo; // 20 }; // fim da classe Horario 21 #endif “Se não houver sido definido” Diretiva do pré-processador define nome Horario1_H . Código entre estas diretivas não incluído se o nome Horario1_H já tiver sido definido. Código do pré-processador destinado a evitar inclusões múltiplas. Convenção da denominação: nome do arquivo de cabeçalho com underscore (_) substituindo o ponto (.).

6.7 Interface x Implementação – Exemplo de Arquivo de Código-Fonte (1/3)
01 // Exemplo de arquivo de código-fonte – Horario1.cpp 02 // definições das funções-membros para a classe Horario. #include <iostream> 04 05 using std::cout; 06 07 #include <iomanip> 08 09 using std::setfill; using std::setw; 11 // inclusão da definição da classe Horario de Horario1.h 13 #include "Horario1.h" 14 // inicialização de cada membro de dados com zero pelo construtor 16 // Horario, assegurando um estado inicial consistente para todos 17 // os objetos do tipo Horario. 18 Horario::Horario() 19 { 20 hora = minuto = segundo = 0; 21 } // fim do construtor Horario Nome do arquivo de cabeçalho entre aspas (“ ”). O uso de < > para o pré-processador implica a inclusão de arquivos de cabeçalho da Biblioteca Padrão da linguagem C++. Inclusão do arquivo de cabeçalho Horario1.h.

22 // apresentação do novo valor de Horario no formato universal, 23 // validação e verificação dos valores dos dados e ajuste dos valores 24 // inválidos para zero 25 void Horario::alteraHorario( int h, int m, int s ) 26 { hora = ( h >= 0 && h < 24 ) ? h : 0; minuto = ( m >= 0 && m < 60 ) ? m : 0; segundo = ( s >= 0 && s < 60 ) ? s : 0; 30 31 } // fim da função alteraHorario 32 // impressão do horário no formato universal 33 void Horario::imprUniv() 34 { cout << setfill( '0' ) << setw( 2 ) << hora << ":" << setw( 2 ) << minuto << ":" << setw( 2 ) << segundo; 38 39 } // fim da função imprUniv 40

41 // impressão do horário no formato padrão 42 void Horario::imprPadrao() 43 { cout << ( ( hora == 0 || hora == 12 ) ? 12 : hora % 12 ) << ":" << setfill( '0' ) << setw( 2 ) << minuto << ":" << setw( 2 ) << segundo << ( hora < 12 ? " AM" : " PM" ); 48 } // fim da função imprPadrao 49

6.7 Interface x Implementação – Programa de Teste da Classe Horario (1/3)
01 // Exemplo de programa de teste da classe Horario 02 // ATENÇÃO! Este arquivo deverá ser compilado juntamente com 03 // Horario1.cpp 04 #include <iostream> 05 06 using std::cout; 07 using std::endl; 08 09 // inclusão da definição da classe Horario de Horario1.h 10 #include “Horario1.h” 11 12 int main() 13 { 14 Horario t; // instanciação do objeto t da classe Horario 15 16 // impressão dos valores iniciais do objeto t da classe Horario 17 cout << “O horario Universal inicial eh ”; 18 t.imprUniv(); // 00:00:00 19 cout << “\nO horario Padrao inicial eh ”; 20 t.imprPadrao(); // 12:00:00 AM 21 t.alteraHorario( 13, 27, 6 ); // alteração do horário para 13:27:06 22 Inclusão de Horario1.h visando a criação e manipulação correta, assim como a determinação do tamanho do objeto da classe Horario.

23 // impressão dos valores iniciais do objeto t da classe Horario 24 cout << “\n\nO horario Universal apos alteraHorario eh ”; 25 t.imprUniv(); // 13:27:06 26 cout << “\nO horario Padrao apos alteraHorario eh ”; 27 t.imprPadrao(); 1:27:06 PM 28 t.alteraHorario( 99, 99, 99 ); // Verificação de alterações inválidas 29 30 // impressão de t após especificação de valores inválidos 31 cout << “\n\nApos verificacao de valores invalidos” 32 << "\nHorario Universal: "; 33 t.imprUniv(); // 00:00:00 34 cout << “\nHorario Padrao: ”; 35 t.imprPadrao(); // 12:00:00 AM 36 cout << endl; 37 38 return 0; 39 } // fim do main

Resultado da Execução do Programa 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 inicial eh 1:27:06 PM Apos verificacao de valores invalidos: O horario Universal eh 00:00:00 O horario Universal eh 12:00:00 AM

6.8 Controle de Acesso a Membros
Modos de Acesso a Membros private: Modo de Acesso default Acessibilidade a funções-membros e “amigas” (friends) public: Acesso a qualquer função do programa que manipule objetos da classe protected: Acesso por funções-membros da classe e por funções-membros de classes derivadas (Capítulo 9).

6.8 Controle de Acesso a Membros - Exemplo de Erro (1/2)
01 // Erros. cpp - Demonstração de erros resultantes de tentativas de 02 // acesso a membros de uma classe privada (private). 03 #include <iostream> 04 05 using std::cout; 06 07 // include definição of class Horario from Horario1.h 08 #include "Horario1.h" 09 10 int main() 11 { 12 Horario t; // criação de objeto da classe Horario. 13 14 t.hora = 7; // ERRO!!! Horario::hora não está acessível! 15 16 cout << "minuto = " << t.minuto; // ERRO!!! Horario::minuto não 17 // está acessível! 18 19 return 0; 20 } // fim do main. Tentativas de acesso a membros privados (private) (no caso, o membro de dados hora) resulta em erros. 14 t.hora = 7; // ERRO!!! Horario::hora não está acessível! 16 cout << "minuto = " << t.minuto; // ERRO!!! Horario::minuto não 17 // está acessível! Erro resultante da tentativa de acesso ao membro de dados minuto (também private).

6.8 Controle de Acesso a Membros - Exemplo de Erro (2/2)
Resultado da Execução do Programa C:\Tc\bin\examples\erros.cpp(14) : error C2248: ‘hora’ : cannot access private member declared in class ‘Horario’ C:\Tc\bin\examples\erros.cpp(16) : error C2248: ‘minuto’ : cannot access private member declared in class ‘Horario’

Acesso a Membros de Classes (class) Default  private Possibilidade de alteração explícita para private, public ou protected Acesso a Membros de Estruturas (struct) Default  public

Acesso a Dados private de Classes Controle via funções (métodos) de acesso Função get Leitura de dados private Função set Alteração de dados private

6.9 Funções de Acesso e Funções Utilitárias
public Leitura/ Apresentação de dados Funções Predicativas (Predicate functions) Verificação de condições

6.9 Funções de Acesso e Funções Utilitárias
Funções Utilitárias (funções de ajuda) private Suporte à operação de funções-membros public Não desenvolvidas para uso direto de clientes

6.9 Funções de Acesso e Funções Utilitárias – Exemplo (1/1)
01 // VendasPess.h 02 // Definição da classe VendasPess 03 // funções-membros definidas em Vendas.cpp 04 #ifndef VENDASPESS_H 05 #define VENDASPESS_H 06 07 class VendasPess { 08 09 public: 10 VendasPess(); // construtor 11 void recebeVendas(); // entrada de vendas via teclado 12 void validaVendas( int, double ); // verificação de vendas mensais 13 void imprtotVendas(); // síntese e impressão de vendas 14 15 private: 16 double totanVendas(); // função utilitária 17 double vendas[12]; // valores de vendas durante 12 meses 18 }; // fim da classe VendasPess 19 #endif Execução de verificações da validade dos dados digitados pelo usuário pela função de acesso validaVendas. Função utilitária privada destinada à totalização das vendas no intervalo de 1 ano.

20 // VendasPess.cpp 21 // funções-membros da classe VendasPess. 22 #include <iostream> 23 using std::cout; 24 using std::cin; 25 using std::endl; 26 using std::fixed; 27 28 #include <iomanip> 29 using std::setprecision; 30 31 // inclusão da definição da classe VendasPess contida no arquivo de 32 // cabeçalho VendasPess.h. 33 #include “VendasPess.h” 34 35 // inicialização dos elementos do array vendas com 0.0 36 VendasPess::VendasPess() 37 { 38 for ( int i = 0; i < 12; i++ ) 39 vendas[ i ] = 0.0; 40 } // fim do construtor VendasPess 41

41 // aquisição de 12 cifras de vendas digitadas pelo usuário 42 void VendasPess::recebeVendas() 43 { 44 double cifravendas; 45 46 for ( int i = 1; i <= 12; i++ ) { 47 cout << “Digite a cifra de vendas do mes” << i << “: ”; 48 cin >> cifravendas; 49 validaVendas(i, cifravendas); 50 } // fim do laço for 51} // fim da função recebeVendas 51 52 // validação de 1 das 12 cifras mensais (subtração de 1 do índice do mês 53 // para a indexação adequada do array vendas 54 void VendasPess::validaVendas(int mes, double cifra) 52 { 53 // verificação de mês válido e/ou cifra de vendas válida 54 if ( mes >= 1 && mes <= 12 && cifra > 0 ) 55 vendas[mes - 1] = cifra; // ajuste dos índices do array para 0-11 56 if ( (mes < 1 ) || (mes > 12 )) // teste de mês inválido 57 cout << “Valor de mes invalido!”; Verificação da validade dos dados digitados pelo usuário pela função de acesso validaVendas.

56 if ( cifra < 0 ) // teste de cifra inválida 57 cout << “Valor de cifra invalido!” << endl; 58 } // fim da função verificaVendas 59 60 // impressão do total de vendas anuais com o auxílio da função utilitária 61 // pública imprtotVendas 62 void VendasPess::imprtotVendas() 63 { 64 cout << setprecision(2) << fixed 65 << “\nO total de vendas durante o ano eh: R$ ” 66 << totanVendas() << endl; // chamada da função utilitária privada 67 // totanVendas 68 } // fim da função imprtotVendas 69 70 // função utilitária privada destinada à totalização das vendas do ano 71 double VendasPess::totanVendas() 72 { 73 double total = 0.0; // inicialização da variável total 74 75 for(int i = 0; i < 12; i++) // síntese dos resultados das vendas do ano 76 total += vendas[ i ]; 77 Auxílio da função utilitária totanVendas à função de acesso imprtotVendas, (encapsulação da lógica de manipulação de vendas).

78 return total; 79 } // fim da função totanVendas 80

81 // Demonstração de uma função utilitária (Compilar este programa 82 // junto com VendasPess.cpp, caso estejam em arquivos separados 83 84 #include “VendasPess.h” 85 86 int main() 87 { 88 VendasPess v; // criação do objeto s da classe totanVenda 89 90 v.recebeVendas(); 91 v.imprtotVendas(); 92 93 return 0; 94 } // fim de main Inclusão da definição da classe VendasPess de VendasPess.h. Seqüência simples de chamadas de funções-membros, as quais encapsulam a lógica de programação (nenhuma estrutura de controle em main).

Resultado da Execução do Programa Digite a cifra de vendas do mes 1: Digite a cifra de vendas do mes 2: Digite a cifra de vendas do mes 3: Digite a cifra de vendas do mes 4: Digite a cifra de vendas do mes 5: Digite a cifra de vendas do mes 6: Digite a cifra de vendas do mes 7: Digite a cifra de vendas do mes 8: Digite a cifra de vendas do mes 9: Digite a cifra de vendas do mes 10: Digite a cifra de vendas do mes 11: Digite a cifra de vendas do mes 12: O total de vendas durante o ano eh: R$

6.10 Inicialização de Objetos de Classes: Construtores
Construtor ou Função Construtora Função-membro definida no ato de definição de uma classe Chamada automática no ato da declaração de um objeto da classe Inicialização de uma ou todas as variáveis-membros de dados ou qualquer outra espécie de alteração que se faça necessária Mesmo nome da classe

6.10 Inicialização de Objetos de Classes: Construtores
Construtor ou Função Construtora Nenhum tipo fornecido no início da declaração da função ou em seu cabeçalho retorno de valor Nenhum tipo fornecido no início da declaração da função ou em seu cabeçalho (nem mesmo void) Nenhum retorno de valor

6.11 Uso de Argumentos Default com Construtores
Possibilidade de especificação de argumentos default Construtores Default Especificação de todos os argumentos ou não requisição explícita de argumentos Possibilidade de invocação sem argumentos Apenas um por classe

6.11 Uso de Argumentos Default com Construtores - Horario2.h (1/1)
01 // Horario2.h - Declaração da classe Horario. Funções-membros 02 // definidas em Horario2.cpp. 03 04 #ifndef Horario2_H 05 #define Horario2_H 06 07 // definição de tipos abstratos de dados (TAD) Horario 08 class Horario { 09 10 public: 11 Horario(int = 0, int = 0, int = 0, ); // construtor default 12 void alteraHorario( int, int, int ); //alteração do horário 13 void imprUniv(); // impressão do horário no formato universal 14 void imprPadrao(); // impressão do horário no formato padrão 15 16 private: 17 int hora; // (formato de 24 horas) 18 int minuto; // 19 int segundo; // 20 }; // fim da classe Horario 21 #endif Especificação de todos os argumentos pelo construtor default.

6.11 Uso de Argumentos Default com Construtores - Horario2.cpp (1/3)
02 // definições das funções-membros para a classe Horario. #include <iostream> 04 05 using std::cout; 06 07 #include <iomanip> 08 09 using std::setfill; using std::setw; 11 // inclusão da definição da classe Horario de Horario2.h 13 #include "Horario2.h" 14 // inicialização de cada membro de dados com zero pelo construtor 16 // Horario, assegurando um estado inicial consistente para todos 17 // os objetos do tipo Horario. 18 Horario:: Horario(int hora, int minuto, int segundo); 19 { 20 alteraHorario(hora, minuto, segundo); // validação/ alteração 20 // do horário 21 } // fim do construtor Horario Chamada de alteraHorario pelo construtor para a validação dos valores passados (ou de valores default).

22 // apresentação do novo valor de Horario no formato universal, 23 // validação e verificação dos valores dos dados e ajuste dos valores 24 // inválidos para zero 25 void Horario::alteraHorario( int h, int m, int s ) 26 { hora = ( h >= 0 && h < 24 ) ? h : 0; minuto = ( m >= 0 && m < 60 ) ? m : 0; segundo = ( s >= 0 && s < 60 ) ? s : 0; 30 } // fim da função alteraHorario 31 32 // impressão do horário no formato universal 33 void Horario::imprUniv() 34 { cout << setfill( '0' ) << setw( 2 ) << hora << ":" << setw( 2 ) << minuto << ":" << setw( 2 ) << segundo; 38 39 } // fim da função imprUniv 40

41 // impressão do horário no formato padrão 42 void Horario::imprPadrao() 43 { cout << ( ( hora == 0 || hora == 12 ) ? 12 : hora % 12 ) << ":" << setfill( '0' ) << setw( 2 ) << minuto << ":" << setw( 2 ) << segundo << ( hora < 12 ? " AM" : " PM" ); 48 } // fim da função imprPadrao 49

6.11 Uso de Argumentos Default com Construtores - main.cpp (1/3)
02 // Demonstração de um construtor default para a classe Horario. #include <iostream> 04 using std::cout; 05 using std::endl; // inclusão da definição da classe Horario de Horario2.h 07 #include “Horario2.h” 08 09 int main() 10 { 11 Horario t1; // todos os argumentos default 12 Horario t2( 2 ); // minuto e segundo default 13 Horario t3( 21, 34 ); // segundo default 14 Horario t4( 12, 25, 42 ); // todos os argumentos especificados 15 Horario t5( 27, 74, 99 ); // todos os argumentos inválidos 16 // especificados 17 18 cout << “Construido com: \n\n” 19 << “todos os argumentos default: \n”; 20 t1.imprUniv(); // 00:00:00 21 cout << “\n ”; 22 t1.imprPadrao(); // 12:00:00 AM 23 Inicialização de objetos Horario via argumentos especificados inválidos. Inicialização de objetos Horario via argumentos especificados válidos. Inicialização de objetos Horario via argumentos default.

24 cout << “\n\nHora especificada (minuto e segundo default): \n”; 25 t2.imprUniv(); // 02:00:00 26 cout << "\n "; 27 t2.imprPadrao(); // 02:00:00 AM 28 29 cout << “\n\nHora e minuto especificados (segundo default): \n”; 30 t3.imprUniv(); // 21:34:00 31 cout << "\n "; 32 t3.imprPadrao(); // 9:34:00 PM 33 34 cout << “\n\nHora, minuto e segundo especificados (validos): \n”; 35 t4.imprUniv(); // 12:25:42 36 cout << "\n "; 37 t4.imprPadrao(); // 12:25:42 PM 38 39 cout << “\n\nHora, minuto e segundo especificados (invalidos): \n”; 40 t5.imprUniv(); 00:00:00 41 cout << "\n "; 42 t5.imprPadrao(); // 12:00:00 AM 43 cout << endl; 44 Construção de t5 com todos os argumentos inválidos (verificação da validade e alteração dos valores dos argumentos para 0 por alteraHorario).

45 return 0; 46 } // fim do main Construido com: Todos os argumentos default : 00:00:00 12:00:00 AM Hora especificada (minuto e segundo default) : 02:00:00 2:00:00 AM Hora e minuto especificados (segundo default): 21:34:00 9:34:00 PM Hora, minuto e segundo especificados (validos): 12:25:42 12:25:42 PM Hora, minuto e segundo especificados (invalidos):

6.12 Destrutores Destrutores Funções- membros especiais
Complementares aos construtores Mesmo nome da classe precedido de um til (~) Inexistência de argumentos, valor de retorno e sobrecarga Necessidade de criação  Liberação da memória alocada dinamicamente

6.12 Destrutores Destrutores
Chamados quando o escopo de declaração da variável é encerrado  “Limpeza de finalização” Antes da reivindicação (pelo sistema) da memória alocada para a variável Reuso de memória por novos objetos Inexistência de explicitação de destrutor Criação de destrutor “vazio” pelo compilador

6.12 Destrutores Destrutores Sintaxe class NomeClasse {
public : ~ Nome_tipo_classe (); } Sintaxe do destrutor NomeClasse :: ~ NomeClasse () { // código do destrutor

6.13 Chamada de Construtores e Destrutores
Chamada implícita pelo compilador Ordem de chamada Dependência da ordem de execução Quando a execução chega (construtor) e deixa (destrutor) o escopo de objetos Chamadas a destrutores Em geral, em ordem reversa àquelas a construtores

Ordem das chamadas a funções construtoras e destrutoras Objetos de Escopo Global Construtores Antes de qualquer outra função (inclusive main) Destrutores Após o encerramento de main (ou a chamada à função exit) Supressão da chamada se o programa terminar com abort

Ordem das chamadas a funções construtoras e destrutoras Objetos Locais Automáticos Construtores No ato da definição de objetos Cada vez que a execução entra no escopo Destrutores Quando objetos saem do escopo Encerramento da execução do bloco no qual ocorreu a definição do objeto Supressão da chamada se o programa terminar com exit ou abort

Ordem das chamadas a funções construtoras e destrutoras Objetos Locais static Construtores Precisamente uma vez Quando a execução atinge o ponto no qual ocorre a definição do objeto Destrutores No encerramento do main ou na chamada da função exit Supressão da chamada se o programa terminar com abort

6.13 Chamada de Construtores e Destrutores - Criaedestroi.h (1/1)
01 // Criaedestroi.h - Declaração da classe CriaeDestroi. 02 // Funções-membros definidas em Criaedestroi.cpp. 03 04 #ifndef Criaedestroi_H 05 #define Criaedestroi_H 06 07 class CriaeDestroi { 08 09 public: 10 11 CriaeDestroi(int, char *); // construtor 12 ~CriaeDestroi(); // destrutor 13 14 private: 15 int ID_objeto; 16 char *mensagem; 17 18 }; // fim da classe Criaedestroi 19 #endif Par de funções-membros construtora e destrutora. Membros private para a demonstração da ordem de chamada às funções construtora e destrutora.

6.13 Chamada de Construtores e Destrutores - Criaedestroi.cpp (1/2)
02 // definições das funções-membros para a classe CriaeDestroi. #include <iostream> 04 05 using std::cout; 06 using std::endl; 11 // inclusão da definição da classe CriaeDestroi de Criaedestroi.h 13 #include “Criaedestroi.h” 14 // construtor 16 CriaeDestroi:: CriaeDestroi(int Numobj, char *mensApont); 17 { 18 ID_objeto = Numobj; 19 mensagem = mensApont; 20 21 cout << “O construtor do objeto ” << ID_objeto << “ executa ” 22 << mensagem << endl; 23 } // fim do construtor CriaeDestroi Mensagem de saída para a demonstração da temporização das chamadas à função construtora.

6.13 Chamada de Construtores e Destrutores - Criaedestroi.cpp (2/2)
25 CriaeDestroi::~CriaeDestroi() 26 { 27 // linha inserida apenas para fins pedagógicos 28 cout << (ID_objeto == 1 || ID_objeto == 6 ? “\n” : “”); 29 30 cout << “O destrutor do objeto ” << ID_objeto << “ executa ” 31 << mensagem << endl; 34 } // fim do destrutor ~CriaeDestroi Mensagem de saída para a demonstração da temporização das chamadas à função destrutora.

6.13 Chamada de Construtores e Destrutores - main.cpp (1/4)
02 // Demonstração da ordem de chamada de construtores e destrutores #include <iostream> 04 05 using std::cout; 06 using std::endl; 07 // inclusão da definição da classe CriaeDestroi de Criaedestroi.h 09 #include “Criaedestroi.h” 10 void CriaeDestroi(void); // protótipo (função p/ a criação de objetos) 12 13 // objeto global 14 16 CriaeDestroi primeiro(1, “(Global antes de main)”); 17 18 int main() 19 { 20 cout << “\nFunção main: Inicio da execução” << endl; 21 Criação de variável com escopo global.

22 CriaeDestroi segundo(2, “(Local automatico em main)”); 23 24 static CriaeDestroi terceiro(3, “(Local static em main)”); 25 26 CriaeDestroi(); // chamada da função para a criação de objetos 27 28 cout << “\nFunção main: Resumo da execução” << endl 29 30 CriaeDestroi quarto(4, “(Local automatico em main)”); 31 32 cout << “\nFunção main: Fim da execução” << endl 33 34 return 0; 35 36 } // fim do main 37 38 // função para a criação de objetos 39 void CriaeDestroi(void) 40 { 41 cout << “\nFunção CriaeDestroi: Inicio da execução” << endl; 42 43 CriaeDestroi quinto(5, “(Local automatico em CriaeDestroi)”); 44 45 static CriaeDestroi sexto(6, “(Local static em CriaeDestroi)”); 46 Criação de objeto static local na função. Criação de objeto automático local na função. Criação de objeto static local. Criação de objetos automáticos locais. Criação de objeto automático local.

47 CriaeDestroi setimo(7, “(Local automatico em CriaeDestroi)”); 48 49 cout << “\nFunção CriaeDestroi: Fim da execução” << endl; 50 } // fim da função CriaeDestroi Criação de objeto static local na função.

O construtor do Objeto 1 executa (Global antes de main) Função main: Inicio da execução O construtor do Objeto 2 executa (Local automatico em main) O construtor do Objeto 3 executa (Local static em main) Função CriaeDestroi : Inicio da execução O construtor do Objeto 5 executa (Local automatico em CriaeDestroi) O construtor do Objeto 6 executa (Local static em CriaeDestroi) O construtor do Objeto 7 executa (Local automatico em CriaeDestroi) Função CriaeDestroi : Fim da execução O destrutor do Objeto 7 executa (Local automatico em CriaeDestroi) O destrutor do Objeto 5 executa (Local automatico em CriaeDestroi) Função main: Resumo da execução O construtor do Objeto 4 executa (Local automatico em main) Função main : Fim da execução O destrutor do Objeto 4 executa (Local automatico em CriaeDestroi) O destrutor do Objeto 2 executa (Local automatico em CriaeDestroi) O destrutor do Objeto 6 executa (Local static em CriaeDestroi) O destrutor do Objeto 3 executa (Local static em main) O destrutor do Objeto 1 executa (Global antes de main) Objeto global construído antes da execução de main e destruído por último. Chamadas de destrutores para objetos locais automáticos em em ordem reversa às chamadas dos construtores. Objeto static local existe até a finalização do programa. Objetos locais automáticos destruídos após a execução da função finalizam em ordem reversa à da construção. Objeto local static construído na primeira chamada à função e destruído após a finalização de main.

6.14 Uso de Funções de Alteração (set) e Retorno (get) de Dados
Função de Alteração de Dados (set functions) Execução de testes de validade antes da modificação de dados privados (private) Notificação de valores inválidos Indicação com valores de retorno Função de Retorno de Dados (get functions) “Busca” de funções Controle do formato de dados retornados

6.14 Uso de Funções de Alteração e Retorno de Dados - Horario3.h (1/2)
01 // Horario3.h - Declaração da classe Horario. Funções-membros 02 // definidas em Horario3.cpp. 03 04 #ifndef Horario3_H 05 #define Horario3_H 06 07 // definição de tipos abstratos de dados (TAD) Horario 08 class Horario { 09 10 public: 11 Horario(int = 0, int = 0, int = 0, ); // construtor default 12 13 // funções de alteração de dados (set functions) 14 void alteraHorario( int, int, int ); // alteração do horário 15 void alteraHora( int ); // alteração da hora 16 void alteraMinuto( int ); // alteração dos minutos 17 void alteraSegundo( int ); // alteração dos segundos 18 19 // funções de retorno de dados (get functions) 20 int devolveHora(); // retorno da hora 21 int devolveMinuto(); // retorno dos minutos

6.14 Uso de Funções de Alteração e Retorno de Dados - Horario3.h (2/2)
22 int devolveSegundo(); // retorno dos segundos 23 24 void imprUniv(); // impressão do horário no formato universal 25 void imprPadrao(); // impressão do horário no formato padrão 26 27 private: 28 int hora; // (formato de 24 horas) 29 int minuto; // 30 int segundo; // 31 }; // fim da classe Horario 32 #endif

6. 14. Uso de Funções de Alteração e Retorno de Dados - Horario3
6.14 Uso de Funções de Alteração e Retorno de Dados - Horario3.cpp (1/4) 01 // Horario3.cpp 02 // definições das funções-membros para a classe Horario. #include <iostream> 04 05 using std::cout; 06 07 #include <iomanip> 08 09 using std::setfill; using std::setw; 11 // inclusão da definição da classe Horario de Horario3.h 13 #include "Horario3.h" 14 // função construtora para a inicialização de dados privados 16 // chamada da função alteraHorario para alteração de variáveis 17 // valores default iguais a 0 (vide definição da classe Horario) 18 Horario:: Horario(int hora, int minuto, int segundo); 19 { 20 alteraHorario(hora, minuto, segundo); // validação/ alteração 20 // do horário 21 } // fim do construtor Horario

6.14 Uso de Funções de Alteração e Retorno de Dados - Horario3.cpp (2/4) 22 // alteração dos valores da hora, minuto e segundo 23 void Horario::alteraHorario(int h, int m, int s) 24 { alteraHora(h); alteraMinuto(m); alteraSegundo(s); 28 } // fim da função alteraHorario 29 30 // alteração do valor da hora 31 void Horario::alteraHora(int h) 32 { 33 hora = ( h >= 0 && h < 24 ) ? h : 0; 34 } // fim da função alteraHora 35 36 // alteração do valor dos minutos 37 void Horario::alteraMinuto(int m) 38 { 39 minuto = ( m >= 0 && m < 60 ) ? m : 0; 40 } // fim da função alteraMinuto 41 Chamada de funções de alteração (set functions) para verificação da validade dos dados. Verificação da validade dos dados pelas funções de alteração (set functions) antes da modificação de dados.

6.14 Uso de Funções de Alteração e Retorno de Dados - Horario3.cpp (3/4) 42 // alteração do valor dos segundos 43 void Horario::alteraSegundo(int s) 44 { 45 segundo = ( s >= 0 && s < 60 ) ? s : 0; 46 } // fim da função alteraSegundo 47 48 // retorno do valor da hora 49 void Horario::devolveHora() 50 { 51 return hora; 52 } // fim da função devolveHora 53 54 // retorno do valor dos minutos 55 void Horario::devolveMinuto() 56 { 57 return minuto; 58 } // fim da função devolveMinuto 59 Verificação da validade dos dados pelas funções de alteração (set functions) antes da modificação de dados. Possibilidade de leitura de dados pelo usuário, a partir da chamada de funções de retorno (get functions).

6.14 Uso de Funções de Alteração e Retorno de Dados - Horario3.cpp (4/4) 60 // retorno do valor dos segundos 61 void Horario::devolveSegundo() 62 { 63 return segundo; 64 } // fim da função devolveSegundo 65 66 // impressão do horário no formato universal 67 void Horario::imprUniv() 68 { cout << setfill( '0' ) << setw( 2 ) << hora << ":" << setw( 2 ) << minuto << ":" << setw( 2 ) << segundo; 71 } // fim da função imprUniv 72 73 // impressão do horário no formato padrão 74 void Horario::imprPadrao() 75 { cout << ( ( hora == 0 || hora == 12 ) ? 12 : hora % 12 ) << “:” 77 << setfill( '0' ) << setw( 2 ) << minuto << “:” 78 << setw( 2 ) << segundo << ( hora < 12 ? " AM" : " PM" ); 79 } // fim da função imprPadrao 80

6.14 Uso de Funções de Alteração e Retorno de Dados - main.cpp (1/4)
02 // Demonstração de um construtor default para a classe Horario. #include <iostream> 04 using std::cout; 05 using std::endl; // inclusão da definição da classe Horario de Horario3.h 07 #include “Horario3.h” 08 09 void incrementaMinutos(Horario &, const int ); // protótipo 10 11 int main() 12 { 13 Horario t; // criação de objeto da classe Horario 14 15 // alteração do horário via funções de alteração individuais 16 t.alteraHora(17); // alteração da hora para um valor válido 17 t.alteraMinuto(34); // alteração dos minutos para um valor válido 18 t.alteraSegundo(25); // alteração dos segundos para um valor 19 // válido 20 Chamada das funções de alteração (set functions) para a modificação de dados a partir de valores válidos.

21 // Uso das funções de retorno para a obtenção da hora, 22 // minuto e segundo 23 cout << “Resultado da alteração para todos os 24 valores validos:\n\n” 25 << “Hora: ” << t.devolveHora() 26 << “ Minuto: ” << t.devolveMinuto() 27 << “ Segundo: ” << t.devolveSegundo(); 28 29 // Ajuste do horário via funções individuais de alteração 30 t.alteraHora(234); // Ajuste da hora para 0 (234 -> valor inválido) 31 t.alteraMinuto(43); // Ajuste dos minutos para 43 (valor válido) 32 t.alteraSegundo(6373); // Ajuste dos segundos para 0 (6373 -> valor 33 // inválido) 34 35 // Apresentação da hora, minutos e segundos após ajuste 36 cout << “\n\n Resultado da alteracao da hora e dos segundos 37 usando valores invalidos:\n” << “Hora: ” << t.devolveHora() 38 << “Minuto: ” << t.devolveMinuto() 39 << “Segundo: ” << t.devolveSegundo() << “\n\n”; 40 30 t.alteraHora(234); // Ajuste da hora para 0 (234 -> valor inválido) 32 t.alteraSegundo(6373); // Ajuste dos segundos para 0 (6373 -> valor 33 // inválido) Tentativa de modificação de dados a partir de valores inválidos via funções de alteração (set functions). Tentativas de modificação de dados com valores inválidos resulta na alteração dos valores para 0.

41 t.alteraHorario(11, 58, 5); // Ajuste válido do horário 42 incrementaMinutos(t, 3); // Incremento de minuto de t de 3 43 44 return 0; 45 } // fim de main 46 47 // adição de um numero especificado de minutos a um objeto Horario 48 void incrementaMinutos(Horario &tt, const int cont) 49 { 50 cout << “Incremento dos minutos de” << cont 51 << “ vezes:\nHorario inicial: ”; 52 tt.imprPadrao(); 53 54 for (int i = 0; i < count; i++) { 55 tt.alteraMinuto((tt.devolveMinuto() + 1 ) % 60); 56 if (tt.devolveMinuto() == 0) 57 tt.alteraHora((tt.devolveHora() + 1) % 24); 58 59 cout << “\n Minuto + 1: ”; 60 tt.imprPadrao(); 61 } // fim do laço for 62 Modificação conjunta dos membros de dados a partir da função alteraHorario. Uso de funções de retorno para a leitura de dados e de funções de alteração para a modificação de dados.

63 cout << endl; 64 } // fim da função incrementaMinutos Resultado da alteração para todos os valores validos: Hora: 17 Minuto: 34 Segundo: 25 Resultado da alteracao da hora e dos segundos usando valores invalidos: Hora: 0 Minuto: 43 Segundo: 0 Incremento dos minutos de 3 vezes: Horario inicial: 11:58:00 AM Minuto + 1: 11:59:00 AM Minuto + 1: 12:00:00 PM Minuto + 1: 12:01:00 PM

6.15 Retorno de uma Referência para Membros de Dados private
Referência a um objeto Pseudônimo para o nome do objeto lvalue Possibilidade de recebimento de valores em declarações de atribuição Alteração de objeto original

6.15 Retorno de uma Referência para Membros de Dados private
Retorno de referências Possibilidade de retorno de referências não const por funções-membros públicas (public) para membros de dados privados (private) Facilidade de modificação de membros de dados privados (private) pelo usuário

6.15 Retorno de uma Referência para Membros de Dados private (1/6)
01 // Horario4.h - Declaração da classe Horario. Funções-membros 02 //definidas em Horario4.cpp. Prevenção contra inclusões múltiplas de 03 //arquivos de cabeçalho. 04 #ifndef Horario4_H 05 #define Horario4_H 06 07 // definição de tipos abstratos de dados (TAD) Horario 08 class Horario { 09 10 public: 11 Horario(); // construtor 12 void alteraHorario( int, int, int ); //alteração do horario 13 int retornaHorario(); // retorna horario atual 14 int &incalteraHorario( int ); // retorno de referência PERIGOSA!!! 15 16 private: 17 int hora; // (formato de 24 horas) 18 int minuto; // 19 int segundo; // 20 }; // fim da classe Horario 21 #endif Função para demonstração dos efeitos de retorno de referência para membro de dados private. 14 int &incalteraHorario( int ); // retorno de referência PERIGOSA!!!

01 // Horario4.cpp 02 // definições das funções-membros para a classe Horario. 03 // inclusão da definição da classe Horario de Horario4.h 05 #include "Horario4.h" 06 // função construtora para inicialização de dados privados 08 // chamada à função-membro alteraHora para alteração de variáveis 09 // valores default iguais a zero (vide definições da classe). 10 Horario::Horario( int hora, int minuto, int segundo ) 11 { 12 alteraHorario( hora, minuto, segundo ); 13 } // fim do construtor Horario 14 15 // alteração dos valores de hora, minuto e segundo. 16 void Horario::alteraHorario( int h, int m, int s ) 17 { 18 hora = ( h >= 0 && h < 24 ) ? h : 0; 19 minuto = ( m >= 0 && m < 60 ) ? m : 0; 20 segundo = ( s >= 0 && s < 60 ) ? s : 0; 21 } // fim da função alteraHorario

22 // retorno do valor de hora 23 24 int Horario::retornahorario() 25 { 26 return hora; 27 } // fim da função retornaHorario 28 29 // PRÁTICA de programação DEFICIENTE!!! 30 // retorno de uma referência para um membro de dados private. 31 int &Horario::incalteraHorario( int hh ) 32 { 33 hora = ( hh >= 0 && hh < 24 ) ? hh : 0; 34 35 return hora; // retorno de uma referência PERIGOSA!!! 36 } // fim da função incalteraHorario 29 // PRÁTICA de programação DEFICIENTE!!! 30 // retorno de uma referência para um membro de dados private. 31 int &Horario::incalteraHorario( int hh ) 35 return hora; // retorno de uma referência PERIGOSA!!! Retorno de uma referência para o membro de dados private hora.

37 // Demonstração de uma função-membro public que retorna uma 38 // referência para um membro de dados private. 39 40 #include <iostream> 41 using std::cout; 42 using std::endl; 43 44 // inclusão da definição da classe Horario de Horario4.h 45 #include "Horario4.h" 46 47 int main() 48 { 49 Horario t; 50 51 // armazenamento da referência retornada por incalteraHorario 52 // em horaRef 53 int &horaRef = t. incalteraHorario( 20 ); 53 54 cout << “Hora antes da alteracao: ” << horaRef; 55 // uso de horaRef para tornar inválido o valor do objeto Horario t 56 horaRef = 30; 57 58 cout << “\nHora apos a alteracao: ” << t.gethora(); Alteração do membro de dados private hora a partir da referência. Retorno de uma referência para o membro de dados private hora por incalteraHorario. 51 // armazenamento da referência retornada por incalteraHorario 52 // em horaRef 53 int &horaRef = t.badSethora( 20 ); 55 // uso de horaRef para tornar inválido o valor do objeto Horario t 56 horaRef = 30;

58 // ATENÇÃO!!! É PERIGOSA a chamada a uma função que retorna 59 // uma referência, pois esta poderá ser usada como um lvalue! 60 t.badSethora( 12 ) = 74; 61 62 cout << “\n\n************************************************ 63 *****\n’’ 63 << “PRÁTICA de programação DEFICIENTE!!!\n” 64 << “incalteraHorario como um lvalue, hora: ” 65 << t.gethora() 66 << “\n*****************************************************” << endl; 67 68 return 0; 69 70 } // fim do main 58 // ATENÇÃO!!! É PERIGOSA a chamada a uma função que retorna 59 // uma referência, pois esta poderá ser usada como um lvalue! 60 t.badSethora( 12 ) = 74; Possibilidade de uso de uma chamada a função como um lvalue. 63 << “PRÁTICA de programação DEFICIENTE!!!\n” 64 << “incalteraHorario como um lvalue, hora: ”

Hora antes da alteracao: 20 Hora apos a alteracao : 30 ***************************************************** PRÁTICA de programação DEFICIENTE!!! incalteraHorario como um lvalue, Hora: 74 Retorno de uma referência possibilitou a alteração incorreta do membro de dados private hora.

6.16 Atribuição Default de Membro
Atribuição de objetos Operador de Atribuição (=) Possibilidade de atribuição de um objeto a outro do mesmo tipo Default Atribuição de Membros Atribuição do membro à direita do operador de atribuição (=) ao membro à sua esquerda, um a um

6.16 Atribuição Default de Membro
Passagem e Retorno de Objetos Passagem de objetos como argumentos de funções Retorno de objetos de funções Default Passagem por Valor Cópia do objeto passado/ retornado Uso de um construtor de Cópia Cópia dos valores originais para o novo objeto

6.16 Atribuição Default de Membro - Exemplo (1/3)
01 // Demonstração da possibilidade de atribuição de objetos de uma classe, 02 // uns aos outros a partir do uso da atribuição default de membros. 03 #include <iostream> 04 05 using std::cout; 06 using std::endl; 07 08 // definição da classe Data 09 class Data { 10 11 public: 12 Data( int = 1, int = 1, int = 2003 ); // construtor default 13 void imprime(); 14 15 private: 16 int dia; 17 int mes; 18 int ano; 19 }; // fim da classe Data 20

21 // construtor Data sem verificação de faixa 22 Data::Data( int d, int m, int y ) 23 { 24 dia = d; 25 mes = m; 26 ano = a; 27 28 } // fim do construtor Data 29 30 // impressão de Data no formato dd/mm/aa 31 void Date::imprime() 32 { 33 cout << dia << ‘/’ << mes << ‘/’ << ano; 34 } // fim da função imprime 35 36 int main() 37 { 38 Data data1( 17, 11, 2003 ); 39 Data data2; // data2 default: 1/1/2003 40

41 // impressão de data1 e data2 42 cout << “Data 1 = ”; 43 data1.imprime(); 44 cout << “\nData 2 = ”; 45 data2.imprime(); 46 47 data2 = data1; // atribuição default de membro 48 49 cout << “\n\nApos a atribuicao default de membro, Data 2 = ”; 50 data2.imprime(); 51 cout << endl; 52 53 return 0; 54 55 } // fim do main Atribuição default de membro associa individualmente cada membro de data1 a cada membro de data2. data1 = 17/11/2003 data2 = 1/1/2003 Apos a atribuicao default de membro, data2 = 17/11/2003

6.17 Reusabilidade de Software
Bibliotecas de Classes Definição/ Estruturação cuidadosa Testes consistentes e bem planejados Documentação adequada Portabilidade Facilidade de acesso

6.17 Reusabilidade de Software
Favorecimento ao desenvolvimento ágil de aplicações de software poderosas e de alta qualidade Desenvolvimento Rápido de Aplicações (DRA) Problemas Remanescentes Esquemas de Catalogação Esquemas de Licenciamento Mecanismos de Proteção

{joseana, rangel}@dsc.ufcg.edu.br
Joseana Macêdo Fechine José Eustáquio Rangel de Queiroz {joseana, UNIVERSIDADE FEDERAL DE CAMPINA GRANDE CENTRO DE CIÊNCIAS E TECNOLOGIA DEPARTAMENTO DE SISTEMAS E COMPUTAÇÃO

Técnicas de Programação

Apresentações semelhantes

Apresentação em tema: "Técnicas de Programação"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Técnicas de Programação

Apresentações semelhantes

Apresentação em tema: "Técnicas de Programação"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback