1
00:00:04,390 --> 00:00:05,830
‫Witam i zapraszam na ten wykład.

2
00:00:05,830 --> 00:00:12,880
‫Będziemy się uczyć, w jaki sposób możemy wykonać część zmiennej kodu wiele razy, aby

3
00:00:12,880 --> 00:00:19,840
‫wydrukować każdy obiekt, który nakłada się w tym obszarze, ten składnik wyzwalający.

4
00:00:20,080 --> 00:00:24,190
‫Więc tutaj widać, że kiedy jesteśmy oboje, stoję w środku i jest też gargulec.

5
00:00:24,460 --> 00:00:29,140
‫Wypisuje zarówno imię gargulców, jak i nazwę planu gracza.

6
00:00:29,440 --> 00:00:31,090
‫Zanurzmy się i zobaczmy, jak to się robi.

7
00:00:32,020 --> 00:00:38,830
‫Teraz problem z naszym kodem polega na tym, że nasza tablica aktorów może zawierać znacznie więcej niż jednego aktora,

8
00:00:38,830 --> 00:00:44,020
‫a jeśli chcemy, aby wyświetlała wszystkich nakładających się aktorów, chcemy coś zrobić ze wszystkimi

9
00:00:44,020 --> 00:00:44,800
‫tymi aktorami.

10
00:00:45,160 --> 00:00:47,650
‫Musimy być w stanie przejrzeć kod.

11
00:00:47,650 --> 00:00:53,680
‫Byłoby wysoce nieefektywne napisanie instrukcji if dla przypadku, gdy mamy dwa, trzy,

12
00:00:53,680 --> 00:00:58,780
‫cztery lub pięć itd. I na pewno nigdy nie wykryje wszystkich przypadków, ponieważ w naszym

13
00:00:58,780 --> 00:01:00,010
‫pliku mamy ograniczoną liczbę wierszy.

14
00:01:00,640 --> 00:01:08,620
‫Więc jak sobie z tym radzimy, chcemy powtórzyć fragment kodu wiele razy, ale wiele razy, których tak naprawdę

15
00:01:08,620 --> 00:01:09,850
‫nie znamy.

16
00:01:09,850 --> 00:01:15,610
‫Kiedy kompilujemy kod, musimy zastąpić naszą instrukcję if, gdzie instrukcja if zasadniczo mówi, czy mam wykonać

17
00:01:15,610 --> 00:01:21,490
‫ten kod, czy nie, na coś, co mówi, czy powinienem wykonać ten kod, czy powinienem wykonać go

18
00:01:21,490 --> 00:01:25,090
‫wiele razy, dwa razy, trzy razy, cztery razy itd.?

19
00:01:25,570 --> 00:01:29,230
‫Sposób, w jaki to robimy, to coś, co nazywamy dzikim stwierdzeniem.

20
00:01:29,530 --> 00:01:32,380
‫Teraz jest bardzo podobny do instrukcji if.

21
00:01:32,380 --> 00:01:41,230
‫Więc gdy następnie umieścisz jakąś wartość logiczną w nawiasach, a potem mamy kilka nawiasów klamrowych

22
00:01:41,290 --> 00:01:47,650
‫i wewnątrz nawiasów klamrowych, blok kodu, który będzie wykonywany raz

23
00:01:47,650 --> 00:01:54,310
‫za razem, aż warunek w naszym dzikim oświadczeniu stanie się fałszywy .

24
00:01:54,310 --> 00:01:55,960
‫Dlatego nazywa się to póki.

25
00:01:55,960 --> 00:01:59,260
‫Więc póki to jest prawdą, wykonaj ten kod.

26
00:01:59,260 --> 00:02:04,570
‫Przypomina to trochę instrukcję if, ponieważ czasami może w ogóle nie wykonać kodu, ale w

27
00:02:04,570 --> 00:02:09,910
‫przeciwieństwie do instrukcji, która może wykonać fragment kodu tylko raz, instrukcja wild może w zasadzie

28
00:02:09,910 --> 00:02:14,620
‫wykonywać ją w nieskończoność, jeśli ta wartość logiczna nigdy się nie stanie fałszywy.

29
00:02:15,550 --> 00:02:16,990
‫Dlaczego to jest przydatne?

30
00:02:16,990 --> 00:02:22,180
‫Cóż, moglibyśmy stworzyć int 32 i nazwać go indeksem i zacząć od zera.

31
00:02:22,990 --> 00:02:31,690
‫A potem za każdym razem, gdy przechodzimy przez ciało tej dzikiej pętli, zwiększamy wartość przechowywaną w tym indeksie.

32
00:02:31,690 --> 00:02:35,830
‫Możemy więc powiedzieć, że indeks równa się indeks plus jeden.

33
00:02:36,700 --> 00:02:42,460
‫Teraz w C++ jest skrót, jak to zrobić, zamiast robić indeks plus jeden w ten

34
00:02:42,460 --> 00:02:49,210
‫sposób, robisz plus plus indeks, a to po prostu dodaje jeden do wszystkiego, co jest przechowywane w zmiennej indeksu.

35
00:02:50,050 --> 00:02:50,440
‫Dobra.

36
00:02:50,440 --> 00:02:51,910
‫Więc zaczynamy od zera.

37
00:02:52,210 --> 00:02:54,700
‫Za każdym razem, gdy się kręcimy, zwiększamy indeks.

38
00:02:55,060 --> 00:03:03,160
‫Możemy zrobić to tak, że obejdziemy tę szaloną pętlę tylko wtedy, gdy nasz indeks znajduje się w

39
00:03:03,160 --> 00:03:05,170
‫granicach naszej tablicy.

40
00:03:05,200 --> 00:03:11,220
‫Możemy więc powiedzieć, że indeks musi być mniejszy niż liczba aktorów.

41
00:03:11,410 --> 00:03:13,210
‫Więc to jest rozmiar tablicy.

42
00:03:13,210 --> 00:03:19,300
‫Pamiętaj, że kiedy mamy pięć pozycji w tablicy, ostatnią pozycją w tablicy jest indeks czwarty.

43
00:03:19,930 --> 00:03:28,210
‫Widzimy więc, że będzie to prawdą, gdy indeks jest ważny, gdy indeks czwarty jest mniejszy niż pięć.

44
00:03:28,570 --> 00:03:34,460
‫Ale jak tylko ten indeks przekroczy koniec tablicy, kiedy dojdzie do indeksu pięć, to numer aktora

45
00:03:34,480 --> 00:03:39,040
‫nie będzie już wyższy niż pięć, nie będzie już mniejszy niż pięć.

46
00:03:39,310 --> 00:03:44,920
‫Tak więc pętla while zatrzyma wykonywanie i będzie kontynuować resztę funkcji.

47
00:03:45,790 --> 00:03:54,700
‫Oznacza to, że możemy teraz wziąć kod, który mieliśmy powyżej i przepisać go, wziąć, skopiować, wyciąć i

48
00:03:54,700 --> 00:03:57,970
‫wkleić tutaj za jakiś czas.

49
00:03:57,970 --> 00:03:58,210
‫Pętla.

50
00:03:58,210 --> 00:04:03,460
‫Ale zanim zwiększymy indeks, co najważniejsze, ponieważ to, co zamierzamy zrobić, to zastąpić to zero

51
00:04:03,460 --> 00:04:08,290
‫w miejscu, w którym otrzymaliśmy zero aktora, możemy to zastąpić indeksem aktora.

52
00:04:08,890 --> 00:04:10,120
‫Więc prześledźmy to.

53
00:04:10,120 --> 00:04:11,680
‫Jak to działa.

54
00:04:12,580 --> 00:04:12,790
‫Ładny.

55
00:04:12,790 --> 00:04:15,700
‫Usuń naszą instrukcję if, ponieważ jest to trochę mylące.

56
00:04:15,970 --> 00:04:19,960
‫Więc zaczynamy, wartość w indeksie zmiennej będzie wynosić zero.

57
00:04:20,590 --> 00:04:26,770
‫Teraz wyobraź sobie, że musimy działać, aby wszystko było proste, zero mniej niż dwa.

58
00:04:27,160 --> 00:04:28,330
‫Tak tak to jest.

59
00:04:28,690 --> 00:04:37,450
‫Więc wchodzimy i otrzymujemy aktora zero, dostajemy jego nazwę i wylogowujemy go, a następnie zwiększamy wartość indeksu

60
00:04:37,450 --> 00:04:38,620
‫o jeden.

61
00:04:38,620 --> 00:04:40,570
‫Więc przechodzi od zera do jedności.

62
00:04:41,380 --> 00:04:47,200
‫Teraz wracamy do oceny warunku pętli while i mówimy, że jeden mniej niż dwa?

63
00:04:47,320 --> 00:04:47,950
‫Tak to jest.

64
00:04:48,280 --> 00:04:55,300
‫Możemy wtedy wejść i zdobyć aktora pierwszego, a potem uzyskamy jego imię i wydrukujemy jego imię.

65
00:04:55,600 --> 00:05:02,140
‫Następnie ponownie zwiększamy indeks do indeksu dwa i ponownie zadajemy pytanie w pętli while mówiącej, że dwa

66
00:05:02,350 --> 00:05:03,850
‫mniej niż dwa?

67
00:05:04,240 --> 00:05:05,710
‫Cóż, odpowiedź brzmi nie.

68
00:05:05,950 --> 00:05:11,800
‫Pomijamy więc treść pętli while i kontynuujemy wykonywanie reszty kodu.

69
00:05:12,520 --> 00:05:15,090
‫Więc to jest w zasadzie to, co chcemy osiągnąć.

70
00:05:15,100 --> 00:05:23,440
‫Chcemy wypisać nazwę każdego aktora w tablicy i to właśnie zrobi ten fragment kodu.

71
00:05:23,680 --> 00:05:26,200
‫Chodźmy dalej, skompilujmy go i sprawdźmy, czy mam rację.

72
00:05:26,350 --> 00:05:32,980
‫Jeśli pójdziemy dalej, wciśniemy play i wejdziemy do pudełka, widać, że nakładaliśmy się tylko na gracza

73
00:05:32,980 --> 00:05:33,400
‫BP.

74
00:05:33,850 --> 00:05:36,070
‫A jeśli pójdziemy po naszego gargulca?

75
00:05:36,310 --> 00:05:41,020
‫Jeśli włożymy tylko to w odbicie, widać, że nakładamy się na gargulca.

76
00:05:41,050 --> 00:05:43,030
‫Ale co, jeśli ja też wkroczę?

77
00:05:43,360 --> 00:05:50,040
‫Teraz możesz zobaczyć, że drukuje to, co nakłada się na gracza i gargulca w tej samej ramce.

78
00:05:50,050 --> 00:05:52,060
‫Więc nasza dzika pętla działa.

79
00:05:52,060 --> 00:05:58,390
‫Wielokrotnie wykonuje fragment kodu, gdy w tablicy jest wielu aktorów.

80
00:05:58,570 --> 00:06:04,540
‫Teraz, ponieważ ten wzorzec jest tak powszechny, że mamy jakiś indeks i zwiększamy go za każdym razem, gdy przechodzimy

81
00:06:04,540 --> 00:06:05,500
‫przez pętlę.

82
00:06:05,860 --> 00:06:15,250
‫W rzeczywistości jest trochę skrótów w C++, a jeśli wpiszesz for w kodzie Visual Studio, to jest tu

83
00:06:15,250 --> 00:06:23,850
‫fragment z czterema pętlami, które możesz rozwinąć i możesz zobaczyć, że jest to ogólna struktura.

84
00:06:23,860 --> 00:06:25,390
‫Tutaj jest coś, co nazywa się rozmiarem T.

85
00:06:25,390 --> 00:06:29,200
‫Możemy po prostu zastąpić to INT 32 dla naszych celów.

86
00:06:29,710 --> 00:06:36,220
‫Zasadniczo oznacza to, że w nawiasach pętli for znajdują się trzy instrukcje.

87
00:06:36,370 --> 00:06:42,940
‫Pierwsza z nich odpowiada miejscu, w którym ustawiliśmy zmienną indeksową przed pętlą while.

88
00:06:43,840 --> 00:06:48,820
‫Drugi to warunek, który jest równoważny temu, co umieściliśmy w naszej pętli while.

89
00:06:49,600 --> 00:06:54,460
‫I widać, że moglibyśmy zastąpić liczbę aktorami kropka num.

90
00:06:54,730 --> 00:07:01,150
‫I wtedy ostatni bit to w zasadzie plus plus, niezależnie od tego, czy umieścisz go przed,

91
00:07:01,150 --> 00:07:07,180
‫czy po, indeks nie jest zbyt ważny, ale widać, że to zwiększa wartość indeksu.

92
00:07:07,180 --> 00:07:10,810
‫Jest to więc odpowiednik linii, którą umieściliśmy na końcu naszej pętli.

93
00:07:11,560 --> 00:07:17,890
‫To po prostu łączy w jednym wierszu to, co musieliśmy rozłożyć na wiele, używając naszej dzikiej

94
00:07:17,890 --> 00:07:18,700
‫pętli.

95
00:07:18,880 --> 00:07:20,320
‫Oto proste wyzwanie dla Ciebie.

96
00:07:20,320 --> 00:07:23,230
‫Konwertuj pętlę waah na pętlę for.

97
00:07:23,530 --> 00:07:30,220
‫Zamierzasz skopiować, a treść kodu zmieni indeks z tego indeksu nazw na I.

98
00:07:30,220 --> 00:07:36,490
‫Zwykle używamy skrótu w pętlach for z I po prostu skrótem od indeksu, a kompilacja

99
00:07:36,490 --> 00:07:38,560
‫i testowanie odtwarzania wideo.

100
00:07:41,800 --> 00:07:42,130
‫Dobra.

101
00:07:42,130 --> 00:07:42,700
‫Witamy spowrotem.

102
00:07:42,730 --> 00:07:44,680
‫Więc to powinno być całkiem proste.

103
00:07:44,680 --> 00:07:46,810
‫Nie chcemy tutaj indeksu plus plus.

104
00:07:47,170 --> 00:07:49,510
‫Więc zamierzamy wyciąć resztę.

105
00:07:50,100 --> 00:07:54,310
‫Zmiana miejsca indeksowania tablicy aktorów za pomocą zmiennej index.

106
00:07:54,310 --> 00:07:56,550
‫Zmienimy to na IE zmienną.

107
00:07:56,560 --> 00:07:58,420
‫Jest dostępny tylko w tej pętli for.

108
00:07:58,420 --> 00:08:04,700
‫Kolejną zaletą składni pełnej pętli jest to, że zmienna IE jest dostępna tylko w pełnej

109
00:08:04,960 --> 00:08:10,150
‫pętli, podczas gdy kiedy zadeklarowaliśmy ją tutaj w pętli while, jest

110
00:08:10,150 --> 00:08:16,960
‫dostępna na zewnątrz, co powoduje zanieczyszczenie indeksów, które możemy użyj później, abyśmy mogli usunąć tę dziką pętlę.

111
00:08:16,960 --> 00:08:23,170
‫I widać, że pełna pętla jest znacznie bardziej skondensowana i przyzwyczaisz się do nieco

112
00:08:23,170 --> 00:08:25,090
‫dziwnej składni, którą ma.

113
00:08:25,420 --> 00:08:30,430
‫Przejdźmy dalej, skompilujmy i sprawdźmy, czy rzeczywiście wykonuje to samo zadanie.

114
00:08:30,640 --> 00:08:38,020
‫Jeśli pójdę, złapię mojego gargulca i podejdę do nakładających się aktorów, widać, że rzeczywiście drukuje to obu

115
00:08:38,020 --> 00:08:42,010
‫naszych aktorów, kiedy obaj nakładamy się we wnęce.

116
00:08:42,100 --> 00:08:42,790
‫Świetna sprawa.

117
00:08:42,790 --> 00:08:49,810
‫W tym wykładzie widzieliśmy więc nowy pomysł na programowanie, ideę pętli, a szczególnie natknęliśmy się

118
00:08:49,810 --> 00:08:52,960
‫na pętlę Y i pętlę for.

119
00:08:53,200 --> 00:08:54,700
‫Do zobaczenia na następnym wykładzie.