‫Hola y bienvenido.
‫En esta lección, vamos a aprender cómo podemos obtener un indicador del acto de propiedad de un componente.
‫Vamos a averiguar qué es un puntero, qué direcciones hay en la memoria y
‫también las vamos a imprimir en nuestros mensajes de registro.
‫Sumerjámonos.
‫Entonces, tomemos un segundo para comprender un concepto central de lo que sucede en la programación en general
‫sobre las direcciones variables.
‫¿Qué es una dirección de una variable?
‫Bueno, almacenamos todas nuestras variables en la memoria porque hay chips RAM en su computadora y las variables requieren memoria
‫para almacenar sus datos.
‫Entonces, un número de coma flotante requiere 32 bits de datos o 64, si es un número entero doble, requiere cierta cantidad
‫de memoria.
‫Además, cuanto más grandes sean las estructuras que tenga o más grandes las clases que tenga, los actores pueden ser
‫muy grandes y abarcar una gran cantidad de datos que pueden requerir incluso unos pocos kilobytes de memoria por actor, cosas
‫así.
‫Bueno, esa memoria tiene que vivir en algún lugar de este gran campo de datos vacíos que son sus bancos de memoria.
‫Y esa ubicación se conoce como una dirección.
‫Entonces, ¿cómo funciona esto en la práctica?
‫Bueno, imagina que tenemos este gran campo de ceros y unos.
‫Esos son los datos en tu ram.
‫Bueno, entonces la variable, una variable de actor llamada mi actor, necesita tener una cierta ubicación dentro de esa
‫memoria que se asigna para almacenar los datos en el actor.
‫Entonces, esta sección roja de la memoria podría ser donde almacenamos los datos
‫para este actor en particular, y tiene una dirección que generalmente se indica en binario o hexadecimal, que es esencialmente solo la ubicación.
‫Si empiezas a contar todos los bytes, todos los unos y ceros aquí, de hecho, en realidad no contamos los unos
‫y ceros individuales.
‫Contamos en pasos de ocho, pero eso no es demasiado importante.
‫Contamos los bytes.
‫Esa es esencialmente la dirección donde comenzamos.
‫Hablando de nuestro actor.
‫Y luego cada tipo tiene un cierto tamaño.
‫Entonces sabemos que el actor requeriría tantos bytes de datos.
‫Y eso nos dice dónde encontrar los datos sobre nuestro actor en particular.
‫Entonces, ¿por qué es importante?
‫Bueno, echemos un vistazo a la situación en la que podríamos querer hacer una toma.
‫dos actores
‫Solo tenemos dos variables que hacen referencia a los mismos datos.
‫Bueno, en el caso ingenuo, simplemente copiaríamos esto.
‫Así que tenemos una parte de la memoria asignada a la variable mi actor por otra parte de la memoria asignada a una variable
‫vacía llamada tu actor, a la que aún no le hemos asignado nada.
‫Y luego, lo que queremos hacer porque queremos que contengan los mismos datos, es simplemente asignar uno al
‫otro.
‫Y eso esencialmente resulta en que hacemos una copia de todos los bits de datos que estaban en mi actor y los
‫ponemos en todos los bits que componen su actor.
‫Entonces, este puede ser un procedimiento bastante costoso porque su CPU tiene que pasar y evaluar cada pieza de memoria en
‫el original y colocarla en la nueva ubicación, lo que lleva tiempo.
‫Ahora hay una forma de evitar esto usando algo llamado puntero.
‫Así que aquí, en lugar de almacenar la totalidad de Mi actor, tenemos una variable llamada mi actor
‫o un puntero actor a actor que no almacena todo el actor.
‫Simplemente almacena la dirección donde puede encontrar un acto.
‫Entonces puede ver que en realidad usa mucha menos memoria para almacenar una dirección.
‫Y luego lo que hacemos es en su actor, almacenamos la dirección de mi actor, por lo que termina apuntando al actor
‫original en lugar de copiar los datos, de ahí el puntero del nombre.
‫Ahora bien, esta no es la sintaxis real en C++.
‫En C++, la sintaxis es mucho más condensada.
‫Decimos que algo es un puntero poniendo una estrella después del tipo.
‫Entonces, una estrella de actor significa que este es un puntero de actor y para obtener la dirección de una variable, usamos un
‫ampersand que no usaremos.
‫Haga mucho uso de esta dirección desactivada todavía porque hay muchas funciones en irreal que devuelven
‫punteros.
‫Entonces, solo necesitamos saber cómo usar esos puntos en lugar de crearlos por el momento.
‫Entonces, una de esas funciones que nos permite acceder a otros objetos en nuestra escena es get ona.
‫Entonces, ¿por qué se aplica esto cuando tenemos un componente que es propiedad de un actor?
‫Entonces, si queríamos que este componente hablara con nuestro actor, para obtener su ubicación, establecer su ubicación
‫y hacer cosas así, entonces necesitamos poder apuntar a ese actor.
‫No queremos tomar una copia de ella.
‫De hecho, no queremos copiarlo porque queremos cambiar al actor.
‫Si estamos haciendo un cambio en una copia, en realidad no aparecerá en la escena.
‫Entonces necesitamos poder almacenar una variable que sea un puntero a un actor.
‫La forma en que hacemos esto, como acabamos de ver en las diapositivas, es tener un tipo de actor.
‫Pero luego ponemos una estrella al final que nos dice que este no es un actor que se almacena aquí, es
‫solo la dirección de un actor que se almacena.
‫Así que tomamos el actor y lo llamaremos propietario, y luego lo igualaremos al resultado
‫de llamar a obtener propietario.
‫Entonces, obtener propietario es una función de un componente de actor que le permite obtener un puntero de propietario, obtener un
‫puntero de actor que apunta al propietario, poner un punto y coma al final de esa línea.
‫Y lo que tenemos aquí es una variable que almacena la dirección de un actor que posee este componente en
‫particular.
‫Así que me gustaría desafiarte a que hagas algo imprimiendo la dirección de esta variable.
‫Entonces use la variable actor y use el porcentaje que formatea.
‫Especifique finalizar los registros.
‫Entonces, el porcentaje de usted esencialmente significa que está usando un número entero sin signo.
‫Eso significa un número entero que no puede ser negativo, lo cual tiene sentido porque las direcciones no
‫pueden ser negativas cuando hablamos de dónde encontrar memoria y luego averiguar qué imprime, ve a jugar, mira el mensaje de
‫registro, mira qué se imprime.
‫¿Cambia entre diferentes jugadas si dejas de jugar y empiezas a jugar de nuevo?
‫¿Y si la película cuenta con varios actores?
‫¿Hay varias direcciones diferentes impresas en la consola?
‫Pausa el video e investiga un poco.
‫Bueno.
‫Bienvenido de nuevo.
‫Vamos a ir a este otro registro y vamos a decir empresa de mudanzas, dirección propia, porcentaje de dos puntos.
‫Ya sabes, ahí es donde va a poner el punto de valor.
‫Y luego vamos a poner el puntero real.
‫Así que vamos a tener al dueño aquí.
‫Así que va a imprimir la dirección del propietario.
‫Pasemos a lo irreal.
‫Golpea control alt f 11.
‫Y cuando termine de compilarse, vamos a darle al play.
‫Y lo que estamos viendo es que el mensaje de registro mueve la dirección del propietario y nos está dando
‫un número muy grande en realidad para esta dirección.
‫¿Qué pasa si dejo de jugar y vuelvo a jugar solo por un segundo?
‫Puedes ver que la dirección es sustancialmente diferente y eso se debe a que cada vez
‫que presionamos reproducir, Unreal está creando un conjunto completamente nuevo de actores en la escena, básicamente listos para jugar, comenzando desde
‫cero.
‫Es por eso que vemos nuevas ubicaciones de direcciones cada vez que presionamos reproducir.
‫¿Qué sucede si fui a este pilar, por ejemplo, y agregué un movimiento, un componente al pilar también, y presionamos reproducir y nos
‫desplazamos hacia abajo hasta el final de mis registros?
‫Puede ver que aquí se imprimen dos direcciones diferentes para cada marca porque hay dos actores
‫diferentes que se almacenan en dos ubicaciones diferentes en la memoria.
‫Entonces, estas son las dos direcciones y pueden ver que en realidad
‫hay bastantes megabytes de diferencia entre estas dos direcciones, lo que solo indica cuánta información Unreal
‫almacena en la memoria y también por qué es importante ser eficiente con no hacer demasiadas copias.
‫Eso es todo por esta conferencia.
‫Te veré adentro.
‫El próximo será hacer cosas más divertidas con punteros.