Centro de Tecnologia Microgenios - Todos os direitos reservados

Clique aqui para Imprimir o doc

umento

Estruturas de Repetio

1.0 O comando For

1.1 O comando While
1.2 O comando do - while
1.3 O comando break e continue

Introduo
Os laos de repetio servem para repetir uma ou mais vezes determinada instruo ou blocos de
instrues. Existem basicamente trs tipos de estruturas de repetio na linguagem C:
for
While
Do - While
A estrutura for basicamente utilizada para laos finitos de contagem, normalemtne utilizando uma
varivel de controle da contagem.
A estrutura while basicamente utilizado para repetio de um determinado conjunto de instruo
enquanto uma condio for verdadeira.
O comando do - while similar estrutura while, diferenciando apenas o momento que analisada a
condio.
Vamos conhecer sobre cada estrutura de repetio, acompanhe:

voltar para o topo da pagina

O comando For

O lao for utilizado quando necessitamos de um ciclo de repeties controlado, pois

em sua declarao podemos inicializar e incrementar ou decrementar a varivel de
controle. Antes de serem executados os comandos do lao For-next, primeiramente
avaliada a condio do teste. Caso seja verdadeira, so executados os comandos do lao.
A cada ciclo que executado o fao for, a varivel de controle ser incrementada ou
decrementada no valor programado no incremento.
Veja a estrutura do comando For :
For (inicializao ; condio ; incremento ) comando;
ou
For (inicializao ; condio ; incremento )
{
...
comandoA1
comandoA2
...
}

em que:
inicializao: expresso vlida utilizada normalemtne para inicializao da varivel de
controle do lao for.
condio: condio para que decide pela continuidade ou no do lao de repetio,
enquanto esta condio foi verdadeira , o lao for permanecer em execuo.
incremento: valor incrementado em a cada repetio do lao for.
Exemplo:
int contador;
for (contador = 0 ; contador = 10 ; contador ++ ) portb = contador;
Na estrutura anterior, a varivel contador inicialmente carregada com o valor 0
(zero), e os comandos do lao for so executados. Aps a execuo de todos os
comandos presentes no lao for, a varivel contador incrementada no passo do valor
do incremento, que no nosso exemplo 1 unidade, e novamente os comandos do lao
for so executados. A estrutura de repetio for termina quando a varivel contador
assume o valor 10.
Exemplo:
int v, d;
for (v = 0 ; v = d ; v++)
{
Comando A
Comando B
}

Este exemplo funciona da seguinte maneira:

1) A varivel V recebe o valor 0.
2) O comando A e o comando B so executados.
3) A varivel V tem seu valor incrementado em 1 unidade.
4) Aps esta incrementao, o valor de V comparado com o valor D, e a seqncia
retorna ao item 2, para nova repetio.
5) Caso contrrio (V ultrapassou D), o lao de repetio for finalizado.

O grande benifcio do lao for sua flexibilidade, pois aceita qualquer expresso vlida em C, mesmo
que essas expresses no tenham relacionamento com o lao de repetio diretamente.
Um exemplo simples de aplicao do lao for a criao de pequenos tempos de atrasos (delays).

int atraso;
for (atraso = 0 ; atraso < 1000 ; atraso++);
O lao for acima faz com que o processamento fique incrementando constantemente a varivel atraso em
1 at que esta varivel seja igual ao valor 1000;
Observe o fragmento de programa seguinte vlido dentro do loop for:
for (n = 0 ; (n < 100) && portb.f0 ; n++)
No exemplo acima a varivel n ser incrementada 100 vezes, desde que o pino RB0 permanea em estado
lgico alto. Se o pino RB0 em algum momento do lao cair para nivel lgico baixo, o loop ser
imediatamente encerrado.

Programa Exemplo:
Aproveitando que estamos estudando as estruturas do lao de repetio for, vamos elaborar um program
que pisca um led conectado ao pino RD0 do PIC utilizando os recursos do lao for.
Acompanhe o esquema abaixo:

O programa seguinte vai contar at 100.000. Para acomodar um nmero dessa grandeza poderiamos ter
utilizado uma varivel long, mas optamos pela varivel int para que voc entenda a construo de dois
laos for encadeados. Para contar at 100,000 necessrio termos uma varivel que conte at 100 e outra
at 1000 (100 * 1000 = 100.000).

//**********************************************************
// programa de perda de tempo utilizando o lao de repetio for.
//**********************************************************
void atraso(void) // rotina de perda de tempo
{
int contador1, contador2;
for (contador1 = 0 ; contador1 < 100 ; contador1++) //lao de repetio for
for (contador2 = 0; contador2 < 1000; contador2++) ;
}
void main() {
trisd = 0;
while(1) {
atraso();
//chama rotina de perda de tempo
portd = ~portd; // inverte os estados do portd do PIC
}
}

voltar para o topo da pagina

O comando While
Muitos dos programadores iniciantes no sabem do que iremos comentar agora.

Os microcontroladores no geral no possuem sistemas operacionais, os programas que

desenvolvemos para os microcontroladores PIC devem rodar eternamente, ou possuirem
mecanismos que paralise a operao da CPU em alguns momentos.
Isso necessrio, pois, por no possuir sistem operacional, o programa do PIC no tem
para onde sair, devendo ficar em operao, de preferncia eterna. Esses um dos
motivos da funo principal main() dos programa para microcontroladores deverem ser
do tipo void (valor nulo), pois no tem quem receba os valores de retorno da funo
principal main().
O comando while o comando ideal criar loops infinitos no nosso programa.

A estrutura while verIfica inicialmente se a condio de teste verdadeira. Caso

verdadeiro, todas os comandos dentro do lao while sero executados. Ao retornar para
o incio do lao, verificado novamente se a condio de teste verdadeira, se for
verdadeira, executa novamente os blocos de comandos; se for falsa, o lao while
finalizado.
A companhe o exemplo abaixo:
void main() {
while (1) // condio a ser testada. Neste exemplo a condio sempre ser verdadeira (1);
{
declarao 1;
declarao 2;
declarao n;
}
}

Veja outro exemplo de programa:

void main() {
int a = 25;
while (a = 5)
{
a++;
portb = a;
}
}

Repare que no exemplo acima o valor a condio do lao while falsa, neste cado os comandos do lao
no sero executados no programa at que a condio seja verdadeira, ou seja, at que a = 5.

voltar para o topo da pagina

O comando do - while
O comando do -while forma uma estrutura de repetio diferente dos comandos while e for estudado
anteriormente. Sua diferena fundamental com relao as outras tradicionais laos de loop while e for esta
no fato da avaliao da condio de teste ser no final do lao de repetio, contrrio dos outros laos que
estudamos, que testam as condies no incio de cada ciclo.
formato geral:
do comando while (condio);
ou
do
{
comando 1;
comando 2;
} while (condio de teste);

Na estrutura do-while a condio de teste efetuada somente na parte final do loop.

Isso faz com que as instrues contidas no interior do lao do - while sejam executadas
ao menos uma vez. Caso a condio teste seja atendida, o lao de repetio
finalizado, caso contrrio o bloco que est na estrutura seria novamente executado at
que a condio teste seja atendida.
Exemplo:
void main() {
int a = 0;
//declara a varivel a como inteiro com o valor 0
do
{
a++;
//incrementa a varivel a em uma unidade
portd = ~portd; //inverte os estados do portd
}
while(a > 100); // enquanto a < 100 permanece no loop do-while;
}

voltar para o topo da pagina

O comando break e continue

Break
O comando break, na linguagem C, utilizado para interromper (quebrar) qualquer lao
de repetio instantaneamente. No momento da execuo do loop, ao encontrar o
comando break, o lao de repetio finalizado.
Exemplo:
void main() {
int a = 0;
do
{
a++;
//incrementa a varivel A em uma unidade
break;
//interrompe a execuo do lao de repetio do-while
portd = ~portd; //inverte os estados dos portd
}
while(a < 100); //enquanto a varivel a for menor que 100 a rotina do-while ser
executada.
}

O comando break valido para os laos do-while, while, for e case.

Continue
O comando continue reinicia novamente o teste da condio do lao de repetio. Toda
a vez que no lao for encontrado o comando continue, os comandos seguintes no sero
executados no lao.
Exemplo:

void main() {
int a = 0;
do
{
a++;
//incrementa a varivel A em uma unidade
continue;
//iretorna para o inicio do lao de repetio
portd = ~portd; //inverte os estados dos portd
}
while(a < 100); //enquanto a varivel a for menor que 100 a rotina do-while ser
executada.
}

No exemplo de programa acima, os comandos abaixo de continue no sero

executados, pois, toda a vez que for executado o comando continue, automaticamente o
programa ser redirecionado para o cabealho do lao de repetio independente de
qualquer estado de variveis.
O comando continue valido para os laos do-while, while, for e case.

voltar para o topo da pagina

Centro de Tecnologia Microgenios - Curso de Microcontroladores PIC - Programao

em C
Microgenios 1998 - 2008. Todos os direitos reservados. proibido cpia parcial ou
integral desse material sem prvio aviso. Maiores informaes:
suporte@microgenios.com.br