Muito bem.
Aqui eu tô só destacando, tá, a listagem.
Vocês podem fazer a listagem
das duas Disciplinas
do início pro fim, do fim pro começo, tá,
pra mostrar que funciona certinho.
E aqui tá a execução, né.
É no Executar que justamente tá a chamada do ListeAlunosDisc,
a última função chamada,
aonde tem as execuções dadas.
Muito bem.
Bom, naturalmente, né, pessoal, quem tá entendendo essa aula,
quem fez os exercícios.
Quem tá compondo o seu Sistema Acadêmico certinho, lá,
fazendo a coisa passo a passo, montando, né,
esse sistema acadêmico que, na prática, é um grande exercício, tá.
Aqui é uma disciplina orientada a problema, né.
Um problema de montar o Sistema Acadêmico,
segundo os requisitos que vão avançando passo a passo, aula a aula.
Você vai montando esse sistema, tá.
Você tem que tá com o código em dia.
Muito bem.
Aqui é só pra fazer um teste, tá.
Vejam que se vier aqui de fora, por fora,
e você alterar o nome do Aluno triplo A.
O nome do Aluno triplo A é AAA mesmo, tá, mas aqui eu mudei pra "Teste".
E aí, eu posso imprimir, aqui, o nome dele aqui, só pra mostrar que funciona,
que foi atualizado,
e depois eu posso listar de volta o que tem em Computacao2_2007.
E daí, vai aparecer na listagem de Alunos,
vai aparecer não mais AAA, mas vai aparecer "Teste".
Por quê? Porque a lista de Alunos lá em Computacao2_2007
como vocês sabem é uma lista de apontamentos.
Não tenho clonagem dentro da lista.
É o ponteiro das coisas, o endereço das coisas
e, por meio de ponteiros,
se eu tiver endereço, então, se eu mudo na origem
vai se refletir, naturalmente, tá, em quem aponta pra esse cara,
porque daí ele vai acessar esse cara e esse cara vai tá alterado.
Aqui, tem uma consideração justamente, tá.
Então, isso aqui tá ok.
Agora eu tenho uma consideração aqui que é sobre clonagem.
Uma solução de clonagem pode apresentar problemas de dessincronização.
Porque eu tô mostrando isso, tá.
Porque isso aqui, à luz da minha experiência de 14 anos lecionando aí,
esse tipo de conteúdo,
as vezes eu vejo que os alunos cometem esse erro, tá.
Por isso que eu destaco aqui inclusive.
Então, tá aqui, tá. Eu alterei a função.
Aonde que eu alterei a função?
Aqui eu crio paux.
Aloco memória, new Elemento Aluno, apontando pro paux.
Só que agora aqui em vez de eu, simplesmente, utilizar o aluno que tá vindo,
eu aloco um novo Aluno dinamicamente.
Tá vendo ó.
Um ponteiro Aluno 2, ponteiro de Aluno.
Aloco um novo Aluno, Aluno criado dinamicamente
e aí eu copio o conteúdo do Aluno que tá vindo
pro conteúdo desse Aluno que eu acabei de criar, ou seja, eu criei um clone dele.
E insiro esse clone dentro da lista.
Porque eu faço o paux apontar pro clone e não pro cara que tá vindo.
Isso é um pepino.
Porque daí, agora, se eu executar esse código aqui,
A hora que... eu mudei o nome aqui pra "Teste", mas a hora que eu executar a lista,
ele vai aparecer "AAA" de volta e não "Teste", por quê?
Porque o Computacao2_2007, nessa solução que eu acabei de apresentar,
ele é o clone que tá la dentro, não é o triplo A.
É o clone que foi criado dinamicamente que tá apontado lá dentro
Então ele não vai sincronizar.
Tenham muito cuidado com esse tipo de problema, tá.
Legal. Isso considerado,
vamos passar pra um exercício que vocês podem tentar fazer que é o seguinte:
se eu fiz um new, que é alocação de memória,
eu tenho que fazer um delete, que é a desalocação de memória.
Você sabe lá da disciplina de Fundamentos 1, ou equivalente,
Computação 1 e por aí vai, enfim, em algo equivalente.
Você sabe que pra cada memory allocation você tem que ter um free.
Aqui é similar, pra cada new você tem que ter um delete.
Não misture malloc com delete e nem new com free. Dá erro.
malloc se usa com free e new se usa com delete.
Malloc e free eles usam uma maneira de alocar memória e new e delete outra maneira de alocar memória.
Em todo o caso, eu em C++, gente, eu trabalho com new e delete, tá.
No destrutor da classe Disciplina, liberar a memória alocada
para a lista de Alunos, composta... regrada pelos Elementos Alunos,
liberando/destruindo cada objeto criado dinamicamente.
Ora, eu na Disciplina não compus a lista de Alunos?
Através dos Elementos Alunos?
Compus, né, gente.
Legal.
Se eu compus, eu compus.
E pra compor essa lista, pra cada elemento que era inserido na lista, aliás,
Perdão. Pra cada Aluno que era inserido na lista, né.
Cada endereço de Aluno que era inserido na lista ,
eu criava um novo Elemento Aluno pra cuidar dele.
Então, se, por exemplo, numa lista da Disciplina lá Métodos2_algo...
eu inseri 5 Alunos, vai ter 5 Elementos Alunos criados dinamicamente.
Elemento criado dinamicamente, ele não some
quando você desliga o programa
e quando você reexecuta o programa aquela memória alocada não é mais útil,
porque o programa quando ele re-roda, ele não acessa aquela memória, aquela memória ela fica perdida.
Você perdeu os ponteiros para aquela memória na prática.
Então, pessoal, quando você faz uma alocação de memória dinâmica, e você não desaloca
aquela memória vira um zumbi no teu espaço de memória, tá.
Não tá nem vivo nem morto.
Cada vez que você aloca memória dinâmica
Você tem que alocar através do delete.
Se não você fecha o programa e fica lixo na memória.
Se você fez um new e não fez um delete, você criou um zumbi.
E aí, pra você limpar a memória só depois rebootando o PC, né.
Isso aqui, a alocação de memória, acontece na memória RAM, conforme vocês já sabem.
Então, tem que fazer um delete.
Se eu aloquei memória na composição das listas de Alunos, dentro da Disciplina,
aonde eu vou desalocar?
Ao mais tardar na destrutora.
É pra isso que destrutora existe, inclusive.
Aqui tem uma primeira solução
que eu vou deixar vocês verem depois, tá.
E eu vou direto pra uma segunda solução que eu gosto mais, que essa aqui
que é a Outra Solução.
No destrutor da classe Disciplina, liberar a memória
alocada para lista de Alunos
a partir de Elementos Alunos, né.
Aqui eu tô chamando de LAlunos por algum motivo, mas tudo bem.
liberando/destruindo cada objeto criado dinamicamente.
Observação: usar o comando delete, por exemplo, delete aux;
Aqui então eu tenho a destrutora. Como é que eu sei que é a destrutora? Ali, ó,
Símbolo que denota destrutora.
Aqui começa a destrutora e ali termina.
Aqui, pessoal, eu tenho o paux que é ponteiro Elemento Aluno
paux recebe, sim, pElemento Aluno Primeiro
que a gente sabe que a lista foi composta.
Tem lá pelo menos 5 elemento... 5 Alunos dentro da lista. tá.
Apontados através dos Elementos.
Então, paux não é nulo, mas aqui no while
eu não tô analisando o paux, eu estou analisando se o primeiro é nulo
e se tem 5 elementos lá, o primeiro então não é nulo.
Aí, eu faço o seguinte,
o paux já tá apontando pro primeiro, tá, então,
Aquele apontamento, aquele cara que foi apontado pelo primeiro ele está de fato
replicado o apontamento em paux.
Por isso fica mais fácil enxergar, inclusive, no próximo slide. Vejam só.
Eu dizia aqui, ó.
Nós temos aqui, por exemplo,
o pElemento Primeiro, tá apontando pra esse cara aqui.
paux, também tá apontando pra esse cara.
Então, o meu mouse aqui é o paux.
Eu testo se o pElemento Primeiro não é nulo.
Vocês tão vendo que não é nulo, olha a setinha ali, ó. Não é nulo.
Bom, aí acontece o que pessoal?
Ele vai fazer que o Primeiro, que o Primeiro, pare de apontar pra cá, e aponte pra lá.
Então ele atualizou o Primeiro, ele já tá desconsiderando esse cara aqui.
Esse cara aqui não está apontado por paux
é por isso que eu faço ali, ó, um delete paux.
Eu venho aqui e corto esse cara, e já era.
Opa, mas e o primeiro tá apontando pra cá agora.
Ah, tá.
Agora eu faço o paux também apontar pra cá, ó. Essa linha aqui, ó.
Legal.
Tô voltando pra cá. Ali eu do loop.
O primeiro que esse aqui agora, é nulo?
Não, não é. Ele continua aqui, ó. Ele existe.
Foi atualizado, mas ele não é nulo.
Aí eu faço quê?
Amarro o primeiro pra lá.
Através do paux quem tá apontando pra cá, eu venho e elimino esse cara.
e assim eu vou, tá, através do delete.
E aí, ele vai seguir a lógica até que tenha um nulo.
no momento onde eu encontre um nulo, tá.
Naturalmente nos encadeamentos aqui.
Ainda faço o aterramento final aqui, por que não?
E assim funciona o delete.
É mais fácil explicar isso aqui no quadro, porque daí usa as duas mãos,
usa uma série de artifícios de palco, né.
Mas aqui deu pra vocês entenderem também.
Bom, aí eu tenho um exercício 2 aqui, pessoal, que é bem interessante, tá,
pra vocês estudarem em casa, que é o que aparece aqui.
Antes de eu falar do exercício 2, só que lembrar vocês do seguinte, tá.
Agora, eu fiz uma solução que funciona em n pra n,
para tal eu tive que usar alocação de memória dinâmica,
porque eu preciso de um Elemento que cuide de cada Aluno na lista.
Inclusive, por exemplo, se o cara tiver em duas listas,
eu tenho um Elemento Aluno pra primeira lista e outro Elemento Aluno pra segunda lista.
por isso que tem que ter alocação de memória dinâmica.
E se eu fiz alocação de memória dinâmica eu tenho que fazer a desalocação de memória dinâmica.
Se eu fiz um new, eu tenho que fazer um delete e eis o delete posto.
Agora tem um exercício 2 aqui pra vocês
um exercício muito interessante que é o seguinte:
Cada Departamento deve ser capaz de armazenar uma lista de disciplinas.
Legal.
Isso a gente já sabe
Única coisa é que se você olhar lá,
aonde a gente compôs esse exercício,
a gente fez com que a própria Disciplina
tivesse ponteiro de pProximo e pAnterior
Muito embora essa situação da própria Disciplina ter pAnterior e pProximo
funcione em situações 1 pra n,
que é o caso lá, 1 pra n, n pra 1.
Não é elegante.
Cada Departamento deve ser capaz de armazenar uma lista de disciplinas
Ok.
Cada Disciplina, entretanto,
não deverá possuir um ponteiro pra próximo
e um pra anterior também.
Isto deverá estar em uma classe associada chamada Elemento Disciplina
relacionada a Disciplina.
Então, aquela lista que vocês tinham feito lá,
de maneira assaz acoplada, aonde a própria Disciplina
tinha primeiro e tinha anterior, agora não vai ser mais assim.
A gente vai criar uma terceira classe Elemento Disciplina
pra gerenciar as Disciplinas dentro da lista de Disciplinas do Departamento.
E, se vai ser assim, você vai ter que fazer alocação de memória dinâmica.
Você vai ter que ir lá no incluaDisciplinas do Departamento modificar alguma coisa lá
e, em algum momento, fazer um new Elemento Disciplina.
Então, nisso fica esse exercício. Façam ele porque ele é importante.
E vocês já tem... a versão anterior,
então, vocês podem modificar a versão anterior, adaptar pra que funcione
com o que eu tô pedindo aí, tá.
A coisa, até que é pertinente falar agora,
é que cada vez que vocês vão fazer uma modificação mais profunda no código,
como essa aí que eu tô pedindo no exercício
crie uma nova versão do código.
Mantenham a versão anterior e criem uma versão linha lá.
Você pode ter, se vocês quiserem, fazer o gerenciamento como eu faço, tá.
Ali em diretórios,
cada vez que você vai criar uma solução que tem uma mudança impactante,
como essa que eu tô pedindo, insisto,
você copia a versão anterior pra um novo diretório
e nesse novo diretório, que você vai chamar de versão n,
você faz a mudança
e vai incrementando, tá, mantendo o histórico das versões do que você tá fazendo.
Isso é até legal, porque as vezes se der um problema que você não tá localizando,
tá difícil de localizar na versão que você tá mexendo.
Você pode até voltar pra versão anterior.
De repente até abandonar essa versão, aqui, nova
e criar uma... uma outra aqui, né. Derivada aqui pra esquerda aqui,
aonde você recomeça as coisas do passo anterior.
que você fez antes de dar um erro grave que você não tá localizando.
Fica mais fácil de você fazer os avanços de maneira passo a passo incremental.
Aqui tem um exercício 3, também, mais interessante ainda.
que é o seguinte:
Elaborar uma solução para armazenar as notas,
primeira parcial, segunda parcial e final,
e número de faltas de cada aluno em cada Disciplina.
Então, vocês têm que imaginar a coisa.
Tá, eu deixo isso posto.
Vocês pegam o Diagrama de Classes. Olhem o Diagrama de Classes,
tentam modelar isso que tá posto do ponto de vista de classes
e depois fazer a implementação.
Inclusive, isso aqui já foi exercício de prova.
Pessoal, é isso que eu tinha pra contar nessa apresentação de slides, tá.
É interessante que, por fim,
no próximo conjunto de slides,
a gente vai melhorar um pouco mais essas soluções de lista.
Ainda tem um pecado ali, nessa lista aí,
que não tá legal,
e que eu vou resolver pra vocês na próxima... próximo Grupo de Slides.
Esse pecado é uma questão muito mais estética
e de elegância do código,
que impacta largamente na compreensão do código
do que de técnica propriamente dito, em um primeiro momento.
Só que daí, em um segundo momento, você vai ver que
além de questão estética e de compreensão do código,
em outros contextos, isso, sim, impacta tecnicamente
do ponto de vista de reaproveitamento de código.
Mas é assunto pra gente discutir na próxima exibição, próxima apresentação de slides, tá.
Gente, até breve e bons estudos aí.