Linguagem C/C++ - UNIPAN

do laço 
} 
 
printf (“Você digitou a letra A”); 
 
Este laço é executado até que um caractere A seja digitado no teclado. 
 
 3.7.4 USANDO LAÇOS for SEM CONTEÚDO 
 
Um bloco de comandos, como definido pela sintaxe da linguagem C, pode 
ser vazio. Isso significa que o conteúdo do for (ou qualquer outro laço) também pode 
ser vazio. 
Essa característica pode ser usada para aumentar a eficiência de certos 
algoritmos, bem como para criar laços de tempo e espera. É assim que se cria um 
tempo de espera usando-se o for. 
 
for (t = 0; t < ALGUM VALOR; t++); 
 
Exercícios: 
 
1) Fazer uma função que receba um número e retorne o fatorial deste número, 
usando for. (Lembre que 0!=1 e 1!=1). 
2) Fazer uma rotina para contar as ocorrências do caractere 'a' em uma string, 
usando for. 
3) Fazer uma rotina para achar o maior valor de um vetor de 10 posições, usando 
for. 
4) Fazer uma rotina para contar o número de ocorrências das letras de 'A' até 'Z' em 
um string. 
5) Escrever um programa que gera e escreve os 5 primeiros números perfeitos. Um 
número perfeito é aquele que é igual a soma dos seus divisores. Por exemplo: 
 6 = 1 + 2 + 3 
 28 = 1 + 2 + 4 + 7 + 14 
 etc. 
 
3.8 O LAÇO while 
 
O segundo laço disponível na linguagem C é o while. A sua forma geral é 
 
while (condição){ 
 comandos; 
} 
 
 39 
onde comandos, como mencionado anteriormente, pode ser um bloco vazio, um 
comando simples ou um bloco de comandos que deve ser repetido. Condição pode 
ser qualquer expressão válida. O laço é repetido enquanto a condição for 
verdadeira. Quando a condição torna-se falsa, o controle do programa passa para a 
linha seguinte ao código do laço. 
O exemplo a seguir mostra uma rotina de entrada pelo teclado que se 
repete até que o caractere A seja digitado. 
 
espera_por_caractere(){ 
 char ch; 
 
 ch = ‘\0’; 
 while (ch != ‘A’) ch = getche(); 
} 
 
A princípio, a variável ch é inicializada com nulo. Como uma variável 
local, o seu valor é desconhecido quando a rotina espera_por_caractere( ) é 
executada. O laço while começa checando para ver se ch não é igual a A. Uma vez 
que ch foi inicializado como nulo de antemão, o teste é verdadeiro e o laço tem 
início. Cada vez que uma tecla é pressionada, o teste se realiza novamente. Assim 
que um A é informado, a condição torna-se falsa, já que a variável ch é igual a A, e 
o laço encerra-se. 
Assim como os laços for, os laços while verificam a condição do teste no 
início do laço, o que significa dizer que o código do laço pode não ser executado. A 
variável ch teve de ser inicializada no exemplo anterior para prevenir de 
acidentalmente conter um A. Como o teste condicional é feito no início do laço, o 
while é bom em situações em que se pode não querer que o laço seja executado. 
Isto elimina a necessidade de um teste condicional separado antes do laço. 
Por exemplo, a função centraliza( ), no programa seguinte, usa um laço 
while para emitir o número correto de espaços para centralizar a linha em uma tela 
de oitenta colunas. Se tamanho é igual a zero, como é o correto se a linha a ser 
centralizada tiver 80 caracteres, o laço não é executado. Este programa usa outras 
duas funções chamadas gets( ) e strlen( ). A função gets( ) permite ler uma string 
diretamente do teclado; a função strlen( ) retorna o tamanho da string argumento. 
Esta última função está na biblioteca string.h. 
 
#include <stdio.h> 
#include <string.h> 
 
void main(){ 
 char str[255]; 
 int tamanho; 
 
 printf (“Insira uma string: ”); 
 gets (str); 
 
 centraliza (strlen (str)); 
 printf (str); 
} 
void centraliza (int tamanho) { 
 40 
 tamanho = (80 – tamanho)/2; 
 
 while (tamanho > 0){ 
 printf (“ ”); 
 tamanho--; 
 } 
} 
 
Não há, em absoluto, a necessidade de qualquer declaração no corpo do 
laço while. Por exemplo. 
 
while (ch = getche() != ‘A’); 
 
simplesmente será repetido até que o caractere A seja digitado. Se você se sentir 
pouco confortável com a atribuição dentro da expressão condicional while, lembre-
se de que o sinal de igual é somente um operador que especifica o valor do 
operando à sua direita. 
 
Exercício: 
 
1) Fazer uma função que receba um número e retorne o fatorial deste número, 
usando while. (Lembre que 0!=1 e 1!=1). 
2) Fazer uma rotina para contar as ocorrências do caractere 'a' em uma string, 
usando while. 
3) Fazer uma rotina para achar o maior valor de um vetor de 10 posições, usando 
while. 
 
3.9 O LAÇO do-while 
 
Ao contrário dos laços for e while, que testam a condição do laço no 
início, o laço do-while verifica sua condição no final do laço. Isso significa que um 
laço do-while será executado pelo menos uma vez. A forma geral do laço do-while 
é: 
 
do{ 
 comandos; 
}while(condição); 
 
Ainda que as chaves não sejam necessárias quando somente um 
comando será executado no laço, elas são usadas para aumentar a legibilidade do 
código do programa. 
Este programa usa um laço do-while para ler números do teclado até que 
um deles seja menos que 100. 
 
#include <stdio.h> 
 
void main(){ 
 int num; 
 41 
 
 do{ 
 scanf (“%d”, &num); 
 }while(num > 100); 
} 
 
Talvez o uso mais comum do laço do-while seja em uma rotina de 
seleção em menu. Já que você sempre precisará de uma rotina de seleção em menu 
para ser executada no mínimo uma vez, o laço do-while é uma opção óbvia. O 
seguinte fragmento mostra como adicionar um laço do-while no menu do programa 
de conversão numérica. 
 
/* Assegura que o usuário especificou uma opção válida */ 
 
do{ 
 printf (“Converte:\n”); 
 printf (“ 1: decimal para hexadecimal\n”); 
 printf (“ 2: hexadecimal para decimal\n”); 
 printf (“informe sua opção: ”); 
 scanf (“%d”, &opcao); 
}while(opcao < 1 || opcao > 2); 
 
Depois que a opção tiver sido apresentada, o programa se repetirá até 
que uma opção válida seja selecionada. 
 
3.10 LAÇOS ANINHADOS 
 
Quando um laço está dentro de outro, diz-se que o laço mais interno é 
aninhado. Laços aninhados propiciam o meio de resolver alguns problemas 
interessantes de programação. Por exemplo, este pequeno programa exibe as 
quatro primeiras potências dos números de 1 a 9. 
 
/* Exibe uma tabela das 4 primeiras potencies de 1 a 9 */ 
#include <stdio.h> 
 
void main(){ 
 int i, j, k, temp; 
 
 printf(“ i i^2 i^3 i^4\n”); 
 
 for (i = 1; i < 10; i++){ // laço externo 
 for (j = 1; j < 5; j++) { // primeiro aninhamento 
 temp = 1; 
 
 for (k = 0; k < j; k++) // segundo aninhamento 
 temp = temp * i; 
 printf (“%9d”, temp); 
 42 
 } 
 printf (“\n”); 
 } 
} 
 
Algumas vezes, é importante determinar quantas interações o laço interno 
executa. Este número é conseguido multiplicando-se o número de vezes que o laço 
externo intera pelo número de vezes que o laço interno é repetido cada vez que é 
executado. No exemplo do programa de potência, o laço externo é repetido nove 
vezes e o segundo laço, quatro vezes; assim, o segundo laço interagirá 36 vezes. O 
laço interno é executado, em média, duas vezes; dessa forma, o número total de 
interações é 72. 
Como no último exemplo, um melhoramento final para o programa de 
conversão de base numérica usando-se laços aninhados é mostrado aqui. O laço 
externo faz com que o programa seja executado até que o usuário diga para parar. o 
laço interno assegura que o usuário informará uma seleção válida do menu. Agora, 
em vez de simplesmente converter um número toda vez que for executado, o 
programa repete até que o usuário queira parar. 
 
/* Programa de conversão de base numérica – versão final 
 decimal ---> hexadecimal 
 hexadecimal ---> decimal*/ 
#include <stdio.h> 
 
void main(){ 
 int opcao; 
 int valor; 
 
 //repete até que o usuário diga para terminar 
 do{ 
 //assegura que o usuário especificou uma opção válida 
 do{ 
 printf (“Converter: \n”); 
 printf (“1: decimal para hexadecimal\n”);