E aqui eu tenho um exercício bastante interessante também,
mas que revém o mesmo, tá.
Mas é legal, porque isso permite vocês exercitarem e chegarem em uma reflexão.
Cada Universidade deve ser capaz de armazenar uma lista de Departamentos.
Faz sentido.
Isso é novo, tá. Isso não tinha ocorrido ainda.
A classe Departamento, entretanto,
não deverá possuir um ponteiro para o Próximo.
Verdade, tá. Porque isso é acoplante.
Isso deverá estar
em uma classe associada chamada Elemento Departamento
relacionada a ListaDepartamento.
Inclusive, aqui pode ser no plural, né. ListaDepartamentos.
Pessoal, o que vocês vão ver que vocês vão criar, na verdade,
é a ListaDepartamento, ElDepartamento.
Aí vocês vão ver que a inclusão de...
na ListaDepartamentos, a inclusão de Departamento,
ela vai usar um algoritmo muito similar
ao que aconteceu lá na inclusão de Alunos
e na inclusão de Disciplinas, cada qual na sua respectiva lista.
Você vai perceber que os algoritmos de listagem
também são muito parecidos.
O que muda, entretanto, é que num caso
é ListaDisciplina e o ElDisciplina.
O outro caso é a ListaAluno com o ElAluno.
No outro caso vai ser, que é o caso posto agora,
a ListaDepartamento com o ElDepartamento.
O que muda na verdade, é a coisa tratada,
mas a lógica de tratamento é muito similar.
O que, muito que obviamente, leva a reflexão: Pô, professor
se o que muda é só a coisa tratada
não tem uma maneira, então, de eu fugir dessa situação
de eu ter que criar listas específicas.
Como acontece aqui com a ListaDepartamento
Não tem uma maneira de eu criar uma coisa genérica, criar uma lista,
por exemplo, que seja parametrizada com o tipo Departamento?
E aí, aquela lista vai se adaptar pra cada Departamento?
Não tem como eu
criar, sei lá, o... usando outro exemplo. Usando a mesma classe Lista,
mas parametrizada com outra coisa, com Aluno,
gerando uma lista de Alunos?
Tem.
Tem e isso são os templates.
Tanto tem que se você olhar lá as nossas aulas anteriores
olhar aquela biblioteca genérica que tem que é a STL,
ela é a Standard Template Library. Biblioteca Padrão de Templates ou Gabaritos.
E a gente consegue programar os nossos templates.
Então, depois, em uns slides aqui pra frente
se eu não tô equivocado, lá pelo slide... lá pelo Grupo de Slide número 10.
melhor dizendo.
A gente vai aprender a criar os nosso templates.
A gente vai criar a nossa lista que vai ser template.
Por ora, vocês vão criar essas listas específicas mesmo,
mas depois a gente vai criar uma lista mais genérica quanto for possível.
Inclusive, a gente vai notar depois
que não é tudo que a gente consegue fazer genérico.
Você consegue fazer uma parte genérica
e outras partes vão ter que ser específicas,
mas o que for genérico a gente consegue sim generalizar
usando o artifício de templates disponibilizado pela linguagem C++.
Mas, muita calma nessa hora, tá.
Primeiro acostumem a fazerem essas específicas
utilizarem elas bastante, brincarem com elas bastante, tá.
Para depois, que vocês estiverem maduros,
na composição das específicas e no seu uso
que vocês vão migrar pra trabalhar com a história de
templates e criar listas templates, por exemplo, tá.
Ou uma lista template que permite criar várias listas
parametrizando a lista template em questão.
Inclusive, nesse grupo de slide em questão, e mais alguns grupos pra frente aí
Aqui nós estamos em qual Grupo? No Grupo 6, né.
Lá no Grupo 7 ainda, eu vou continuar usando listas específicas, tá.
E mais alguns slides pra frente conforme a situação.
E como eu dizia, lá pelo Grupo de Slides 10, que a gente daí vai
se dedicar a fazer nossa lista template.
Se não for o 10 é perto do 10, mas eu tô quase certo que é o 10.
Bom, isso considerado, até pra gente se acostumar a utilizar uma lista em específico
eu gostaria que vocês parassem um momento e lessem esse exercício.
Exercício 3.
Até então, os objetos têm sido criados de forma 'estática',
ou seja, na unha, por assim dizer,
dentro da classe principal.
Assim sendo,
todos os objetos criados são estabelecidos à priori.
Claro, com exceção dos Elementos, né,
que são criados em tempo de execução
à medida que eu vou jogando os caras dentro das listas.
Bom, enfim,
Elabore uma solução com um menu, um conjunto de opções,
no qual o usuário pode escolher
que elementos quer 'cadastrar',
que objetos quer criar, portanto,
por exemplo Universidades, Departamentos e Disciplinas.
A partir das informações disponibilizadas pelo usuário.
instanciar então, dinamicamente, os objetos.
Agora vai ficar um sistema com uma cara mais profissional, tá, gente.
Antes a gente tava criando as Universidades na unha,
dentro do código.
Os Departamentos na unha, as Disciplinas na unha, os Professores na unha.
Mas não é assim que funciona um sistema real, né.
Imaginem no Sistema Acadêmico eu quero cadastrar uma nova Universidade.
Eu quero cadastrar a USP.
Eu quero cadastrar o ITA. Quero cadastrar a UEPG.
A UEM, a UEL, a Unicentro a Unioeste.
Aqui do... essas universidades do Paraná são Universidades também.
Quero cadastrá-las no sistema.
Como é que eu vou fazer? Eu vou ter que parar o sistema,
abrir o Principal lá .h,
instanciá-las na unha, recompilar tudo,
Pra fazer o sistema funcionar?
Não, né, gente.
Via de regra não, tá. Não nesse tipo de sistema, tá.
Existe outros sistemas
que os objetos não têm essa dinâmica, os objetos são criados mais estaticamente.
Ah, tem exemplo? Tem, tem exemplo.
Imagine, sei lá, controladores de automóveis, controladores de avião.
Ali você já tem objetos criados estaticamente,
porque você já sabe quais são os objetos que existe
É um universo fechado de discurso.
Aí você cria estaticamente.
Inclusive, nesse caso, é aconselhado fazer estaticamente,
porque são sistemas mais críticos esses exemplificados.
Aonde eu não quero ter nenhuma intercorrência
com o tempo de alocação e desalocação de memória.
Já em outros sistemas de universo mais aberto
como esse que a gente tá discutindo aqui, tá. Um Sistema Acadêmico.
Aí sim, vamos utilizar de alocação de memória dinâmica e desalocação dinâmica, né.
E não vou criar tudo na unha.
Vou criar as coisas via artifícios outros como esse, aí, de ter um menu.
Então, eu gostaria que vocês parassem um pouco o slide
e resolvessem o exercício, tentassem resolver o exercício com a maior calma
Gastem um tempo com isso
e depois voltasse aqui pro nosso slide pra ver a solução que eu tô propondo.
Bom, pessoal, retomando
supondo que vocês fizeram o exercício.
Então, o que acontece aqui?
Vocês, muito que provavelmente,
vão chegar numa solução mais ou menos assim, tá.
Vocês vão criar, olha que interessante, na classe Principal agora,
um LUniversidades, um LDepartamentos e um LDisciplinas,
respectivamente, instâncias, objetos
de ListaUniversidade, ListaDepartamentos e ListaDisciplinas.
E por que que cês fazem essa instanciação, aqui, desses atributos?
Porque cês vão criar dinamicamente, agora, objetos.
Universidade, Departamento e Disciplina.
Entretanto, se eu vou criar dinamicamente eu tenho que armazenar eles em algum lugar
Não posso perder esses endereços
e, justamente, eu vou armazenar eles em listas encadeadas.
Ainda bem que, muito que felizmente,
vocês criaram listas, classes-listas desacopladas
que permite essa coesão aqui agora.
Que permite isso aqui agora.
Se vocês não tivessem criado,
vocês iam ter que fazer código imbricado no meio aqui
pra inclusão de Universidades, Departamentos e Disciplinas.
Criar um monte de ponteiro pPrimeiro e pAtual pra cada situação posta
e ia ficar um caos.
E aqui a gente tá deixando a coisa elegante.
Essas reticências, pessoal, continua tendo todos os códigos que já tinha anteriormente.
Eu mantive lá os objetos criados estaticamente
Professores, Alunos.
O que mais? Universidades, Disciplinas e Departamentos.
Até pra vocês verem que é possível coabitar...
coabitar objetos estáticos com objetos dinâmicos.
Isso é interessante, inclusive, de ser dito.
Agora, aqui, além dos códigos que já existiam,
a construtora, a destrutora que não consigo mostrar aqui,
porque é o código que tá nas reticências.
O Inicializa, o Executar.
Eu criei também umas coisas a mais.
Olha só, tem o Cadastro da Disciplina,
o Cadastra Departamento e o Cadastra Universidade.
Também tem os menus.
Tem o Menu Cadastrar e tem o Menu Executar.
O menu, na verdade, tá aqui, ó, já na direita.
Aliás, o Principal, inclusive,
agora eu tô chamando só o menu, não tô chamando todo o resto.
Ah, professor, mas eu queria chamar o resto. Você pode.
Você pode.
Quero continuar chamando o resto. Então, não tem problema.
Você, no seu código, você continua chamando o resto.
Vamos resolver isso pra você aqui.
Pronto. Resolvido.
Legal.
Ele vai fazer o Calc_Idade, ele vai fazer tudo que é pertinente.
Bom, e aí, ele vai chamar o Menu por último.
No menu ele vai dizer pro usuário o seguinte:
Isso daqui é o menu de Fundamentos de Programação 1, tá.
De Computação 1 que seja.
Limpa a tela.
Aqui eu tô usando o comando system, tá.
Esse comando system é um comando que permite você no,
no caso do Windows,
imagino que no Linux tenha coisa parecida
que é limpar a tela.
Aqui, eu tô mandando o console.
Tô mandando executar um comando no console.
Console porque isso aqui é um projeto de console, tá.
É um projeto textual, né.
Eu rodo no console de texto do Windows
que é o antigo DOS, mas tudo bem.
Então, ele limpa aquele console.
Clear Screen.
Então, ele vai lá no console e limpa o console
aonde eu vou imprimir esses dados aqui,
usando o dispositivo de saída.
Aí, "Informe sua opção:", "1 - Cadastrar", "2 - Executar", "3 - Sair.".
Leio a opção através de um cin.
Switch, né, escolho a opção.
Aí, vai entrar no caso 1, 2, 3 ou default.
No 1, vai chamar a função MenuCad,
o 2 é MenuExe,
o 3 mensagenzinha de fim aí, pra fins de elegância
e o default é "Opção Inválida".
Avancemos.
Ali eu tô salientando algo sobre...
aliás, eu tô pintando o comando system("Pause"), tá.
Pintando o comando system("Pause").
Perfeccionismo, vamos lá.
Legal.
E no próximo slide vai acontecer o quê?
Eu vou explicar o que que é isso, tá.
Pessoal, aqui eu vou também pintar em vermelho, aqui, pra fins de justiça, tá.
Justiça feita.
E aqui, também pra ser justo.
Legal.
Observação à parte.
O comando system
nos permite introduzir o princípio de API,
por não deixar de ser uma, mesmo que simplificadamente.
Como eu dizia pra vocês ali, tá, no meu discurso anterior.
O system permite eu ir lá e dizer como é que o meu console vai ser comportar.
Aqui eu vou limpar o console
e aqui eu vou dar um pause no console.
Isso aqui é como um equivalente a fazer um getchar no teu código, tá.
Aqui eu tô fazendo, não via código, tô fazendo lá no console ele mesmo.
API, Application Programming Interface,
Interface de Programação de Aplicação,
permite o programa acessar uma outra aplicação
via uma interface.
Essa outra aplicação pode ser uma que tá rodando em tempo de execução,
como o console, tá.
Ou uma outra biblioteca inserida dentro do teu sistema,
como, por exemplo, sei lá eu,
eu usar a API do time.h do windows.h.
Neste caso, o system é
a interface que permite acessar os comandos do, então, chamado DOS.
DOS é uma maneira antiga de chamar o console de comando do Windows.
Muito bem.
Pra quem não sabe, tá, já que eu entrei no assunto,
antes de existir o Windows graficamente, existia o Windows textual
Bom, então não era Windows, porque não eram janelas, né,
mas existia um sistema operacional da Microsoft textual, tá,
que era chamado de MS-DOS.
Bom, se aqui eu tenho o menu
o menu que é o menu do Principal
e ele chama submenus, MenuCad e MenuExe, onde estão?
Estão definidos aqui.
Tal qual essas funções que estão no Principal.cpp,
enquanto a definição está no Principal.h,
o MenuCad e o MenuExe também estão no Principal.cpp implementados.
Então, tá aqui o MenuCad.
Ali eu vou ter opções.
"Cadastrar Disciplina", "Cadastrar Departamento", "Cadastrar Universidade".
Se for o caso 1,
eu vou chamar a função CadDisciplina do Principal.
Se for o 2, CadDepartamento. Se for o 3, CadUniversidade.
Depois, com o MenuExe, ele faz o seguinte
Ele dá as opções: "Listar Disciplinas", "Listar Departamentos", "Listar Universidade".
Ele, simplesmente, vai, por exemplo, se for o caso 1
mandar a lista de Disciplinas do Principal
listar suas Disciplinas.
Professor, mas como é que esse cara cadastrou as Disciplinas nele?
Como essa lista recebeu?
Através da função CadDisciplina.
A função CadDisiciplina
que também tem acesso, tal qual, ao Menu Executar,
ao atributo LDisciplinas da Principal,
ele vai, aqui dentro, e cadastra a Disciplina.
Coisa que eu vou mostrar no próximo slide pra vocês.
Opção 2, lista Departamentos.
Opção 3, listar aqui as Universidades
a partir de lista apropriada.
E essas funções aqui, tá,
permitem cadastrar as coisas nas listas.
Aqui, você vai cadastrar na Lista Disciplinas,
aqui você vai cadastrar na Lista Departamentos
e aqui você vai cadastrar na Lista Universidade.