‫Olá e bem-vindo.
‫Nesta palestra, vamos aprender como podemos obter um ponteiro para o ato de propriedade de um componente.
‫Vamos descobrir o que é um ponteiro, quais endereços estão na memória,
‫e vamos imprimi-los em nossas mensagens de log também.
‫Vamos mergulhar.
‫Então, vamos tomar um segundo para entender um conceito central do que está acontecendo na programação em geral
‫sobre endereços de variáveis.
‫O que é um endereço de uma variável?
‫Bem, nós armazenamos todas as nossas variáveis na memória em que há chips de memória RAM em seu computador e variáveis requerem
‫memória para armazenar seus dados.
‫Portanto, um número de ponto flutuante requer 32 bits de dados ou 64, se for um número inteiro duplo, requer uma certa quantidade
‫de memória.
‫Além disso, quanto maiores as estruturas que você possui ou maiores as classes que você possui, como
‫atores podem ser muito grandes e abranger muitos dados podem exigir até alguns kilobytes de memória por ator, coisas
‫assim.
‫Bem, essa memória tem que viver em algum lugar nesse grande campo de dados vazios que são seus bancos de memória.
‫E esse local é conhecido como endereço.
‫Então, como isso funciona na prática?
‫Bem, imagine que temos esse grande campo de zeros e uns.
‫Esses são os dados da sua ram.
‫Bom, então a variável, uma variável de ator chamada meu ator precisa ter uma certa localização dentro dessa
‫memória que é alocada para armazenar os dados no ator.
‫Portanto, essa seção vermelha da memória pode ser onde estamos armazenando os
‫dados para esse ator em particular, e tem um endereço geralmente indicado em binário ou hexadecimal que é essencialmente apenas o local.
‫Se você começar a contar todos os bytes, todos os uns e zeros aqui, na verdade, nós não contamos os zeros
‫e uns individuais.
‫Contamos em passos de oito, mas isso não é muito importante.
‫Contamos os bytes.
‫Esse é essencialmente o endereço por onde começamos.
‫Falando sobre nosso ator.
‫E então cada tipo tem um certo tamanho.
‫Portanto, sabemos que o ator exigiria tantos bytes de dados.
‫E isso nos diz onde encontrar os dados sobre nosso ator em particular.
‫Então, por que isto é importante?
‫Bem, vamos dar uma olhada na situação em que podemos querer fazer uma tomada.
‫Dois atores.
‫Temos apenas duas variáveis que referenciam os mesmos dados.
‫Bem, no caso ingênuo, simplesmente copiamos isso.
‫Portanto, temos um pedaço de memória que é alocado para a variável meu ator por outro pedaço de memória que está alocado
‫para uma variável vazia chamada seu ator, à qual ainda não atribuímos nada.
‫E então o que queremos fazer porque queremos que eles contenham os mesmos dados, é apenas atribuir um ao
‫outro.
‫E isso essencialmente resulta em apenas fazer uma cópia de todos os bits de dados que estavam no meu ator e colocá-los
‫em todos os bits que compõem o seu ator.
‫Portanto, esse pode ser um procedimento bastante caro porque sua CPU precisa avaliar cada pedaço de memória
‫no original e colocá-lo no novo local, o que leva tempo.
‫Agora há uma maneira de contornar isso usando algo chamado ponteiro.
‫Então aqui, em vez de armazenar a totalidade do Meu Ator, temos uma variável chamada meu ator ou
‫um ator um ponteiro de ator que não armazena o ator inteiro.
‫Ele apenas armazena o endereço onde você pode encontrar um ato.
‫Então você pode ver que realmente usa muito menos memória para armazenar um endereço.
‫E então o que fazemos é no seu ator, armazenamos o endereço do meu ator, então ele acaba apontando para o
‫ator original em vez de copiar os dados, daí o ponteiro do nome.
‫Agora esta não é a sintaxe real em C++.
‫Em C++, a sintaxe é muito mais condensada.
‫Dizemos que algo é um ponteiro colocando uma estrela após o tipo.
‫Portanto, uma estrela de ator significa que este é um ponteiro de ator e para obter o endereço de uma variável, usamos um e
‫comercial que não usaremos.
‫Faça muito uso deste endereço ainda porque há muitas funções no irreal que retornam
‫ponteiros.
‫Então, só precisamos saber como usar esses pontos em vez de criá-los por enquanto.
‫Então, uma dessas funções que nos permite ter acesso a outros objetos em nossa cena é get ona.
‫Então, por que isso se aplica quando temos um componente que pertence a um ator?
‫Então, se quisermos que esse componente converse com nosso ator, obtenha sua localização, defina sua localização e faça
‫coisas assim, precisamos ser capazes de obter um ponteiro para esse ator.
‫Não queremos fazer uma cópia dele.
‫Na verdade, não queremos copiar porque queremos mudar o ator.
‫Se estivermos fazendo uma alteração em uma cópia, ela não aparecerá na cena.
‫Portanto, precisamos ser capazes de armazenar uma variável que seja um ponteiro para um ator.
‫A maneira como fazemos isso, como acabamos de ver nos slides, é ter um tipo de ator.
‫Mas então colocamos uma estrela no final que nos diz que este não é um ator sendo armazenado aqui, este é
‫apenas o endereço de um ator sendo armazenado.
‫Então, pegamos o ator e vamos chamar esse proprietário, e então vamos definir isso igual ao
‫resultado de chamar get proprietário.
‫Então, get owner é uma função de um componente de ator que permite que você obtenha um ponteiro de proprietário, obtenha um
‫ponteiro de ator que aponte para o proprietário, coloque um ponto e vírgula no final dessa linha.
‫E o que temos aqui é uma variável que armazena o endereço de um ator que possui esse componente
‫específico.
‫Então eu gostaria de desafiá-lo a fazer algo imprimindo o endereço desta variável.
‫Portanto, use a variável ator e use a porcentagem que você formata.
‫Especifique o fim dos logs.
‫Então por cento significa essencialmente que você está usando um inteiro sem sinal.
‫Isso significa um inteiro que não pode ser negativo, o que faz sentido porque os endereços não podem ser
‫negativos quando estamos falando sobre onde encontrar memória e depois descobrir o que ela imprime, vá jogar, veja a mensagem de log,
‫veja o que ele imprime.
‫Ele muda entre diferentes jogadas se você parar de jogar e começar a jogar novamente?
‫E se o filme for sobre vários atores?
‫Existem vários endereços diferentes impressos no console?
‫Pause o vídeo e faça uma pequena investigação.
‫OK.
‫Bem vindo de volta.
‫Então vamos para este outro log e vamos dizer mudança, endereço próprio, dois pontos percentuais.
‫Você sabe, é aí que vai colocar o ponto de valor.
‫E então vamos colocar o ponteiro real.
‫Então vamos ter o dono aqui.
‫Então ele vai imprimir o endereço do proprietário.
‫Vamos para o irreal.
‫Controle de hits alt f 11.
‫E quando isso terminar de compilar, vamos apertar o play.
‫E o que estamos vendo é que a mensagem de log que move o endereço do proprietário está chegando e está nos
‫dando um número muito grande, na verdade, para esse endereço.
‫E se eu parar de jogar e jogar novamente só por um segundo?
‫Você pode ver que o endereço é substancialmente diferente e isso porque toda vez que
‫apertamos o play, a Unreal está criando um novo conjunto de atores na cena, basicamente prontos para jogar, começando do
‫zero.
‫Então é por isso que estamos vendo novos endereços cada vez que apertamos o play.
‫O que acontece se eu for para este pilar, por exemplo, e adicionar um movimento, um componente ao pilar também, e nós apertarmos o play
‫e rolarmos para baixo até o final dos meus logs.
‫Você pode ver que há cada tick dois endereços diferentes sendo impressos aqui porque há dois
‫atores diferentes que são armazenados em dois locais diferentes na memória.
‫Então, esses são os dois endereços e você pode ver que na verdade
‫há alguns megabytes de diferença entre esses dois endereços, o que apenas diz quanta informação está sendo
‫armazenada na memória pelo Unreal e também por que é importante ser eficiente em não fazer muitas cópias.
‫Isso é tudo para esta palestra.
‫Eu vou te ver entrar.
‫O próximo será fazer coisas mais divertidas com ponteiros.