Técnicas de Programação. Classes e. Abstração de Dados. Prof.: José Eustáquio Rangel de Queiroz [email protected] [email protected]. Carga Horária: 60 horas. Classes e Abstração de Dados. Tó p icos 6.1 Introdução 6.2 Definições de Estruturas - PowerPoint PPT Presentation
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
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
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 (;)
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
Operadores de Acesso a Membros
Exemplo
cout << tempObj.segundo;
Uso dos parênteses Prioridade de * inferior a .
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
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>
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
{joseana, rangel}@dsc.ufcg.edu.br
6.4 Implementação de Tipos Definidos pelo Usuário - struct Horario
(2/4)
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
{joseana, rangel}@dsc.ufcg.edu.br
6.4 Implementação de Tipos Definidos pelo Usuário - struct Horario
(3/4)
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
{joseana, rangel}@dsc.ufcg.edu.br
6.4 Implementação de Tipos Definidos pelo Usuário - struct Horario
(4/4)
Resultado da execução do programa
O jantar será servido às 18:30:00 (horário universal),
que corresponde a 6:30:00 PM no horário padrão.
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
Classes e Objetos
Objetos do Modelo
Membro de funções
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
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
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
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
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
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
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
struct x class
6.5 Implementação de Tipos Abstratos de Dados com uma 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.
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
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.
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
Especificadores de Acesso a Membros
Atributos
6.5 Implementação de Tipos Abstratos de Dados com uma class
Construtores
Mesmo nome da classe
};
Chamada no ato da instanciação do objeto (quando ocorre a alocação
de memória)
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
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));
6.5 Implementação de Tipos Abstratos de Dados com uma class
Construtores
Regra geral
Não é aconselhável vincular ao construtor funções que não estejam
associadas ao processo de inicialização
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
Construtores - Exemplo
class Ponto {
};
cin >> x >> y;
6.5 Implementação de Tipos Abstratos de Dados com uma class
01 // Circulo.h - Definição da classe Circulo
02
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
Objetos de classes
Especificador do novo tipo Nome da Classe
C++ Linguagem extensível
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
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.
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
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
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
Funções-membros definidas fora da classe
Formato para definição de funções-membros
Tipo_de_Retorno Nome_da_Classe::Nome_da_FuncaoMembro( ){
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
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
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
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
{joseana, rangel}@dsc.ufcg.edu.br
02 #include <iostream>
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)
{joseana, rangel}@dsc.ufcg.edu.br
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
6.5 Implementação de Tipos Abstratos de Dados - class Horario
(2/5)
Inicialização dos membros de dados privados (private) com 0 pelo
construtor, assegurando um estado inicial consistente para todos os
objetos do tipo Horario
{joseana, rangel}@dsc.ufcg.edu.br
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
6.5 Implementação de Tipos Abstratos de Dados - class Horario
(3/5)
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
{joseana, rangel}@dsc.ufcg.edu.br
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
6.5 Implementação de Tipos Abstratos de Dados - class Horario
(4/5)
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
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados - class Horario
(5/5)
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
6.5 Implementação de Tipos Abstratos de Dados com uma class
{joseana, rangel}@dsc.ufcg.edu.br
NomeClasse :: ~ NomeClasse () {
6.5 Implementação de Tipos Abstratos de Dados com uma class
{joseana, rangel}@dsc.ufcg.edu.br
6.5 Implementação de Tipos Abstratos de Dados com uma class
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++
6.5 Implementação de Tipos Abstratos de Dados com uma class
{joseana, rangel}@dsc.ufcg.edu.br
Simplificação da Programação
Reuso de Software
Objetos de uma classe incluídos como membros de outras
classes
Herança
6.5 Implementação de Tipos Abstratos de Dados com uma class
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
6.6 Escopo de Classe e Acesso a Membros de uma Classe
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
{joseana, rangel}@dsc.ufcg.edu.br
6.6 Escopo de Classe e Acesso a Membros de uma 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
{joseana, rangel}@dsc.ufcg.edu.br
6.6 Escopo de Classe e Acesso a Membros de uma Classe
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)!
04 #include <iostream>
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)
{joseana, rangel}@dsc.ufcg.edu.br
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
6.6 Escopo de Classe e Acesso a Membros de uma Classe (2/3)
{joseana, rangel}@dsc.ufcg.edu.br
Resultado da Execução do Programa
6.6 Escopo de Classe e Acesso a Membros de uma Classe (3/3)
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
{joseana, rangel}@dsc.ufcg.edu.br
Vantagem
Desvantagens
Porções de implementação
{joseana, rangel}@dsc.ufcg.edu.br
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
19 int segundo; // 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 .
{joseana, rangel}@dsc.ufcg.edu.br
02 // definições das funções-membros para a classe Horario.
03 #include <iostream>
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++.
{joseana, rangel}@dsc.ufcg.edu.br
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
26 {
30
32 // impressão do horário no formato universal
33 void Horario::imprUniv()
36 << setw( 2 ) << minuto << ":"
37 << setw( 2 ) << segundo;
40
{joseana, rangel}@dsc.ufcg.edu.br
41 // impressão do horário no formato padrão
42 void Horario::imprPadrao()
45 << ":" << setfill( '0' ) << setw( 2 ) <<
minuto
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.
{joseana, rangel}@dsc.ufcg.edu.br
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
de Teste da Classe Horario (2/3)
{joseana, rangel}@dsc.ufcg.edu.br
de Teste da Classe Horario (3/3)
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
{joseana, rangel}@dsc.ufcg.edu.br
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).
{joseana, rangel}@dsc.ufcg.edu.br
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).
03 #include <iostream>
08 #include "Horario1.h"
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).
{joseana, rangel}@dsc.ufcg.edu.br
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’
{joseana, rangel}@dsc.ufcg.edu.br
Default private
Acesso a Membros de Estruturas (struct)
Default public
6.8 Controle de Acesso a Membros
{joseana, rangel}@dsc.ufcg.edu.br
Função get
{joseana, rangel}@dsc.ufcg.edu.br
Funções de Acesso
Funções Utilitárias (funções de ajuda)
private
Não desenvolvidas para uso direto de clientes
{joseana, rangel}@dsc.ufcg.edu.br
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.
{joseana, rangel}@dsc.ufcg.edu.br
22 #include <iostream>
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
{joseana, rangel}@dsc.ufcg.edu.br
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!”;
6.9 Funções de Acesso e Funções Utilitárias – Exemplo (2/4)
Verificação da validade dos dados digitados pelo usuário pela
função de acesso validaVendas.
{joseana, rangel}@dsc.ufcg.edu.br
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).
{joseana, rangel}@dsc.ufcg.edu.br
78 return total;
80
{joseana, rangel}@dsc.ufcg.edu.br
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).
{joseana, rangel}@dsc.ufcg.edu.br
Digite a cifra de vendas do mes 1: 5314.76
Digite a cifra de vendas do mes 2: 4292.38
Digite a cifra de vendas do mes 3: 4589.83
Digite a cifra de vendas do mes 4: 5534.03
Digite a cifra de vendas do mes 5: 4376.34
Digite a cifra de vendas do mes 6: 5698.45
Digite a cifra de vendas do mes 7: 4439.22
Digite a cifra de vendas do mes 8: 5893.57
Digite a cifra de vendas do mes 9: 4909.67
Digite a cifra de vendas do mes 10: 5123.45
Digite a cifra de vendas do mes 11: 4024.97
Digite a cifra de vendas do mes 12: 5923.92
O total de vendas durante o ano eh: R$ 60120.59
6.9 Funções de Acesso e Funções Utilitárias – Exemplo (2/2)
{joseana, rangel}@dsc.ufcg.edu.br
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
19 int segundo; // 0 - 59
20 }; // fim da classe Horario
21 #endif
{joseana, rangel}@dsc.ufcg.edu.br
01 // Horario2.cpp
03 #include <iostream>
13 #include "Horario2.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(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).
{joseana, rangel}@dsc.ufcg.edu.br
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
26 {
30 } // fim da função alteraHorario
31
33 void Horario::imprUniv()
36 << setw( 2 ) << minuto << ":"
37 << setw( 2 ) << segundo;
40
41 // impressão do horário no formato padrão
42 void Horario::imprPadrao()
45 << ":" << setfill( '0' ) << setw( 2 ) <<
minuto
46 << ":" << setw( 2 ) << segundo
49
01 // main.cpp
02 // Demonstração de um construtor default para a classe
Horario.
03 #include <iostream>
04 using std::cout;
05 using std::endl;
07 #include “Horario2.h”
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.
{joseana, rangel}@dsc.ufcg.edu.br
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).
{joseana, rangel}@dsc.ufcg.edu.br
45 return 0;
02:00:00
21:34:00
12:25:42
00:00:00
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
Ordem das chamadas a funções construtoras e destrutoras
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
{joseana, rangel}@dsc.ufcg.edu.br
Ordem das chamadas a funções construtoras e destrutoras
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
{joseana, rangel}@dsc.ufcg.edu.br
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.
{joseana, rangel}@dsc.ufcg.edu.br
01 // Criaedestroi.cpp
03 #include <iostream>
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.
{joseana, rangel}@dsc.ufcg.edu.br
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.
{joseana, rangel}@dsc.ufcg.edu.br
01 // main.cpp
02 // Demonstração da ordem de chamada de construtores e
destrutores
03 #include <iostream>
09 #include “Criaedestroi.h”
11 void CriaeDestroi(void); // protótipo (função p/ a criação de
objetos)
12
17
21
{joseana, rangel}@dsc.ufcg.edu.br
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.
{joseana, rangel}@dsc.ufcg.edu.br
47 CriaeDestroi setimo(7, “(Local automatico em
CriaeDestroi)”);
48
50 } // fim da função CriaeDestroi
Criação de objeto static local na função.
{joseana, rangel}@dsc.ufcg.edu.br
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.
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
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)
{joseana, rangel}@dsc.ufcg.edu.br
23
26
29 int minuto; // 0 - 59
30 int segundo; // 0 - 59
31 }; // fim da classe Horario
32 #endif
6.14 Uso de Funções de Alteração e Retorno de Dados - Horario3.h
(2/2)
{joseana, rangel}@dsc.ufcg.edu.br
03 #include <iostream>
13 #include "Horario3.h"
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)
{joseana, rangel}@dsc.ufcg.edu.br
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
6.14 Uso de Funções de Alteração e Retorno de Dados - Horario3.cpp
(2/4)
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.
{joseana, rangel}@dsc.ufcg.edu.br
43 void Horario::alteraSegundo(int s)
46 } // fim da função alteraSegundo
47
49 void Horario::devolveHora()
53
55 void Horario::devolveMinuto()
59
6.14 Uso de Funções de Alteração e Retorno de Dados - Horario3.cpp
(3/4)
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).
{joseana, rangel}@dsc.ufcg.edu.br
61 void Horario::devolveSegundo()
65
67 void Horario::imprUniv()
71 } // fim da função imprUniv
72
74 void Horario::imprPadrao()
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 - Horario3.cpp
(4/4)
{joseana, rangel}@dsc.ufcg.edu.br
02 // Demonstração de um construtor default para a classe
Horario.
03 #include <iostream>
04 using std::cout;
05 using std::endl;
07 #include “Horario3.h”
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.
{joseana, rangel}@dsc.ufcg.edu.br
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
6.14 Uso de Funções de Alteração e Retorno de Dados - main.cpp
(2/4)
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.
{joseana, rangel}@dsc.ufcg.edu.br
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
6.14 Uso de Funções de Alteração e Retorno de Dados - main.cpp
(3/4)
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.
{joseana, rangel}@dsc.ufcg.edu.br
63 cout << endl;
64 } // fim da função incrementaMinutos
6.14 Uso de Funções de Alteração e Retorno de Dados - main.cpp
(4/4)
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
6.15 Retorno de uma Referência para Membros de Dados private
Referência a um objeto
lvalue
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
{joseana, rangel}@dsc.ufcg.edu.br
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
19 int segundo; // 0 - 59
20 }; // fim da classe Horario
21 #endif
Função para demonstração dos efeitos de retorno de referência para
membro de dados private.
{joseana, rangel}@dsc.ufcg.edu.br
6.15 Retorno de uma Referência para Membros de Dados private
(2/6)
01 // Horario4.cpp
03
05 #include "Horario4.h"
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
{joseana, rangel}@dsc.ufcg.edu.br
6.15 Retorno de uma Referência para Membros de Dados private
(3/6)
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.
{joseana, rangel}@dsc.ufcg.edu.br
6.15 Retorno de uma Referência para Membros de Dados private
(4/6)
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
45 #include "Horario4.h"
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.
{joseana, rangel}@dsc.ufcg.edu.br
6.15 Retorno de uma Referência para Membros de Dados private
(5/6)
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.
{joseana, rangel}@dsc.ufcg.edu.br
6.15 Retorno de uma Referência para Membros de Dados private
(6/6)
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.
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
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>
09 class Data {
12 Data( int = 1, int = 1, int = 2003 ); // construtor
default
13 void imprime();
20
{joseana, rangel}@dsc.ufcg.edu.br
22 Data::Data( int d, int m, int y )
23 {
29
31 void Date::imprime()
35
40
{joseana, rangel}@dsc.ufcg.edu.br
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
{joseana, rangel}@dsc.ufcg.edu.br
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