1
00:00:04,390 --> 00:00:05,830
‫Olá e bem-vindo a esta palestra.

2
00:00:05,830 --> 00:00:12,880
‫Vamos aprender como podemos executar um pedaço de código variável números de vezes para que possamos

3
00:00:12,880 --> 00:00:19,840
‫imprimir todos os objetos que se sobrepõem dentro desta área, este componente de gatilho.

4
00:00:20,080 --> 00:00:24,190
‫Então você pode ver aqui que quando estamos os dois, eu estou dentro e há uma gárgula também.

5
00:00:24,460 --> 00:00:29,140
‫Ele está imprimindo tanto o nome das gárgulas quanto o nome das plantas do jogador.

6
00:00:29,440 --> 00:00:31,090
‫Vamos mergulhar e ver como isso é feito.

7
00:00:32,020 --> 00:00:38,830
‫Agora, o problema com nosso código aqui é que nosso array de atores pode ter muito mais do que apenas um

8
00:00:38,830 --> 00:00:44,020
‫ator nele, e se quisermos exibir todos os atores sobrepostos, queremos fazer algo com todos

9
00:00:44,020 --> 00:00:44,800
‫esses atores.

10
00:00:45,160 --> 00:00:47,650
‫Precisamos ser capazes de executar através do código.

11
00:00:47,650 --> 00:00:53,680
‫Seria altamente ineficiente escrever uma instrução if para o caso em que temos dois ou

12
00:00:53,680 --> 00:00:58,780
‫três ou quatro ou cinco, etc. E certamente nunca pegaria todos os casos porque temos uma quantidade limitada

13
00:00:58,780 --> 00:01:00,010
‫de linhas em nosso arquivo.

14
00:01:00,640 --> 00:01:08,620
‫Então, da maneira como lidamos com isso, queremos repetir um pedaço de código várias vezes, mas várias vezes que

15
00:01:08,620 --> 00:01:09,850
‫não sabemos.

16
00:01:09,850 --> 00:01:15,610
‫Quando estamos compilando o código, precisamos substituir nossa instrução if, onde a instrução if essencialmente diz,

17
00:01:15,610 --> 00:01:21,490
‫devo executar este código ou não por algo que diz, devo executar este código ou devo executá-lo

18
00:01:21,490 --> 00:01:25,090
‫muitas vezes, duas vezes, três vezes, quatro vezes, etc.?

19
00:01:25,570 --> 00:01:29,230
‫A maneira como fazemos isso é com algo chamado de declaração selvagem.

20
00:01:29,530 --> 00:01:32,380
‫Agora é construído muito parecido com uma instrução if.

21
00:01:32,380 --> 00:01:41,230
‫Então, enquanto você coloca algum tipo de valor booleano dentro dos parênteses, e então temos algumas chaves

22
00:01:41,290 --> 00:01:47,650
‫e dentro das chaves, um bloco de código que continuará sendo executado

23
00:01:47,650 --> 00:01:54,310
‫repetidamente até que a condição em nossa instrução wild se torne falsa .

24
00:01:54,310 --> 00:01:55,960
‫É por isso que é chamado de enquanto.

25
00:01:55,960 --> 00:01:59,260
‫Então, enquanto isso é verdade, execute este código.

26
00:01:59,260 --> 00:02:04,570
‫Portanto, é um pouco como uma instrução if, pois às vezes pode não executar o código, mas

27
00:02:04,570 --> 00:02:09,910
‫ao contrário de sua instrução que só pode executar um pedaço de código uma vez, a instrução

28
00:02:09,910 --> 00:02:14,620
‫wild pode basicamente continuar executando-o para sempre se esse booleano nunca se tornar falso.

29
00:02:15,550 --> 00:02:16,990
‫Então, por que isso é útil?

30
00:02:16,990 --> 00:02:22,180
‫Bem, poderíamos criar um int 32 e chamá-lo de índice e iniciá-lo em zero.

31
00:02:22,990 --> 00:02:31,690
‫E então toda vez que passamos pelo corpo desse loop selvagem, aumentamos o valor armazenado nesse índice.

32
00:02:31,690 --> 00:02:35,830
‫Então podemos dizer que índice é igual a índice mais um.

33
00:02:36,700 --> 00:02:42,460
‫Agora, em C++, há um atalho para fazer isso em vez de ter que fazer index mais

34
00:02:42,460 --> 00:02:49,210
‫um assim, você faz mais mais índice, e isso apenas adiciona um ao que está armazenado na variável de índice.

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

36
00:02:50,440 --> 00:02:51,910
‫Então começamos do zero.

37
00:02:52,210 --> 00:02:54,700
‫Nós cada vez que damos a volta, aumentamos o índice.

38
00:02:55,060 --> 00:03:03,160
‫E o que podemos fazer é fazer com que apenas passemos por esse loop selvagem enquanto nosso índice estiver dentro dos

39
00:03:03,160 --> 00:03:05,170
‫limites de nossa matriz.

40
00:03:05,200 --> 00:03:11,220
‫Então podemos dizer que o índice deve ser menor que os atores dot num.

41
00:03:11,410 --> 00:03:13,210
‫Então esse é o tamanho da matriz.

42
00:03:13,210 --> 00:03:19,300
‫Lembre-se que quando temos cinco itens no array, o último item do array é o índice quatro.

43
00:03:19,930 --> 00:03:28,210
‫E assim podemos ver que isso será verdade quando o índice for válido, quando o índice quatro for menor que cinco.

44
00:03:28,570 --> 00:03:34,460
‫Mas assim que esse índice passar do final da matriz, quando chegar ao índice cinco, o

45
00:03:34,480 --> 00:03:39,040
‫número do ator não será mais cinco não será menor que cinco.

46
00:03:39,310 --> 00:03:44,920
‫Portanto, o loop while parará de ser executado e continuará com o restante da função.

47
00:03:45,790 --> 00:03:54,700
‫Então, o que isso significa é que agora podemos pegar o código que tínhamos acima e reescrevê-lo, pegá-lo, copiá-lo, cortá-lo

48
00:03:54,700 --> 00:03:57,970
‫e colocá-lo aqui em um tempo.

49
00:03:57,970 --> 00:03:58,210
‫Ciclo.

50
00:03:58,210 --> 00:04:03,460
‫Mas antes de aumentarmos o índice, o mais importante, porque o que vamos fazer é substituir

51
00:04:03,460 --> 00:04:08,290
‫esse zero onde estávamos obtendo o ator zero, podemos substituí-lo pelo índice do ator.

52
00:04:08,890 --> 00:04:10,120
‫Então vamos seguir isso.

53
00:04:10,120 --> 00:04:11,680
‫Como isso funcionaria.

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

55
00:04:12,790 --> 00:04:15,700
‫Remova nossa instrução if porque isso é um pouco confuso.

56
00:04:15,970 --> 00:04:19,960
‫Então começamos o valor na variável index vai ser zero.

57
00:04:20,590 --> 00:04:26,770
‫Agora imagine que temos que agir é manter as coisas simples é zero menos que dois.

58
00:04:27,160 --> 00:04:28,330
‫Sim Sim é isso.

59
00:04:28,690 --> 00:04:37,450
‫Então entramos e obtemos o ator zero, obtemos seu nome e o desconectamos e então aumentamos o valor no índice

60
00:04:37,450 --> 00:04:38,620
‫em um.

61
00:04:38,620 --> 00:04:40,570
‫Então, vai de zero a um.

62
00:04:41,380 --> 00:04:47,200
‫Agora voltamos para avaliar a condição do laço while e dizemos que é um a menos que dois?

63
00:04:47,320 --> 00:04:47,950
‫É sim.

64
00:04:48,280 --> 00:04:55,300
‫Podemos então entrar e pegar o ator um e então vamos pegar seu nome e imprimir seu nome.

65
00:04:55,600 --> 00:05:02,140
‫Em seguida, aumentamos o índice novamente para o índice dois e fazemos a pergunta novamente no loop while dizendo que dois

66
00:05:02,350 --> 00:05:03,850
‫é menor que dois?

67
00:05:04,240 --> 00:05:05,710
‫Então, a resposta é não.

68
00:05:05,950 --> 00:05:11,800
‫Então, pulamos o corpo do loop while e continuamos e executamos o resto do código.

69
00:05:12,520 --> 00:05:15,090
‫Então é basicamente isso que queremos alcançar.

70
00:05:15,100 --> 00:05:23,440
‫Queremos imprimir o nome de cada ator na matriz, e é isso que esse código fará.

71
00:05:23,680 --> 00:05:26,200
‫Vamos em frente e compilá-lo e verificar se estou certo.

72
00:05:26,350 --> 00:05:32,980
‫Se formos em frente e apertar o play e entrar na caixa, você pode ver que estávamos sobrepondo apenas o jogador

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

74
00:05:33,850 --> 00:05:36,070
‫E se formos buscar nossa gárgula?

75
00:05:36,310 --> 00:05:41,020
‫Se colocarmos apenas no salto, você pode ver que ficamos sobrepondo a gárgula.

76
00:05:41,050 --> 00:05:43,030
‫Mas e se eu entrar também?

77
00:05:43,360 --> 00:05:50,040
‫Agora você pode ver que está imprimindo tanto o jogador quanto a gárgula, todos no mesmo quadro.

78
00:05:50,050 --> 00:05:52,060
‫Então nosso loop selvagem está funcionando.

79
00:05:52,060 --> 00:05:58,390
‫Ele está executando um pedaço de código várias vezes quando há vários atores na matriz.

80
00:05:58,570 --> 00:06:04,540
‫Agora, porque esse padrão é tão comum que temos algum tipo de índice e o aumentamos toda vez que

81
00:06:04,540 --> 00:06:05,500
‫passamos pelo loop.

82
00:06:05,860 --> 00:06:15,250
‫Na verdade, há uma abreviação para isso em C++ e, se você digitar no código do Visual Studio, há um trecho

83
00:06:15,250 --> 00:06:23,850
‫para um loop de quatro aqui que você pode expandir e ver que essa é uma estrutura geral.

84
00:06:23,860 --> 00:06:25,390
‫Tem algo chamado tamanho T aqui.

85
00:06:25,390 --> 00:06:29,200
‫Podemos substituir isso por INT 32 para nossos propósitos.

86
00:06:29,710 --> 00:06:36,220
‫E essencialmente o que isso está dizendo é que existem três instruções dentro dos parênteses do loop for.

87
00:06:36,370 --> 00:06:42,940
‫O primeiro é equivalente a onde configuramos nossa variável de índice antes de nosso loop while.

88
00:06:43,840 --> 00:06:48,820
‫A segunda é a condição que é equivalente ao que colocamos dentro do nosso laço while.

89
00:06:49,600 --> 00:06:54,460
‫E você pode ver que poderíamos substituir a contagem por atores ponto num.

90
00:06:54,730 --> 00:07:01,150
‫E então o último bit é basicamente o plus plus se você colocar antes ou depois, o índice

91
00:07:01,150 --> 00:07:07,180
‫não é muito importante, mas você pode ver que isso está aumentando o valor no índice.

92
00:07:07,180 --> 00:07:10,810
‫Então é equivalente à linha que colocamos no final do nosso loop.

93
00:07:11,560 --> 00:07:17,890
‫Então, isso apenas reúne tudo em uma linha o que estávamos tendo que espalhar em vários usando nosso

94
00:07:17,890 --> 00:07:18,700
‫loop selvagem.

95
00:07:18,880 --> 00:07:20,320
‫Então aqui está um desafio simples para você.

96
00:07:20,320 --> 00:07:23,230
‫Converta seu loop waah em um loop for.

97
00:07:23,530 --> 00:07:30,220
‫Você vai copiar e o corpo do código mudará o índice desse índice de nome para I.

98
00:07:30,220 --> 00:07:36,490
‫Normalmente usamos a abreviação em loops for de I apenas uma abreviação para index realmente e compile e

99
00:07:36,490 --> 00:07:38,560
‫teste o vídeo de reprodução.

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

101
00:07:42,130 --> 00:07:42,700
‫Bem vindo de volta.

102
00:07:42,730 --> 00:07:44,680
‫Portanto, isso deve ser bastante simples.

103
00:07:44,680 --> 00:07:46,810
‫Não queremos o índice mais mais aqui.

104
00:07:47,170 --> 00:07:49,510
‫Então vamos cortar o resto.

105
00:07:50,100 --> 00:07:54,310
‫Uma mudança sobre onde estamos indexando o array de atores com a variável de índice.

106
00:07:54,310 --> 00:07:56,550
‫Vamos mudar isso para IE a variável.

107
00:07:56,560 --> 00:07:58,420
‫Está disponível apenas dentro deste loop for.

108
00:07:58,420 --> 00:08:04,700
‫Essa é outra vantagem pela sintaxe do loop completo é que a variável IE está disponível apenas, disponível apenas

109
00:08:04,960 --> 00:08:10,150
‫dentro do loop completo, enquanto que quando a declaramos aqui no loop while, ela

110
00:08:10,150 --> 00:08:16,960
‫está disponível fora, o que polui os índices que podemos use mais tarde para que possamos excluir esse loop selvagem.

111
00:08:16,960 --> 00:08:23,170
‫E você pode ver que o loop completo é muito mais condensado e você se acostumará com a sintaxe um

112
00:08:23,170 --> 00:08:25,090
‫pouco estranha que ele possui.

113
00:08:25,420 --> 00:08:30,430
‫Vamos em frente e compilar e apenas verificar se ele realmente faz o mesmo trabalho.

114
00:08:30,640 --> 00:08:38,020
‫Se eu for e pegar minha gárgula e for até os atores sobrepostos, você pode ver que de fato está imprimindo

115
00:08:38,020 --> 00:08:42,010
‫nossos dois atores quando nós dois estamos sobrepostos na alcova.

116
00:08:42,100 --> 00:08:42,790
‫Coisas boas.

117
00:08:42,790 --> 00:08:49,810
‫Então, nesta palestra vimos uma nova ideia de programação, a ideia de loops, e encontramos particularmente

118
00:08:49,810 --> 00:08:52,960
‫o loop Y e o loop for.

119
00:08:53,200 --> 00:08:54,700
‫Vejo você na próxima palestra.