‫Entonces sabemos que necesitamos algunos componentes en nuestra clase base.
‫Sabemos que necesitamos una malla base para la parte inferior del tanque y la torreta.
‫También necesitamos una malla de torreta para la parte superior.
‫Necesitamos una cápsula para manejar la colisión y necesitamos un punto de generación de proyectiles.
‫Eso va a ser un componente de la escena.
‫Ahora, una vez que hayamos agregado estas cosas a la clase de pod base, todo lo que creemos basado
‫en esta clase heredará esas cosas.
‫Así que podríamos crear un tanque basado en la base, y luego podríamos ir y crear una torre también basada en
‫la base.
‫Y debido a que se basan en el pod base, heredan estos componentes.
‫El tanque puede tener su propia malla de base, su propia malla de torreta, su propia cápsula y su propio punto de generación de
‫proyectiles.
‫Y del mismo modo, la torre obtendrá su propio componente de cápsula de malla de torreta de malla base y también un punto de
‫generación de proyectiles.
‫Y veremos muy pronto cómo podemos asignar diferentes mallas a cada uno de estos para que se vean diferentes.
‫Así que sabemos que necesitamos algunos componentes.
‫Ahora es el momento de agregar algunos componentes a nuestra clase base.
‫Ahora, por defecto, ya tenemos una sección pública, una sección protegida y la segunda sección pública
‫aquí abajo.
‫Hay varias razones para tener múltiples secciones públicas y hablaremos de ellas más adelante.
‫Pero para nuestros componentes, vamos a crear una sección privada.
‫Como aprendió anteriormente, es bueno que las variables miembro sean privadas, de modo que solo sean accesibles
‫desde dentro de la clase que las posee.
‫Así que necesitamos algunos componentes.
‫El primero que voy a añadir es la cápsula.
‫Así que vamos a crear una variable de tipo componente de cápsula.
‫Ahora esto va a ser un puntero.
‫Vamos a usar punteros para la mayoría de nuestras variables siempre que no sean tipos base
‫como entero o flotante.
‫Y como saben, eso se debe a que los punteros son livianos, son solo direcciones y nos
‫permiten ser más eficientes.
‫Así que tenemos este indicador de componente de cápsula U y lo llamaremos componente de cápsula como abreviatura de componente de
‫cápsula.
‫Ahora, justo encima del componente de la cápsula, vamos a agregar una macro específica del motor irreal y es de su
‫propiedad en mayúsculas con sus propios paréntesis.
‫Su propiedad es una forma de hacer que el motor irreal sea consciente de esta variable para que pueda participar en los motores
‫irreales.
‫Sistema de reflexión.
‫El sistema de reflexión nos permite hacer cosas como exponer esta variable a planos y participar en la recolección
‫de basura y cosas por el estilo.
‫Entonces, agregar la propiedad you será algo que se agregará a nuestros componentes a medida que los creamos.
‫Así que tenemos este componente de cápsula y debido a que estamos usando el tipo de componente de
‫cápsula TÚ, debemos informarle al compilador sobre este tipo.
‫No sabe por defecto qué es un componente de cápsula.
‫Ahora, normalmente para decirle al compilador qué es un componente de la cápsula, incluiríamos un archivo de encabezado aquí en la
‫parte superior con nuestras directivas de inclusión si vamos a la documentación del motor irreal y
‫buscamos su componente de la cápsula, podemos ver aquí donde dice incluya el archivo de encabezado que necesitaríamos
‫incluir para informar al compilador sobre el componente de la cápsula.
‫Ahora podríamos incluir esto aquí en la parte superior y luego nuestra U.
‫El compilador reconocería el tipo de componente de la cápsula y todo sería perfecto.
‫Pero, en general, una buena práctica cuando se trata de codificar estas cosas es tratar de mantener este archivo de
‫encabezado lo más pequeño posible.
‫Cada vez que incluimos un archivo de encabezado en este archivo, un programa llamado preprocesador toma todo el contenido de
‫ese archivo de encabezado, elimina algunas cosas como comentarios y luego, literalmente, pega todo el contenido
‫de ese archivo de encabezado en este archivo.
‫El resultado es que este archivo se hace más grande porque tiene el contenido de ese archivo incluido y
‫pégalo aquí.
‫Solo queremos incluir cosas cuando las usamos.
‫Entonces, ¿cómo nos salimos con la nuestra sin incluir el archivo de encabezado aquí en el encabezado base?
‫Bueno, podemos usar algo en C++ conocido como declaración directa.
‫Reenviamos la declaración de este tipo de componente de cápsula u usando la palabra clave class como esta.
‫Observe que el compilador ahora muestra este tipo en verde cada vez que reenviamos declarar una variable y luego pudimos salirnos con
‫la nuestra sin incluir su archivo de encabezado.
‫Le dice al compilador que este es un tipo, por lo que ya no nos dará errores de IntelliSense, diciendo
‫que no lo reconoce como un tipo.
‫Ahora bien, este es un tipo incompleto.
‫Si intentamos usar este tipo ya sea accediendo a miembros como funciones y variables o tratando de construir
‫un objeto de este tipo, obtendríamos un error porque es un tipo incompleto.
‫Necesitaríamos incluir el archivo de encabezado siempre que usemos este tipo para hacer esas cosas, de modo que podamos declarar un
‫puntero de un tipo para evitar necesitar el archivo de encabezado.
‫Pero es importante tener en cuenta que necesitamos archivos de encabezado para heredar de clases particulares.
‫Tenga en cuenta que esta clase se hereda de un estanque y el archivo de encabezado del estanque se incluye aquí en la parte superior.
‫Entonces, la herencia requiere el archivo de encabezado para el tipo del que estamos heredando.
‫Así que analicemos la declaración directa y por qué queremos hacerlo.
‫Digamos que tenemos una clase llamada Base Pon que necesita tener una variable de puntero del tipo de componente
‫de cápsula.
‫Ahora su componente de cápsula está en el archivo de encabezado del componente de cápsula.
‫Ahora vamos a usar este tipo en base a cuando construimos un objeto de la U.
‫Tipo de componente de la cápsula.
‫Entonces, en base a todo lo que realmente necesitamos es tener un puntero del componente de cápsula tipo U.
‫Ahora, la verdad se basa en que H en realidad no necesita los detalles de implementación de la clase de componente de
‫la cápsula.
‫En otras palabras, no necesita saber cómo se definen las funciones o incluso qué tan grande es la clase del
‫componente de la cápsula.
‫Un puntero de componente de cápsula tiene el mismo tamaño que cualquier otro puntero.
‫Es solo una dirección.
‫Ahora en la clase del plan base.
‫Queremos construir el componente de la cápsula.
‫Por esta razón, necesitamos saber el tamaño de un componente de cápsula para diseñar la memoria necesaria para
‫crear este objeto.
‫Entonces, si bien el encabezado del componente de la cápsula no es estrictamente necesario en la base Ponca, es absolutamente necesario en la base.
‫Porkpie Entonces, una buena práctica de programación es incluir solo encabezados donde realmente los necesite para que podamos declarar un puntero de
‫tipo U puntero de componente de cápsula en el producto base H y luego incluir componentes de cápsula donde
‫necesitamos los detalles de implementación porque estamos construyendo un componente de la cápsula y necesitamos saber el
‫tamaño de a.
‫Componente de la cápsula en la memoria.
‫Ahora analicemos las consecuencias de incluir el archivo de encabezado en el estanque base FX en su lugar.
‫Como hemos visto, podemos hacer esto absolutamente y usted puede estar pensando, bueno, lo estamos incluyendo
‫en base pont CP De todos modos, entonces, ¿qué diferencia hay si lo incluimos en un archivo u otro?
‫Ahora aquí es donde viene el problema.
‫Los archivos de encabezado están diseñados para ser incluidos por otros archivos.
‫Así que digamos que tenemos Base Pond H y hemos incluido componentes de cápsulas en él.
‫Y luego, más adelante, tenemos otra clase y vamos a tener un puntero de estanque base en otra clase,
‫al igual que teníamos un puntero de componente de cápsula en la vaina base.
‫Ahora, en lugar de tomarnos la molestia de declarar hacia adelante el puntero del estanque
‫base y alguna otra clase, simplemente lo declararemos como normal e incluiremos el peón base en alguna otra clase.
‫Entonces, ahora Base Pond H no solo incluye el encabezado del componente de la cápsula, lo que da como resultado que se copie más código
‫en ese archivo de encabezado.
‫Ahora alguna otra clase tiene base, que incluye el componente de la cápsula.
‫Entonces, todo el contenido y los componentes de la cápsula también están dentro de alguna otra clase H y ni siquiera se
‫necesitan allí.
‫Alguna otra clase que H solo necesita saber sobre la base de que no se preocupa por el componente de la cápsula.
‫Ahora digamos que continuamos con este patrón y creamos alguna otra clase llamada otra clase más, y es posible que
‫otra clase necesite tener un puntero de tipo alguna otra clase ahora en lugar de declarar hacia adelante.
‫Solo incluimos otra clase H en otra clase H y ahora dentro de otra clase H.
‫Aunque ni siquiera necesitamos el encabezado para el estanque base o el componente H de la cápsula, lo tenemos
‫en otra clase porque otra clase incluye esos archivos de encabezado dentro de él.
‫Así que tenemos copias de todos los contenidos de los componentes de la cápsula y basados en H simplemente atascados aquí en
‫otra clase más, inflando ese archivo y aumentando los tiempos de compilación, todo porque no reenviamos la declaración.
‫Entonces, en cambio, lo mejor que puede hacer es incluir archivos de encabezado donde realmente se necesitan.
‫Entonces, si tomamos los componentes de la cápsula y solo los incluimos en función del CPP, luego, más adelante, cuando creamos
‫alguna otra clase y realmente necesitamos usar el módulo base, podemos incluir el encabezado allí y
‫la base no incluye los componentes de la cápsula. por lo que todo ese código adicional no está incluido en alguna otra
‫clase.
‫Y luego, cuando vamos y creamos otra clase que necesita otra clase, podemos incluir otra clase
‫que h en otra clase más que CPP donde realmente se necesita y luego otra clase más que
‫H no se llena con el contenido de otros archivos de encabezado que no necesita.
‫Entonces, cuando las clases tienen dependencias como esta basadas en el componente de la cápsula, es mejor mantener
‫esas dependencias al mínimo.
‫Así que voy a desafiarte a que crees un error de compilación.
‫No debemos temer los errores de compilación.
‫Son sólo una parte normal del proceso de desarrollo.
‫Así que vamos a generar uno intencionalmente, retroceder y eliminar la palabra clave de clase y compilar sin
‫declarar hacia adelante cápsula comp.
‫Ahora, cuando digo compilar, quiero decir que puede compilar desde el código de Visual Studio, solo una compilación normal de C++.
‫Aprendió cómo hacerlo, o simplemente puede guardar su archivo y el código de Visual Studio e iniciar la
‫codificación en vivo.
‫Cualquiera de los dos está bien y una vez que analicemos esto juntos, te mostraré lo que sucede con ambos
‫métodos.
‫Si usa la codificación en vivo, por supuesto que verá la salida generada en la ventana de codificación
‫en vivo en lugar de la salida que vería en el código de Visual Studio.
‫Ahora, spoiler, obtendrá un error de compilación, mire el mensaje de error de compilación, vea lo
‫que le dice.
‫Esto es solo para familiarizarnos con los errores que generamos.
‫Luego, después de esto, retroceda y avance, declare la composición de la cápsula usando la palabra clave de clase.
‫Una vez que haya hecho eso, vuelva a compilar, debería obtener una compilación exitosa esta vez.
‫Pausa el video y pruébalo.
‫Muy bien, vamos a causar estragos en nuestro código aquí.
‫Voy a eliminar la palabra clave class.
‫Bien, hemos intentado compilar, y aquí está el resultado en la terminal.
‫Lo primero que vemos es un error y nos da un código de error y dice que la composición de la cápsula no
‫es miembro de un peón base.
‫Tenemos una nota que dice declaración C de un peón base y luego vemos que tenemos otros errores como resultado
‫de esto.
‫Entonces, a menudo, los estudiantes se confunden cuando intentan compilar y parecen tener múltiples errores.
‫Así que esto demuestra que un solo error puede propagar una serie de errores.
‫Y eso no significa que tengas que ir y arreglar un montón de archivos.
‫El error podría tener un único origen aquí.
‫Sabemos cuál es el origen del error.
‫Necesitamos reenviar declarar.
‫Ahora veamos qué sucede si usamos la codificación en vivo en lugar de la compilación normal y el código de Visual Studio.
‫Así que seguiré adelante y haré clic en el botón para iniciar la codificación en vivo y de inmediato en rojo veo
‫que la compilación falló y vemos lo mismo aquí.
‫Aquí mismo.
‫Capsule comp no es miembro de una nota de empeño base.
‫Ver la declaración de un peón base.
‫Así que vemos lo mismo aquí.
‫Entonces, en cualquier caso, veremos un error como este cuando olvidemos declarar hacia adelante.
‫Así que ahora sabemos cómo se ve y ahora estamos más informados y menos temerosos de estos misteriosos mensajes de
‫error de compilación.
‫Entonces, lo que vamos a hacer es corregir este error declarando hacia adelante su componente de cápsula, y
‫luego podemos intentar compilar nuevamente.
‫Y ahora hemos compilado sin ningún error.
‫Así que ahora vemos cómo se ve cuando nos olvidamos de declarar una variable.
‫Tenga eso en cuenta cuando tenga errores del compilador en el futuro.
‫Entonces, en resumen, discutimos la declaración directa al crear un nuevo puntero y aprendimos que
‫solo debe incluir lo que usa en el archivo CP y debemos incluir lo menos posible en el archivo
‫H.
‫Sabemos que no necesitamos el archivo de encabezado para declarar un nuevo puntero, siempre que reenviemos la declaración y que
‫sí necesitamos el archivo de encabezado si vamos a construir un objeto de un tipo particular.
‫Y necesitamos el archivo de encabezado para acceder a miembros como funciones y variables y vimos que en
‫realidad necesitamos el archivo de encabezado para heredar de una clase.
‫Necesitamos ese archivo de encabezado allí.
‫Así que ahora que sabemos cómo reenviar declarar un tipo y tenemos nuestra composición de cápsula de puntero, estamos listos
‫para construir un objeto de componente de cápsula y lo haremos en el siguiente video.
‫Te veré pronto.