Está en la página 1de 13

OO - Engenharia de Computação/Eletrônica

Orientação a Objetos
Programação em C++
Slides 10B: Utilização efetiva e desacoplada de Lista
encadeada com templates

Prof. Jean Marcelo SIMÃO


Aluno monitor: Fabiano Cezar Domingos
Melhorando a solução
apresentada nos slides 10...
template<class TIPO> Elemento.h
class Elemento
{
private:
Elemento<TIPO>* pProximo;
Elemento<TIPO>* pAnterior;
TIPO* pInfo;
//char nome[150];

public:
Elemento ( ); Atributo nome da classe
~Elemento ( ); Elemento não deve existir.
Deve-se evitar a replicação
void setProximo ( Elemento<TIPO>* pP ); de dados!
Elemento<TIPO>* getProximo ( );
Dado necessários para uma
void setAnterior ( Elemento<TIPO>* pA ); posterior listagem devem ser
Elemento<TIPO>* getAnterior ( ); obtidos através do ponteiro
pInfo.
void setInfo ( TIPO* pI );
TIPO* getInfo ( );

//void setNome ( char* n );


//char* getNome ( );
};
Elemento.h
template<class TIPO> template<class TIPO>
Elemento<TIPO>::Elemento ( ) void Elemento<TIPO>::setAnterior (
{ Elemento<TIPO>* pA )
pProximo = NULL; pAnterior = NULL; pInfo = {
NULL; pAnterior = pA;
} }

template<class TIPO> template<class TIPO>


Elemento<TIPO>::~Elemento ( ) Elemento<TIPO>* Elemento<TIPO>::getAnterior ( )
{ {
pProximo = NULL; pAnterior = NULL; pInfo = return pProximo;
NULL; }
}
template<class TIPO>
template<class TIPO> void Elemento<TIPO>::setInfo (TIPO* pI )
void Elemento<TIPO>::setProximo ( {
Elemento<TIPO>* pP ) pInfo = pI;
{ }
pProximo = pP;
} template<class TIPO>
TIPO* Elemento<TIPO>::getInfo()
template<class TIPO> {
Elemento<TIPO>* Elemento<TIPO>::getProximo ( ) return pInfo;
{ }
return pProximo;
}
template<class TIPO> Lista.h
class Lista
{
private:
Elemento<TIPO>* pPrimeiro;
Elemento<TIPO>* pAtual;

public:

Lista ( );
~Lista ( );

void inicializa ( );
void limpar(); A Lista template não deve
possuir métodos para
bool incluaElemento ( Elemento<TIPO>* pElemento ); listar os seus dados. Não
bool incluaInfo (TIPO* pInfo ); há como generalizar os
algoritmos de listagem.
//void listeInfos ( );

Elemento<TIPO>* getpPrimeiro();
Elemento<TIPO>* getpAtual();

};
Lista.h
template<class TIPO> template<class TIPO>
Lista<TIPO>::Lista ( ) void Lista<TIPO>::limpar ( )
{ {
inicializa ( ); Elemento<TIPO>* paux1;
} Elemento<TIPO>* paux2;

template<class TIPO> paux1 = pPrimeiro;


Lista<TIPO>::~Lista ( ) paux2 = paux1;
{
limpar(); while (paux1 != NULL)
} {
paux2 = paux1->getProximo();
template<class TIPO> delete (paux1);
void Lista<TIPO>::inicializa ( ) paux1 = paux2;
{ }
pPrimeiro = NULL;
pAtual = NULL; pPrimeiro = NULL;
} pAtual = NULL;
template<class TIPO> }
Elemento<TIPO>* Lista<TIPO>::getpPrimeiro()
{
return pPrimeiro;
}
template<class TIPO>
Elemento<TIPO>* Lista<TIPO>::getpAtual()
{
return pAtual;
}
Lista.h
template<class TIPO> template<class TIPO>
bool Lista<TIPO>::incluaInfo (TIPO *pInfo ) bool Lista<TIPO>::incluaElemento (
{ Elemento<TIPO>* pElemento )
if (NULL != pInfo) {
{ if (NULL != pElemento)
Elemento<TIPO>* pElemento = NULL; {
pElemento = new Elemento<TIPO>();
pElemento->setInfo (pInfo); if (NULL == pPrimeiro)
incluaElemento (pElemento); {
return true; pPrimeiro = pElemento;
} pPrimeiro->setAnterior ( NULL );
else pPrimeiro->setProximo ( NULL );
{ pAtual = pPrimeiro;
printf ( "Erro, elemento (informação) nulo(a) }
na lista. \n" ); else
return false; {
} pElemento->setAnterior ( pAtual );
} pElemento->setProximo ( NULL );
pAtual->setProximo ( pElemento );
pAtual = pAtual->getProximo ( );
}
return true;
}
else
{
cout << "Erro, elemento nulo na lista." <<
endl;
return false;
}
}
ListaAlunos.h

class ListaAlunos
A classe ListaAlunos
{
private:
armazenará os
apontamentos de aluno
//template class através de uma Lista
Lista< Aluno > LTAlunos; template parametrizada
public: com Aluno.

ListaAlunos();
~ListaAlunos(); Os métodos limpar() e
incluaAluno() chamam
void limpaLista(); diretamente os métodos
void incluaAluno(Aluno* pa); da Lista template, visto
que o código é
void listeAlunos(); generalizado.
void listeAlunos2();

void graveAlunos(); Já o algoritmos de


void recupereAlunos(); listagem para os Alunos
}; são específicos e são
definidos nesta classe.
ListaAlunos.cpp
ListaAlunos::ListaAlunos() void ListaAlunos::listeAlunos()
{ } {
Elemento<Aluno>* pElAux = NULL;
ListaAlunos::~ListaAlunos() Aluno* pAlAux = NULL;
{ pElAux = LTAlunos.getpPrimeiro();
limpaLista();
} while (NULL != pElAux)
{
void ListaAlunos::limpaLista() pAlAux = pElAux->getInfo();
{ cout << " Aluno " << pAlAux->getNome() << "
LTAlunos.limpar(); com RA " << pAlAux->getRA() << "." << endl;
} pElAux = pElAux->getProximo();
}
void ListaAlunos::incluaAluno ( Aluno* pa ) }
{ void ListaAlunos::listeAlunos2()
if(NULL != pa) {
LTAlunos.incluaInfo(pa); Elemento<Aluno>* pElAux = NULL;
else Aluno* pAlAux = NULL;
cout << "Erro! Aluno não incluído. Ponteiro Aluno pElAux = LTAlunos.getpAtual();
inválido." << endl;
} while (NULL != pElAux)
{
void ListaAlunos::graveAlunos() pAlAux = pElAux->getInfo();
{…} cout << " Aluno " << pAlAux->getNome() << "
com RA " << pAlAux->getRA() << "." << endl;
void ListaAlunos::recupereAlunos() pElAux = pElAux->getAnterior();
{…} }
}
class Disciplina Disciplina.h
{
private:
int id;
int cont_alunos;
int numero_alunos;
char nome[150];
char area_conhecimento[150];
A classe Disciplina irá
Departamento* DeptoAssociado; gerenciar os seus
ListaAlunos ObjLAlunos; ponteiros de Aluno
através de 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* d); Como os métodos de
Departamento* getDepartamento(); inclusão e listagem já
foram definidos na classe
void incluaAluno(Aluno* pa); ListaAlunos, basta
void listeAlunos();
chamá-los diretamente.
void listeAlunos2();
};
Disciplina.cpp
Disciplina::Disciplina(int i, int na, char* ac) void Disciplina::incluaAluno ( Aluno* pa )
{ {
id = i; if(NULL != pa)
cont_alunos = 0; {
numero_alunos = na; if (( cont_alunos < numero_alunos ) || ( -1 ==
DeptoAssociado = NULL; numero_alunos))
strcpy (area_conhecimento, ac ); {
} ObjLAlunos.incluaAluno(pa);
cont_alunos++;
Disciplina::~Disciplina() }
{ else
DeptoAssociado = NULL; {
} cout << "Aluno não incluído. Turma já
lotada em " << numero_alunos << " alunos." <<
… endl;
}
void Disciplina::listeAlunos()
{ }
cout << "\n\nAlunos matriculados na disciplina " else
<< area_conhecimento << ": "<< endl; {
ObjLAlunos.listeAlunos(); cout << "Erro! Aluno não incluído. Ponteiro
} Aluno inválido." << endl;
}
void Disciplina::listeAlunos2() }
{
cout << "\n\nAlunos matriculados na disciplina "
<< area_conhecimento << ": "<< endl;
ObjLAlunos.listeAlunos2();
}
Exercícios Propostos
• 1) Conforme Slides 12, fazer com que
Elemento<Tipo> seja uma classe aninhada
(privada) de Lista<Tipo>.
– Exemplo de Lista template com Elemento aninhada
disponível em:
http://pessoal.utfpr.edu.br/jeansimao/ProgramacaoAv
ancada/Provas/MA3.cpp
• 2) Substituir o objeto de Lista template
LTAlunos na classe ListaAlunos por um vector
ou list da STL, seguindo os Slides 16.