Witam i zapraszam.
W tym filmie pokażę Ci jak zbudować i uruchomić program z poprzedniego filmu.
Więc jeśli pamiętasz, mieliśmy mały program, który w zasadzie prosił użytkownika o wprowadzenie jego ulubionego numeru,
a następnie drukował ten ulubiony numer.
Więc z przeszłych filmów powinieneś zrozumieć, że istnieje wiele kroków, aby stworzyć program, który można uruchomić.
Musisz skompilować, musisz połączyć, a następnie musisz stworzyć tę binarną.
I tak do tego momentu udało nam się skompilować z powodzeniem.
Nie widzimy żadnych błędów.
Teraz musimy w zasadzie wziąć wszystkie zewnętrzne zależności dla tego programu, napisać standardowy plik nagłówkowy
i o oraz wszelkie inne biblioteki dostarczane przez język programowania C.
Bierzesz wszystko, co może być wieloma plikami O i bierzesz cały ten zewnętrzny kod, aby stworzyć jeden plik
wykonywalny.
Prawda?
Mamy więc tutaj nasz kod źródłowy.
Zobaczysz, że mamy kod źródłowy, który jest jakby zgrupowany razem.
Możesz faktycznie uczynić ten kod nieco bardziej czytelnym, dodając kilka nowych linii, coś w tym stylu.
To tylko sprawia, że jest trochę bardziej czytelny.
Teraz, jak już wspomniałem, mamy to już skompilowane.
Po prostu, aby odświeżyć pamięć, możesz skompilować plik źródłowy na wiele różnych sposobów.
Możesz kliknąć prawym przyciskiem myszy na pliku źródłowym i powiedzieć skompiluj, lub możesz faktycznie wybrać ten plik
źródłowy, przejść do budowania i możesz powiedzieć skompiluj bieżący plik.
Jeśli wybierzemy nasz projekt, zobaczymy wiele różnych opcji związanych z budową.
Widzisz build, rebuild, clean, stop, build.
Porozmawiajmy najpierw o czystości.
Clean będzie w zasadzie wymazać wszystkie stare pliki, które miałeś.
Więc pamiętaj wcześniej z poprzednich filmów, że program C kiedy się kompiluje, kompilujesz każdy plik źródłowy,
a program może składać się z wielu plików źródłowych.
Main dot C Jakieś inne pliki też?
Istnieją programy, które zawierają tysiące i tysiące plików źródłowych C.
Po skompilowaniu wszystkich tych plików C, tworzy wszystkie stare pliki, a następnie bierzesz te stare
pliki i łączysz je razem, aby stworzyć jeden plik wykonywalny.
Teraz, kiedy wybierasz projekt, ustawiasz selfie projektu i mówisz clean, to co robisz, to
w zasadzie usuwasz wszystkie te stare pliki, usuwasz wszelkie dodatkowe artefakty, usuwasz program
wykonywalny i zaczynasz od zera.
Zasadniczo otrzymujesz czystą przestrzeń roboczą, którą możesz następnie przekompilować, odbudować, ponownie połączyć i odtworzyć
sam program.
Zazwyczaj chcesz użyć czystego, jeśli napotykasz błędy, a może po prostu chcesz przekompilować
każdy plik źródłowy, ponieważ zazwyczaj, gdy uruchamiasz kompilator C, jeśli kod jako nie zmienia się i próbujesz skompilować
ten kod, zwykle nie rekompiluje go.
I tak, jeśli po prostu napotykasz problemy, masz wiele plików źródłowych, widzisz błędy,
które nie mają sensu.
Dobrym rozwiązaniem może być rozpoczęcie od stanu czystego, przejście na czystą, wyczyszczenie wszystkiego.
Mówisz czysty, a on ci to dokładnie pokaże.
Jest to w zasadzie usunięcie wszystkiego z twojego folderu debugowania kompilacji.
Znowu wszystkie te kropki os executable, które zaczynasz od zera.
Jest to miły sposób na rozwiązanie wszelkiego rodzaju zależności lub wszelkich problemów z nie rekompilowaniem całego
projektu ponownie, aby zacząć od zera.
Więc po uruchomieniu clean, nie mamy nic skompilowanego ani zbudowanego i możemy przejść i możemy skompilować
poszczególne pliki mówiąc compile i klikając na każdy plik.
Jeśli masz wiele plików źródłowych, to nie jest to naprawdę świetny sposób na dotarcie do ostatecznego pliku wykonywalnego.
Zazwyczaj to co się stanie, to upewnienie się, że masz swój projekt aplikacji i typowo
po prostu powiesz build i to przejdzie przez cały kod źródłowy w twoim projekcie i zbuduje wszystkie pliki.
Więc kiedy uderzysz w build, zobaczysz, że przejdzie i złapie wszystkie kody źródłowe i przebuduje.
I to samo, jeśli jeśli klikniesz prawym przyciskiem myszy i powiesz rebuild, to nie odbuduje wszystkich plików
lub tylko odbuduje pliki, które się zmieniły.
I tak możesz powiedzieć build, co czyni go nieco łatwiejszym niż kompilacja każdego pliku źródłowego.
Kompilacja ponownie skompiluje wszystkie pliki źródłowe, ale także połączy je, więc możesz zobaczyć to
na wyjściu, prawda?
Jeśli przejdziesz do okna wyjściowego kompilacji, możesz zobaczyć, że najpierw wydajemy polecenie GCC dash C,
które jest flagą do kompilacji na głównej kropce C, Następnie przekazujemy parametry do optymalizacji architektury 64, trochę
debugowania standardowego C, 99 ostrzeżeń dla wszystkich ostrzeżeń.
A potem robimy kreskę o, żeby połączyć się z Main. plik cpp.
Zasadniczo zamierzamy również włączyć kilka katalogów include.
A następnie w następnym kroku, prawda, wydajemy kreskę zero, aby zrobić nasze łączenie z każdą zewnętrzną zależnością.
W tym przypadku tak naprawdę nie mamy ich wiele, mamy tylko w zasadzie łączenie, łączymy statycznie
z kreską L i w zasadzie budujemy ten tekst listy obiektów.
Ważną rzeczą jest to, że tworzy on plik wykonywalny o nazwie nasz pierwszy program.
Zobacz.
I tak budynek robi oba kroki programu C, prawda?
Kompiluje go i łączy i tworzy plik wykonywalny.
I tak po prostu ułatwia rzeczy poprzez budowanie w przeciwieństwie do kompilacji wszystkiego na początku.
Teraz możesz chcieć skompilować poszczególne pliki tylko po to, aby być może zobaczyć, co się dzieje, aby upewnić się, że twój
kod źródłowy jest poprawny i nie jesteś gotowy do łączenia.
Możesz mieć tu pięć plików.
Wybierasz każdy, który chcesz powiedzieć, ok, właśnie napisałem trochę kodu, skompilujmy go,
upewnij się, że wszystko jest w porządku, a następnie pójdę i na następny plik, skompiluj to, a następnie ostatecznie zbudujesz
wszystko.
Teraz, gdy mamy już utworzony plik wykonywalny programu, możemy faktycznie uruchomić nasz program.
I tak chcesz się upewnić, że masz swój program, swój projekt jako aktywny projekt i masz go podświetlonego, a następnie
możesz przejść do budowania i możesz po prostu powiedzieć uruchom.
Teraz, gdy wybierzesz run, prawdopodobnie pojawi się to okienko z napisem, Czy chcesz zbudować ponownie i wykonać?
Teraz już zbudowałeś, więc tak naprawdę nie musisz.
Możesz po prostu powiedzieć "wykonaj".
Możesz zaznaczyć pole wyboru, aby to nie zawsze się pojawiało.
A jak się biegnie, to nie zawsze się odbudowuje.
To zależy od ciebie.
To zajmuje trochę czasu przetwarzania procesora, aby odbudować wszystko, ale prawdopodobnie nie martwisz się o to.
Więc zawsze możesz powiedzieć buduj i wykonaj i nie mieć pop up lub zawsze możesz po prostu wykonać.
Teraz, jeśli wybierzemy execute, to weźmiemy ten plik wykonywalny i zostanie on uruchomiony.
I to, co zauważysz, to prośba o wpisanie ulubionego numeru, użytkownika.
I tak możesz po prostu wpisać liczbę 45, uderzyć w przycisk enter na klawiaturze i wtedy po prostu wyświetli
się, że wpisałeś liczbę 45.
Ponownie, bardzo prosty program prosi o wejście, wyświetla, wyjście, a następnie możesz uderzyć dowolny klawisz, aby kontynuować,
aby zamknąć to okno.
Teraz, jeśli wrócimy do naszego widoku obszaru roboczego, naszego okna obszaru roboczego, naszego panelu obszaru roboczego,
jakkolwiek chcesz to nazwać, zauważysz, że mamy trzy projekty, prawda?
Nasz pierwszy program jest wyróżniony.
To jest właśnie ten aktywny projekt.
Pozostałe projekty nadal mają w nich swoje pliki źródłowe, prawda?
Główna kropka C, prawa.
A nasze inne projekty są dość mocno szablonowe.
Hello, World Code.
Ale to, czego nie widzisz, to nie widzisz żadnego z plików obiektowych, plików kropki zero,
nie widzisz pliku wykonywalnego, niczego takiego.
Teraz możesz je wyświetlić klikając na zakładkę Explorer i możesz określić folder do otwarcia.
I zazwyczaj powinien to być folder główny miejsca, w którym tworzysz wszystkie swoje przestrzenie robocze.
Więc typowo umieszczam je, myślę, że umieszczam je w dokumentach wewnątrz prawych wewnątrz dokumentów.
Mam swoje miejsca pracy.
Zobaczysz, że rzeczywiście jest tu sporo rzeczy.
Więc zazwyczaj chcesz umieścić to lokalnie, ale zobaczysz, że masz Workspace one i Workspace two, i
zobaczysz, że ten obszar roboczy ma plik dot code light.
W rzeczywistości prawdopodobnie lepiej będzie otworzyć dokładne pliki obszaru roboczego, prawda?
Bo tak naprawdę tylko to nas obejmuje.
Przestrzeń robocza nr 2 jest tym, co nas interesuje.
Powiedzmy więc, że wybierzemy folder, obszar roboczy dwa, a następnie przejdźmy do przodu i zamknijmy nasze istniejące dokumenty, więc możemy przejść do
przodu i możemy po prostu powiedzieć zamknij.
Mamy więc teraz drugi obszar roboczy i możemy zobaczyć wszystkie pliki wykonawcze dla wszystkich
naszych projektów oraz wszystkie nasze pliki.
I tak zauważyliście, że jest tam folder code light.
Ten katalog code light zawiera po prostu niektóre preferencje dotyczące obszaru roboczego i tak dalej.
Mamy nasz folder build debug.
To zawiera nasz katalog binarny, który zawiera nasz plik wykonywalny i zauważysz, że mamy również katalog pierwszego programu
R i to jest wewnątrz build debug, ponieważ ten obszar roboczy, ten projekt został zbudowany i zobaczysz tam mamy nasze
pliki obiektów i wszelkie inne zależności, które są zbudowane ta lista
obiektów.
Mamy właściwie pierwszy projekt programu, prawda?
I to dotyczy naszego pliku źródłowego i wszelkich innych plików make i tak dalej.
I to samo widać w przypadku innych projektów.
A następnie na samym dole widzisz polecenia kompilacji, kropka JSON.
Jest to zwykle używane do uzupełniania kodu.
Widzisz plik make, a następnie widzisz plik obszaru roboczego.
Zakładka Explore pomaga nam zobaczyć cały układ przestrzeni roboczej, wszystkie nasze projekty, wszystko co zostało zbudowane,
wszystkie pliki ustawień projektu i wszystkie pliki źródłowe projektu, a także wszelkie zależności od plików uzupełniania
kodu i tak dalej dla samej przestrzeni roboczej.
I tak rozmawialiśmy o czystym, prawda?
Jak clean może faktycznie usunąć wszystko, wszystkie pliki obiektów w pliku wykonywalnym.
Jeśli więc wrócimy do Workspace View i podświetlimy nasz pierwszy projekt programu, gdy klikniemy prawym przyciskiem
myszy i powiemy clean, to usuniemy wszystkie te projekty.
Więc teraz, jeśli wrócisz do zakładki Explorer i przejdziesz do debugu build, zobaczysz, że zobaczysz tam wszystko,
ponieważ nie zostało odświeżone.
Więc możesz faktycznie odświeżyć ten widok.
Więc zamierzam kliknąć prawym przyciskiem myszy na naszym obszarze roboczym i powiem, że odświeżam folder debugowania kompilacji.
Więc to zwykle zostaje usunięte, ale w środku nie ma nic, prawda?
Być może znów będziesz miał kosz.
Zwykle to się sprząta.
Zależy od uprawnień, ale nie masz żadnych starych plików.
Nie masz swojego pliku wykonywalnego po zrobieniu clean.
Teraz, ponownie, jeśli wrócimy do obszaru roboczego, możesz zobaczyć to małe rozwijane menu, które mówi ci, co budować,
czy budujesz dla debugowania lub czy budujesz dla wydania.
Kiedy budujesz dla debugowania, zawiera on informacje o debugowaniu w samym pliku wykonywalnym programu.
Tak się zwykle dzieje, gdy rozwijasz swój kod.
Chcesz informacji o debugowaniu i w przypadku, gdy musisz uruchomić debugger i tak dalej.
To nie zawsze jest dobre do zrobienia, gdy wypuszczasz jakiś program w teren lub do klienta w tryb
produkcyjny, więc możesz zmienić wydanie na wydanie, gdy budujesz i chcesz dystrybuować ten program
gdzieś.
I tak potem, kiedy go zbudujesz, to co zauważysz, to jeśli przejdziesz do zakładki explore, zobaczysz ponownie zrobić
odświeżenie.
Zobaczysz folder build release i to będzie brakowało informacji o debugowaniu zasadniczo, więc nie będziesz musiał
się martwić.
Zasadniczo, jeśli masz informacje o debugowaniu, możesz wygenerować plik rdzeniowy i możesz mieć hakerów, którzy
mogą w pewnym sensie uzyskać informacje o twoim kodzie źródłowym.
Więc budujesz tylko debug dla trybu debugowania, kiedy rozwijasz program i zmieniasz go na tryb budowania
wydania, kiedy być może wypuszczasz swój program do klienta.
Ponownie, to zależy, czy pracujesz gdzieś, czy pracujesz dla pracownika, czy faktycznie
dostarczasz gdzieś jakiś kod.
Zazwyczaj w zakładce Explorer nie modyfikujesz tak naprawdę niczego.
Po prostu daje ci widok na to, co jest zbudowane i twoje pliki wykonywalne i tak dalej.
Ponownie, wspomniałem, że widzisz kilka plików pomocniczych.
Można przyjrzeć się niektórym z tych rzeczy.
Niektóre z tych rzeczy będą generowane automatycznie.
Możesz zobaczyć plik make w tym miejscu.
I to jest właściwie plik make, który może być wygenerowany w zależności od ustawień projektu.
To jest plik make dla całego obszaru roboczego.
Możesz spojrzeć na konkretne programy i zobaczyć niektóre z plików make, które są ponownie generowane, ale zwykle nie chcesz zadzierać
z żadną z tych rzeczy.
To po prostu ponownie dostarcza plik make do kompilacji.
Czasami, gdy masz błędy, możesz spojrzeć na plik make, aby zobaczyć dokładnie, co się dzieje.
Może coś nie zostało poprawnie wygenerowane.
Kod jak to czasem bywa ma jakieś błędy w zależności od tego jakiego systemu make używasz.
Ponownie, zwykle idziemy z systemem UNIX file make dla jeśli jesteś w systemie Windows, a następnie jeśli jesteś w systemie
Linux lub Mac OS, po prostu idziesz z domyślnym.
Więc to w zasadzie wszystko, prawda?
Możesz zamknąć te pliki, ale w pewnym sensie widzisz, co się dzieje w eksploratorze i widoku obszaru roboczego.
Teraz w widoku Workspace, ponownie, jeśli wybierzesz projekt, możesz również powiedzieć stop, build.
Więc czasami kompilacja i budowanie i twój plik wykonywalny może zająć dużo czasu.
Mam na myśli, że jeśli masz tysiące plików, możesz budować przez 30 minut.
Więc stop, build po prostu pozwala ci przestać budować cokolwiek, wiesz, kompilować i łączyć cokolwiek, jakikolwiek
z projektów.
Ponownie, przydatne, gdy masz długi proces kompilacji, ale zazwyczaj nie widzisz tego w niektórych kodach, które
będziemy pisać dla naszej klasy.
Inną rzeczą, która może być miła, jest to, że jeśli podświetlisz widok obszaru roboczego, możesz faktycznie zbudować wszystkie
projekty w jednym ujęciu.
Możesz powiedzieć build workspace lub clean workspace i usunąć wszystkie zależności dla wszystkich projektów.
Ale jeśli powiesz build workspace, to zbuduje wszystkie projekty niezależnie od tego, czy jest aktywny i to właśnie
widzisz w oknie wyjściowym.
Racja.
Budujemy projekt trzeci, budujemy projekt drugi i budujemy pierwszy program.
I tak oto, po raz kolejny, krótkie podsumowanie tego, jak można budować i uruchamiać kod z aktywnego projektu, niektóre
z ustawień i jak można zobaczyć zakładkę Explorer.
Dziękuję.