‫Quindi sappiamo che abbiamo bisogno di alcuni componenti sulla nostra base: classe.
‫Sappiamo che abbiamo bisogno di una rete di base per la parte inferiore del serbatoio e la torretta.
‫Abbiamo anche bisogno di una maglia della torretta per la parte superiore.
‫Abbiamo bisogno di una capsula per gestire la collisione e abbiamo bisogno di un punto di spawn dei proiettili.
‫Sarà una componente della scena.
‫Ora, una volta aggiunte queste cose alla classe pod di base, tutto ciò che creiamo in base
‫a questa classe erediterà quelle cose.
‫Quindi potremmo creare un carro armato basato sulla base -- e poi potremmo creare una torre anch'essa basata sulla base
‫--.
‫E poiché si basano sul pod di base, ereditano questi componenti.
‫Il serbatoio può avere la propria rete di base, la propria rete della torretta, la propria capsula e il proprio punto di spawn del
‫proiettile.
‫E allo stesso modo, la torre avrà il suo componente della capsula della maglia della torretta della maglia di base e anche il punto di
‫spawn del proiettile.
‫E vedremo molto presto come assegnare mesh diverse a ciascuna di queste in modo che sembrino diverse.
‫Quindi sappiamo che abbiamo bisogno di alcuni componenti.
‫Ora è il momento di aggiungere effettivamente alcuni componenti alla nostra classe base.
‫Ora, per impostazione predefinita, abbiamo già una sezione pubblica, una sezione protetta e la seconda sezione pubblica
‫qui sotto.
‫Ci sono vari motivi per avere più sezioni pubbliche e ne parleremo più avanti.
‫Ma per i nostri componenti creeremo una sezione privata.
‫Come hai appreso in precedenza, è bene che le variabili membro siano private, in modo che siano
‫accessibili solo dall'interno della classe che le possiede.
‫Quindi abbiamo bisogno di alcuni componenti.
‫Il primo che ho intenzione di aggiungere è la capsula.
‫Quindi creiamo una variabile di tipo componente della capsula.
‫Ora questo sarà un puntatore.
‫Useremo i puntatori per la maggior parte delle nostre variabili purché non siano tipi di base
‫come interi o float.
‫E come sai, questo perché i puntatori sono leggeri, sono solo indirizzi e ci consentono di
‫essere più efficienti.
‫Quindi abbiamo questo puntatore del componente della capsula U e chiameremo questo componente della capsula abbreviazione di componente della
‫capsula.
‫Ora appena sopra il componente della capsula, aggiungeremo una macro specifica per il motore irreale e la tua proprietà
‫in maiuscolo con le sue parentesi.
‫La tua proprietà è un modo per rendere il motore irreale consapevole di questa variabile in modo che possa partecipare ai motori
‫irreali.
‫Sistema di riflessione.
‫Il sistema di riflessione ci consente di fare cose come esporre questa variabile a progetti e partecipare alla raccolta
‫dei rifiuti e cose del genere.
‫Quindi aggiungere la tua proprietà sarà qualcosa che si aggiungerà ai nostri componenti mentre li creiamo.
‫Quindi abbiamo questo componente capsula e poiché stiamo usando il tipo di componente capsula YOU,
‫dobbiamo informare il compilatore di questo tipo.
‫Non sa per impostazione predefinita cos'è un componente della capsula.
‫Ora normalmente per dire al compilatore cos'è un componente capsula, includeremmo un file di intestazione qui in alto
‫con le nostre direttive include se andiamo alla documentazione del motore irreale e cerchiamo
‫il tuo componente capsula, possiamo vedere proprio qui dove dice include il file di intestazione
‫che dovremmo includere per informare il compilatore del componente capsule.
‫Ora potremmo includerlo proprio qui in alto e poi il nostro U.
‫Il tipo di componente della capsula verrebbe riconosciuto dal compilatore e tutto sarebbe hunky dory.
‫Ma in generale, una buona pratica quando si tratta di codificare queste cose è cercare di mantenere questo file di
‫intestazione il più piccolo possibile.
‫Ogni volta che includiamo un file di intestazione in questo file, un programma chiamato preprocessore prende tutto il contenuto di
‫quel file di intestazione, elimina alcune cose come i commenti e quindi incolla letteralmente tutto il
‫contenuto di quel file di intestazione in questo file.
‫Il risultato è che questo file diventa più grande perché ha il contenuto di quel file incluso
‫incollalo qui.
‫Vogliamo includere le cose solo quando le usiamo.
‫Quindi, come possiamo farla franca non includendo il file di intestazione qui nella base -- intestazione?
‫Bene, possiamo usare qualcosa in C++ noto come dichiarazione in avanti.
‫Dichiariamo questo tipo di componente della capsula u usando la parola chiave class in questo modo.
‫Si noti che il compilatore ora mostra questo tipo come verde ogni volta che inoltriamo la dichiarazione che una variabile è stata in grado di
‫farla franca non includendo il suo file di intestazione.
‫Sta dicendo al compilatore che questo è un tipo, quindi non ci darà più errori IntelliSense, dicendo che
‫non lo riconosce come un tipo.
‫Ora questo è un tipo incompleto.
‫Se proviamo effettivamente a utilizzare questo tipo accedendo a membri come funzioni e variabili o tentando di costruire
‫un oggetto di questo tipo, otterremmo un errore perché è un tipo incompleto.
‫Avremmo bisogno del file di intestazione incluso ovunque utilizziamo questo tipo per fare quelle cose in modo da poter inoltrare dichiarare un puntatore
‫di un tipo per evitare di aver bisogno del file di intestazione.
‫Ma è importante notare che abbiamo bisogno di file di intestazione per ereditare da classi particolari.
‫Si noti che questa classe eredita da uno stagno e il file di intestazione dello stagno è incluso qui in alto.
‫Quindi l'ereditarietà richiede il file di intestazione per il tipo da cui stiamo ereditando.
‫Quindi discutiamo della dichiarazione anticipata e del perché vogliamo farlo.
‫Diciamo che abbiamo una classe chiamata Base Pon che deve avere una variabile puntatore di tipo tuo
‫componente capsula.
‫Ora il tuo componente capsula si trova nel file di intestazione del componente capsula.
‫Ora useremo effettivamente questo tipo in base a quando costruiamo un oggetto della U.
‫Tipo di componente della capsula.
‫Quindi, in base a tutto ciò di cui abbiamo veramente bisogno è avere un puntatore del componente della capsula di tipo U.
‫Ora la verità è basata su H non ha effettivamente bisogno dei dettagli di implementazione della classe dei componenti della
‫capsula.
‫In altre parole, non è necessario sapere come sono definite le funzioni o anche quanto è grande la classe dei
‫componenti della capsula.
‫Un puntatore a componente capsula ha le stesse dimensioni di qualsiasi altro puntatore.
‫È solo un indirizzo.
‫Ora nella classe del piano di base.
‫Vogliamo costruire il componente della capsula.
‫Per questo motivo, abbiamo bisogno di conoscere la dimensione di un componente della capsula per poter disporre la memoria necessaria
‫per creare questo oggetto.
‫Quindi, mentre l'intestazione del componente della capsula non è strettamente necessaria nella base Ponca, è assolutamente necessaria nella base.
‫Porkpie Quindi una buona pratica di programmazione consiste nell'includere solo le intestazioni dove ne hai effettivamente bisogno, così possiamo farla franca dichiarando un puntatore
‫del componente della capsula di tipo U nel prodotto di base H e quindi includere i componenti della capsula in
‫cui abbiamo bisogno dei dettagli di implementazione perché stiamo costruendo un componente della capsula e abbiamo bisogno di conoscere
‫la dimensione di a.
‫Componente della capsula in memoria.
‫Ora discutiamo invece delle conseguenze dell'inclusione del file di intestazione in base pond FX.
‫Come abbiamo visto, possiamo assolutamente farlo e potresti pensare, beh, lo stiamo includendo in base
‫pont CP Comunque, quindi che differenza fa se lo includiamo in un file rispetto a un altro?
‫Ora è qui che entra in gioco il problema.
‫I file di intestazione sono progettati per essere inclusi da altri file.
‫Quindi diciamo che abbiamo Base Pond H e abbiamo incluso componenti della capsula in esso.
‫E poi più avanti abbiamo un'altra classe e avremo un puntatore del laghetto di base in un'altra
‫classe, proprio come avevamo un puntatore del componente della capsula nel pod di base.
‫Ora, invece di affrontare il problema di dichiarare in avanti il puntatore dello stagno di base
‫e qualche altra classe, lo dichiareremo semplicemente come normale e includeremo il pedone di base in qualche altra classe.
‫Quindi ora Base Pond H non include solo l'intestazione del componente della capsula, il che comporta la copia di più codice
‫in quel file di intestazione.
‫Ora qualche altra classe ha una base su, che include il componente della capsula.
‫Quindi tutto il contenuto e i componenti della capsula sono anche all'interno di qualche altra classe H e non è nemmeno
‫necessario lì.
‫Qualche altra classe di cui H deve solo conoscere la base non si preoccupa della componente della capsula.
‫Ora diciamo che continuiamo questo schema e creiamo un'altra classe chiamata ancora un'altra classe e ancora un'altra classe
‫potrebbe aver bisogno di avere un puntatore di tipo un'altra classe ora piuttosto che dichiarare in avanti.
‫Includiamo solo un'altra classe H in un'altra classe H e ora all'interno di un'altra classe H.
‫Anche se non abbiamo nemmeno bisogno dell'intestazione per la base pond o il componente della capsula H, l'abbiamo ottenuta
‫in un'altra classe perché un'altra classe include quei file di intestazione al suo interno.
‫Quindi abbiamo copie di tutto il contenuto dei componenti della capsula e sulla base di H bloccato qui in un'altra
‫classe, gonfiando quel file e aumentando i tempi di compilazione, tutto perché non abbiamo inoltrato la dichiarazione.
‫Quindi, invece, la cosa migliore da fare è includere i file di intestazione dove sono effettivamente necessari.
‫Quindi, se prendiamo i componenti della capsula e lo includiamo solo in base a CPP, poi in seguito, quando creiamo
‫un'altra classe e abbiamo effettivamente bisogno di usare il pod di base, possiamo includere l'intestazione lì
‫e la base su non include i componenti della capsula, quindi tutto quel codice extra non è incluso in qualche altra
‫classe.
‫E poi quando andiamo a creare un'altra classe che ha bisogno di un'altra classe, possiamo includere un'altra
‫classe che h in un'altra classe che CPP dove è effettivamente necessario e poi ancora un'altra classe che H non
‫viene riempita con il contenuto di altri file di intestazione di cui non ha bisogno.
‫Quindi, quando le classi hanno dipendenze come questa basate su dipende dal componente della capsula, è meglio mantenere
‫tali dipendenze al minimo.
‫Quindi ti sfiderò a creare un errore di compilazione.
‫Non dobbiamo avere paura degli errori di compilazione.
‫Sono solo una parte normale del processo di sviluppo.
‫Quindi ne genereremo uno intenzionalmente, torneremo indietro e rimuoveremo la parola chiave class e compileremo senza dichiarare
‫in avanti capsule comp.
‫Ora, quando dico compila, intendo che puoi compilare dal codice di Visual Studio, solo una normale compilazione C++.
‫Hai imparato come farlo oppure puoi semplicemente salvare il file e il codice di Visual Studio e avviare la codifica
‫in tempo reale.
‫Uno di questi va bene e una volta che lo avremo affrontato insieme, ti mostrerò cosa succede con entrambi i
‫metodi.
‫Se usi la codifica live, ovviamente guarderai l'output generato nella finestra di
‫codifica live anziché l'output che vedresti nel codice di Visual Studio.
‫Ora spoiler, riceverai un errore di compilazione, guarda il messaggio di errore di compilazione, guarda
‫cosa ti dice.
‫Questo è solo un familiarizzare con gli errori che generiamo.
‫Quindi, dopo questo, vai avanti e indietro, dichiara capsule comp usando la parola chiave class.
‫Dopo averlo fatto, compila di nuovo, questa volta dovresti ottenere una compilazione di successo.
‫Metti in pausa il video e prova.
‫Va bene, quindi distruggiamo il nostro codice qui.
‫Ho intenzione di rimuovere la parola chiave class.
‫Ok, quindi abbiamo tentato di compilare, ed ecco l'output nel terminale.
‫La prima cosa che vediamo è l'errore e ci fornisce un codice di errore e dice che capsule comp non è un membro
‫di un pedone di base.
‫Abbiamo una nota che dice dichiarazione C di un pedone di base e quindi vediamo che otteniamo altri errori come risultato
‫di ciò.
‫Così spesso gli studenti si confondono quando tentano di compilare e sembrano errori multipli.
‫Quindi questo dimostra che un singolo errore può propagare una serie di errori.
‫E questo non significa che devi andare a riparare un sacco di file.
‫L'errore potrebbe avere un'unica origine qui.
‫Sappiamo qual è l'origine dell'errore.
‫Dobbiamo inoltrare la dichiarazione.
‫Ora vediamo cosa succede se usiamo la codifica live invece della normale compilazione e del codice di Visual Studio.
‫Quindi andrò avanti e farò clic sul pulsante per avviare la codifica dal vivo e subito in rosso vedo la build
‫non riuscita e vediamo la stessa cosa qui.
‫Giusto qui.
‫Capsule comp non è un membro di una nota di pedone di base.
‫Vedi la dichiarazione di una pedina base.
‫Quindi vediamo la stessa cosa qui.
‫Quindi in entrambi i casi vedremo un errore come questo quando ci dimentichiamo di inoltrare la dichiarazione.
‫Quindi ora sappiamo che aspetto ha e ora siamo più informati e meno spaventati da questi misteriosi messaggi di errore
‫di compilazione.
‫Quindi quello che faremo è correggere questo errore dichiarando in avanti il componente della capsula, quindi possiamo tentare
‫di compilare di nuovo.
‫E ora abbiamo compilato senza errori.
‫Quindi ora vediamo come appare quando ci siamo dimenticati di dichiarare una variabile.
‫Tienilo a mente quando ricevi errori del compilatore in futuro.
‫Quindi, in sintesi, abbiamo discusso della dichiarazione anticipata durante la creazione di un nuovo puntatore e
‫abbiamo appreso che dovresti includere solo ciò che usi nel file CP e dovremmo includere il meno possibile nel file
‫H.
‫Sappiamo che non abbiamo bisogno del file di intestazione per dichiarare un nuovo puntatore fintanto che inoltriamo la dichiarazione e
‫che abbiamo bisogno del file di intestazione se stiamo costruendo un oggetto di un tipo particolare.
‫E abbiamo bisogno del file di intestazione per accedere a membri come funzioni e variabili e abbiamo visto che in realtà
‫abbiamo bisogno del file di intestazione per l'ereditarietà per ereditare da una classe.
‫Abbiamo bisogno di quel file di intestazione lì.
‫Quindi ora che sappiamo come inoltrare la dichiarazione di un tipo e abbiamo il nostro pointer capsule comp,
‫siamo pronti per costruire effettivamente un oggetto componente capsula e lo faremo nel prossimo video.
‫Ci vediamo presto.