prof.: josé eustáquio rangel de queiroz [email protected] rangeldequeiroz@gmail

Informática na Educaçã[email protected]
[email protected]
Tópicos
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
{joseana, rangel}@dsc.ufcg.edu.br
Tópicos
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
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
Dados (membros de dados)
Funções (funções-membros ou métodos)
Similares a fotocópias Reusáveis
Instâncias de Classe Objetos
Estrutura
Agregação de variáveis do mesmo tipo ou de tipos diferentes em uma única entidade
Conceito comum no quotidiano
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
Rótulo ou Etiqueta
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
Operadores de Acesso a Membros
Operador Ponto (.) Membros de estrutura e classe
Operador Seta (->) Membros de estrutura e classe via apontador para objeto
Operadores de Acesso a Membros
Exemplo
cout << tempObj.segundo;
Uso dos parênteses Prioridade de * inferior a .
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
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>
16 int minuto; // 0-59
17 int segundo; // 0-59
20
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()
27
31 cout << “ O jantar será servido às ”;
32 imprUniv( Jantar );
34 imprPadrao( Jantar );
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
40 //valor inválido
42 imprUniv(Jantar);
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 {
53 << setw( 2 ) << t.minuto << ":"
54 << setw( 2 ) << t.segundo;
57
59 void imprPadrao( const Horario &t )
60 {
63 << setw( 2 ) << t.minuto << ":"
64 << setw( 2 ) << t.segundo
66
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.

Classes e Objetos
Objetos do Modelo
Membro de funções
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++
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
Sintaxe de class
Declaração de um novo tipo para o compilador.
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:
protected:
Acesso por funções-membros da classe e por funções-membros de classes derivadas desta classe.
Especificadores de Acesso a Membros
Atributos
Construtores
Mesmo nome da classe
};
Chamada no ato da instanciação do objeto (quando ocorre a alocação de memória)
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
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 {
};
cin >> x >> y;
01 // Circulo.h - Definição da classe Circulo
02
Objetos de classes
Especificador do novo tipo Nome da Classe
C++ Linguagem extensível
Objetos de classes - Exemplo
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
Nome da classe (Horario) torna-se novo tipo de especificador.
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
Formato para definição de funções-membros
Tipo_de_Retorno Nome_da_Classe::Nome_da_FuncaoMembro( ){
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
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
13 class Horario {
18 void imprUniv(); // impressão no formato universal
19 void imprPadrao(); // impressão no formato padrão
20
6.5 Implementação de Tipos Abstratos de Dados - class Horario (1/5)
23 int minuto; // 0 - 59
24 int segundo; // 0 - 59
25
27
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
37 {
41
Inicialização dos membros de dados privados (private) com 0 pelo construtor, assegurando um estado inicial consistente para todos os objetos do tipo Horario
44 void Horario::imprUniv()
47 << setw( 2 ) << minuto << ":"
48 << setw( 2 ) << segundo;
51
53 void Horario::imprPadrao()
56 << ":" << setfill( '0' ) << setw( 2 ) << minuto
57 << ":" << setw( 2 ) << segundo
60
63 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
66 cout << " O horario universal inicial eh ";
67 t.imprUniv(); // 00:00:00
70 t.imprPadrao(); // 12:00:00 AM
73
76 t.imprUniv(); // 13:27:06
79 t.imprPadrao(); // 1:27:06 PM
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
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
O horario universal inicial eh 00:00:00
O horario padrao inicial eh 12:00:00 AM

O horario padrao apos alteraHorario eh 1:27:06 PM

Horario universal : 00:00:00
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
NomeClasse :: ~ NomeClasse () {
class Org {
char *razãoSocial;
cin.get(aux, 80);
Chamada do construtor
Alocação de memória heap
Liberação de memória heap
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++
Simplificação da Programação
Reuso de Software
Objetos de uma classe incluídos como membros de outras classes
Herança
6.6 Escopo de Classe e Acesso a Membros de uma Classe
Escopo de Classes
Dados-membros e funções-membros
Referência pelo nome
Referência via manipulações (handles)
Nome do objeto, referência ao objeto, apontador para o objeto
Escopo de Arquivos
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
Apontadores
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)!
10 class Cont {
19 }; // fim da classe Cont
6.6 Escopo de Classe e Acesso a Membros de uma Classe (1/3)
Membro de dados públicos (public) x para ilustração de operadores de acesso a membros de classe; tipicamente, membros de dados privados (private)
23 Cont *contApont = &cont; // criação do apontador para contador
24 Cont &contRef = cont; // criação de referência para contador
25
26 cout << “Atribuicao de 1 a x e impressão via nome do
27 objeto: ";
28 cont.x = 1; // atribuição de 1 ao membro de dados x
29 cont.impr(); // chamada de função-membro impr
30 cout << "Atribuicao de 2 a x e impressão via referencia
31 do objeto: ";
32 contRef.x = 2; // atribuição de 2 ao membro de dados x
33 contRef.impr(); // chamada de função-membro impr
34 cout << "Atribuicao de 3 a x e impressão via apontador
35 do objeto: ";
36 contApont->x = 3; // atribuição de 3 ao membro de dados x
37 contApont->impr(); // chamada de função-membro impr
38 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
Vantagem
Desvantagens
Porções de implementação
Extensão do arquivo .h
#include “caminho_do_arquivo.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
08 class Horario {
15
18 int minuto; // 0 - 59
20 }; // fim da classe Horario
21 #endif
Convenção da denominação:
nome do arquivo de cabeçalho com underscore (_) substituindo o ponto (.).
Código entre estas diretivas não incluído se o nome Horario1_H já tiver sido definido.
“Se não houver sido definido”
Diretiva do pré-processador define nome Horario1_H .
02 // definições das funções-membros para a classe Horario.
13 #include "Horario1.h"
14
15 // 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()
Inclusão do arquivo de cabeçalho Horario1.h.
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++.
26 {
30
32 // impressão do horário no formato universal
36 << setw( 2 ) << minuto << ":"
40
41 // impressão do horário no formato padrão
46 << ":" << setw( 2 ) << segundo
49
03 // Horario1.cpp
10 #include “Horario1.h”
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
20 t.imprPadrao(); // 12:00:00 AM
21 t.alteraHorario( 13, 27, 6 ); // alteração do horário para 13:27:06
22
de Teste da Classe Horario (1/3)
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
27 t.imprPadrao(); 1:27:06 PM
29
31 cout << “\n\nApos verificacao de valores invalidos”
32 << "\nHorario Universal: ";
33 t.imprUniv(); // 00:00:00
O horario Universal inicial eh 00:00:00
O horario Padrao inicial eh 12:00:00 AM

Apos verificacao de valores invalidos:
O horario Universal eh 00:00:00
O horario Universal eh 12:00:00 AM
Modos de Acesso a Membros
private:
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)
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!
01 // Erros. cpp - Demonstração de erros resultantes de tentativas de
02 // acesso a membros de uma classe privada (private).
13
15
17 // está acessível!
20 } // fim do main.
Tentativas de acesso a membros privados (private) (no caso, o membro de dados hora) resulta em erros.
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’
Default private
Acesso a Membros de Estruturas (struct)
Default public
6.8 Controle de Acesso a Membros
Função get
Funções de Acesso
Funções Utilitárias (funções de ajuda)
private
Não desenvolvidas para uso direto de clientes
04 #ifndef VENDASPESS_H
05 #define VENDASPESS_H
12 void validaVendas( int, double ); // verificação de vendas mensais
13 void imprtotVendas(); // síntese e impressão de vendas
14
17 double vendas[12]; // valores de vendas durante 12 meses
18 }; // fim da classe VendasPess
19 #endif
6.9 Funções de Acesso e Funções Utilitárias – Exemplo (1/1)
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.
23 using std::cout;
24 using std::cin;
25 using std::endl;
26 using std::fixed;
30
31 // inclusão da definição da classe VendasPess contida no arquivo de
32 // cabeçalho VendasPess.h.
33 #include “VendasPess.h”
36 VendasPess::VendasPess()
39 vendas[ i ] = 0.0;
41
41 // aquisição de 12 cifras de vendas digitadas pelo usuário
42 void VendasPess::recebeVendas()
47 cout << “Digite a cifra de vendas do mes” << i << “: ”;
48 cin >> cifravendas;
49 validaVendas(i, cifravendas);
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.
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()
65 << “\nO total de vendas durante o ano eh: R$ ”
66 << totanVendas() << endl; // chamada da função utilitária privada
67 // totanVendas
69
70 // função utilitária privada destinada à totalização das vendas do ano
71 double VendasPess::totanVendas()
74
75 for(int i = 0; i < 12; i++) // síntese dos resultados das vendas do ano
76 total += vendas[ i ];
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;
80
83
88 VendasPess v; // criação do objeto s da classe totanVenda
89
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).
Digite a cifra de vendas do mes 1: 5314.76

O total de vendas durante o ano eh: R$ 60120.59
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
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
Construtores
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
01 // Horario2.h - Declaração da classe Horario. Funções-membros
02 // definidas em Horario2.cpp.
08 class Horario {
15
18 int minuto; // 0 - 59
21 #endif
01 // Horario2.cpp
14
15 // 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 // do horário
21 } // fim do construtor Horario
Chamada de alteraHorario pelo construtor para a validação dos valores passados (ou de valores default).
26 {
30 } // fim da função alteraHorario
31
36 << setw( 2 ) << minuto << ":"
40
41 // impressão do horário no formato padrão
46 << ":" << setw( 2 ) << segundo
49
01 // main.cpp
02 // Demonstração de um construtor default para a classe Horario.
04 using std::cout;
05 using std::endl;
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
20 t1.imprUniv(); // 00:00:00
21 cout << “\n ”;
Inicialização de objetos Horario via argumentos especificados válidos.
Inicialização de objetos Horario via argumentos especificados inválidos.
24 cout << “\n\nHora especificada (minuto e segundo default): \n”;
25 t2.imprUniv(); // 02:00:00
26 cout << "\n ";
29 cout << “\n\nHora e minuto especificados (segundo default): \n”;
30 t3.imprUniv(); // 21:34:00
31 cout << "\n ";
34 cout << “\n\nHora, minuto e segundo especificados (validos): \n”;
35 t4.imprUniv(); // 12:25:42
36 cout << "\n ";
39 cout << “\n\nHora, minuto e segundo especificados (invalidos): \n”;
40 t5.imprUniv(); 00:00:00
41 cout << "\n ";
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;
02:00:00
21:34:00
12:25:42
00:00:00
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
Construtores e Destrutores
Dependência da ordem de execução
Quando a execução chega (construtor) e deixa (destrutor) o escopo de objetos
Chamadas a destrutores
Ordem das chamadas a funções construtoras e destrutoras
Objetos de Escopo Global
Destrutores
Após o encerramento de main (ou a chamada à função exit)
Supressão da chamada se o programa terminar com abort
Objetos Locais Automáticos
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
Objetos Locais static
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
01 // Criaedestroi.h - Declaração da classe CriaeDestroi.
02 // Funções-membros definidas em Criaedestroi.cpp.
03
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.
01 // Criaedestroi.cpp
13 #include “Criaedestroi.h”
17 {
22 << mensagem << endl;
23 } // fim do construtor CriaeDestroi
Mensagem de saída para a demonstração da temporização das chamadas à função construtora.
24 // destrutor
29
31 << mensagem << endl;
34 } // fim do destrutor ~CriaeDestroi
Mensagem de saída para a demonstração da temporização das chamadas à função destrutora.
01 // main.cpp
02 // Demonstração da ordem de chamada de construtores e destrutores
09 #include “Criaedestroi.h”
11 void CriaeDestroi(void); // protótipo (função p/ a criação de objetos)
12
17
21
22 CriaeDestroi segundo(2, “(Local automatico em main)”);
23
25
26 CriaeDestroi(); // chamada da função para a criação de objetos
27
29
31
33
39 void CriaeDestroi(void)
42
44
46
Criação de objeto automático local na função.
Criação de objeto static local na função.
47 CriaeDestroi setimo(7, “(Local automatico em CriaeDestroi)”);
48
50 } // fim da função CriaeDestroi
Criação de objeto static local na função.

Função CriaeDestroi : Fim da execução

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 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
Função de Retorno de Dados (get functions)
“Busca” de funções
02 // definidas em Horario3.cpp.
08 class Horario {
12
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
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 (1/2)
23
26
29 int minuto; // 0 - 59
32 #endif
6.14 Uso de Funções de Alteração e Retorno de Dados - Horario3.h (2/2)
15 // 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 // do horário
21 } // fim do construtor Horario
6.14 Uso de Funções de Alteração e Retorno de Dados - Horario3.cpp (1/4)
23 void Horario::alteraHorario(int h, int m, int s)
24 {
29
31 void Horario::alteraHora(int h)
34 } // fim da função alteraHora
35
37 void Horario::alteraMinuto(int m)
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.
43 void Horario::alteraSegundo(int s)
46 } // fim da função alteraSegundo
47
49 void Horario::devolveHora()
53
55 void Horario::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).
61 void Horario::devolveSegundo()
65
71 } // fim da função imprUniv
72
77 << setfill( '0' ) << setw( 2 ) << minuto << “:”
78 << setw( 2 ) << segundo << ( hora < 12 ? " AM" : " PM" );
79 } // fim da função imprPadrao
80
02 // Demonstração de um construtor default para a classe Horario.
04 using std::cout;
05 using std::endl;
10
14
18 t.alteraSegundo(25); // alteração dos segundos para um valor
19 // válido
20
6.14 Uso de Funções de Alteração e Retorno de Dados - main.cpp (1/4)
Chamada das funções de alteração (set functions) para a modificação de dados a partir de valores válidos.
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)
21 // Uso das funções de retorno para a obtenção da hora,
22 // minuto e segundo
24 valores validos:\n\n”
25 << “Hora: ” << t.devolveHora()
26 << “ Minuto: ” << t.devolveMinuto()
27 << “ Segundo: ” << t.devolveSegundo();
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)
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()
40
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.
42 incrementaMinutos(t, 3); // Incremento de minuto de t de 3
43
46
47 // adição de um numero especificado de minutos a um objeto Horario
48 void incrementaMinutos(Horario &tt, const int cont)
49 {
51 << “ vezes:\nHorario inicial: ”;
55 tt.alteraMinuto((tt.devolveMinuto() + 1 ) % 60);
56 if (tt.devolveMinuto() == 0)
57 tt.alteraHora((tt.devolveHora() + 1) % 24);
60 tt.imprPadrao();
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

Horario inicial: 11:58:00 AM
Minuto + 1: 11:59:00 AM
Minuto + 1: 12:00:00 PM
Minuto + 1: 12:01:00 PM
Referência a um objeto
lvalue
Alteração de objeto original
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)
14 int &incalteraHorario( int ); // retorno de referência PERIGOSA!!!
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.
08 class Horario {
13 int retornaHorario(); // retorna horario atual
14 int &incalteraHorario( int ); // retorno de referência PERIGOSA!!!
15
18 int minuto; // 0 - 59
21 #endif
Função para demonstração dos efeitos de retorno de referência para membro de dados private.
01 // Horario4.cpp
03
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 {
14
17 {
21 } // fim da função alteraHorario
35 return hora; // retorno de uma referência PERIGOSA!!!
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 )
22 // retorno do valor de hora
23
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 {
34
36 } // fim da função incalteraHorario
Retorno de uma referência para o membro de dados private hora.
55 // uso de horaRef para tornar inválido o valor do objeto Horario t
56 horaRef = 30;
52 // em horaRef
37 // Demonstração de uma função-membro public que retorna uma
38 // referência para um membro de dados private.
39
52 // em horaRef
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;
58 cout << “\nHora apos a alteracao: ” << t.gethora();
Retorno de uma referência para o membro de dados private hora por incalteraHorario.
Alteração do membro de dados private hora a partir da referência.
63 << “PRÁTICA de programação DEFICIENTE!!!\n”
64 << “incalteraHorario como um lvalue, hora: ”
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;
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;
65 << t.gethora()
70 } // fim do main
Possibilidade de uso de uma chamada a função como um lvalue.
Hora antes da alteracao: 20
Hora apos a alteracao : 30

*****************************************************
*****************************************************
Retorno de uma referência possibilitou a alteração incorreta do membro de dados private hora.
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
Passagem de objetos como argumentos de funções
Retorno de objetos de funções
Default
Uso de um construtor de Cópia
Cópia dos valores originais para o novo objeto
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.
09 class Data {
12 Data( int = 1, int = 1, int = 2003 ); // construtor default
13 void imprime();
20
22 Data::Data( int d, int m, int y )
23 {
29
31 void Date::imprime()
35
40
42 cout << “Data 1 = ”;
48
49 cout << “\n\nApos a atribuicao default de membro, Data 2 = ”;
50 data2.imprime();
55 } // fim do main
Atribuição default de membro associa individualmente cada membro de data1 a cada membro de data2.
6.16 Atribuição Default de Membro - Exemplo (3/3)
data1 = 17/11/2003
data2 = 1/1/2003
Documentação adequada
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

prof.: josé eustáquio rangel de queiroz [email protected] rangeldequeiroz@gmail

Documents