Aula 5: OO e C++

„ Diagramas
„ De Classes
„ De Caso de Uso
„ De Seqüência
„ 5 Visões de Projeto
„ Classes em C++ Definição
„ Escopo: Public, Private, Protected
„ Exemplo: Inserindo Cliente
„ Contrutor e Destrutor
„ Funções e Classes Friends
„ Ponteiro this
„ Alocação Dinâmica
„ Exemplo: Lista Ligada – Importante Estrutura de Dados
Diagrama de Classes
Vinculo TipoAtividade

1 1

0.. *
0..*
Endereco CCliente HistoricoContatos
1 0..*
1

Localizac ao

0..* 0..* 0..*

PessoaContato CanaisComunicacao HistoricoProduc ao
Diagrama de Caso de Uso
USO DE CASO DOS CLIENTES

+Preenche
Vendedores
Atendente
+Faz

Pedido de Orçamento <<realize>>

+Orçamento

Cliente

Orçamento
Diagrama de Seqüência
:
R e l a c i o n a m e n t o C li e n t e

: Ve n d e d o re s : A te n d e n te
C l i e n te : C l i e n te

P e d i d o d e O rç a m e n t o C l i e n t e fa z p e d i d o
P e d id o O r ç a m e n t o d e o rç a m e n t o a o
a te n d e n te
O rç a m e n t o

O rç a m e n t o

P e d id o O rç a m en t o
P e d id o O r ç a m en t o C l ie n t e fa z p e d i d o
P e d id o O r ç a m e n t o
d e o rç a m e n t o a o
O rç a m e n t o ve n d e d o r

O rç a m e n t o

O rç a m e n t o

C l ie n t e fa z p e d id o de
o rç a m en t o
d ir e t a m e n t e a o
P e d id o de O r ç a m e n t o s is t e m a

O rç a m e n t o
Implatação X Implemtentação
„ Implementação: algo que foi desenvolvido
e está, ou será, implantado.

„ Implantação: fazer uso de recursos já

desenvolvidos
Visões Interligadas

Visão da
Visão de Projeto
Visão de Implementação
Caso de
Uso
Visão do Processo Visão da Implantação
Visão de Caso de Uso
„ Descreve o comportamento do sistema.
„ Visto pelos usuários finais, analistas e pessoal
de teste.
„ Não especifica a organização de um software.
„ Especificam as forças que determinam a forma
da arquitetura do sistema.
„ Os aspectos dinâmicos são capturados em
diagramas de interação, diagramas de estados
e diagramas de atividades.
Visão de Projeto
„ Abrange as classes, interfaces e colaborações que
formam o vocabulário do problema e sua solução.
„ Suporte para os requisitos funcionais do sistema.
„ Serviços que o sistema deverá fornecer a seus
usuários finais.
„ Aspectos estáticos captados em diagramas de
classes e de objetos.
„ Aspectos dinâmicos que são captados em
diagramas de interação, diagramas de gráfico de
estados e diagramas de atividades.
Visão de Processo
„ Abrange os processos que formam os
mecanismos de concorrência e de sincronização
do sistema.
„ Cuida principalmente das questões referentes
ao desempenho, escalabilidade e a saída do
sistema.
„ Aspectos estáticos e dinâmicos captados nos
mesmos tipos de diagramas de visão de projeto.
„ Foco voltado para as classes ativas que
representam esses processos.
Visão de Implementação
„ Componentes e arquivos utilizados para a
montagem e fornecimento do sistema físico.
„ Envolve principalmente o gerenciamento da
configuração das versões do sistema.
„ Os componentes e arquivos de uma certa forma são
independentes e podem ser reunidos de diferentes
formas para a produção de um sistema executável.
„ Os aspectos estáticos são capturados em
diagramas de componentes.
„ Aspectos dinâmicos são capturados em diagramas
de interações, gráficos de estados e atividades
Visão de Implantação
„ Abrange os nós que formam a topologia de
hardware em que o sistema é executado.
„ Direciona principalmente a distribuição, o
fornecimento e a instalação das partes que
constituem o sistema físico.
„ Os aspectos estáticos são capturados em
diagramas de implantação.
„ Os aspectos dinâmicos são capturados em
diagramas de interações, de gráfico de estados
e diagrama de atividades.
5 visões
„ Cada uma dessas cinco visões podem ser
consideradas isoladamente.
„ Permitem que diferentes participantes dirijam seu
foco para os aspectos da arquitetura do sistema que
mais lhes interessa.
„ Interagem entre si.
„ Os nós da visão de implantação contêm
componentes da visão de implementação, que por
sua vez, representa a realização física de classes,
interfaces, colaborações e classes ativas
provenientes das visões de projeto e de processo.
C++: Classe-Escopo
class Nome {
public:
int x;
void coordenada()
{
int y;
cout <<“Coordenada X: ”;
cin >> x;
cout << “Coordenada Y: “;
cin >> y;
}
}
C++: Classe-Escopo
class Nome {
public:
void inserir()
{
cout << “X: “;
cin >> x;
cout << “Y: “;
cin >> y;
}
(protected:) (private:)
int x;
int y;
};
Exemplo: Cadastro Cliente.h
#include <iostream>
#include <string.h>

using std::cout;
using std::cin;
using std::string;

class Clientes{
public:
Clientes();
~Clientes();
void Inserir(void);
void Imprimir(void);
Exemplo: Cadastro Cliente.H
private:
string nome;
string endereco;
}; // Final da Classe
void Clientes::Inserir()
{
cout << "Nome : ";
cin >> nome;
cout << "Endereço : ";
cin >> endereco;
};
void Clientes::Imprimir()
{
cout << "Nome: " << nome << "\nEndereço: " << endereco;
};
Exemplo: ProgramaPrincipal.cpp
#include <iostream.h>
#include <stdlib.h>
#include <string>
using std::string;
using std::cin;
using std::cout;
#include "clientes.h"
int main(int argc, char ** argv)
{
Clientes obj;
obj.Inserir();
obj.Imprimir();
return 0;
}
C++: Construtor
„ Contrutor é uma função membro (método)
com o mesmo nome da classe.
„ É acionado quando um objeto é criado.
„ Construtores podem ser sobrecarregados
„ Principal Funcionalidade: Inicialização do
objeto (Boa prática de Programação e
Engenharia de Software).
„ Erro: Declarar um tipo de retorno para o
construtor.
C++: Destrutor
„ É uma função membro com o mesmo nome da
classe, precedido de ~
„ Chamado quando um objeto é destruído como,
por exemplo, para objetos automáticos, quando a
execução do programa deixar o escopo em que
um objeto foi instanciado.
„ “Complemento do construtor”
„ Um destruir não recebe nenhum argumento e
também não retorna nenhum valor.
„ Não pode ser sobrecarregado.
Exemplo: Contrutor/Destrutor
#include <iostream.h>
using std::cout;
using std::cin;

class cliente {
public:
cliente();
void inserir();
void imprimir();
~cliente();
private:
char * nome;
char * endereco;

};
Exemplo: Construtor/Destrutor
cliente::cliente()
{
nome = (char*) malloc (sizeof(char) * 100);
endereco= (char*) malloc (sizeof(char) * 100);
}

void cliente::inserir()
{
cout << "Nome: ";
cin >> nome;
cout << "Endereço: ";
cin >> endereco;
}
Exemplo: Construtor/Destrutor
void cliente::imprimir()
{
cout << "\nNome: " << nome << "Endereço: " << endereco <<
"\n";
}

cliente::~cliente()
{
free(nome);
free(endereco);
}
Exemplo: Construtor/Destrutor
int main(int argc, char ** argv)
{
cliente obj;
obj.inserir();
obj.imprimir();
return 0;
}
Sobrecarga do Construtor
cliente::cliente()
{
nome = (char*) malloc (sizeof(char) * 100);
endereco= (char*) malloc (sizeof(char) * 100);
}
cliente::cliente(int valor)
{
nome = (char*) malloc (sizeof(char) * valor);
endereco= (char*) malloc (sizeof(char) * valor);
}

Cliente obj;
Cliente obj2(300);
Funções Friend: Quebrando o
Encapsulamento
„ Uma função friend de uma classe é
definida fora do escopo daquela classe,
porém tem direito de acessar membros
private da classe.
„ Melhoria de desempenho (Tempo).
„ Bastante utilizado na sobrecarga de
operadores e para criar classes iteradoras
„ Definição:
friend class Nome;
Friend: Exemplo
#include <iostream.h>
using std::cout;
using std::cin;
class Contador {
friend void AtribuirX(Contador &, int);
public:
Contador() { x=0; }
void imprimir();
private:
int x;
};
void AtribuirX(Contador &c, int val)
{
c.x = val;
}
Friend: Exemplo
void Contador::imprimir()
{
cout << "Valor de X= " << x << "\n";
}
int main(int argc, char ** argv)
{
Contador cont;
cont.imprimir();
cout << "Após chamar a Friend. \n";
AtribuirX(cont, 8);
cont.imprimir();
return 0;
}
Ponteiro: This
„ Todo objeto tem acesso ao seu próprio
endereço através de um ponteiro chamado
this.
„ Não faz parte do objeto.
„ Utilizado implicitamente pra prover
referência tanto para os membros de dados
como para as funções membro de um
objeto.
„ Também pode ser usado explicitamente.
Ponteiro: This
„ Utilizado para evitar que um objeto seja
atribuído a si próprio.
„ Habilitar chamadas a funções membro em
cascata. Exemplo:
class Tempo {
Tempo &Atribuir(int, int, int)
}
void &Tempo::Atribuir(int h, int m, int s)
{
...
return *this;
}
Alocação Dinâmica: New/Delete
„ Modo mais agradável de alocação
dinâmica de memória.
„ Exemplo:
Cliente * obj;
C obj = malloc (sizeof (Cliente) );
C++ obj = new Cliente;
Exemplo: Lista Ligada
#include <iostream.h>
#include <stdlib.h>

struct Livro
{
char titulo[30];
char autor[30];
int numreg;
double preco;
Livro *proximo; // ponteiro para a estrutura Livro
} ;
Exemplo: Lista Ligada
class ListaLigada
{
private :
Livro *fim;
public :
ListaLigada()
{
fim = (Livro *)NULL; // lista vazia
}
void novonome();
void print();
} ;
Exemplo: Lista Ligada
void ListaLigada::novonome()
{
Livro *novolivro = new Livro; // aloca memória
cout << "\nDigite Titulo : ";
cin >> novolivro->titulo; //entra valores
cout << "\nDigite Autor : ";
cin >> novolivro->autor;
cout << "\nDigite o Numero do Registro : ";
cin >> novolivro->numreg;
cout << "\nDigite o Preco : ";
cin >> novolivro->preco;
novolivro->proximo = fim; // encadeia (une os elos)
fim = novolivro; // atualiza ponteiro fim
}
Exemplo: Lista Ligada
void ListaLigada::print()
{
Livro *atual = fim; // inicializa ponteiro de
percurso
while (atual != NULL) // enquanto tiver elos
...
{
cout << "\n\nTitulo : " << atual->titulo; // imprime
campos
cout << "\nAutor : " << atual->autor;
cout << "\nNo.Reg. : " << atual->numreg;
cout << "\nPreco : " << atual->preco;
atual = atual->proximo; // anda com ponteiro
}
}
Exemplo: Lista Ligada
int main( )
{
ListaLigada li;
char opcao;
do // entra com dados
{
li.novonome();
cout << "\nInserir outro livro (s/n) "; cin >> opcao;
}while(opcao == 's');
cout << "\n*********************************";
cout << "\nLista dos Livros cadastrados";
cout << "\n*********************************\n";
li.print(); // imprime a lista
return 0;
}