1
00:00:04,470 --> 00:00:08,280
‫Wiemy więc, że potrzebujemy jakichś komponentów w naszej bazie -- klasa.

2
00:00:08,280 --> 00:00:12,570
‫Wiemy, że potrzebujemy siatki bazowej dla dolnej części czołgu i wieży.

3
00:00:12,600 --> 00:00:15,270
‫Potrzebujemy również siatki wieżyczki do górnej części.

4
00:00:15,300 --> 00:00:19,500
‫Potrzebujemy kapsuły, aby poradzić sobie z kolizją i potrzebujemy punktu odrodzenia pocisku.

5
00:00:19,500 --> 00:00:21,270
‫To będzie składnik sceny.

6
00:00:21,300 --> 00:00:26,460
‫Teraz, gdy dodamy te rzeczy do podstawowej klasy pod, wszystko, co utworzymy na podstawie

7
00:00:26,460 --> 00:00:28,320
‫tej klasy, odziedziczy te rzeczy.

8
00:00:28,320 --> 00:00:34,920
‫Więc moglibyśmy stworzyć czołg oparty na podstawie -- a potem moglibyśmy stworzyć wieżę również opartą na podstawie

9
00:00:34,920 --> 00:00:35,550
‫--.

10
00:00:35,700 --> 00:00:39,620
‫A ponieważ są one oparte na podstawach, dziedziczą te składniki.

11
00:00:39,630 --> 00:00:46,800
‫Czołg może mieć własną siatkę bazową, własną siatkę wieży, własną kapsułę i własny punkt odradzania pocisków.

12
00:00:46,800 --> 00:00:52,500
‫I podobnie, wieża otrzyma własną kapsułę z siatki bazowej wieżyczki oraz punkt odradzania się

13
00:00:52,500 --> 00:00:53,370
‫pocisków.

14
00:00:53,370 --> 00:00:58,560
‫Wkrótce zobaczymy, jak możemy przypisać różne siatki do każdego z nich, aby wyglądały inaczej.

15
00:00:58,560 --> 00:01:00,750
‫Wiemy więc, że potrzebujemy jakichś komponentów.

16
00:01:00,750 --> 00:01:05,490
‫Teraz nadszedł czas, aby faktycznie dodać kilka komponentów do naszej bazy -- klasy.

17
00:01:05,910 --> 00:01:11,400
‫Teraz domyślnie mamy już sekcję publiczną, sekcję chronioną i drugą sekcję publiczną

18
00:01:11,400 --> 00:01:12,240
‫tutaj.

19
00:01:12,570 --> 00:01:17,520
‫Istnieje wiele powodów, dla których istnieje wiele sekcji publicznych, o których porozmawiamy później.

20
00:01:17,520 --> 00:01:20,880
‫Ale dla naszych komponentów stworzymy sekcję prywatną.

21
00:01:22,070 --> 00:01:28,400
‫Jak już wiesz, dobrze jest, aby zmienne składowe były prywatne, aby były dostępne tylko

22
00:01:28,400 --> 00:01:31,790
‫z poziomu klasy, która jest ich właścicielem.

23
00:01:31,790 --> 00:01:33,410
‫Potrzebujemy więc kilku komponentów.

24
00:01:33,680 --> 00:01:36,190
‫Pierwszą, którą dodam, jest kapsuła.

25
00:01:36,200 --> 00:01:40,760
‫Więc stwórzmy zmienną typu kapsuły.

26
00:01:42,160 --> 00:01:44,030
‫Teraz to będzie wskazówka.

27
00:01:44,070 --> 00:01:48,880
‫Będziemy używać wskaźników dla większości naszych zmiennych, o ile nie są to typy podstawowe, takie

28
00:01:48,880 --> 00:01:50,340
‫jak integer lub float.

29
00:01:50,350 --> 00:01:55,600
‫A jak wiecie, to dlatego, że wskaźniki są lekkie, są tylko adresami i pozwalają

30
00:01:55,600 --> 00:01:56,860
‫nam działać wydajniej.

31
00:01:56,950 --> 00:02:03,400
‫Mamy więc wskaźnik na komponent kapsuły U i będziemy nazywać tę kapsułę skrótem od składnik

32
00:02:03,400 --> 00:02:04,030
‫kapsuły.

33
00:02:04,030 --> 00:02:11,140
‫Teraz, tuż nad komponentem kapsuły, dodamy nierealne makro specyficzne dla silnika, które jest Twoją własnością we

34
00:02:11,470 --> 00:02:14,020
‫wszystkich wersalikach z własnymi nawiasami.

35
00:02:14,020 --> 00:02:20,980
‫Właściwość Twoja jest sposobem na uświadomienie nierzeczywistemu silnikowi tej zmiennej, aby mogła uczestniczyć w nierzeczywistych silnikach.

36
00:02:20,980 --> 00:02:22,240
‫System odbicia.

37
00:02:22,690 --> 00:02:28,750
‫System odbić pozwala nam na takie rzeczy, jak wystawianie tej zmiennej na projekty i uczestniczenie w

38
00:02:28,750 --> 00:02:31,060
‫zbieraniu śmieci i tym podobnych.

39
00:02:31,060 --> 00:02:36,400
‫Zatem dodanie właściwości you będzie czymś, co doda do naszych komponentów w miarę ich tworzenia.

40
00:02:36,400 --> 00:02:41,980
‫Więc mamy ten składnik kapsuły, a ponieważ używamy kapsuły typu YOU, musimy

41
00:02:41,980 --> 00:02:44,860
‫poinformować kompilator o tym typie.

42
00:02:44,860 --> 00:02:48,250
‫Domyślnie nie wie, czym jest składnik kapsułki.

43
00:02:48,250 --> 00:02:54,640
‫Teraz normalnie, aby powiedzieć kompilatorowi, czym jest komponent kapsuły, dołączylibyśmy plik nagłówkowy tutaj na górze

44
00:02:54,640 --> 00:02:59,680
‫z naszymi dyrektywami dołączania, jeśli przejdziemy do nierzeczywistej dokumentacji silnika i

45
00:02:59,710 --> 00:03:05,200
‫wyszukamy komponent kapsuły, możemy zobaczyć tutaj, gdzie jest napisane dołącz plik nagłówkowy, który

46
00:03:05,200 --> 00:03:08,950
‫musielibyśmy dołączyć, aby poinformować kompilator o komponencie kapsuły.

47
00:03:08,950 --> 00:03:13,000
‫Teraz moglibyśmy dołączyć to tutaj na górze, a potem nasze U.

48
00:03:13,000 --> 00:03:18,160
‫Typ komponentu kapsuły zostałby rozpoznany przez kompilator i wszystko byłoby niezgrabne.

49
00:03:18,220 --> 00:03:24,070
‫Ale ogólnie, dobrą praktyką, jeśli chodzi o kodowanie tych rzeczy, jest próba utrzymania tego pliku nagłówkowego tak

50
00:03:24,070 --> 00:03:25,720
‫małego, jak to możliwe.

51
00:03:25,720 --> 00:03:32,380
‫Za każdym razem, gdy dołączamy plik nagłówkowy do tego pliku, program zwany preprocesorem pobiera całą zawartość tego

52
00:03:32,380 --> 00:03:37,720
‫pliku nagłówkowego, usuwa niektóre rzeczy, takie jak komentarze, a następnie dosłownie wkleja całą

53
00:03:37,720 --> 00:03:40,780
‫zawartość tego pliku nagłówkowego do tego pliku.

54
00:03:41,050 --> 00:03:46,810
‫W rezultacie ten plik staje się większy, ponieważ zawiera zawartość tego dołączonego pliku, wklej go

55
00:03:46,810 --> 00:03:47,530
‫tutaj.

56
00:03:47,530 --> 00:03:50,950
‫Chcemy uwzględniać rzeczy tylko wtedy, gdy ich używamy.

57
00:03:50,950 --> 00:03:56,740
‫Jak więc obejść się bez uwzględnienia pliku nagłówkowego w bazie -- nagłówek?

58
00:03:56,740 --> 00:04:02,380
‫Cóż, możemy użyć czegoś w C++ znanego jako deklaracja forward.

59
00:04:02,380 --> 00:04:07,990
‫Przekazujemy ten typ komponentu kapsułki u za pomocą słowa kluczowego class w ten sposób.

60
00:04:08,470 --> 00:04:15,310
‫Zwróć uwagę, że kompilator wyświetla teraz ten typ jako zielony, gdy tylko zadeklarujemy, że zmienna była wtedy w

61
00:04:15,310 --> 00:04:18,010
‫stanie uniknąć nieuwzględniania jej pliku nagłówkowego.

62
00:04:18,010 --> 00:04:23,830
‫Mówi kompilatorowi, że jest to typ, więc nie będzie już wyświetlał błędów IntelliSense, mówiąc, że

63
00:04:23,830 --> 00:04:26,170
‫nie rozpoznaje tego jako typu.

64
00:04:26,170 --> 00:04:28,150
‫To jest niekompletny typ.

65
00:04:28,150 --> 00:04:34,150
‫Jeśli rzeczywiście spróbujemy użyć tego typu, uzyskując dostęp do elementów członkowskich, takich jak funkcje i zmienne, lub

66
00:04:34,150 --> 00:04:38,560
‫próbując skonstruować obiekt tego typu, otrzymalibyśmy błąd, ponieważ jest to typ niekompletny.

67
00:04:38,560 --> 00:04:44,950
‫Potrzebowalibyśmy pliku nagłówkowego dołączonego wszędzie tam, gdzie używamy tego typu, aby wykonać te rzeczy, abyśmy mogli przekazać

68
00:04:44,950 --> 00:04:48,400
‫dalej zadeklarować wskaźnik typu, aby uniknąć potrzeby pliku nagłówkowego.

69
00:04:48,400 --> 00:04:53,230
‫Należy jednak zauważyć, że potrzebujemy plików nagłówkowych do dziedziczenia z poszczególnych klas.

70
00:04:53,230 --> 00:05:00,130
‫Zauważ, że ta klasa dziedziczy po stawie, a plik nagłówka stawu jest dołączony tutaj na górze.

71
00:05:00,130 --> 00:05:05,470
‫Tak więc dziedziczenie wymaga pliku nagłówkowego dla typu, z którego dziedziczymy.

72
00:05:05,470 --> 00:05:09,100
‫Porozmawiajmy więc o przekazaniu deklaracji i dlaczego chcemy to zrobić.

73
00:05:09,130 --> 00:05:16,120
‫Powiedzmy, że mamy klasę o nazwie Base Pon, która musi mieć zmienną wskaźnikową typu kapsuła

74
00:05:16,120 --> 00:05:17,020
‫komponentu.

75
00:05:17,050 --> 00:05:22,060
‫Teraz komponent kapsułki znajduje się w pliku nagłówkowym komponentu kapsułki.

76
00:05:22,060 --> 00:05:28,470
‫Teraz faktycznie użyjemy tego typu w oparciu o konstruowanie obiektu U.

77
00:05:28,480 --> 00:05:30,010
‫Typ składnika kapsułki.

78
00:05:30,010 --> 00:05:36,820
‫Tak więc, w oparciu o wszystko, czego naprawdę potrzebujemy, to mieć wskaźnik składnika kapsułki typu U.

79
00:05:37,000 --> 00:05:44,440
‫Teraz prawda opiera się na tym, że H tak naprawdę nie potrzebuje szczegółów implementacji klasy komponentów

80
00:05:44,440 --> 00:05:45,160
‫kapsuły.

81
00:05:45,160 --> 00:05:50,680
‫Innymi słowy, nie musi wiedzieć, jak zdefiniowane są funkcje, ani nawet jak duża jest klasa

82
00:05:50,680 --> 00:05:51,820
‫komponentów kapsuły.

83
00:05:51,850 --> 00:05:55,750
‫Wskaźnik komponentu kapsułki ma taki sam rozmiar jak każdy inny wskaźnik.

84
00:05:55,750 --> 00:05:57,250
‫To tylko adres.

85
00:05:57,250 --> 00:05:58,810
‫Teraz w klasie planu podstawowego.

86
00:05:58,810 --> 00:06:01,420
‫Chcemy zbudować komponent kapsuły.

87
00:06:01,510 --> 00:06:08,260
‫Z tego powodu musimy znać rozmiar komponentu kapsuły, aby rozłożyć pamięć niezbędną do stworzenia

88
00:06:08,260 --> 00:06:09,790
‫tego obiektu.

89
00:06:09,790 --> 00:06:16,330
‫Tak więc, podczas gdy nagłówek komponentu kapsułki nie jest ściśle potrzebny w bazie Ponca, jest absolutnie potrzebny w bazie.

90
00:06:16,350 --> 00:06:24,970
‫Porkpie Tak więc dobrą praktyką programistyczną jest dołączanie nagłówków tylko tam, gdzie naprawdę ich potrzebujesz, abyśmy mogli

91
00:06:24,970 --> 00:06:32,410
‫deklarować wskaźnik typu U wskaźnik komponentu kapsułki w produkcie bazowym H, a następnie dołączać

92
00:06:32,410 --> 00:06:39,310
‫komponenty kapsułki tam, gdzie potrzebujemy szczegółów implementacji, ponieważ konstruujemy składnik kapsułki i musimy

93
00:06:39,310 --> 00:06:41,020
‫znać rozmiar.

94
00:06:41,310 --> 00:06:43,230
‫Składnik kapsułki w pamięci.

95
00:06:43,350 --> 00:06:49,920
‫Omówmy teraz konsekwencje dołączenia pliku nagłówkowego do efektu base pond.

96
00:06:50,010 --> 00:06:55,410
‫Jak widzieliśmy, absolutnie możemy to zrobić i możesz pomyśleć, no cóż, w każdym razie włączamy

97
00:06:55,410 --> 00:07:01,230
‫to do bazy CP, więc jaka to różnica, jeśli uwzględnimy to w jednym pliku w porównaniu z innym?

98
00:07:01,260 --> 00:07:03,180
‫Oto, gdzie pojawia się problem.

99
00:07:03,210 --> 00:07:07,390
‫Pliki nagłówkowe są przeznaczone do dołączania do innych plików.

100
00:07:07,410 --> 00:07:12,810
‫Załóżmy więc, że mamy staw Base H i zawarliśmy w nim składniki kapsułki.

101
00:07:12,810 --> 00:07:18,600
‫I dalej w dół drogi mamy inną klasę i będziemy mieli wskaźnik stawu bazowego w

102
00:07:18,600 --> 00:07:23,370
‫innej klasie, tak jak mieliśmy wskaźnik komponentu kapsuły w kapsule bazowej.

103
00:07:23,400 --> 00:07:28,230
‫Teraz, zamiast męczyć się z deklarowaniem do przodu wskaźnika stawu bazowego i

104
00:07:28,230 --> 00:07:33,810
‫jakiejś innej klasy, po prostu zadeklarujemy to jako normalne i dodamy pionka bazowego do innej klasy.

105
00:07:34,680 --> 00:07:41,520
‫Więc teraz Base Pond H zawiera nie tylko nagłówek komponentu kapsułki, co skutkuje kopiowaniem większej ilości kodu

106
00:07:41,520 --> 00:07:43,190
‫do tego pliku nagłówkowego.

107
00:07:43,200 --> 00:07:47,820
‫Teraz bazuje na innej klasie, która obejmuje komponent kapsułki.

108
00:07:47,820 --> 00:07:55,470
‫Tak więc cała zawartość i składniki kapsuły są również w jakiejś innej klasie H i nie są tam

109
00:07:55,470 --> 00:07:56,400
‫nawet potrzebne.

110
00:07:56,400 --> 00:08:01,910
‫Jakaś inna klasa, o której H musi tylko wiedzieć, nie dba o komponent kapsułki.

111
00:08:01,920 --> 00:08:07,920
‫Teraz powiedzmy, że kontynuujemy ten wzorzec i tworzymy inną klasę zwaną jeszcze inną klasą, a

112
00:08:07,920 --> 00:08:13,680
‫jeszcze inna klasa może potrzebować wskaźnika typu innej klasy, zamiast deklarowania w przód.

113
00:08:13,680 --> 00:08:21,180
‫Po prostu włączamy jeszcze jedną klasę H do jeszcze innej klasy H, a teraz do jeszcze innej klasy H.

114
00:08:21,210 --> 00:08:27,840
‫Mimo że nie potrzebujemy nawet nagłówka dla komponentu H stawu bazowego lub kapsuły, otrzymaliśmy go w jeszcze

115
00:08:27,840 --> 00:08:32,730
‫innej klasie, ponieważ jakaś inna klasa zawiera te pliki nagłówkowe w sobie.

116
00:08:32,730 --> 00:08:40,140
‫Więc mamy kopie całej zawartości komponentów kapsuły i bazując na H po prostu utknęliśmy tutaj w kolejnej klasie,

117
00:08:40,140 --> 00:08:46,620
‫rozsadzając ten plik i wydłużając czas kompilacji, wszystko dlatego, że nie przekazaliśmy dalej deklaracji.

118
00:08:46,620 --> 00:08:52,440
‫Więc zamiast tego lepiej jest dołączyć pliki nagłówkowe tam, gdzie są one rzeczywiście potrzebne.

119
00:08:52,440 --> 00:08:59,610
‫Więc jeśli weźmiemy komponenty kapsuły i uwzględnimy je tylko w oparciu o CPP, a później, gdy

120
00:08:59,610 --> 00:09:05,340
‫stworzymy inną klasę i faktycznie będziemy musieli użyć kapsuły, możemy dołączyć tam nagłówek,

121
00:09:05,340 --> 00:09:12,840
‫a podstawa nie zawiera komponentów kapsuły, więc cały ten dodatkowy kod nie jest zawarty w jakiejś innej

122
00:09:12,840 --> 00:09:13,440
‫klasie.

123
00:09:13,440 --> 00:09:18,810
‫A potem, kiedy idziemy i tworzymy kolejną klasę, która potrzebuje innej klasy, możemy dołączyć inną

124
00:09:18,810 --> 00:09:24,990
‫klasę, która h do jeszcze innej klasy, to CPP, gdzie jest rzeczywiście potrzebna, a następnie jeszcze inną

125
00:09:24,990 --> 00:09:30,270
‫klasę, której H nie wypełnia się zawartością inne pliki nagłówkowe, których nie potrzebuje.

126
00:09:30,270 --> 00:09:36,990
‫Więc kiedy klasy mają takie zależności oparte na składniku kapsuły, najlepiej ograniczyć te

127
00:09:36,990 --> 00:09:38,670
‫zależności do minimum.

128
00:09:38,880 --> 00:09:42,570
‫Więc rzucę Ci wyzwanie, abyś stworzył błąd kompilacji.

129
00:09:42,570 --> 00:09:44,970
‫Nie powinniśmy bać się błędów kompilacji.

130
00:09:44,970 --> 00:09:47,550
‫Są po prostu normalną częścią procesu rozwoju.

131
00:09:47,550 --> 00:09:54,210
‫Więc wygenerujemy celowo, cofniemy się i usuniemy słowo kluczowe class i skompilujemy bez deklarowania

132
00:09:54,210 --> 00:09:56,160
‫w przód kapsuły comp.

133
00:09:56,160 --> 00:10:04,080
‫Teraz, kiedy mówię kompiluj, mam na myśli, że możesz skompilować z kodu Visual Studio, po prostu zwykłą kompilację C++.

134
00:10:04,110 --> 00:10:10,500
‫Nauczyłeś się, jak to zrobić, lub możesz po prostu zapisać plik i kod programu Visual Studio i zainicjować

135
00:10:10,500 --> 00:10:11,670
‫kodowanie na żywo.

136
00:10:11,670 --> 00:10:16,800
‫Każda z nich jest w porządku i kiedy przejdziemy przez to razem, pokażę ci, co dzieje się z obiema

137
00:10:16,800 --> 00:10:17,280
‫metodami.

138
00:10:17,280 --> 00:10:22,440
‫Jeśli używasz kodowania na żywo, oczywiście będziesz patrzeć na wygenerowane dane wyjściowe w oknie kodowania na

139
00:10:22,440 --> 00:10:27,270
‫żywo, w przeciwieństwie do danych wyjściowych, które można zobaczyć w kodzie programu Visual Studio.

140
00:10:27,270 --> 00:10:33,060
‫Teraz spoiler, dostaniesz błąd kompilacji, spójrz na komunikat o błędzie kompilacji, zobacz, co

141
00:10:33,060 --> 00:10:34,260
‫ci mówi.

142
00:10:34,470 --> 00:10:38,070
‫To tylko zapoznanie się z błędami, które generujemy.

143
00:10:38,070 --> 00:10:43,500
‫Następnie przejdź do przodu i do tyłu, zadeklaruj kapsułę comp za pomocą słowa kluczowego class.

144
00:10:43,620 --> 00:10:48,450
‫Kiedy już to zrobisz, skompiluj ponownie, tym razem powinieneś otrzymać udaną kompilację.

145
00:10:48,780 --> 00:10:51,060
‫Zatrzymaj wideo i spróbuj.

146
00:10:53,520 --> 00:10:56,350
‫W porządku, więc dokonajmy tutaj spustoszenia w naszym kodzie.

147
00:10:56,370 --> 00:10:58,320
‫Zamierzam usunąć słowo kluczowe class.

148
00:10:58,700 --> 00:11:03,540
‫Dobra, więc próbowaliśmy skompilować, a oto dane wyjściowe w terminalu.

149
00:11:03,570 --> 00:11:09,300
‫Pierwszą rzeczą, którą widzimy, jest błąd, który daje nam kod błędu i mówi, że kapsuła nie

150
00:11:09,300 --> 00:11:10,830
‫jest członkiem pionka podstawowego.

151
00:11:10,860 --> 00:11:17,040
‫Mamy notatkę, która mówi o deklaracji C pionka bazowego, a następnie widzimy, że w wyniku tego otrzymujemy

152
00:11:17,040 --> 00:11:17,940
‫inne błędy.

153
00:11:17,940 --> 00:11:23,390
‫Tak więc często uczniowie są zdezorientowani, gdy próbują skompilować i wydają wiele błędów.

154
00:11:23,400 --> 00:11:28,560
‫To pokazuje, że pojedynczy błąd może rozprzestrzenić serię błędów.

155
00:11:28,560 --> 00:11:31,670
‫I to nie znaczy, że musisz naprawić całą masę plików.

156
00:11:31,680 --> 00:11:34,410
‫Błąd może mieć tutaj jedno pochodzenie.

157
00:11:34,410 --> 00:11:36,420
‫Wiemy, jakie jest źródło błędu.

158
00:11:36,420 --> 00:11:37,820
‫Musimy przekazać deklarację.

159
00:11:37,830 --> 00:11:45,150
‫Zobaczmy teraz, co się stanie, jeśli użyjemy kodowania na żywo zamiast zwykłej kompilacji i kodu Visual Studio.

160
00:11:45,150 --> 00:11:51,450
‫Więc zamierzam iść dalej i kliknąć przycisk, aby rozpocząć kodowanie na żywo i od razu na czerwono widzę, że kompilacja

161
00:11:51,450 --> 00:11:54,270
‫nie powiodła się i widzimy to samo tutaj.

162
00:11:54,270 --> 00:11:55,050
‫Tutaj.

163
00:11:55,050 --> 00:11:59,310
‫Skład kapsuły nie jest członkiem nuty pionka podstawowego.

164
00:11:59,340 --> 00:12:01,860
‫Zobacz deklarację pionka bazowego.

165
00:12:01,860 --> 00:12:03,750
‫Więc widzimy to samo tutaj.

166
00:12:03,750 --> 00:12:08,490
‫Tak więc w obu przypadkach zobaczymy taki błąd, gdy zapomnimy o przekazaniu deklaracji.

167
00:12:08,490 --> 00:12:16,170
‫Więc teraz wiemy, jak to wygląda i teraz jesteśmy lepiej poinformowani i mniej boimy się tych tajemniczych komunikatów o

168
00:12:16,170 --> 00:12:17,340
‫błędach kompilacji.

169
00:12:17,460 --> 00:12:23,280
‫Więc zamierzamy naprawić ten błąd, deklarując w przód komponent kapsuły, a następnie możemy

170
00:12:23,280 --> 00:12:24,990
‫spróbować ponownie skompilować.

171
00:12:24,990 --> 00:12:27,780
‫A teraz skompilowaliśmy bez błędów.

172
00:12:27,870 --> 00:12:32,070
‫Więc teraz widzimy, jak to wygląda, gdy zapomnieliśmy zadeklarować zmienną do przodu.

173
00:12:32,100 --> 00:12:35,250
‫Miej to na uwadze, gdy w przyszłości pojawią się błędy kompilatora.

174
00:12:35,760 --> 00:12:41,490
‫Podsumowując, omówiliśmy deklarację przekazywania podczas tworzenia nowego wskaźnika i dowiedzieliśmy się, że w

175
00:12:41,490 --> 00:12:48,370
‫pliku CP powinno się umieszczać tylko to, czego używasz, a w pliku H powinno się umieszczać jak

176
00:12:48,450 --> 00:12:49,020
‫najmniej.

177
00:12:49,050 --> 00:12:55,020
‫Wiemy, że nie potrzebujemy pliku nagłówkowego do deklarowania nowego wskaźnika, o ile deklarujemy go dalej,

178
00:12:55,020 --> 00:13:00,090
‫i że potrzebujemy pliku nagłówkowego, jeśli zamierzamy konstruować obiekt określonego typu.

179
00:13:00,090 --> 00:13:05,850
‫I potrzebujemy pliku nagłówkowego, aby uzyskać dostęp do elementów członkowskich, takich jak funkcje i zmienne, i widzieliśmy, że

180
00:13:05,850 --> 00:13:09,780
‫rzeczywiście potrzebujemy pliku nagłówkowego do dziedziczenia w celu dziedziczenia z klasy.

181
00:13:09,780 --> 00:13:11,460
‫Potrzebujemy tam tego pliku nagłówkowego.

182
00:13:11,580 --> 00:13:17,160
‫Więc teraz, gdy wiemy, jak przekazać typ i mamy naszą kapsułę wskaźnika, jesteśmy gotowi

183
00:13:17,160 --> 00:13:21,840
‫do skonstruowania obiektu komponentu kapsuły i zrobimy to w następnym filmie.

184
00:13:22,200 --> 00:13:23,040
‫Zobaczymy się wkrótce.