1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] TOMMY MacWilliam: Vamos falar sobre loops, um dos comum

2
00:00:09,760 --> 00:00:13,380
construções de programação, vamos ver ao longo CS50.

3
00:00:13,380 --> 00:00:15,570
Nós vamos usar loops quando queremos realizar uma

4
00:00:15,570 --> 00:00:17,200
tarefa mais do que uma vez.

5
00:00:17,200 --> 00:00:20,700
Por exemplo, podemos querer imprimir "Olá!" 100 vezes ou impressão

6
00:00:20,700 --> 00:00:22,700
todas as letras do alfabeto.

7
00:00:22,700 --> 00:00:26,030
Em ambos os casos, temos uma coisa que nós queremos fazer

8
00:00:26,030 --> 00:00:28,700
várias vezes, imprimir algo.

9
00:00:28,700 --> 00:00:31,970
No entanto, o que imprimir cada tempo pode variar.

10
00:00:31,970 --> 00:00:34,530
Assim, podemos fazer algo um pouco diferente em cada

11
00:00:34,530 --> 00:00:37,820
iteração, ou percorrer, do loop.

12
00:00:37,820 --> 00:00:41,280
Vamos ver três diferentes tipos de loops em C, enquanto

13
00:00:41,280 --> 00:00:44,700
loops, loops, e fazer enquanto loops.

14
00:00:44,700 --> 00:00:47,850
Embora estes três tipos de alças têm uma sintaxe diferente,

15
00:00:47,850 --> 00:00:50,630
as idéias por trás delas são o mesmo.

16
00:00:50,630 --> 00:00:53,930
Vamos definir um bloco de código dentro de chaves,

17
00:00:53,930 --> 00:00:57,810
chamada o corpo do loop, que deseja ser executada

18
00:00:57,810 --> 00:00:59,790
um determinado número de vezes.

19
00:00:59,790 --> 00:01:03,370
Ao alterar os valores de variáveis ​​usadas no corpo,

20
00:01:03,370 --> 00:01:07,570
pode fazer o nosso laço fazer algo diferente a cada vez que ele for executado.

21
00:01:07,570 --> 00:01:10,750
Com qualquer laço que escrevemos, vamos também precisa decidir quando o

22
00:01:10,750 --> 00:01:12,400
loop irá parar de correr.

23
00:01:12,400 --> 00:01:15,650
Se não fizermos isso, então nosso fiel computador vai continuar

24
00:01:15,650 --> 00:01:19,040
para executar esse ciclo até que matar o programa.

25
00:01:19,040 --> 00:01:22,490
No Scratch, podemos usar a repetir n vezes

26
00:01:22,490 --> 00:01:24,600
bloco para criar um loop.

27
00:01:24,600 --> 00:01:28,200
Todos os pedaços dentro de um bloco que disse repetição 10

28
00:01:28,200 --> 00:01:30,130
seria executado 10 vezes.

29
00:01:30,130 --> 00:01:34,160
E então, a gente passar para as peças depois que o loop.

30
00:01:34,160 --> 00:01:38,140
Portanto, a nossa condição de parada foi simplesmente, este bloco tem sido

31
00:01:38,140 --> 00:01:39,830
executar 10 vezes.

32
00:01:39,830 --> 00:01:43,900
Então, vamos recriar isso em C. Para zero para garantir

33
00:01:43,900 --> 00:01:46,920
que as peças no interior do bloco de repetição são executadas

34
00:01:46,920 --> 00:01:51,180
exatamente 10 vezes, Scratch precisa manter o controle de cada

35
00:01:51,180 --> 00:01:53,750
execução do bloco de repetição.

36
00:01:53,750 --> 00:01:56,790
Para manter o controle de quantas vezes o nosso corpo do laço foi

37
00:01:56,790 --> 00:02:00,360
executado, vamos criar uma variável chamada i.

38
00:02:00,360 --> 00:02:03,400
Vamos começar i off em zero, uma vez que nosso laço

39
00:02:03,400 --> 00:02:04,650
não foi executado ainda.

40
00:02:10,009 --> 00:02:10,949
Ok

41
00:02:10,949 --> 00:02:15,560
Agora vamos usar a palavra-chave, enquanto para começar nossa loop.

42
00:02:20,100 --> 00:02:24,180
Agora precisamos descobrir quando nosso loop irá parar, mas

43
00:02:24,180 --> 00:02:26,730
vamos deixar isso por agora e depois voltar a ele.

44
00:02:30,970 --> 00:02:32,150
Tudo bem.

45
00:02:32,150 --> 00:02:35,260
Dentro de nosso laço, vamos imprimir uma mensagem, como

46
00:02:35,260 --> 00:02:38,535
"Oi". Podemos usar a função printf para isso.

47
00:02:48,400 --> 00:02:49,230
Tudo bem.

48
00:02:49,230 --> 00:02:54,210
Então agora vamos registrar que uma iteração do loop tem corpo

49
00:02:54,210 --> 00:02:55,750
sido executado.

50
00:02:55,750 --> 00:03:00,320
Nós podemos fazer isso adicionando uma, ou o incremento, nosso contador

51
00:03:00,320 --> 00:03:01,740
variável, i.

52
00:03:01,740 --> 00:03:09,180
Para isso, podemos dizer i é igual a i + 1, ou mais

53
00:03:09,180 --> 00:03:16,520
simplesmente, i mais além.

54
00:03:16,520 --> 00:03:17,320
Grande.

55
00:03:17,320 --> 00:03:21,810
Então agora podemos ver que cada vez que o loop é executado, o nosso

56
00:03:21,810 --> 00:03:24,500
variável de contador vai até a um.

57
00:03:24,500 --> 00:03:29,410
Então, nós sabemos exatamente quantas iterações nós funcionamos até agora.

58
00:03:29,410 --> 00:03:31,630
Depois de uma iteração do loop, o nosso valor

59
00:03:31,630 --> 00:03:34,270
de i será 1.

60
00:03:34,270 --> 00:03:37,460
Depois de duas iterações, vou ser 2.

61
00:03:37,460 --> 00:03:42,640
E depois de 10 iterações, vou ser 10.

62
00:03:42,640 --> 00:03:46,780
Portanto, se deseja executar este loop exatamente 10 vezes, então

63
00:03:46,780 --> 00:03:49,240
isto é, quando queremos parar.

64
00:03:49,240 --> 00:03:53,860
Então, nós queremos executar este loop while i é inferior a 10, e

65
00:03:53,860 --> 00:03:57,630
que é exatamente o que vou escrever, enquanto eu

66
00:03:57,630 --> 00:04:02,450
é inferior a 10.

67
00:04:02,450 --> 00:04:06,380
Esta condição parece, como as condições que usamos em se

68
00:04:06,380 --> 00:04:07,830
blocos mais.

69
00:04:07,830 --> 00:04:11,690
Depois que o corpo de nosso laço foi executado, o nosso programa

70
00:04:11,690 --> 00:04:14,690
vai saltar de volta para a condição de loops.

71
00:04:14,690 --> 00:04:17,290
Se a condição é verdadeira, então o corpo da

72
00:04:17,290 --> 00:04:18,990
laço será executado novamente.

73
00:04:18,990 --> 00:04:22,190
Se a condição não é mais verdade, então o nosso laço não será

74
00:04:22,190 --> 00:04:25,700
correr mais e vai passar para a próxima linha de código

75
00:04:25,700 --> 00:04:27,876
embaixo do nosso loop.

76
00:04:27,876 --> 00:04:28,550
Tudo bem.

77
00:04:28,550 --> 00:04:30,740
Então, vamos dar uma olhada em um segundo tipo de

78
00:04:30,740 --> 00:04:33,000
loop, o loop for.

79
00:04:33,000 --> 00:04:37,310
Ao lado da palavra-chave, enquanto, entre parênteses, tivemos uma coisa,

80
00:04:37,310 --> 00:04:39,840
a condição de que precisava para ser verdade para o

81
00:04:39,840 --> 00:04:42,010
corpo do laço ser executado.

82
00:04:42,010 --> 00:04:45,440
Isso significa que tivemos de criar a nossa variável de contador fora

83
00:04:45,440 --> 00:04:48,760
do circuito e lembre-se de incrementá-lo em algum ponto

84
00:04:48,760 --> 00:04:51,050
no interior do laço.

85
00:04:51,050 --> 00:04:54,320
O cabeçalho para o nosso loop for, por outro lado, tem três

86
00:04:54,320 --> 00:04:58,510
partes, cada uma das quais vai ser separados com um ponto e vírgula.

87
00:04:58,510 --> 00:05:01,950
No nosso primeiro terço, podemos declarar qualquer balcão ou ajudante

88
00:05:01,950 --> 00:05:05,000
variáveis ​​que gostaria de usar no nosso loop.

89
00:05:05,000 --> 00:05:07,350
Na prática, isso pode ser realmente útil.

90
00:05:07,350 --> 00:05:10,590
Nós realmente não precisa dessa variável, i, depois do nosso tempo

91
00:05:10,590 --> 00:05:13,650
laço foi executado, então nós realmente não deveria ter que declará-lo

92
00:05:13,650 --> 00:05:15,810
fora do circuito.

93
00:05:15,810 --> 00:05:19,080
O segundo terço será a condição que deve ser verdadeira

94
00:05:19,080 --> 00:05:21,850
para o corpo a ser executada mais uma vez, tal como

95
00:05:21,850 --> 00:05:23,330
no nosso loop while.

96
00:05:23,330 --> 00:05:26,350
No nosso último terço, podemos executar uma instrução que será

97
00:05:26,350 --> 00:05:30,270
executado após cada iteração do loop, então não temos

98
00:05:30,270 --> 00:05:32,710
para construí-lo no corpo do laço.

99
00:05:32,710 --> 00:05:38,390
Então vamos escrever um loop for que contagem regressiva de 5 a 1.

100
00:05:38,390 --> 00:05:41,790
Vamos começar com a palavra-chave para.

101
00:05:41,790 --> 00:05:44,680
Podemos criar uma variável de contador em primeiro lugar, que vamos

102
00:05:44,680 --> 00:05:47,840
definido para 5 neste momento, já que estamos em contagem decrescente,

103
00:05:47,840 --> 00:05:50,110
seguido por um ponto e vírgula.

104
00:05:50,110 --> 00:05:53,660
Em seguida é a nossa condição, que nós vamos voltar.

105
00:05:53,660 --> 00:05:57,540
Em terceiro lugar, gostaria de diminuir a nossa variável contador após

106
00:05:57,540 --> 00:05:59,620
cada iteração do loop.

107
00:05:59,620 --> 00:06:04,740
Então, ao invés de dizer que eu mais mais, vamos dizer que eu menos menos.

108
00:06:04,740 --> 00:06:05,300
Tudo bem.

109
00:06:05,300 --> 00:06:09,490
Então, queremos que o corpo do laço seja executado enquanto i é ainda

110
00:06:09,490 --> 00:06:11,960
maior do que 0.

111
00:06:11,960 --> 00:06:16,160
No corpo do loop, vamos imprimir o valor de i.

112
00:06:16,160 --> 00:06:20,480
Para isso, vamos utilizar a função printf, usando o% d

113
00:06:20,480 --> 00:06:21,650
espaço reservado.

114
00:06:21,650 --> 00:06:24,820
Recorde, esse marcador de posição será substituído com o

115
00:06:24,820 --> 00:06:27,040
valor de i.

116
00:06:27,040 --> 00:06:32,060
Finalmente, vamos adicionar uma declaração depois do nosso loop for.

117
00:06:32,060 --> 00:06:35,850
Quando executar este loop, eu vou começar a 5,

118
00:06:35,850 --> 00:06:38,070
so 5 serão impressos.

119
00:06:38,070 --> 00:06:42,000
Uma vez que eu começa a 0, a condição de continuação, i é

120
00:06:42,000 --> 00:06:44,450
maior que 0, não vai mais segurar.

121
00:06:44,450 --> 00:06:47,330
Assim, o nosso ciclo vai parar de executar, e vamos ver o

122
00:06:47,330 --> 00:06:49,850
instrução após o loop.

123
00:06:49,850 --> 00:06:51,340
Então, vamos executar esse código.

124
00:06:51,340 --> 00:06:52,700
Primeiro, vamos compilar um

125
00:06:52,700 --> 00:06:56,460
countdown.c com fazer contagem regressiva.

126
00:06:56,460 --> 00:06:59,320
Agora, podemos executar esse código com. Contagem regressiva /.

127
00:07:02,340 --> 00:07:06,040
Em ambos os circuitos, enquanto e loops, a continuação

128
00:07:06,040 --> 00:07:09,010
condição será verificado antes de o corpo

129
00:07:09,010 --> 00:07:10,960
do laço é executado.

130
00:07:10,960 --> 00:07:13,840
Isso significa que, se a nossa condição não é, inicialmente,

131
00:07:13,840 --> 00:07:18,100
verdade, então o corpo do nosso laço nunca será executado.

132
00:07:18,100 --> 00:07:22,060
Então, às vezes é útil para verificar a condição após a

133
00:07:22,060 --> 00:07:25,150
corpo do laço, em vez de antes.

134
00:07:25,150 --> 00:07:28,270
Então vamos escrever um loop para avisar o usuário para um número

135
00:07:28,270 --> 00:07:30,990
até que um número positivo é fornecido.

136
00:07:30,990 --> 00:07:34,740
Se o usuário insere um número negativo, nós vamos querer perguntar-lhes

137
00:07:34,740 --> 00:07:36,260
para outro número.

138
00:07:36,260 --> 00:07:38,940
Então, nós vamos querer esta solicitação para estar dentro do

139
00:07:38,940 --> 00:07:41,050
corpo fora do loop.

140
00:07:41,050 --> 00:07:44,730
No entanto, quando o laço é executado pela primeira vez, o utilizador

141
00:07:44,730 --> 00:07:46,750
não tem nos dado o número ainda.

142
00:07:46,750 --> 00:07:49,640
Portanto, não faz sentido para verificar se ele é positivo.

143
00:07:49,640 --> 00:07:54,020
Em vez disso, vai querer verificar o número após o corpo de

144
00:07:54,020 --> 00:07:55,720
o loop é executado.

145
00:07:55,720 --> 00:08:00,310
Podemos fazer isso com um do while.

146
00:08:00,310 --> 00:08:03,560
Primeiro, vamos criar uma variável, n, que irá realizar

147
00:08:03,560 --> 00:08:05,230
de entrada do usuário.

148
00:08:05,230 --> 00:08:09,960
Agora vamos usar a palavra-chave do, seguido de chaves que

149
00:08:09,960 --> 00:08:12,930
vai começar o corpo do nosso loop.

150
00:08:12,930 --> 00:08:16,230
No corpo, o que pode levar o usuário para um número com o

151
00:08:16,230 --> 00:08:18,480
GetInt função.

152
00:08:18,480 --> 00:08:23,230
Agora, nós vamos querer o corpo deste loop para executar novamente se

153
00:08:23,230 --> 00:08:28,370
o usuário digitou um número negativo, por isso vamos dizer enquanto n

154
00:08:28,370 --> 00:08:30,420
é menor do que 0.

155
00:08:30,420 --> 00:08:33,140
Observe o ponto e vírgula aqui depois da declaração de tempo.

156
00:08:38,909 --> 00:08:40,679
Então, vamos executar esse código.

157
00:08:40,679 --> 00:08:44,780
Primeiro, vamos compilar este com make positivo.

158
00:08:44,780 --> 00:08:49,340
Agora podemos executar o programa com. / Positivo.

159
00:08:49,340 --> 00:08:52,660
Se nós dar a este programa um número negativo, como negativa

160
00:08:52,660 --> 00:08:56,560
4, então vamos ser solicitado novamente para um número desde que o

161
00:08:56,560 --> 00:09:00,490
condição do nosso loop Do While era verdade.

162
00:09:00,490 --> 00:09:04,690
Uma vez que dão um número positivo, como 8, então o

163
00:09:04,690 --> 00:09:08,560
condição do nosso loop Do While não será mais verdade.

164
00:09:08,560 --> 00:09:12,080
Assim, o loop não será executado novamente.

165
00:09:12,080 --> 00:09:15,290
E é isso para os três tipos de loops que usaremos em C.

166
00:09:15,290 --> 00:09:18,840
Meu nome é Tommy, e este é o CS50.