‫Wiemy więc, że potrzebujemy jakichś komponentów w naszej bazie -- klasa.
‫Wiemy, że potrzebujemy siatki bazowej dla dolnej części czołgu i wieży.
‫Potrzebujemy również siatki wieżyczki do górnej części.
‫Potrzebujemy kapsuły, aby poradzić sobie z kolizją i potrzebujemy punktu odrodzenia pocisku.
‫To będzie składnik sceny.
‫Teraz, gdy dodamy te rzeczy do podstawowej klasy pod, wszystko, co utworzymy na podstawie
‫tej klasy, odziedziczy te rzeczy.
‫Więc moglibyśmy stworzyć czołg oparty na podstawie -- a potem moglibyśmy stworzyć wieżę również opartą na podstawie
‫--.
‫A ponieważ są one oparte na podstawach, dziedziczą te składniki.
‫Czołg może mieć własną siatkę bazową, własną siatkę wieży, własną kapsułę i własny punkt odradzania pocisków.
‫I podobnie, wieża otrzyma własną kapsułę z siatki bazowej wieżyczki oraz punkt odradzania się
‫pocisków.
‫Wkrótce zobaczymy, jak możemy przypisać różne siatki do każdego z nich, aby wyglądały inaczej.
‫Wiemy więc, że potrzebujemy jakichś komponentów.
‫Teraz nadszedł czas, aby faktycznie dodać kilka komponentów do naszej bazy -- klasy.
‫Teraz domyślnie mamy już sekcję publiczną, sekcję chronioną i drugą sekcję publiczną
‫tutaj.
‫Istnieje wiele powodów, dla których istnieje wiele sekcji publicznych, o których porozmawiamy później.
‫Ale dla naszych komponentów stworzymy sekcję prywatną.
‫Jak już wiesz, dobrze jest, aby zmienne składowe były prywatne, aby były dostępne tylko
‫z poziomu klasy, która jest ich właścicielem.
‫Potrzebujemy więc kilku komponentów.
‫Pierwszą, którą dodam, jest kapsuła.
‫Więc stwórzmy zmienną typu kapsuły.
‫Teraz to będzie wskazówka.
‫Będziemy używać wskaźników dla większości naszych zmiennych, o ile nie są to typy podstawowe, takie
‫jak integer lub float.
‫A jak wiecie, to dlatego, że wskaźniki są lekkie, są tylko adresami i pozwalają
‫nam działać wydajniej.
‫Mamy więc wskaźnik na komponent kapsuły U i będziemy nazywać tę kapsułę skrótem od składnik
‫kapsuły.
‫Teraz, tuż nad komponentem kapsuły, dodamy nierealne makro specyficzne dla silnika, które jest Twoją własnością we
‫wszystkich wersalikach z własnymi nawiasami.
‫Właściwość Twoja jest sposobem na uświadomienie nierzeczywistemu silnikowi tej zmiennej, aby mogła uczestniczyć w nierzeczywistych silnikach.
‫System odbicia.
‫System odbić pozwala nam na takie rzeczy, jak wystawianie tej zmiennej na projekty i uczestniczenie w
‫zbieraniu śmieci i tym podobnych.
‫Zatem dodanie właściwości you będzie czymś, co doda do naszych komponentów w miarę ich tworzenia.
‫Więc mamy ten składnik kapsuły, a ponieważ używamy kapsuły typu YOU, musimy
‫poinformować kompilator o tym typie.
‫Domyślnie nie wie, czym jest składnik kapsułki.
‫Teraz normalnie, aby powiedzieć kompilatorowi, czym jest komponent kapsuły, dołączylibyśmy plik nagłówkowy tutaj na górze
‫z naszymi dyrektywami dołączania, jeśli przejdziemy do nierzeczywistej dokumentacji silnika i
‫wyszukamy komponent kapsuły, możemy zobaczyć tutaj, gdzie jest napisane dołącz plik nagłówkowy, który
‫musielibyśmy dołączyć, aby poinformować kompilator o komponencie kapsuły.
‫Teraz moglibyśmy dołączyć to tutaj na górze, a potem nasze U.
‫Typ komponentu kapsuły zostałby rozpoznany przez kompilator i wszystko byłoby niezgrabne.
‫Ale ogólnie, dobrą praktyką, jeśli chodzi o kodowanie tych rzeczy, jest próba utrzymania tego pliku nagłówkowego tak
‫małego, jak to możliwe.
‫Za każdym razem, gdy dołączamy plik nagłówkowy do tego pliku, program zwany preprocesorem pobiera całą zawartość tego
‫pliku nagłówkowego, usuwa niektóre rzeczy, takie jak komentarze, a następnie dosłownie wkleja całą
‫zawartość tego pliku nagłówkowego do tego pliku.
‫W rezultacie ten plik staje się większy, ponieważ zawiera zawartość tego dołączonego pliku, wklej go
‫tutaj.
‫Chcemy uwzględniać rzeczy tylko wtedy, gdy ich używamy.
‫Jak więc obejść się bez uwzględnienia pliku nagłówkowego w bazie -- nagłówek?
‫Cóż, możemy użyć czegoś w C++ znanego jako deklaracja forward.
‫Przekazujemy ten typ komponentu kapsułki u za pomocą słowa kluczowego class w ten sposób.
‫Zwróć uwagę, że kompilator wyświetla teraz ten typ jako zielony, gdy tylko zadeklarujemy, że zmienna była wtedy w
‫stanie uniknąć nieuwzględniania jej pliku nagłówkowego.
‫Mówi kompilatorowi, że jest to typ, więc nie będzie już wyświetlał błędów IntelliSense, mówiąc, że
‫nie rozpoznaje tego jako typu.
‫To jest niekompletny typ.
‫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
‫próbując skonstruować obiekt tego typu, otrzymalibyśmy błąd, ponieważ jest to typ niekompletny.
‫Potrzebowalibyśmy pliku nagłówkowego dołączonego wszędzie tam, gdzie używamy tego typu, aby wykonać te rzeczy, abyśmy mogli przekazać
‫dalej zadeklarować wskaźnik typu, aby uniknąć potrzeby pliku nagłówkowego.
‫Należy jednak zauważyć, że potrzebujemy plików nagłówkowych do dziedziczenia z poszczególnych klas.
‫Zauważ, że ta klasa dziedziczy po stawie, a plik nagłówka stawu jest dołączony tutaj na górze.
‫Tak więc dziedziczenie wymaga pliku nagłówkowego dla typu, z którego dziedziczymy.
‫Porozmawiajmy więc o przekazaniu deklaracji i dlaczego chcemy to zrobić.
‫Powiedzmy, że mamy klasę o nazwie Base Pon, która musi mieć zmienną wskaźnikową typu kapsuła
‫komponentu.
‫Teraz komponent kapsułki znajduje się w pliku nagłówkowym komponentu kapsułki.
‫Teraz faktycznie użyjemy tego typu w oparciu o konstruowanie obiektu U.
‫Typ składnika kapsułki.
‫Tak więc, w oparciu o wszystko, czego naprawdę potrzebujemy, to mieć wskaźnik składnika kapsułki typu U.
‫Teraz prawda opiera się na tym, że H tak naprawdę nie potrzebuje szczegółów implementacji klasy komponentów
‫kapsuły.
‫Innymi słowy, nie musi wiedzieć, jak zdefiniowane są funkcje, ani nawet jak duża jest klasa
‫komponentów kapsuły.
‫Wskaźnik komponentu kapsułki ma taki sam rozmiar jak każdy inny wskaźnik.
‫To tylko adres.
‫Teraz w klasie planu podstawowego.
‫Chcemy zbudować komponent kapsuły.
‫Z tego powodu musimy znać rozmiar komponentu kapsuły, aby rozłożyć pamięć niezbędną do stworzenia
‫tego obiektu.
‫Tak więc, podczas gdy nagłówek komponentu kapsułki nie jest ściśle potrzebny w bazie Ponca, jest absolutnie potrzebny w bazie.
‫Porkpie Tak więc dobrą praktyką programistyczną jest dołączanie nagłówków tylko tam, gdzie naprawdę ich potrzebujesz, abyśmy mogli
‫deklarować wskaźnik typu U wskaźnik komponentu kapsułki w produkcie bazowym H, a następnie dołączać
‫komponenty kapsułki tam, gdzie potrzebujemy szczegółów implementacji, ponieważ konstruujemy składnik kapsułki i musimy
‫znać rozmiar.
‫Składnik kapsułki w pamięci.
‫Omówmy teraz konsekwencje dołączenia pliku nagłówkowego do efektu base pond.
‫Jak widzieliśmy, absolutnie możemy to zrobić i możesz pomyśleć, no cóż, w każdym razie włączamy
‫to do bazy CP, więc jaka to różnica, jeśli uwzględnimy to w jednym pliku w porównaniu z innym?
‫Oto, gdzie pojawia się problem.
‫Pliki nagłówkowe są przeznaczone do dołączania do innych plików.
‫Załóżmy więc, że mamy staw Base H i zawarliśmy w nim składniki kapsułki.
‫I dalej w dół drogi mamy inną klasę i będziemy mieli wskaźnik stawu bazowego w
‫innej klasie, tak jak mieliśmy wskaźnik komponentu kapsuły w kapsule bazowej.
‫Teraz, zamiast męczyć się z deklarowaniem do przodu wskaźnika stawu bazowego i
‫jakiejś innej klasy, po prostu zadeklarujemy to jako normalne i dodamy pionka bazowego do innej klasy.
‫Więc teraz Base Pond H zawiera nie tylko nagłówek komponentu kapsułki, co skutkuje kopiowaniem większej ilości kodu
‫do tego pliku nagłówkowego.
‫Teraz bazuje na innej klasie, która obejmuje komponent kapsułki.
‫Tak więc cała zawartość i składniki kapsuły są również w jakiejś innej klasie H i nie są tam
‫nawet potrzebne.
‫Jakaś inna klasa, o której H musi tylko wiedzieć, nie dba o komponent kapsułki.
‫Teraz powiedzmy, że kontynuujemy ten wzorzec i tworzymy inną klasę zwaną jeszcze inną klasą, a
‫jeszcze inna klasa może potrzebować wskaźnika typu innej klasy, zamiast deklarowania w przód.
‫Po prostu włączamy jeszcze jedną klasę H do jeszcze innej klasy H, a teraz do jeszcze innej klasy H.
‫Mimo że nie potrzebujemy nawet nagłówka dla komponentu H stawu bazowego lub kapsuły, otrzymaliśmy go w jeszcze
‫innej klasie, ponieważ jakaś inna klasa zawiera te pliki nagłówkowe w sobie.
‫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,
‫rozsadzając ten plik i wydłużając czas kompilacji, wszystko dlatego, że nie przekazaliśmy dalej deklaracji.
‫Więc zamiast tego lepiej jest dołączyć pliki nagłówkowe tam, gdzie są one rzeczywiście potrzebne.
‫Więc jeśli weźmiemy komponenty kapsuły i uwzględnimy je tylko w oparciu o CPP, a później, gdy
‫stworzymy inną klasę i faktycznie będziemy musieli użyć kapsuły, możemy dołączyć tam nagłówek,
‫a podstawa nie zawiera komponentów kapsuły, więc cały ten dodatkowy kod nie jest zawarty w jakiejś innej
‫klasie.
‫A potem, kiedy idziemy i tworzymy kolejną klasę, która potrzebuje innej klasy, możemy dołączyć inną
‫klasę, która h do jeszcze innej klasy, to CPP, gdzie jest rzeczywiście potrzebna, a następnie jeszcze inną
‫klasę, której H nie wypełnia się zawartością inne pliki nagłówkowe, których nie potrzebuje.
‫Więc kiedy klasy mają takie zależności oparte na składniku kapsuły, najlepiej ograniczyć te
‫zależności do minimum.
‫Więc rzucę Ci wyzwanie, abyś stworzył błąd kompilacji.
‫Nie powinniśmy bać się błędów kompilacji.
‫Są po prostu normalną częścią procesu rozwoju.
‫Więc wygenerujemy celowo, cofniemy się i usuniemy słowo kluczowe class i skompilujemy bez deklarowania
‫w przód kapsuły comp.
‫Teraz, kiedy mówię kompiluj, mam na myśli, że możesz skompilować z kodu Visual Studio, po prostu zwykłą kompilację C++.
‫Nauczyłeś się, jak to zrobić, lub możesz po prostu zapisać plik i kod programu Visual Studio i zainicjować
‫kodowanie na żywo.
‫Każda z nich jest w porządku i kiedy przejdziemy przez to razem, pokażę ci, co dzieje się z obiema
‫metodami.
‫Jeśli używasz kodowania na żywo, oczywiście będziesz patrzeć na wygenerowane dane wyjściowe w oknie kodowania na
‫żywo, w przeciwieństwie do danych wyjściowych, które można zobaczyć w kodzie programu Visual Studio.
‫Teraz spoiler, dostaniesz błąd kompilacji, spójrz na komunikat o błędzie kompilacji, zobacz, co
‫ci mówi.
‫To tylko zapoznanie się z błędami, które generujemy.
‫Następnie przejdź do przodu i do tyłu, zadeklaruj kapsułę comp za pomocą słowa kluczowego class.
‫Kiedy już to zrobisz, skompiluj ponownie, tym razem powinieneś otrzymać udaną kompilację.
‫Zatrzymaj wideo i spróbuj.
‫W porządku, więc dokonajmy tutaj spustoszenia w naszym kodzie.
‫Zamierzam usunąć słowo kluczowe class.
‫Dobra, więc próbowaliśmy skompilować, a oto dane wyjściowe w terminalu.
‫Pierwszą rzeczą, którą widzimy, jest błąd, który daje nam kod błędu i mówi, że kapsuła nie
‫jest członkiem pionka podstawowego.
‫Mamy notatkę, która mówi o deklaracji C pionka bazowego, a następnie widzimy, że w wyniku tego otrzymujemy
‫inne błędy.
‫Tak więc często uczniowie są zdezorientowani, gdy próbują skompilować i wydają wiele błędów.
‫To pokazuje, że pojedynczy błąd może rozprzestrzenić serię błędów.
‫I to nie znaczy, że musisz naprawić całą masę plików.
‫Błąd może mieć tutaj jedno pochodzenie.
‫Wiemy, jakie jest źródło błędu.
‫Musimy przekazać deklarację.
‫Zobaczmy teraz, co się stanie, jeśli użyjemy kodowania na żywo zamiast zwykłej kompilacji i kodu Visual Studio.
‫Więc zamierzam iść dalej i kliknąć przycisk, aby rozpocząć kodowanie na żywo i od razu na czerwono widzę, że kompilacja
‫nie powiodła się i widzimy to samo tutaj.
‫Tutaj.
‫Skład kapsuły nie jest członkiem nuty pionka podstawowego.
‫Zobacz deklarację pionka bazowego.
‫Więc widzimy to samo tutaj.
‫Tak więc w obu przypadkach zobaczymy taki błąd, gdy zapomnimy o przekazaniu deklaracji.
‫Więc teraz wiemy, jak to wygląda i teraz jesteśmy lepiej poinformowani i mniej boimy się tych tajemniczych komunikatów o
‫błędach kompilacji.
‫Więc zamierzamy naprawić ten błąd, deklarując w przód komponent kapsuły, a następnie możemy
‫spróbować ponownie skompilować.
‫A teraz skompilowaliśmy bez błędów.
‫Więc teraz widzimy, jak to wygląda, gdy zapomnieliśmy zadeklarować zmienną do przodu.
‫Miej to na uwadze, gdy w przyszłości pojawią się błędy kompilatora.
‫Podsumowując, omówiliśmy deklarację przekazywania podczas tworzenia nowego wskaźnika i dowiedzieliśmy się, że w
‫pliku CP powinno się umieszczać tylko to, czego używasz, a w pliku H powinno się umieszczać jak
‫najmniej.
‫Wiemy, że nie potrzebujemy pliku nagłówkowego do deklarowania nowego wskaźnika, o ile deklarujemy go dalej,
‫i że potrzebujemy pliku nagłówkowego, jeśli zamierzamy konstruować obiekt określonego typu.
‫I potrzebujemy pliku nagłówkowego, aby uzyskać dostęp do elementów członkowskich, takich jak funkcje i zmienne, i widzieliśmy, że
‫rzeczywiście potrzebujemy pliku nagłówkowego do dziedziczenia w celu dziedziczenia z klasy.
‫Potrzebujemy tam tego pliku nagłówkowego.
‫Więc teraz, gdy wiemy, jak przekazać typ i mamy naszą kapsułę wskaźnika, jesteśmy gotowi
‫do skonstruowania obiektu komponentu kapsuły i zrobimy to w następnym filmie.
‫Zobaczymy się wkrótce.