[Powered by Google Translate] TOMMY MacWilliam: Vamos falar sobre loops, um dos comum
construções de programação, vamos ver ao longo CS50.
Nós vamos usar loops quando queremos realizar uma
tarefa mais do que uma vez.
Por exemplo, podemos querer imprimir "Olá!" 100 vezes ou impressão
todas as letras do alfabeto.
Em ambos os casos, temos uma coisa que nós queremos fazer
várias vezes, imprimir algo.
No entanto, o que imprimir cada tempo pode variar.
Assim, podemos fazer algo um pouco diferente em cada
iteração, ou percorrer, do loop.
Vamos ver três diferentes tipos de loops em C, enquanto
loops, loops, e fazer enquanto loops.
Embora estes três tipos de alças têm uma sintaxe diferente,
as idéias por trás delas são o mesmo.
Vamos definir um bloco de código dentro de chaves,
chamada o corpo do loop, que deseja ser executada
um determinado número de vezes.
Ao alterar os valores de variáveis ​​usadas no corpo,
pode fazer o nosso laço fazer algo diferente a cada vez que ele for executado.
Com qualquer laço que escrevemos, vamos também precisa decidir quando o
loop irá parar de correr.
Se não fizermos isso, então nosso fiel computador vai continuar
para executar esse ciclo até que matar o programa.
No Scratch, podemos usar a repetir n vezes
bloco para criar um loop.
Todos os pedaços dentro de um bloco que disse repetição 10
seria executado 10 vezes.
E então, a gente passar para as peças depois que o loop.
Portanto, a nossa condição de parada foi simplesmente, este bloco tem sido
executar 10 vezes.
Então, vamos recriar isso em C. Para zero para garantir
que as peças no interior do bloco de repetição são executadas
exatamente 10 vezes, Scratch precisa manter o controle de cada
execução do bloco de repetição.
Para manter o controle de quantas vezes o nosso corpo do laço foi
executado, vamos criar uma variável chamada i.
Vamos começar i off em zero, uma vez que nosso laço
não foi executado ainda.
Ok
Agora vamos usar a palavra-chave, enquanto para começar nossa loop.
Agora precisamos descobrir quando nosso loop irá parar, mas
vamos deixar isso por agora e depois voltar a ele.
Tudo bem.
Dentro de nosso laço, vamos imprimir uma mensagem, como
"Oi". Podemos usar a função printf para isso.
Tudo bem.
Então agora vamos registrar que uma iteração do loop tem corpo
sido executado.
Nós podemos fazer isso adicionando uma, ou o incremento, nosso contador
variável, i.
Para isso, podemos dizer i é igual a i + 1, ou mais
simplesmente, i mais além.
Grande.
Então agora podemos ver que cada vez que o loop é executado, o nosso
variável de contador vai até a um.
Então, nós sabemos exatamente quantas iterações nós funcionamos até agora.
Depois de uma iteração do loop, o nosso valor
de i será 1.
Depois de duas iterações, vou ser 2.
E depois de 10 iterações, vou ser 10.
Portanto, se deseja executar este loop exatamente 10 vezes, então
isto é, quando queremos parar.
Então, nós queremos executar este loop while i é inferior a 10, e
que é exatamente o que vou escrever, enquanto eu
é inferior a 10.
Esta condição parece, como as condições que usamos em se
blocos mais.
Depois que o corpo de nosso laço foi executado, o nosso programa
vai saltar de volta para a condição de loops.
Se a condição é verdadeira, então o corpo da
laço será executado novamente.
Se a condição não é mais verdade, então o nosso laço não será
correr mais e vai passar para a próxima linha de código
embaixo do nosso loop.
Tudo bem.
Então, vamos dar uma olhada em um segundo tipo de
loop, o loop for.
Ao lado da palavra-chave, enquanto, entre parênteses, tivemos uma coisa,
a condição de que precisava para ser verdade para o
corpo do laço ser executado.
Isso significa que tivemos de criar a nossa variável de contador fora
do circuito e lembre-se de incrementá-lo em algum ponto
no interior do laço.
O cabeçalho para o nosso loop for, por outro lado, tem três
partes, cada uma das quais vai ser separados com um ponto e vírgula.
No nosso primeiro terço, podemos declarar qualquer balcão ou ajudante
variáveis ​​que gostaria de usar no nosso loop.
Na prática, isso pode ser realmente útil.
Nós realmente não precisa dessa variável, i, depois do nosso tempo
laço foi executado, então nós realmente não deveria ter que declará-lo
fora do circuito.
O segundo terço será a condição que deve ser verdadeira
para o corpo a ser executada mais uma vez, tal como
no nosso loop while.
No nosso último terço, podemos executar uma instrução que será
executado após cada iteração do loop, então não temos
para construí-lo no corpo do laço.
Então vamos escrever um loop for que contagem regressiva de 5 a 1.
Vamos começar com a palavra-chave para.
Podemos criar uma variável de contador em primeiro lugar, que vamos
definido para 5 neste momento, já que estamos em contagem decrescente,
seguido por um ponto e vírgula.
Em seguida é a nossa condição, que nós vamos voltar.
Em terceiro lugar, gostaria de diminuir a nossa variável contador após
cada iteração do loop.
Então, ao invés de dizer que eu mais mais, vamos dizer que eu menos menos.
Tudo bem.
Então, queremos que o corpo do laço seja executado enquanto i é ainda
maior do que 0.
No corpo do loop, vamos imprimir o valor de i.
Para isso, vamos utilizar a função printf, usando o% d
espaço reservado.
Recorde, esse marcador de posição será substituído com o
valor de i.
Finalmente, vamos adicionar uma declaração depois do nosso loop for.
Quando executar este loop, eu vou começar a 5,
so 5 serão impressos.
Uma vez que eu começa a 0, a condição de continuação, i é
maior que 0, não vai mais segurar.
Assim, o nosso ciclo vai parar de executar, e vamos ver o
instrução após o loop.
Então, vamos executar esse código.
Primeiro, vamos compilar um
countdown.c com fazer contagem regressiva.
Agora, podemos executar esse código com. Contagem regressiva /.
Em ambos os circuitos, enquanto e loops, a continuação
condição será verificado antes de o corpo
do laço é executado.
Isso significa que, se a nossa condição não é, inicialmente,
verdade, então o corpo do nosso laço nunca será executado.
Então, às vezes é útil para verificar a condição após a
corpo do laço, em vez de antes.
Então vamos escrever um loop para avisar o usuário para um número
até que um número positivo é fornecido.
Se o usuário insere um número negativo, nós vamos querer perguntar-lhes
para outro número.
Então, nós vamos querer esta solicitação para estar dentro do
corpo fora do loop.
No entanto, quando o laço é executado pela primeira vez, o utilizador
não tem nos dado o número ainda.
Portanto, não faz sentido para verificar se ele é positivo.
Em vez disso, vai querer verificar o número após o corpo de
o loop é executado.
Podemos fazer isso com um do while.
Primeiro, vamos criar uma variável, n, que irá realizar
de entrada do usuário.
Agora vamos usar a palavra-chave do, seguido de chaves que
vai começar o corpo do nosso loop.
No corpo, o que pode levar o usuário para um número com o
GetInt função.
Agora, nós vamos querer o corpo deste loop para executar novamente se
o usuário digitou um número negativo, por isso vamos dizer enquanto n
é menor do que 0.
Observe o ponto e vírgula aqui depois da declaração de tempo.
Então, vamos executar esse código.
Primeiro, vamos compilar este com make positivo.
Agora podemos executar o programa com. / Positivo.
Se nós dar a este programa um número negativo, como negativa
4, então vamos ser solicitado novamente para um número desde que o
condição do nosso loop Do While era verdade.
Uma vez que dão um número positivo, como 8, então o
condição do nosso loop Do While não será mais verdade.
Assim, o loop não será executado novamente.
E é isso para os três tipos de loops que usaremos em C.
Meu nome é Tommy, e este é o CS50.