1
00:00:04,390 --> 00:00:05,830
‫Hallo en welkom deze lezing.

2
00:00:05,830 --> 00:00:12,880
‫We gaan leren hoe we een stuk codevariabel aantal keren kunnen uitvoeren, zodat

3
00:00:12,880 --> 00:00:19,840
‫we elk object kunnen afdrukken dat binnen dit gebied, deze triggercomponent, overlapt.

4
00:00:20,080 --> 00:00:24,190
‫Dus je kunt hier zien dat als we allebei zijn, ik binnen sta en er is ook een waterspuwer.

5
00:00:24,460 --> 00:00:29,140
‫Het drukt zowel de naam van de waterspuwers als de blauwdrukken van de speler af.

6
00:00:29,440 --> 00:00:31,090
‫Laten we erin duiken en kijken hoe dit wordt gedaan.

7
00:00:32,020 --> 00:00:38,830
‫Het probleem met onze code hier is dat onze array met acteurs veel meer dan één acteur kan bevatten, en

8
00:00:38,830 --> 00:00:44,020
‫als we willen dat alle acteurs elkaar overlappen, willen we iets met al die

9
00:00:44,020 --> 00:00:44,800
‫acteurs doen.

10
00:00:45,160 --> 00:00:47,650
‫We moeten de code kunnen doorlopen.

11
00:00:47,650 --> 00:00:53,680
‫Het zou zeer inefficiënt zijn om een if-statement te schrijven voor het geval we er twee of

12
00:00:53,680 --> 00:00:58,780
‫drie of vier of vijf hebben, enz. En het zou zeker nooit alle gevallen opvangen omdat we een beperkt aantal

13
00:00:58,780 --> 00:01:00,010
‫regels in ons bestand hebben.

14
00:01:00,640 --> 00:01:08,620
‫Dus de manier waarop we hiermee omgaan, we willen een stuk code meerdere keren herhalen, maar een aantal keren dat we het

15
00:01:08,620 --> 00:01:09,850
‫eigenlijk niet weten.

16
00:01:09,850 --> 00:01:15,610
‫Wanneer we de code compileren, moeten we onze if-statement, waar het if-statement in wezen zegt, moet ik deze

17
00:01:15,610 --> 00:01:21,490
‫code uitvoeren of niet, vervangen door iets dat zegt, moet ik deze code uitvoeren of moet ik het

18
00:01:21,490 --> 00:01:25,090
‫vele malen, twee keer uitvoeren, drie keer, vier keer, enz.?

19
00:01:25,570 --> 00:01:29,230
‫De manier waarop we dit doen is met iets dat een wild statement wordt genoemd.

20
00:01:29,530 --> 00:01:32,380
‫Nu is het heel erg gebouwd als een if-statement.

21
00:01:32,380 --> 00:01:41,230
‫Dus terwijl je dan een soort booleaanse waarde tussen haakjes plaatst, en dan hebben we enkele

22
00:01:41,290 --> 00:01:47,650
‫accolades en binnen de accolades, een codeblok dat steeds opnieuw

23
00:01:47,650 --> 00:01:54,310
‫wordt uitgevoerd totdat de voorwaarde in onze wilde verklaring onwaar wordt .

24
00:01:54,310 --> 00:01:55,960
‫Daarom heet het while.

25
00:01:55,960 --> 00:01:59,260
‫Dus terwijl dit ding waar is, voer deze code uit.

26
00:01:59,260 --> 00:02:04,570
‫Het lijkt dus een beetje op een if-statement in die zin dat het de code soms helemaal

27
00:02:04,570 --> 00:02:09,910
‫niet uitvoert, maar in tegenstelling tot het statement dat een stuk code maar één keer kan uitvoeren, kan

28
00:02:09,910 --> 00:02:14,620
‫het wild-statement het eigenlijk voor altijd blijven uitvoeren als deze boolean nooit wordt vals.

29
00:02:15,550 --> 00:02:16,990
‫Dus waarom is dit handig?

30
00:02:16,990 --> 00:02:22,180
‫Welnu, we kunnen een int 32 maken en het index noemen en beginnen bij nul.

31
00:02:22,990 --> 00:02:31,300
‫En elke keer dat we door de body van deze wilde lus gaan, verhogen we de waarde die in die index is

32
00:02:31,300 --> 00:02:31,690
‫opgeslagen.

33
00:02:31,690 --> 00:02:35,830
‫We zouden dus kunnen zeggen dat index gelijk is aan index plus één.

34
00:02:36,700 --> 00:02:42,460
‫In C++ is er een afkorting om dit te doen in plaats van index plus één te doen,

35
00:02:42,460 --> 00:02:49,210
‫zoals dit, je doet plus plus index, en dat voegt er gewoon één toe aan wat er in de indexvariabele is opgeslagen.

36
00:02:50,050 --> 00:02:50,440
‫Oké.

37
00:02:50,440 --> 00:02:51,910
‫Dus we beginnen bij nul.

38
00:02:52,210 --> 00:02:54,700
‫Elke keer dat we rondgaan, verhogen we de index.

39
00:02:55,060 --> 00:03:03,160
‫En wat we kunnen doen, is dat we het zo kunnen maken dat we alleen rond deze wilde lus gaan terwijl onze index binnen de

40
00:03:03,160 --> 00:03:05,170
‫grenzen van onze array ligt.

41
00:03:05,200 --> 00:03:11,220
‫We kunnen dus zeggen dat de index kleiner moet zijn dan de actoren dot num.

42
00:03:11,410 --> 00:03:13,210
‫Dus dat is de grootte van de array.

43
00:03:13,210 --> 00:03:19,300
‫Onthoud dat als we vijf items in de array hebben, het laatste item in de array index vier is.

44
00:03:19,930 --> 00:03:28,210
‫En dus kunnen we zien dat dit waar is wanneer de index geldig is, wanneer index vier kleiner is dan vijf.

45
00:03:28,570 --> 00:03:34,460
‫Maar zodra die index voorbij het einde van de array gaat, als het index vijf bereikt, dan

46
00:03:34,480 --> 00:03:39,040
‫zal het acteursgetal niet langer zijn, vijf is niet langer minder dan vijf.

47
00:03:39,310 --> 00:03:44,920
‫Dus de while-lus stopt met uitvoeren en gaat verder met de rest van de functie.

48
00:03:45,790 --> 00:03:54,700
‫Dus wat dat betekent is dat we nu de code die we hierboven hadden kunnen nemen en deze kunnen herschrijven, nemen, kopiëren,

49
00:03:54,700 --> 00:03:57,970
‫uitknippen en hier over een tijdje plakken.

50
00:03:57,970 --> 00:03:58,210
‫Lus.

51
00:03:58,210 --> 00:04:03,460
‫Maar voordat we de index verhogen, het belangrijkste, want wat we gaan doen is deze

52
00:04:03,460 --> 00:04:08,290
‫nul vervangen waar we acteur nul kregen, kunnen we deze vervangen door acteursindex.

53
00:04:08,890 --> 00:04:10,120
‫Dus laten we dit volgen.

54
00:04:10,120 --> 00:04:11,680
‫Hoe zou dit werken.

55
00:04:12,580 --> 00:04:12,790
‫Leuk.

56
00:04:12,790 --> 00:04:15,700
‫Verwijder onze if-verklaring, want dat verwart de zaken een beetje.

57
00:04:15,970 --> 00:04:19,960
‫Dus we beginnen met de waarde in de variabele index wordt nul.

58
00:04:20,590 --> 00:04:26,770
‫Stel je nu voor dat we moeten handelen om de dingen eenvoudig te houden is nul minder dan twee.

59
00:04:27,160 --> 00:04:28,330
‫Ja ja het is.

60
00:04:28,690 --> 00:04:37,450
‫Dus we gaan naar binnen en we krijgen acteur nul, we krijgen de naam en we loggen uit en dan verhogen we de waarde in

61
00:04:37,450 --> 00:04:38,620
‫index met één.

62
00:04:38,620 --> 00:04:40,570
‫Dus het gaat van nul naar één.

63
00:04:41,380 --> 00:04:47,200
‫Nu gaan we terug om de while-lusvoorwaarde te evalueren en we zeggen is één minder dan twee?

64
00:04:47,320 --> 00:04:47,950
‫Jawel.

65
00:04:48,280 --> 00:04:55,300
‫We kunnen dan naar binnen gaan en acteur één halen en dan gaan we zijn naam halen en zijn naam afdrukken.

66
00:04:55,600 --> 00:05:02,140
‫Dan verhogen we de index opnieuw naar index twee en stellen we de vraag opnieuw in de while-lus en zeggen we dat

67
00:05:02,350 --> 00:05:03,850
‫twee minder dan twee is?

68
00:05:04,240 --> 00:05:05,710
‫Nou, het antwoord is nee.

69
00:05:05,950 --> 00:05:11,800
‫Dus we slaan de body van de while-lus over en voeren de rest van de code uit.

70
00:05:12,520 --> 00:05:15,090
‫Dat is dus eigenlijk wat we willen bereiken.

71
00:05:15,100 --> 00:05:22,930
‫We willen de naam van elke actor in de array afdrukken, en dat is wat dit stukje code gaat

72
00:05:22,930 --> 00:05:23,440
‫doen.

73
00:05:23,680 --> 00:05:26,200
‫Laten we doorgaan en het compileren en controleren of ik gelijk heb.

74
00:05:26,350 --> 00:05:32,980
‫Als we doorgaan en op play drukken en in de box stappen, kun je zien dat we alleen de BP-speler

75
00:05:32,980 --> 00:05:33,400
‫overlapten.

76
00:05:33,850 --> 00:05:36,070
‫Wat als we onze waterspuwer gaan halen?

77
00:05:36,310 --> 00:05:41,020
‫Als we het alleen in de stuiter steken, kun je zien dat we de waterspuwer overlappen.

78
00:05:41,050 --> 00:05:43,030
‫Maar wat als ik ook instap?

79
00:05:43,360 --> 00:05:50,040
‫Nu kun je zien dat het zowel de speler als de waterspuwer overlapt, allemaal in hetzelfde frame.

80
00:05:50,050 --> 00:05:52,060
‫Dus onze wilde lus werkt.

81
00:05:52,060 --> 00:05:58,390
‫Het voert een stuk code meerdere keren uit wanneer er meerdere actoren in de array zijn.

82
00:05:58,570 --> 00:06:04,540
‫Omdat dit patroon zo gewoon is dat we een soort index hebben en we verhogen het elke keer dat we door

83
00:06:04,540 --> 00:06:05,500
‫de lus gaan.

84
00:06:05,860 --> 00:06:15,250
‫Er is eigenlijk een afkorting hiervoor in C ++, en als je typt voor in je Visual Studio-code, dan is er een

85
00:06:15,250 --> 00:06:23,850
‫fragment voor een vier lus hier dat je kunt uitbreiden en je kunt zien dat dit een algemene structuur is.

86
00:06:23,860 --> 00:06:25,390
‫Het heeft hier iets dat maat T wordt genoemd.

87
00:06:25,390 --> 00:06:29,200
‫We kunnen dat gewoon vervangen door INT 32 voor onze doeleinden.

88
00:06:29,710 --> 00:06:36,220
‫En wat dit in wezen zegt, is dat er drie uitspraken zijn tussen de haakjes van de for-lus.

89
00:06:36,370 --> 00:06:42,940
‫De eerste is gelijk aan waar we onze indexvariabele instellen vóór onze while-lus.

90
00:06:43,840 --> 00:06:48,820
‫De tweede is de voorwaarde die gelijk is aan wat we in onze while-lus plaatsen.

91
00:06:49,600 --> 00:06:54,460
‫En je kunt zien dat we de telling kunnen vervangen door acteurs punt num.

92
00:06:54,730 --> 00:07:01,150
‫En dan is het laatste stukje eigenlijk de plus plus of je het nu ervoor of erna zet, de

93
00:07:01,150 --> 00:07:07,180
‫index is niet zo belangrijk, maar je kunt zien dat dit de waarde in de index verhoogt.

94
00:07:07,180 --> 00:07:10,810
‫Het is dus gelijk aan de regel die we aan het einde van onze lus plaatsen.

95
00:07:11,560 --> 00:07:17,890
‫Dus dit brengt alles in één regel samen wat we moesten verspreiden over meerdere met behulp van onze

96
00:07:17,890 --> 00:07:18,700
‫wilde lus.

97
00:07:18,880 --> 00:07:20,320
‫Dus hier is een simpele uitdaging voor jou.

98
00:07:20,320 --> 00:07:23,230
‫Converteer je waah-lus naar een for-lus.

99
00:07:23,530 --> 00:07:30,220
‫Je gaat kopiëren en de hoofdtekst van de code verandert de index van die naamindex in I.

100
00:07:30,220 --> 00:07:36,490
‫We gebruiken meestal de afkorting in for-loops van I gewoon een afkorting voor index echt en compileren

101
00:07:36,490 --> 00:07:38,560
‫en testen speelt video af.

102
00:07:41,800 --> 00:07:42,130
‫Oké.

103
00:07:42,130 --> 00:07:42,700
‫Welkom terug.

104
00:07:42,730 --> 00:07:44,680
‫Dit zou dus vrij eenvoudig moeten zijn.

105
00:07:44,680 --> 00:07:46,810
‫We willen de index plus plus hier niet.

106
00:07:47,170 --> 00:07:49,510
‫Dus de rest schrappen we.

107
00:07:50,100 --> 00:07:54,310
‫Een verandering over waar we de actoren-array indexeren met de index-variabele.

108
00:07:54,310 --> 00:07:56,550
‫We gaan dat veranderen in IE de variabele.

109
00:07:56,560 --> 00:07:58,420
‫Het is alleen beschikbaar binnen deze for-lus.

110
00:07:58,420 --> 00:08:04,700
‫Dat is een ander voordeel van de syntaxis van de volledige lus, dat de IE-variabele alleen beschikbaar is, alleen

111
00:08:04,960 --> 00:08:10,150
‫beschikbaar binnen de volledige lus, terwijl wanneer we het hier in de while-lus hebben

112
00:08:10,150 --> 00:08:16,960
‫gedeclareerd, het buiten beschikbaar is, wat de indexen vervuilt die we kunnen later gebruiken, zodat we die wilde lus kunnen verwijderen.

113
00:08:16,960 --> 00:08:23,170
‫En je kunt zien dat de volledige lus veel compacter is en je zult wennen aan de enigszins

114
00:08:23,170 --> 00:08:25,090
‫vreemde syntaxis die het heeft.

115
00:08:25,420 --> 00:08:30,430
‫Laten we doorgaan en compileren en gewoon controleren of het inderdaad hetzelfde werk doet.

116
00:08:30,640 --> 00:08:38,020
‫Als ik mijn waterspuwer ga pakken en bij de overlappende acteurs kom, kun je zien dat het inderdaad onze beide acteurs

117
00:08:38,020 --> 00:08:42,010
‫aan het printen is als we allebei overlappen in de alkoof.

118
00:08:42,100 --> 00:08:42,790
‫Goed spul.

119
00:08:42,790 --> 00:08:49,810
‫Dus in deze lezing hebben we een nieuw programmeeridee gezien, het idee van lussen, en we zijn

120
00:08:49,810 --> 00:08:52,960
‫vooral de Y-lus en de for-lus tegengekomen.

121
00:08:53,200 --> 00:08:54,700
‫Ik zie je in de volgende lezing.