Orientação a Objetos - Programação em C++

Apresentação em tema: "Orientação a Objetos - Programação em C++"— Transcrição da apresentação:

1 Orientação a Objetos - Programação em C++
OO – Engenharia Eletrônica Orientação a Objetos - Programação em C++ Slides 10: 10.1 Noção de Evento. 10.2 Gabaritos ou Templates. Prof. Jean Marcelo SIMÃO

2 Primeira Parte Eventos - Recursão

3 Eventos Noções de: Programação orientada a eventos
Conceitos de estados e eventos. Comunicação entre objetos via eventos.

4 Evento void Principal::MenuCad ( ) { int op = -1; while (op != 5)
system("cls"); cout << " Informe sua opção: " << endl; cout << " 1 - Cadastrar Disciplina. " << endl; cout << " 2 - Cadastrar Departamentos. " << endl; cout << " 3 - Cadastrar Universidade. " << endl; cout << " 4 - Cadastrar Aluno. " << endl; cout << " 5 – Sair. " << endl; cin >> op; switch ( op ) case 1 : { CadDisciplina (); } break; case 2: { CadDepartamento (); } case 3: { CadUniversidade (); } case 4: { CadAluno (); } case 5: { cout << " FIM " << endl; } default: { cout << "Opção Inválida - Pressione uma tecla." << endl; getchar(); } Evento

5 Um evento dispara a execução deste método...
void Principal::CadDepartamento ( ) { char nomeUniversidade [150]; char nomeDepartamento [150]; Universidade* univ; Departamento* depart; cout << "Qual o nome da universidade do departamento" << endl; cin >> nomeUniversidade; univ = LUniversidades.localizar (nomeUniversidade); if ( univ != NULL ) cout << "Qual o nome do departamento" << endl; cin >> nomeDepartamento; depart = new Departamento ( ); depart->setNome ( nomeDepartamento ); depart->setUniversidade ( univ ); LDepartamentos.incluaDepartamento ( depart ); } else cout << "Universidade inexistente." << endl; } ...que promove a comunicação entre alguns objetos... ...e que promove a alteração de estados de outros objetos.

6 Gabaritos ou Templates
Segunda Parte Gabaritos ou Templates

7 Retomando conteúdo anterior
- Cada Disciplina deve ser capaz de armazenar uma lista de Alunos. - A classe Aluno, entretanto, não deverá possuir um ponteiro para o Próximo. Isto deverá estar em uma classe associada chamada ElAluno relacionada a classe LAlunos... Reflexão: Esta solução de criar uma classe El‘Algo’ cada vez que se faz necessário uma lista em um classe dada, parece-lhes uma solução inteligente ou mesmo razoável? Não seria melhor ter um classe Elemento genérica para tratar disto?

8 Gabaritos ou Templates
#ifndef _ELEMENTO_H_ #define _ELEMENTO_H_ // Um gabarito se define inteiramente no .h template<class TIPO> class Elemento { private: Elemento<TIPO>* pProximo; Elemento<TIPO>* pAnterior; TIPO* pInfo; char nome[150]; public: Elemento ( ); ~Elemento ( ); void setProximo ( Elemento<TIPO>* pp ); Elemento<TIPO>* getProximo ( ); void setAnterior ( Elemento<TIPO>* pa ); Elemento<TIPO>* getAnterior ( ); void setInfo ( TIPO* pi ); TIPO* getInfo ( ); void setNome ( char* n ); char* getNome ( ); }; Gabaritos permitem criar classes genéricas... Vejamos um exemplo:

9 #ifndef _ELEMENTO_H_ #define _ELEMENTO_H_ // Um gabarito se define inteiramente no .h template<class TIPO> class Elemento { private: Elemento<TIPO>* pProximo; Elemento<TIPO>* pAnterior; TIPO* pInfo; char nome [ 150 ]; public: Elemento ( ); ~Elemento ( ); void setProximo ( Elemento<TIPO>* pp ); Elemento<TIPO>* getProximo ( ); void setAnterior ( Elemento<TIPO>* pa ); Elemento<TIPO>* getAnterior ( ); void setInfo ( TIPO* pi ); TIPO* getInfo ( ); void setNome ( char* n ); char* getNome ( ); }; template<class TIPO> Elemento<TIPO>* Elemento<TIPO>::getProximo ( ) { return pProximo; } void Elemento<TIPO>::setAnterior ( Elemento<TIPO>* pa ) pAnterior = pa; Elemento<TIPO>* Elemento<TIPO>::getAnterior ( ) void Elemento<TIPO>::setInfo ( TIPO* pi ) pInfo = pi; TIPO* Elemento<TIPO>::getInfo ( ) return pInfo; void Elemento<TIPO>::setNome ( char* n ) strcpy ( nome, n ); char* Elemento<TIPO>::getNome () return nome; #endif template<class TIPO> Elemento<TIPO>::Elemento ( ) { pProximo = NULL; pAnterior = NULL; pInfo = NULL; } void Elemento<TIPO>::setProximo ( Elemento<TIPO>* pp ) pProximo = pp;

10 Atenção: Templates são implementados somente no
Atenção: Templates são implementados somente no .h, incluindo a implementação dos métodos! #ifndef _ELEMENTO_H_ #define _ELEMENTO_H_ // Um gabarito se define inteiramente no .h template<class TIPO> class Elemento { private: Elemento<TIPO>* pProximo; Elemento<TIPO>* pAnterior; TIPO* pInfo; char nome [ 150 ]; public: Elemento ( ); ~Elemento ( ); void setProximo ( Elemento<TIPO>* pp ); Elemento<TIPO>* getProximo ( ); void setAnterior ( Elemento<TIPO>* pa ); Elemento<TIPO>* getAnterior ( ); void setInfo ( TIPO* pi ); TIPO* getInfo ( ); void setNome ( char* n ); char* getNome ( ); }; template<class TIPO> Elemento<TIPO>* Elemento<TIPO>::getProximo ( ) { return pProximo; } void Elemento<TIPO>::setAnterior ( Elemento<TIPO>* pa ) pAnterior = pa; Elemento<TIPO>* Elemento<TIPO>::getAnterior ( ) void Elemento<TIPO>::setInfo ( TIPO* pi ) pInfo = pi; TIPO* Elemento<TIPO>::getInfo ( ) { return pInfo; void Elemento<TIPO>::setNome ( char* n ) { strcpy ( nome, n ); char* Elemento<TIPO>::getNome () { return nome; #endif template<class TIPO> Elemento<TIPO>::Elemento ( ) { pProximo = NULL; pAnterior = NULL; pInfo = NULL; } void Elemento<TIPO>::setProximo ( Elemento<TIPO>* pp ) { pProximo = pp;

11 #ifndef _LISTAALUNOS_H_
#define _LISTAALUNOS_H_ #include "Elemento.h" #include "Aluno.h" class ListaAlunos { private: int cont_alunos; int numero_alunos; char nome [ 150 ]; Elemento<Aluno> *pElAlunoPrim; Elemento<Aluno> *pElAlunoAtual; public: ListaAlunos ( int na = -1, char* n = "" ); ~ListaAlunos ( ); void limpaLista ( ); void incluaAluno ( Aluno* pa ); void listeAlunos ( ); void listeAlunos2 ( ); void graveAlunos ( ); void recupereAlunos ( ); }; #endif #include "stdafx.h" #include "ListaAlunos.h" ListaAlunos::ListaAlunos (int na, char* n) { numero_alunos = na; cont_alunos = 0; ElAlunoPrim = NULL; ElAlunoAtual = NULL; strcpy (nome, n ); } ListaAlunos::~ListaAlunos () limpaLista (); void ListaAlunos::limpaLista () Elemento<Aluno> *paux1; Elemento<Aluno> *paux2; paux1 = pElAlunoPrim; paux2 = paux1; while ( paux1 != NULL ) paux2 = paux1->getProximo(); delete ( paux1 ); paux1 = paux2; pElAlunoPrim = NULL; pElAlunoAtual = NULL;

12 void ListaAlunos::incluaAluno ( Aluno* pa )
{ // Aqui é criado um ponteiro para LAluno Elemento <Aluno>* paux; // Aqui é criado um objeto LAluno, // sendo seu endereço armazenado em aux paux = new Elemento<Aluno>( ); paux->setNome ( pa->getNome() ); // Aqui recebe uma ref do objeto interm. paux->setInfo ( pa ); if ( ( ( cont_alunos < numero_alunos ) && ( pa != NULL ) ) || ( ( -1 == numero_alunos) && ( pa != NULL ) ) ) { if ( pElAlunoPrim == NULL ) pElAlunoPrim = paux; pElAlunoAtual = paux; } else pElAlunoAtual->setProximo ( paux ); paux->setAnterior ( pElAlunoAtual ); pElAlunoAtual = paux; cont_alunos++; cout << "Aluno não incluído. Turma já lotada em " << numero_alunos << " alunos." << endl; void ListaAlunos::listeAlunos ( ) { Elemento < Aluno >* paux; paux = pElAlunoPrim; while ( paux != NULL ) cout << " Aluno " << paux->getNome() << " matriculado na Disciplina " << nome << "." << endl; paux = paux->getProximo(); }

13 void ListaAlunos::incluaAluno ( Aluno* pa )
{ // Aqui é criado um ponteiro para LAluno Elemento <Aluno>* paux; // Aqui é criado um objeto LAluno, // sendo seu endereço armazenado em aux paux = new Elemento<Aluno>( ); // paux->setNome ( pa->getNome() ); // Aqui recebe uma ref do objeto interm. paux->setInfo ( pa ); if ( ( ( cont_alunos < numero_alunos ) && ( pa != NULL ) ) || ( ( -1 == numero_alunos) && ( pa != NULL ) ) ) { if ( pElAlunoPrim == NULL ) pElAlunoPrim = paux; pElAlunoAtual = paux; } else pElAlunoAtual->setProximo ( paux ); paux->setAnterior ( pElAlunoAtual ); pElAlunoAtual = paux; cont_alunos++; cout << "Aluno não incluído. Turma já lotada em " << numero_alunos << " alunos." << endl; void ListaAlunos::listeAlunos ( ) { Elemento < Aluno >* paux; paux = pElAlunoPrim; while ( paux != NULL ) cout << " Aluno " << paux->getNome() << " matriculado na Disciplina " << nome << "." << endl; paux = paux->getProximo(); } void ListaAlunos::listeAlunos ( ) { Aluno * pauxAl = NULL Elemento < Aluno >* pauxEL = NULL; pauxEL = pElAlunoPrim; while ( pauxEL != NULL ) pauxAl = pauxEL->getInfo(); cout << " Aluno " << pauxAl->getNome() << " matriculado na Disciplina " << nome << "." << endl; pauxEL = pauxEL->getProximo(); }

14 Retomando o exercício anterior
- Cada Departamento deve ser capaz de armazenar uma lista de disciplinas. - A classe Disciplina, entretanto, não deverá possuir um ponteiro para o Próximo. Isto deverá estar em uma classe associada chamada “ElDisciplina” relacionada a LDisciplina... Utilizar o gabarito template<class TIPO> class Elemento para resolver o exercício em questão

15 Reflexão Continuando Reflexão: A solução utilizando o gabarito template<class TIPO> class Elemento facilita a composição de listas em um classe. Mas o tratamento de inclusão e consulta da lista em cada classe que necessita de uma lista parece-lhes uma solução inteligente ou mesmo razoável? Não seria melhor ter um classe Lista genérica para tratar disto?

16 #ifndef _LISTA_H_ #define _LISTA_H_ #include "Elemento.h" template<class TIPO> class Lista { private: Elemento<TIPO>* pPrimeiro; Elemento<TIPO>* pAtual; public: Lista ( ); ~Lista ( ); void inicializa ( ); bool incluaElemento ( Elemento<TIPO>* pElemento ); bool incluaInfo ( TIPO* pInfo, char* nome = "" ); void listeInfos ( ); }; Lista<TIPO>::Lista ( ) inicializa ( ); } Lista<TIPO>::~Lista ( ) // Fazer código de desalocação... template<class TIPO> void Lista<TIPO>::inicializa ( ) { pPrimeiro = NULL; pAtual = NULL; } bool Lista<TIPO>::incluaElemento ( Elemento<TIPO>* pElemento ) if (NULL != pElemento) if (NULL == pPrimeiro) pPrimeiro = pElemento; pAtual = pPrimeiro; else pElemento->setAnterior ( pAtual ); pElemento->setProximo ( NULL ); pAtual->setProximo ( pElemento ); pAtual = pAtual->getProximo ( ); return true; cout << " Erro, elemento nulo na lista. " << endl; return false;

17 template<class TIPO>
bool Lista<TIPO>::incluaInfo ( TIPO * pInfo, char* nome ) { if (NULL != pInfo) Elemento<TIPO>* pElemento; pElemento = new Elemento<TIPO>(); pElemento->setNome ( nome ); pElemento->setInfo ( pInfo ); incluaElemento ( pElemento ); return true; } else printf ( "Erro, elemento (informação) nulo(a) na lista. \n" ); return false; void Lista<TIPO>::listeInfos ( ) Elemento<TIPO>* pAux; pAux = pPrimeiro; if (NULL != pPrimeiro ) while ( NULL != pAux ) printf ( " Elemento na lista %s \n", pAux->getNome() ); pAux = pAux->getProximo(); #endif

18 class Disciplina { private: int id; char nome [150]; char area_conhecimento [150]; Departamento* pDeptoAssociado; Lista < Aluno > ObjLAlunos; public: Disciplina ( int i, int na = 45, char* ac = "" ); ~Disciplina ( ); void setId ( int i ); int getId (); void setNome (char* n); char* getNome (); void setDepartamento (Departamento* pd); Departamento* getDepartamento ( ); void incluaAluno ( Aluno* pa ); void listeAlunos ( ); void listeAlunos2 ( ); }; #endif #include "stdafx.h" #include "Disciplina.h" Disciplina::Disciplina (int i, int na, char* ac): ObjLAlunos () { id = i; pDeptoAssociado = NULL; strcpy (area_conhecimento, ac ); } Disciplina::~Disciplina () DeptoAssociado = NULL; void Disciplina::setId ( int i ) int Disciplina::getId ( ) return id; Disciplina.h Disciplina.cpp

19 void Disciplina::setNome ( char* n )
{ strcpy ( nome, n ); } char* Disciplina::getNome ( ) return nome; void Disciplina::setDepartamento (Departamento* pd) // Cada vez que um Departamento // é associado a uma Disciplina, // esta Disciplina passa a fazer // parte da lista de disciplina // do Departamento, por meio do comando abaixo. pDeptoAssociado = pd; pDeptoAssociado->incluaDisciplina ( this ); Departamento* Disciplina::getDepartamento ( ) return DeptoAssociado; void Disciplina::incluaAluno ( Aluno* pa ) ObjLAlunos.incluaInfo ( pa, pa->getNome() ); void Disciplina::listeAlunos () { ObjLAlunos.listeInfos (); } void Disciplina::listeAlunos2 ( ) // ObjLAlunos.listeAlunos2 (); Disciplina.cpp

20 void Disciplina::setNome ( char* n ) { strcpy ( nome, n ); }
char* Disciplina::getNome ( ) return nome; void Disciplina::setDepartamento (Departamento* pd) // Cada vez que um Departamento // é associado a uma Disciplina, // esta Disciplina passa a fazer // parte da lista de disciplina // do Departamento, por meio do comando abaixo. pDeptoAssociado = pd; pDeptoAssociado->incluaDisciplina ( this ); Departamento* Disciplina::getDepartamento ( ) return DeptoAssociado; void Disciplina::incluaAluno ( Aluno* pa ) ObjLAlunos.incluaInfo ( pa ); void Disciplina::listeAlunos () { // ObjLAlunos.listeInfos (); Elemento<Aluno>* pAux; pAux = ObjLAluno.getPrimeiro(); if (NULL != pPrimeiro ) while ( NULL != pAux ) Aluno* pAluno = NULL; pAluno = pAux->getInfo(); printf ( " Elemento na lista %s %d \n", pAluno->getNome(), pAluno->getRA() ); pAux = pAux->getProximo(); } void Disciplina::listeAlunos2 ( ) // ObjLAlunos.listeAlunos2 (); Disciplina.cpp

21 Exercícios a) Substituir todas as outras listas ‘específicas’ elaboradas nas versões anteriores do ‘sistema exemplo’, por ‘instâncias’ do gabarito ou template desenvolvido para o tratamento de listas. b) Estender o template de Lista desenvolvido para que suas instâncias tenham a ‘capacidade’ de gravar e recuperar as informações incluídas nela. c) Retomando um exercício anterior: - Elaborar uma solução para o armazenar as notas (1a parcial, 2a parcial e final) e número de faltas de cada aluno em cada disciplina.

22 Templates em UML (conceito de dependência)
Aluno CONHECER 1 1..* Departamento -RA: int -id: int -nome: char[100] <<destroy>>+Aluno() +. . . <<create>>+Aluno(i: int) +objtLAlunos: Lista<Aluno> +setRA(ra: int): void +getRA(): int <<create>>+Departamento(i: int) 1..* CONHECER 1 +setDepartamento(d: Departamento*): void <<destroy>>+Departamento() +getDepartamento(): Departamento* +getId(): int +setId(i: int): void +setNome(n: char*): void +getId(): int +getNome(): char* +incluaAluno(a: Aluno*): void +listeAlunos(): void +. . .() 1 Tipo Elemento 1 -nome: char[100] Tipo <<create>>+Elemento(info: Tipo*, nome: char*) ConhecerPrimeiro Lista <<destroy>>+~Elemento() +setInfo(info: Tipo*): void 0..1 0..1 <<create>>+Lista() +getInfo(): Tipo* <<destroy>>+~Lista() +setNome(n: char*): void 0..1 0..1 +incluaElemento(elemento: *Elemento<Tipo>): void ConhecerAtual +getNome(): char* +inicializa(): void +incluaInfo(info: *Tipo, char* n): void 0..1 0..1 0..1 0..1 +listeInfos(): void ConhecerProximo ConhecerAnterior

23 Templates em UML (conceito de dependência)
Aluno CONHECER 1 1..* Departamento -RA: int -id: int -nome: char[100] <<destroy>>+Aluno() +. . . <<create>>+Aluno(i: int) +objtLAlunos: Lista<Aluno> +setRA(ra: int): void +getRA(): int <<create>>+Departamento(i: int) +setDepartamento(d: Departamento*): void <<destroy>>+Departamento() +getDepartamento(): Departamento* +getId(): int +setId(i: int): void +setNome(n: char*): void +getId(): int +getNome(): char* +incluaAluno(a: Aluno*): void +listeAlunos(): void +. . .() 1 Tipo Elemento 1 -nome: char[100] Tipo <<create>>+Elemento(info: Tipo*, nome: char*) ConhecerPrimeiro Lista <<destroy>>+~Elemento() +setInfo(info: Tipo*): void 0..1 0..1 <<create>>+Lista() +getInfo(): Tipo* <<destroy>>+~Lista() +setNome(n: char*): void 0..1 0..1 +incluaElemento(elemento: *Elemento<Tipo>): void ConhecerAtual +getNome(): char* +inicializa(): void +incluaInfo(info: *Tipo, char* n): void 0..1 0..1 0..1 0..1 +listeInfos(): void ConhecerProximo ConhecerAnterior