Nesse momento de execução do código, tá
que é aonde a gente está.
Ali, ó, seta vermelha.
A gente vai simular a execução do código,
como se a gente tivesse debugando, depurando o código passo a passo.
Eu fiz uma espécie de mapa de memória aqui, tá.
Ainda que o mapa de memória eu tô usando uma espécie de Diagrama de Objetos.
Não é um diagrama puro UML, tá.
Em UML vai usar só quadrados
com algumas peculiaridades e eu tô usando cubos, porque eu acho mais simpático.
Até eu podia propor para a UML substituir o Diagrama de Objetos
de quadrados por cubos.
Mas tudo bem, esse é outro assunto.
O fato é que eu tô mapeando aqui a memória,
contando que tem uma série de coisas na memória, olha lá a reticências.
Dentre elas este ObjetoPrincipal, existe sim o DAELN,
existe cada uma dessas disciplinas aqui.
Cada uma dessas disciplinas, dentre outras coisas,
têm o pProximo aterrado com nulo, porque a construtora dela garante isso.
O DAELN, olha aqui a reticências, aqui, ó.
dentre outras coisas, têm o pPrimeiro com nulo
e o pAtual com nulo também.
Até esse momento.
O que acontece ali naquela situação
aonde eu chamo a função incluaDisciplinas() do DAELN?
Eu tô nesse momento de código em vermelho, tá,
como se tivesse depurando ali, fazendo um F10 ali na minha execução,
indo linha a linha em modo de debugagem, depuração, tá, no código em execução.
Ali eu tô fazendo o que eu vou dizendo
que eu vou chamar a função-membro incluaDisciplinas()
do objeto DAELN.
Vou passar um parâmetro, que parâmetro é esse?
É o endereço de Computação 2006.
Como o DAELN é da classe Departamento
naturalmente, que o DAELN executa a sua IncluaDisciplina enquanto Departamento.
E tem lá naquela função, à luz da classe,
foi definido o parâmetro pd, tá.
Tem esse parâmetro, aqui, pd, aqui.
Ele é o ponteiro de Disciplina.
Esse ponteiro de Disciplina
ele recebe que valor?
Recebe o que tá vindo por parâmetro
O endereço de Computação 2006.
Ah, então ele aponta pra cá. Legal.
Olha aqui, ó, o ponteiro de Disciplina aqui, ó.
Legal.
Aí vai acontecer o quê?
Eu tô executando o código dentro do DAELN.
Nessas reticências aqui eu tenho a função IncluaDisciplina
que é o que tá mostrado ali em cima.
Eu vou testar se o pDisciplPrim
pPrimeiro, aqui, é nulo.
Ele é nulo? É!
Ah, então ele aprova o if.
Ele vai fazer com que o pDisciplPrim
que tá aqui e que nesse momento é nulo
aponte, também, pro mesmo lugar que o ponteiro Disciplina.
Ah, tá ali.
Por sua vez, nessa segunda linha de código aqui,
eu vou fazer que o pDisciplAtual
aponte pro mesmo lugar que o ponteiro de Disciplina.
Que tá ali, ó.
Muito bem.
Aí, se ele executou o if,
naturalmente, ele não vai executar o else
e ele vai pro final da função.
No final da função, o parâmetro
Nada mais é do que uma variável temporária da função
ele sabe que a função tá terminando de executar
Ela tá se extinguindo essa função nessa execução.
Bem entendido.
Se extinguindo nessa execução.
E tá aqui, ó, eu inclui
o Computação 2006 na lista encadeada do
do Departamento, né, o DAELN
e, de fato, ele é o primeiro e nesse momento ele também é o atual, ele também é o último.
Só tem um incluso até então.
Aí a gente passa pra um segundo momento do código.
Aonde eu vou incluir a Introdução a Algoritmos 2007.
Muito legal.
Vai acontecer o que ali?
É uma segunda chamada da função.
Agora o parâmetro disciplina está sendo alimentado, né.
O parâmetro disciplina aqui ele é recriado nessa segunda execução,
mas eu vou voltar um pouquinho.
Ele é recriado.
Ele é recriado com que valor?
O endereço de Introdução a Algoritmos 2007.
Como ele é um ponteiro então ele aponta pro Introdução a Algoritmos 2007,
conforme mostra aqui o grafismo, tá.
Essa animação.
Aí, acontece o que, gente?
Ele vai tentar passar o if lá, ó.
Vai tentar passar o if.
pDisciplPrim é nulo?
É igual a nulo? É igual, igual a nulo? Não, não é.
Ele já aponta pra um cara. Opa, então ele cai no else.
No else ele faz o quê?
Ele diz o seguinte
pDisciplAtual...
quem que é pDisciplAtual?
Ou pProx do cara apontado por pDisciplAtual.
Quem é pDisciplAtual? Esse cara aqui, ó.
Opa, é o Computação 2006.
Então, o pProx, do Computação 2006 vai apontar pro cara
considerado por ponteiro Disciplina que tá aqui, ó.
Ah, então esse cara aqui, o pProx desse cara, vai apontar pra aquele ali.
É isso que vai acontecer.
E ali está feito, ó. Tão vendo?
Aqui eu criei um encadeamento, portanto.
Mas isso não basta.
Agora eu tenho que atualizar o atual,
porque o atual nesse momento é o Introdução a Algoritmos 2007,
que inclusive é apontado pelo ponteiro Disciplina, que vem por parâmetro.
Ah, então, eu vou atualizar o atual.
E tá ali, ó.
Naturalmente, o Computação 2006 não é mais o atual.
O atual é o Introdução a Algoritmos 2007.
Isso aqui como é uma variável temporária, né, esse parâmetro
no final da execução... dessa execução ele se extingue nessa execução.
Bom, e aí, eu vou incluir o terceiro elemento.
Quem que é o terceiro elemento?
É o Computação 2 2007.
Aqui que entra meu automatismo.
Agora o ponteiro Disciplina aponta pro Computação 2 2007,
conforme vocês tão vendo aqui, ó.
É esse o parâmetro dado, então, naturalmente isso ocorre.
Vai tentar passar do if, não vai dar certo, porque o primeiro não é nulo.
Então, ele cai no else, naturalmente.
Cai no else, ele faz o quê?
Vai fazer que o atual aponte pro próximo.
E aí, eu faço... atualizo o atual.
E ele some aqui.
Aqui, na verdade, no próximo slide,
eu vou pedir que vocês continuem a simulação.
Então, nesse momento, o que eu peço pra vocês
é que vocês parem o vídeo,
peguem um pedaço de papel, remontem esse cenário aqui
e continue a simulação, agora, desse cara aqui.
Como se vocês estivessem animando isso.
Inclusive, não parem aqui. Vão até o final aqui.
Vão até essa execução dessas chaves aqui.
Então, tá aqui, a simulação
Eu rogo a vocês que vocês façam uma pausa no slide
e voltem pra ver se vocês simularam certinho aqui.
Eu, em ato contínuo,
já que eu não vou fazer pausa nenhuma.
Eu vou mostrar o resultado dessa simulação.
É isso que acontece, tá.
Ele vai inserir todos os quatro elementos.
Veja que o último continua apontando pra nulo.
Por quê? Porque ele não teve um próximo
e como na construtora dele ele foi aterrado em nulo, ele continua com nulo.
E, aqui, é normal, né.
A hora que eu faço o setDepartamento vai acontecer o quê?
Por exemplo, no Computação1_2006,
ele vai apontar pro Departamento.
Acontece em cada um deles.
Aqui é uma relação, e prestem atenção no que eu vou falar, 1 pra n.
Departamento inclui uma série de Disciplinas,
mas cada Disciplina só conhece um Departamento.
Uma relação 1 pra n, n pra 1.
E esse espectro matemático é importante pra nós nesse caso.
E vocês vão entender o porquê na sequência, tá.
Nem sempre uma solução que funciona, por exemplo, em 1 pra n, n pra 1,
vai funcionar num espectro matemático um pouquinho mais complexo como n pra n.
Muito bem.
Bom, se aqui nós temos a função que permite compor a lista
nós temos uma função, também, na classe Principal, né.
Ah, bom, aqui a função que permite compor a lista é essa, tá.
Aqui é a inicializaDisciplinas que anima
essas composições conforme a gente simulou.
Na classe Principal ainda,
eu também posso no Departamento
a partir do Departamento DAELN, chamar o listeDisciplinas no âmbito dessa função
ListeDiscDeptos do Principal.
Enfim, como é que funciona esse liste Disciplinas
lá dentro de cada Departamento?
Vou explicar pra vocês aqui.
Vocês tão vendo aqui que tem o pAux, aqui
É um ponteiro de Disciplina
Esse pAux, vejam que eu tô dentro de DAELN, tá.
O pAux aponta pro pPrimeiro.
pPrimeiro, pDisciplPrim.
Aqui, ó.
Então, pAux tá apontando pra esse cara aqui, ó.
Imaginem que o ponteiro do mouse aqui é o pAux.
Enquanto o pAux não for nulo eu vou fazer alguma coisa.
Eu vou dizer que a Disciplina tal
pertence ao Departamento tal.
Como é que eu vou ter o nome da Disciplina?
Ora, o pAux, eu tô dentro do DAELN.
O pAux tá apontando aqui pro
pro Computação1_2006
então eu posso fazer getNome a partir do pAux, ou seja,
pegar no getNome o nome dessa Disciplina aqui em questão.
Pra onde o pAux está apresentando.
E o segundo parâmetro que é o nome é o nome do próprio DAELN.
Lembre que eu tô executando isso dentro do DAELN.
Lá onde faz apontamento, aqui, pro pAux
recupera o nome da Disciplina e do Departamento
Então: "A Disciplina tal pertence ao Departamento tal".
Legal.
O pAux, aqui, tá apontando pra Disciplina.
Agora, eu vou fazer o pAux apontar
o próximo apontado por pAux,
ou seja, eu vou fazer o pAux apontar pro próximo.
pAux vai evoluir, ele vem pra cá, ó.
Aí, eu dou loop.
Dou loop, porque eu cheguei no final dessa execução...
quer dizer, no final da execução não, eu cheguei
nesse momento de retorno do loop.
pAux, que é o meu mouse aqui,
é nulo? Não, não é.
Ele tá apontando pro Introd_Alg_2007.
Ah, então ele vai imprimir o nome da Disciplina
e do DAELN no âmbito do printf ali,
e aponta pro próximo.
Vai dar loop.
Computacao2_2007 é nulo? Não, não é.
Então ele vai imprimir o nome de Computacao2_2007
e mais o nome do DAELN,
e vai pro próximo e aí dá loop.
Aí, o Metodos2_2007 é nulo?
Não, não é.
Ele faz o quê? Imprime o nome de Metodos2_2007,
imprime o nome do DAELN,
e faz pProx... e faz o pAux pProx,
que cai em nulo.
Dá loop.
pAux é diferente de nulo?
Ih, ele não é diferente de nulo, ele é nulo.
Então, ele sendo nulo, ele tem que sair do loop.
Então, nessa última situação
ele não atende o while e termina o loop, tá,
permitindo que você tenha percorrido a lista.
Bem entendido.
Essa aqui é uma... bom, uma explicação mais ou menos obvia, né.
de execução dessa lista encadeada nessa estrutura aqui
que foi criada, tá, de relacionamentos entre os objetos.
Em suma, pra navegar, ele vai do primeiro
em próximo, próximo, próximo, próximo até que encontre uma situação nula.
Voltando ao código pra melhorá-lo um pouquinho.
Isso é muito legal.
Aqui, pessoal, eu vou fazer uma melhora
lá dentro da classe Disciplina.
Se você olhar a classe Disciplina,
Até então, ela só tinha essa linha de código aqui, ó,
no tocante... essa que eu tô salientando aqui
no tocante ao setDepartamento.
O setDepartamento de Disciplina,
deixa eu voltar um pouquinho aqui,
é o que permite fazer essa conexão aqui, ó.
Cada vez que a Disciplina recebe o endereço de DAELN aqui, por exemplo, ó.
Uma delas, ela faz o seguinte
isso aqui é via setDepartamento conforme a gente já viu
em slides anteriores, tá lá, ó.
Computacao1_2006.setDepartamento(), ela recebe o endereço DAELN.
Ele pega esse endereço, coloca o endereço no pDptoAssociado
e linca ali.
Até a versão anterior,
até a primeira versão, só tinha isso aqui, ó.
No setDepartamento de Disciplina.
Então, insisto, só tinha isso aqui.
Agora eu adicionei uma nova linha de código
que é essa que tá aí em belo destaque aqui.
Aqui eu tô usando o ponteiro this.
Vejam o que tem aqui.
Aqui eu tô usando o incluaDisciplina,
incluaDisciplina,
do cara apontado por pdpto.
No código que a gente tem simulado,
quem que é o cara que tá apontado por pdpto, nos códigos que a gente simulou?
É o DAELN.
A título de exemplo, tá.
A título do código simulado, aqui do caso, que é nosso exemplo.
Então, chama o incluaDisciplina do cara apontado por pdpto.
na prática eu tô chamando aqui, nesse caso, o incluaDisciplina do DAELN
Eu vou passar quem pro DAELN? Eu vou passar o this.
O que que é o this?
O this é um ponteiro preexistente,
é um ponteiro predefinido melhor dizendo, no C++.
O this é um ponteiro pro objeto que está rodando nesse momento.
Se o cara que estiver rodando nesse momento for o Computação, lá, 2007
Aqui, eu vou fazer o DAELN incluir o endereço do Computação 2007.
Cada vez que um Departamento é associado a uma Disciplina,
essa Disciplina passa a fazer parta da lista de Disciplinas
do Departamento, por meio do comando abaixo.
Que é esse comando que eu expliquei pra vocês.
Aqui eu tô fazendo o incluaDisciplina do DAELN, no caso posto.
receber o endereço deste, this.
Este quem? O objeto que tá rodando nesse momento.
Se for da Disciplina Computação 2007,
o DAELN vai incluir o Computação1_2007.
Bom, deixa eu voltar. Vou voltar slides, tá, prestem atenção.
Tô no 40, vou voltar lá para o 37.
Se você olhar aqui, nesse momento aqui,
eu faço o DAELN conhecer cada uma das Disciplinas
e aí faço cada Disciplina conhecer o DAELN.
Na próxima versão de código, eu vou eliminar isso daqui, ó.
Vai ter só essa segunda parte aqui.
Por quê?
Por causa dessa evolução aqui. Slide 40 de volta.
Porque agora quando a conhecer o Departamento
automaticamente ele já vai fazer com que
o Departamento inclua a Disciplina em questão.
Então, se vocês olharem o próximo slide, 41.
De fato, é o inicia... aqui, o InicializaDisciplinas agora
tem apenas o nome das Disciplinas e
faz com que a Disciplina conheça o Departamento.
Vocês não tão vendo o código explícito, aí,
do Departamento conhecer as Disciplinas.
Nem antes, nem depois.
Mas como é que ocorre então, professor?
Através daquela função this que eu tava falando pra vocês.
Vamos simular isso aqui, pra ficar mais fácil pra vocês perceberem, tá.
Então, eu vou destacar só a função InicializaDisciplinas de volta.
Essa segunda versão agora, tá.
Tá ali. Eu tô naquele momento do código
e nesse mapa de memória, nessa situação dada.
E aí, eu faço o quê, gente?
Faço o evidente.
E o que é o evidente?
É o seguinte
eu faço o Computacao1_2006 chamar a sua função setDepartamento
passando por parâmetro o DAELN. O endereço do DAELN, bem entendido.
Computacao1_2006 é da classe Disciplina, conforme vocês tão vendo aqui, ó.
Ele vai chamar, então, o setDepartamento() definido na classe Disciplina.
Sendo que cada objeto respeita
na instância, um exemplo daquele código, né.
Fim daquela classe.
Então, isso daqui é setDepartamento() do Computação1_2006.
Vamos dizer assim nesses termos.
Então, eu tô chamando o setDepartamento do Computacao1_2006.
Ele recebe por param... ele tem um parâmetro que é o pdpto,
que recebe o endereço do DAELN.
Então, tá ali, ó.
pdpto é uma variável temporária. Todo parâmetro é uma variável temporária da função,
tá apontando pro endereço DAELN conforme posto ali.
Agora, tem que fazer o quê? Eu tenho que fazer o pdpto
apontar pro mesmo lugar, aliás eu tenho que fazer o pDeptoAssociado
apontar pro mesmo lugar que o pdpto.
Tá ali, ó.
pDeptoAssociado vai apontar pro mesmo lugar que o dpto.
E tá ali, ó, tá feito.
Conforme vocês já simularam, inclusive, agora há pouco aí, tá.
Só que agora aqui, ó, tem mais uma linha.
Eu vou fazer o incluaDisciplina do cara apontado por pdpto.
Quem que é o cara apontado por pdpto?
É o DAELN.
Então, eu vou fazer o DAELN incluir this.
Quem que é this?
This é este.
Este quem que é?
É o Computacao1_2006.
Ah, tá. Então, agora o DAELN vai incluir quem?
O Computacao1_2006.
Legal.
Então, tá ali, ó.
Eu tô chamando o incluaDisciplina do DAELN,
pdpto é DAELN. O incluaDisciplina do DAELN.
Agora o DAELN cria uma variável temporária pra ele.
Na sua instância que é o ponteiro Disciplina.
Quem que é esse ponteiro Disciplina?
É quem eu tô passando por parâmetro, é this.
Quem que é this?
É o endereço de Computacao1_2006.
Ah, legal.
Então, vai fazer o que aqui?
Vou testar se o pPrimeiro é nulo no DAELN.
É nulo.
Vou fazer o pDisciplPrim
apontar pro mesmo lugar que o ponteiro Disciplina.
Ele tá apontando pra Computacao1_2006, então ele vai apontar pra Computacao1_2006.
O pDisciplAtual vai apontar também pro mesmo lugar que o
pd, aqui, o ponteiro Disciplina.
Ah, então, vamos lá.
Beleza.
Não vai... se ele executou o if, naturalmente, ele não executa o else.
Vai terminar a função eliminando variáveis temporárias, inclusive, seus parâmetros.
E tá aqui a primeira execução.
Agora eu vou fazer a Introd_Alg_2007 conhecer o DAELN.
Ali, ó.
A execução normalzinha.
Chama o setDepartamento
Faz a conexão.
E agora eu vou fazer o DAELN conhecer o Introd_Alg_2007 usando o ponteiro this.
E faço ali a execução de pProximo e pAtual.
Até posso ir com um pouco mais calmo. Voltar aqui um pouquinho.
Aqui, o que aconteceu aqui?
A gente fez a Disciplina em questão
que é Introd_Alg_2007 conhecer o DAELN.
Tá ali, né, vocês viram.
Agora eu vou fazer o DAELN, insisto, incluir a Disciplina em questão,
que é Introd_Alg_2007.
Aí o DAELN vai executar isso.
É criado o ponteiro de Disciplina (pd).
Ponteiro de Disciplina aponta pra quem foi passado por parâmetro.
O this que, nesse caso, é Introd_Alg_2007.
Legal.
Introd_Alg_2007 vai fazer o quê?
Vai ser incluído aqui no Departamento.
Aí, o Departamento, que é o DAELN, vai testar se o primeiro é NULL
Não, não é.
Aí ele vai fazer o quê? Vai passar pro else.
Lá no else ele vai fazer
o Computação1_2006 apontar pra quem tá sendo incluído agora nesse momento,
que é Introd_Alg_2007, e vai atualizar o atual.
Então, tá tudo encaminhado.
Aí, vai terminar essa execução, eliminando variáveis temporárias, né.
Desempilhando, ali, o chamamento de funções, bem entendido.
E aí, eu vou rogar que vocês façam uma pausa no vídeo
e continuem a simulação.