﻿1
00:00:04,470 --> 00:00:08,280
‫Quindi sappiamo che abbiamo bisogno di alcuni componenti sulla nostra base: classe.

2
00:00:08,280 --> 00:00:12,570
‫Sappiamo che abbiamo bisogno di una rete di base per la parte inferiore del serbatoio e la torretta.

3
00:00:12,600 --> 00:00:15,270
‫Abbiamo anche bisogno di una maglia della torretta per la parte superiore.

4
00:00:15,300 --> 00:00:19,500
‫Abbiamo bisogno di una capsula per gestire la collisione e abbiamo bisogno di un punto di spawn dei proiettili.

5
00:00:19,500 --> 00:00:21,270
‫Sarà una componente della scena.

6
00:00:21,300 --> 00:00:26,460
‫Ora, una volta aggiunte queste cose alla classe pod di base, tutto ciò che creiamo in base

7
00:00:26,460 --> 00:00:28,320
‫a questa classe erediterà quelle cose.

8
00:00:28,320 --> 00:00:34,920
‫Quindi potremmo creare un carro armato basato sulla base -- e poi potremmo creare una torre anch'essa basata sulla base

9
00:00:34,920 --> 00:00:35,550
‫--.

10
00:00:35,700 --> 00:00:39,620
‫E poiché si basano sul pod di base, ereditano questi componenti.

11
00:00:39,630 --> 00:00:46,380
‫Il serbatoio può avere la propria rete di base, la propria rete della torretta, la propria capsula e il proprio punto di spawn del

12
00:00:46,380 --> 00:00:46,800
‫proiettile.

13
00:00:46,800 --> 00:00:52,500
‫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

14
00:00:52,500 --> 00:00:53,370
‫spawn del proiettile.

15
00:00:53,370 --> 00:00:58,560
‫E vedremo molto presto come assegnare mesh diverse a ciascuna di queste in modo che sembrino diverse.

16
00:00:58,560 --> 00:01:00,750
‫Quindi sappiamo che abbiamo bisogno di alcuni componenti.

17
00:01:00,750 --> 00:01:05,490
‫Ora è il momento di aggiungere effettivamente alcuni componenti alla nostra classe base.

18
00:01:05,910 --> 00:01:11,400
‫Ora, per impostazione predefinita, abbiamo già una sezione pubblica, una sezione protetta e la seconda sezione pubblica

19
00:01:11,400 --> 00:01:12,240
‫qui sotto.

20
00:01:12,570 --> 00:01:17,520
‫Ci sono vari motivi per avere più sezioni pubbliche e ne parleremo più avanti.

21
00:01:17,520 --> 00:01:20,880
‫Ma per i nostri componenti creeremo una sezione privata.

22
00:01:22,070 --> 00:01:28,400
‫Come hai appreso in precedenza, è bene che le variabili membro siano private, in modo che siano

23
00:01:28,400 --> 00:01:31,790
‫accessibili solo dall'interno della classe che le possiede.

24
00:01:31,790 --> 00:01:33,410
‫Quindi abbiamo bisogno di alcuni componenti.

25
00:01:33,680 --> 00:01:36,190
‫Il primo che ho intenzione di aggiungere è la capsula.

26
00:01:36,200 --> 00:01:40,760
‫Quindi creiamo una variabile di tipo componente della capsula.

27
00:01:42,160 --> 00:01:44,030
‫Ora questo sarà un puntatore.

28
00:01:44,070 --> 00:01:48,880
‫Useremo i puntatori per la maggior parte delle nostre variabili purché non siano tipi di base

29
00:01:48,880 --> 00:01:50,340
‫come interi o float.

30
00:01:50,350 --> 00:01:55,600
‫E come sai, questo perché i puntatori sono leggeri, sono solo indirizzi e ci consentono di

31
00:01:55,600 --> 00:01:56,860
‫essere più efficienti.

32
00:01:56,950 --> 00:02:03,400
‫Quindi abbiamo questo puntatore del componente della capsula U e chiameremo questo componente della capsula abbreviazione di componente della

33
00:02:03,400 --> 00:02:04,030
‫capsula.

34
00:02:04,030 --> 00:02:11,140
‫Ora appena sopra il componente della capsula, aggiungeremo una macro specifica per il motore irreale e la tua proprietà

35
00:02:11,470 --> 00:02:14,020
‫in maiuscolo con le sue parentesi.

36
00:02:14,020 --> 00:02:20,590
‫La tua proprietà è un modo per rendere il motore irreale consapevole di questa variabile in modo che possa partecipare ai motori

37
00:02:20,590 --> 00:02:20,980
‫irreali.

38
00:02:20,980 --> 00:02:22,240
‫Sistema di riflessione.

39
00:02:22,690 --> 00:02:28,750
‫Il sistema di riflessione ci consente di fare cose come esporre questa variabile a progetti e partecipare alla raccolta

40
00:02:28,750 --> 00:02:31,060
‫dei rifiuti e cose del genere.

41
00:02:31,060 --> 00:02:36,400
‫Quindi aggiungere la tua proprietà sarà qualcosa che si aggiungerà ai nostri componenti mentre li creiamo.

42
00:02:36,400 --> 00:02:41,980
‫Quindi abbiamo questo componente capsula e poiché stiamo usando il tipo di componente capsula YOU,

43
00:02:41,980 --> 00:02:44,860
‫dobbiamo informare il compilatore di questo tipo.

44
00:02:44,860 --> 00:02:48,250
‫Non sa per impostazione predefinita cos'è un componente della capsula.

45
00:02:48,250 --> 00:02:54,640
‫Ora normalmente per dire al compilatore cos'è un componente capsula, includeremmo un file di intestazione qui in alto

46
00:02:54,640 --> 00:02:59,680
‫con le nostre direttive include se andiamo alla documentazione del motore irreale e cerchiamo

47
00:02:59,710 --> 00:03:05,200
‫il tuo componente capsula, possiamo vedere proprio qui dove dice include il file di intestazione

48
00:03:05,200 --> 00:03:08,950
‫che dovremmo includere per informare il compilatore del componente capsule.

49
00:03:08,950 --> 00:03:13,000
‫Ora potremmo includerlo proprio qui in alto e poi il nostro U.

50
00:03:13,000 --> 00:03:18,160
‫Il tipo di componente della capsula verrebbe riconosciuto dal compilatore e tutto sarebbe hunky dory.

51
00:03:18,220 --> 00:03:24,070
‫Ma in generale, una buona pratica quando si tratta di codificare queste cose è cercare di mantenere questo file di

52
00:03:24,070 --> 00:03:25,720
‫intestazione il più piccolo possibile.

53
00:03:25,720 --> 00:03:32,380
‫Ogni volta che includiamo un file di intestazione in questo file, un programma chiamato preprocessore prende tutto il contenuto di

54
00:03:32,380 --> 00:03:37,720
‫quel file di intestazione, elimina alcune cose come i commenti e quindi incolla letteralmente tutto il

55
00:03:37,720 --> 00:03:40,780
‫contenuto di quel file di intestazione in questo file.

56
00:03:41,050 --> 00:03:46,810
‫Il risultato è che questo file diventa più grande perché ha il contenuto di quel file incluso

57
00:03:46,810 --> 00:03:47,530
‫incollalo qui.

58
00:03:47,530 --> 00:03:50,950
‫Vogliamo includere le cose solo quando le usiamo.

59
00:03:50,950 --> 00:03:56,740
‫Quindi, come possiamo farla franca non includendo il file di intestazione qui nella base -- intestazione?

60
00:03:56,740 --> 00:04:02,380
‫Bene, possiamo usare qualcosa in C++ noto come dichiarazione in avanti.

61
00:04:02,380 --> 00:04:07,990
‫Dichiariamo questo tipo di componente della capsula u usando la parola chiave class in questo modo.

62
00:04:08,470 --> 00:04:15,310
‫Si noti che il compilatore ora mostra questo tipo come verde ogni volta che inoltriamo la dichiarazione che una variabile è stata in grado di

63
00:04:15,310 --> 00:04:18,010
‫farla franca non includendo il suo file di intestazione.

64
00:04:18,010 --> 00:04:23,830
‫Sta dicendo al compilatore che questo è un tipo, quindi non ci darà più errori IntelliSense, dicendo che

65
00:04:23,830 --> 00:04:26,170
‫non lo riconosce come un tipo.

66
00:04:26,170 --> 00:04:28,150
‫Ora questo è un tipo incompleto.

67
00:04:28,150 --> 00:04:34,150
‫Se proviamo effettivamente a utilizzare questo tipo accedendo a membri come funzioni e variabili o tentando di costruire

68
00:04:34,150 --> 00:04:38,560
‫un oggetto di questo tipo, otterremmo un errore perché è un tipo incompleto.

69
00:04:38,560 --> 00:04:44,950
‫Avremmo bisogno del file di intestazione incluso ovunque utilizziamo questo tipo per fare quelle cose in modo da poter inoltrare dichiarare un puntatore

70
00:04:44,950 --> 00:04:48,400
‫di un tipo per evitare di aver bisogno del file di intestazione.

71
00:04:48,400 --> 00:04:53,230
‫Ma è importante notare che abbiamo bisogno di file di intestazione per ereditare da classi particolari.

72
00:04:53,230 --> 00:05:00,130
‫Si noti che questa classe eredita da uno stagno e il file di intestazione dello stagno è incluso qui in alto.

73
00:05:00,130 --> 00:05:05,470
‫Quindi l'ereditarietà richiede il file di intestazione per il tipo da cui stiamo ereditando.

74
00:05:05,470 --> 00:05:09,100
‫Quindi discutiamo della dichiarazione anticipata e del perché vogliamo farlo.

75
00:05:09,130 --> 00:05:16,120
‫Diciamo che abbiamo una classe chiamata Base Pon che deve avere una variabile puntatore di tipo tuo

76
00:05:16,120 --> 00:05:17,020
‫componente capsula.

77
00:05:17,050 --> 00:05:22,060
‫Ora il tuo componente capsula si trova nel file di intestazione del componente capsula.

78
00:05:22,060 --> 00:05:28,470
‫Ora useremo effettivamente questo tipo in base a quando costruiamo un oggetto della U.

79
00:05:28,480 --> 00:05:30,010
‫Tipo di componente della capsula.

80
00:05:30,010 --> 00:05:36,820
‫Quindi, in base a tutto ciò di cui abbiamo veramente bisogno è avere un puntatore del componente della capsula di tipo U.

81
00:05:37,000 --> 00:05:44,440
‫Ora la verità è basata su H non ha effettivamente bisogno dei dettagli di implementazione della classe dei componenti della

82
00:05:44,440 --> 00:05:45,160
‫capsula.

83
00:05:45,160 --> 00:05:50,680
‫In altre parole, non è necessario sapere come sono definite le funzioni o anche quanto è grande la classe dei

84
00:05:50,680 --> 00:05:51,820
‫componenti della capsula.

85
00:05:51,850 --> 00:05:55,750
‫Un puntatore a componente capsula ha le stesse dimensioni di qualsiasi altro puntatore.

86
00:05:55,750 --> 00:05:57,250
‫È solo un indirizzo.

87
00:05:57,250 --> 00:05:58,810
‫Ora nella classe del piano di base.

88
00:05:58,810 --> 00:06:01,420
‫Vogliamo costruire il componente della capsula.

89
00:06:01,510 --> 00:06:08,260
‫Per questo motivo, abbiamo bisogno di conoscere la dimensione di un componente della capsula per poter disporre la memoria necessaria

90
00:06:08,260 --> 00:06:09,790
‫per creare questo oggetto.

91
00:06:09,790 --> 00:06:16,330
‫Quindi, mentre l'intestazione del componente della capsula non è strettamente necessaria nella base Ponca, è assolutamente necessaria nella base.

92
00:06:16,350 --> 00:06:24,970
‫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

93
00:06:24,970 --> 00:06:32,410
‫del componente della capsula di tipo U nel prodotto di base H e quindi includere i componenti della capsula in

94
00:06:32,410 --> 00:06:39,310
‫cui abbiamo bisogno dei dettagli di implementazione perché stiamo costruendo un componente della capsula e abbiamo bisogno di conoscere

95
00:06:39,310 --> 00:06:41,020
‫la dimensione di a.

96
00:06:41,310 --> 00:06:43,230
‫Componente della capsula in memoria.

97
00:06:43,350 --> 00:06:49,920
‫Ora discutiamo invece delle conseguenze dell'inclusione del file di intestazione in base pond FX.

98
00:06:50,010 --> 00:06:55,410
‫Come abbiamo visto, possiamo assolutamente farlo e potresti pensare, beh, lo stiamo includendo in base

99
00:06:55,410 --> 00:07:01,230
‫pont CP Comunque, quindi che differenza fa se lo includiamo in un file rispetto a un altro?

100
00:07:01,260 --> 00:07:03,180
‫Ora è qui che entra in gioco il problema.

101
00:07:03,210 --> 00:07:07,390
‫I file di intestazione sono progettati per essere inclusi da altri file.

102
00:07:07,410 --> 00:07:12,810
‫Quindi diciamo che abbiamo Base Pond H e abbiamo incluso componenti della capsula in esso.

103
00:07:12,810 --> 00:07:18,600
‫E poi più avanti abbiamo un'altra classe e avremo un puntatore del laghetto di base in un'altra

104
00:07:18,600 --> 00:07:23,370
‫classe, proprio come avevamo un puntatore del componente della capsula nel pod di base.

105
00:07:23,400 --> 00:07:28,230
‫Ora, invece di affrontare il problema di dichiarare in avanti il puntatore dello stagno di base

106
00:07:28,230 --> 00:07:33,810
‫e qualche altra classe, lo dichiareremo semplicemente come normale e includeremo il pedone di base in qualche altra classe.

107
00:07:34,680 --> 00:07:41,520
‫Quindi ora Base Pond H non include solo l'intestazione del componente della capsula, il che comporta la copia di più codice

108
00:07:41,520 --> 00:07:43,190
‫in quel file di intestazione.

109
00:07:43,200 --> 00:07:47,820
‫Ora qualche altra classe ha una base su, che include il componente della capsula.

110
00:07:47,820 --> 00:07:55,470
‫Quindi tutto il contenuto e i componenti della capsula sono anche all'interno di qualche altra classe H e non è nemmeno

111
00:07:55,470 --> 00:07:56,400
‫necessario lì.

112
00:07:56,400 --> 00:08:01,910
‫Qualche altra classe di cui H deve solo conoscere la base non si preoccupa della componente della capsula.

113
00:08:01,920 --> 00:08:07,920
‫Ora diciamo che continuiamo questo schema e creiamo un'altra classe chiamata ancora un'altra classe e ancora un'altra classe

114
00:08:07,920 --> 00:08:13,680
‫potrebbe aver bisogno di avere un puntatore di tipo un'altra classe ora piuttosto che dichiarare in avanti.

115
00:08:13,680 --> 00:08:21,180
‫Includiamo solo un'altra classe H in un'altra classe H e ora all'interno di un'altra classe H.

116
00:08:21,210 --> 00:08:27,840
‫Anche se non abbiamo nemmeno bisogno dell'intestazione per la base pond o il componente della capsula H, l'abbiamo ottenuta

117
00:08:27,840 --> 00:08:32,730
‫in un'altra classe perché un'altra classe include quei file di intestazione al suo interno.

118
00:08:32,730 --> 00:08:40,140
‫Quindi abbiamo copie di tutto il contenuto dei componenti della capsula e sulla base di H bloccato qui in un'altra

119
00:08:40,140 --> 00:08:46,620
‫classe, gonfiando quel file e aumentando i tempi di compilazione, tutto perché non abbiamo inoltrato la dichiarazione.

120
00:08:46,620 --> 00:08:52,440
‫Quindi, invece, la cosa migliore da fare è includere i file di intestazione dove sono effettivamente necessari.

121
00:08:52,440 --> 00:08:59,610
‫Quindi, se prendiamo i componenti della capsula e lo includiamo solo in base a CPP, poi in seguito, quando creiamo

122
00:08:59,610 --> 00:09:05,340
‫un'altra classe e abbiamo effettivamente bisogno di usare il pod di base, possiamo includere l'intestazione lì

123
00:09:05,340 --> 00:09:12,840
‫e la base su non include i componenti della capsula, quindi tutto quel codice extra non è incluso in qualche altra

124
00:09:12,840 --> 00:09:13,440
‫classe.

125
00:09:13,440 --> 00:09:18,810
‫E poi quando andiamo a creare un'altra classe che ha bisogno di un'altra classe, possiamo includere un'altra

126
00:09:18,810 --> 00:09:24,990
‫classe che h in un'altra classe che CPP dove è effettivamente necessario e poi ancora un'altra classe che H non

127
00:09:24,990 --> 00:09:30,270
‫viene riempita con il contenuto di altri file di intestazione di cui non ha bisogno.

128
00:09:30,270 --> 00:09:36,990
‫Quindi, quando le classi hanno dipendenze come questa basate su dipende dal componente della capsula, è meglio mantenere

129
00:09:36,990 --> 00:09:38,670
‫tali dipendenze al minimo.

130
00:09:38,880 --> 00:09:42,570
‫Quindi ti sfiderò a creare un errore di compilazione.

131
00:09:42,570 --> 00:09:44,970
‫Non dobbiamo avere paura degli errori di compilazione.

132
00:09:44,970 --> 00:09:47,550
‫Sono solo una parte normale del processo di sviluppo.

133
00:09:47,550 --> 00:09:54,210
‫Quindi ne genereremo uno intenzionalmente, torneremo indietro e rimuoveremo la parola chiave class e compileremo senza dichiarare

134
00:09:54,210 --> 00:09:56,160
‫in avanti capsule comp.

135
00:09:56,160 --> 00:10:04,080
‫Ora, quando dico compila, intendo che puoi compilare dal codice di Visual Studio, solo una normale compilazione C++.

136
00:10:04,110 --> 00:10:10,500
‫Hai imparato come farlo oppure puoi semplicemente salvare il file e il codice di Visual Studio e avviare la codifica

137
00:10:10,500 --> 00:10:11,670
‫in tempo reale.

138
00:10:11,670 --> 00:10:16,800
‫Uno di questi va bene e una volta che lo avremo affrontato insieme, ti mostrerò cosa succede con entrambi i

139
00:10:16,800 --> 00:10:17,280
‫metodi.

140
00:10:17,280 --> 00:10:22,440
‫Se usi la codifica live, ovviamente guarderai l'output generato nella finestra di

141
00:10:22,440 --> 00:10:27,270
‫codifica live anziché l'output che vedresti nel codice di Visual Studio.

142
00:10:27,270 --> 00:10:33,060
‫Ora spoiler, riceverai un errore di compilazione, guarda il messaggio di errore di compilazione, guarda

143
00:10:33,060 --> 00:10:34,260
‫cosa ti dice.

144
00:10:34,470 --> 00:10:38,070
‫Questo è solo un familiarizzare con gli errori che generiamo.

145
00:10:38,070 --> 00:10:43,500
‫Quindi, dopo questo, vai avanti e indietro, dichiara capsule comp usando la parola chiave class.

146
00:10:43,620 --> 00:10:48,450
‫Dopo averlo fatto, compila di nuovo, questa volta dovresti ottenere una compilazione di successo.

147
00:10:48,780 --> 00:10:51,060
‫Metti in pausa il video e prova.

148
00:10:53,520 --> 00:10:56,350
‫Va bene, quindi distruggiamo il nostro codice qui.

149
00:10:56,370 --> 00:10:58,320
‫Ho intenzione di rimuovere la parola chiave class.

150
00:10:58,700 --> 00:11:03,540
‫Ok, quindi abbiamo tentato di compilare, ed ecco l'output nel terminale.

151
00:11:03,570 --> 00:11:09,300
‫La prima cosa che vediamo è l'errore e ci fornisce un codice di errore e dice che capsule comp non è un membro

152
00:11:09,300 --> 00:11:10,830
‫di un pedone di base.

153
00:11:10,860 --> 00:11:17,040
‫Abbiamo una nota che dice dichiarazione C di un pedone di base e quindi vediamo che otteniamo altri errori come risultato

154
00:11:17,040 --> 00:11:17,940
‫di ciò.

155
00:11:17,940 --> 00:11:23,390
‫Così spesso gli studenti si confondono quando tentano di compilare e sembrano errori multipli.

156
00:11:23,400 --> 00:11:28,560
‫Quindi questo dimostra che un singolo errore può propagare una serie di errori.

157
00:11:28,560 --> 00:11:31,670
‫E questo non significa che devi andare a riparare un sacco di file.

158
00:11:31,680 --> 00:11:34,410
‫L'errore potrebbe avere un'unica origine qui.

159
00:11:34,410 --> 00:11:36,420
‫Sappiamo qual è l'origine dell'errore.

160
00:11:36,420 --> 00:11:37,820
‫Dobbiamo inoltrare la dichiarazione.

161
00:11:37,830 --> 00:11:45,150
‫Ora vediamo cosa succede se usiamo la codifica live invece della normale compilazione e del codice di Visual Studio.

162
00:11:45,150 --> 00:11:51,450
‫Quindi andrò avanti e farò clic sul pulsante per avviare la codifica dal vivo e subito in rosso vedo la build

163
00:11:51,450 --> 00:11:54,270
‫non riuscita e vediamo la stessa cosa qui.

164
00:11:54,270 --> 00:11:55,050
‫Giusto qui.

165
00:11:55,050 --> 00:11:59,310
‫Capsule comp non è un membro di una nota di pedone di base.

166
00:11:59,340 --> 00:12:01,860
‫Vedi la dichiarazione di una pedina base.

167
00:12:01,860 --> 00:12:03,750
‫Quindi vediamo la stessa cosa qui.

168
00:12:03,750 --> 00:12:08,490
‫Quindi in entrambi i casi vedremo un errore come questo quando ci dimentichiamo di inoltrare la dichiarazione.

169
00:12:08,490 --> 00:12:16,170
‫Quindi ora sappiamo che aspetto ha e ora siamo più informati e meno spaventati da questi misteriosi messaggi di errore

170
00:12:16,170 --> 00:12:17,340
‫di compilazione.

171
00:12:17,460 --> 00:12:23,280
‫Quindi quello che faremo è correggere questo errore dichiarando in avanti il componente della capsula, quindi possiamo tentare

172
00:12:23,280 --> 00:12:24,990
‫di compilare di nuovo.

173
00:12:24,990 --> 00:12:27,780
‫E ora abbiamo compilato senza errori.

174
00:12:27,870 --> 00:12:32,070
‫Quindi ora vediamo come appare quando ci siamo dimenticati di dichiarare una variabile.

175
00:12:32,100 --> 00:12:35,250
‫Tienilo a mente quando ricevi errori del compilatore in futuro.

176
00:12:35,760 --> 00:12:41,490
‫Quindi, in sintesi, abbiamo discusso della dichiarazione anticipata durante la creazione di un nuovo puntatore e

177
00:12:41,490 --> 00:12:48,370
‫abbiamo appreso che dovresti includere solo ciò che usi nel file CP e dovremmo includere il meno possibile nel file

178
00:12:48,450 --> 00:12:49,020
‫H.

179
00:12:49,050 --> 00:12:55,020
‫Sappiamo che non abbiamo bisogno del file di intestazione per dichiarare un nuovo puntatore fintanto che inoltriamo la dichiarazione e

180
00:12:55,020 --> 00:13:00,090
‫che abbiamo bisogno del file di intestazione se stiamo costruendo un oggetto di un tipo particolare.

181
00:13:00,090 --> 00:13:05,850
‫E abbiamo bisogno del file di intestazione per accedere a membri come funzioni e variabili e abbiamo visto che in realtà

182
00:13:05,850 --> 00:13:09,780
‫abbiamo bisogno del file di intestazione per l'ereditarietà per ereditare da una classe.

183
00:13:09,780 --> 00:13:11,460
‫Abbiamo bisogno di quel file di intestazione lì.

184
00:13:11,580 --> 00:13:17,160
‫Quindi ora che sappiamo come inoltrare la dichiarazione di un tipo e abbiamo il nostro pointer capsule comp,

185
00:13:17,160 --> 00:13:21,840
‫siamo pronti per costruire effettivamente un oggetto componente capsula e lo faremo nel prossimo video.

186
00:13:22,200 --> 00:13:23,040
‫Ci vediamo presto.

