teorico 3

Prévia do material em texto

Paradigmas de 
Programação
Responsável pelo Conteúdo:
Prof. Me. Roberto Luiz Garcia Vichinsky 
Revisão Textual:
Prof. Me. Claudio Brites
Programação Estruturada
Programação Estruturada
 
 
• Introduzir os conceitos da programação estruturada;
• Capacitar o estudante a desenvolver softwares utilizando esse paradigma.
OBJETIVOS DE APRENDIZADO 
• Introdução;
• A Linguagem C e o Paradigma Estruturado;
• Operadores Aritméticos;
• Operadores Relacionais;
• Operadores Lógicos;
• Funções Nativas;
• Estruturas de Controle.
UNIDADE Programação Estruturada
Introdução
Os computadores eletrônicos, que até o final da década de 1950 tinham suas apli-
cações voltadas exclusivamente para as áreas científicas e militares, tornaram-se pre-
sentes em outras áreas com o surgimento dos primeiros modelos comerciais. Com a 
evolução das tecnologias de processamento de dados e a crescente popularização dos 
computadores, novas aplicações tornavam-se possíveis e cada vez mais solicitadas 
pelos usuários. Empresas de diversos ramos, assim como órgãos governamentais e 
universidades, começavam a utilizar intensamente os computadores, o que causou 
um aumento sensível na demanda por softwares específicos.
No final da década de 1960, em função da falta de técnicas adequadas para 
o desenvolvimento de software e da crescente demanda por aplicações, eclodiu a 
chamada “crise do software”, que foi um momento histórico caracterizado pelos pro-
blemas relativos ao desenvolvimento de programas de computadores. Nessa época, 
cerca de 50% a 80% dos projetos de software não eram concluídos ou não atendiam 
às expectativas do cliente. Dos projetos concluídos com sucesso, cerca de 90% 
terminavam acima do orçamento e do cronograma previstos.
Leia o artigo “O que foi a Crise do Software e o início da Engenharia de Software”. 
Disponível em: https://bit.ly/2Nl100Y
Uma das causas dessa crise era a falta de um paradigma de programação que per-
mitisse a construção de códigos mais legíveis e de fácil manutenção. As linguagens de 
programação da época não possuíam recursos que permitissem conferir melhor legi-
bilidade aos programas fontes. Os desvios de fluxo na programação eram realizados 
por instruções do tipo GOTO (Go To – vá para), que se tornaram os principais vilões 
dos problemas de legibilidade dos códigos. Em programas muito longos, o uso abu-
sivo de instruções do tipo GOTO gerava códigos confusos e difíceis de serem lidos, 
tornando-os sujeitos a erros e dificultando os eventuais trabalhos de manutenção.
Para apelidar esse tipo de programa, foi cunhado o termo Spaghetti Code (código 
espaguete), em alusão a um prato de spaghetti, no qual podemos encontrar uma das 
pontas do macarrão, porém, no emaranhado do prato, é muito difícil saber onde se 
encontra a outra ponta. Para dar um pequeno exemplo desse tipo de problema, veja 
a seguir um programa fonte escrito em linguagem C onde se aplica desvios de fluxo 
por meio de instruções “goto”. Note que mesmo sendo pequeno, o programa apre-
senta certa dificuldade em relação ao entendimento de sua lógica.
// Programa para calcular a área de triângulos
main() {
 float base, altura, area;
 inicio:
8
9
 printf(“Base..:”);scanf(“%f”,&base);
 printf(“Altura..:”);scanf(“%f”,&altura);
 if(base<1 || altura<1) goto fim; 
 area=base*altura/2; 
 printf(“Área...: %f\n\n”,area);
 getch();
 goto inicio;
 fim:
 exit(0);
}
Na tentativa de sanar os problemas citados, em 1968 ocorreu a Conferência da 
OTAN sobre Engenharia de Software (NATO Software Engineering Conference) 
em Garmisch, Alemanha. Nesse encontro, foram lançadas as primeiras ideias para 
se estabelecer práticas mais maduras e mais eficientes para as atividades de desen-
volvimento de software. A partir de então, desenvolvedores de linguagens de pro-
gramação dirigiram esforços para a inclusão de novos recursos em seus produtos, 
visando conferir maior produtividade no desenvolvimento de software, assim como 
maior legibilidade nos códigos fontes produzidos. Nasceu assim o “Paradigma Estru-
turado”, no qual o programa é escrito com base em estruturas de controle, eliminando 
ou diminuindo a necessidade do uso de desvios incondicionais do tipo goto. 
Leia sobre “código espaguete”. Disponível em: https://bit.ly/2zX2NpQ
A Linguagem C e o Paradigma Estruturado
A linguagem de programação C foi criada em 1972 por Dennis Ritch e Brian 
Kernighan da empresa americana de telecomunicações AT&T Bell Labs. O pro-
pósito inicial dessa linguagem era servir como ferramenta para o desenvolvi-
mento do sistema operacional UNIX, o qual, até então, era programado com a 
linguagem Assembly. 
Até o ano de 1978, a linguagem C era utilizada por poucos pesquisadores em ativi-
dades de cunho científico. Porém, após o lançamento do livro The C Programming 
Language, escrito por Ritch e Kernighan, a linguagem C se tornou uma das mais 
populares entre os desenvolvedores de software, sendo hoje uma das mais utilizadas 
no mundo.
A linguagem C já nasceu dentro do paradigma estruturado, ou seja, ela possui 
recursos que incluem estruturas de controle, tais como: estruturas de decisão e 
estruturas de repetição.
9
UNIDADE Programação Estruturada
Nas seções a seguir, serão abordados os aspectos básicos da Linguagem C, 
exemplificados por meio de programas que você poderá reproduzir usando um 
compilador da linguagem. 
Dentre os diversos compiladores C disponíveis, sugerimos que utilize o ambiente de desenvol-
vimento DEVC++, que pode ser baixado gratuitamente. Disponível em: https://bit.ly/2NgRITB
Faça também o download do tutorial do DEVC++. Acesse em: https://bit.ly/2zTJWMn
Organização Básica de um Programa C
Um programa C deve obedecer não apenas as regras sintáticas da linguagem, 
mas também as regras organizacionais impostas, as quais definem a localização ade-
quada dos blocos que compõem o programa (diretivas de pré-processamento, blocos 
de instruções, declarações etc.). De modo geral, um programa em linguagem C é 
organizado da seguinte forma:
• Bloco 1: Documentação ou comentários iniciais;
• Bloco 2: Diretivas de pré processamento;
• Bloco 3: Declarações globais;
• Bloco 4: Corpo principal;
• Bloco 5: Funções definidas pelo usuário.
Para exemplificar, é mostrado a seguir um programa escrito em linguagem C, 
onde os blocos são destacados com o propósito de demonstrar a organização ado-
tada no código. 
// -----------------------------------------------------------------------
// Programa raizes Bloco 1: Comentários iniciais 
// Calcula as raízes de um 
// polinômio de 2º grau.
// ----------------------------------------------------------------------
#include <stdio.h> Bloco 2: Diretivas de pré-processamento
#include <stdlib.h> 
#include <math.h>
// ----------------------------------------------------------------------
float a,b,c; Bloco 3: Declarações Globais
char r;
void entradas(void); 
// ----------------------------------------------------------------------
10
11
main() { Bloco 4: Corpo principal
 float delta,r1,r2;
 int continua=1;
 while(continua) {
 entradas();
 delta=(b*b)-(4*a*c);
 if(delta<0){
 printf(“Não existe raiz real”);
 }else{
 r1=(-b+sqrt(delta))/(2*a);
 r2=(-b-sqrt(delta))/(2*a);
 printf (“Raizes: %f %f”,r1,r2);
 }
 printf(“\nDigite S para continuar “);
 scanf(“%s”,&r);
 if(r!=’S’ && r!=’s’) continua=0;
 }
}
// ----------------------------------------------------------------------
void entradas(void) { Bloco 5: Funções definidas pelo usuário
 system(“cls”);
 a=0;
 while (a==0){
 printf(“Coeficiente a: “);
 scanf(“%f”,&a);
 }
 printf(“Coeficiente b: “);
 scanf(“%f”,&b);
 printf(“Coeficiente c: “);
 scanf(“%f”,&c);
}
// ----------------------------------------------------------------------11
UNIDADE Programação Estruturada
• O bloco 1: é reservado à documentação inicial do programa. É nesse bloco que 
são informados os dados essenciais para a identificação do processo, tais como: 
nome do programa, breve descrição, data de sua criação, nome do autor etc. 
Apesar de ser um bloco opcional, é extremamente importante a sua presença;
• No bloco 2: são introduzidas as diretivas de pré-processamento responsáveis 
pela inclusão das bibliotecas de funções necessárias à execução do programa, 
assim como a definição das constantes de macro substituição;
• O bloco 3: é reservado para a declaração das variáveis globais, ou seja, aquelas 
que poderão ser acessadas em qualquer parte do programa. É também nesse bloco 
que declaramos os protótipos das funções definidas pelo usuário (programador);
• O bloco 4: constitui o corpo principal do programa, onde as instruções princi-
pais do algoritmo são escritas;
• No bloco 5: são escritas as funções definidas pelo usuário, cujos protótipos 
 foram declarados no bloco 3. Esse bloco só é utilizado se houver necessidade, ou 
seja, se o programador incluir uma ou mais funções específicas escritas por ele.
Elementos Básicos da Linguagem C
Primeiramente, devemos salientar que a linguagem C é case sensitive, ou seja, 
letras maiúsculas e minúsculas são consideradas diferentes. Dessa forma, se o pro-
gramador escrever um determinado comando usando letras maiúsculas, sendo que 
esse comando é definido pela linguagem com letras minúsculas, o compilador não 
poderá reconhecê-lo, gerando assim um erro de compilação. Portanto, tenha muita 
atenção ao escrever um programa!
Como qualquer linguagem de programação, a linguagem C possui um conjunto 
de elementos que formam a base de sua sintaxe. Esses elementos são:
• Diretivas de compilação;
• Variáveis;
• Operadores aritméticos, relacionais e lógicos;
• Funções;
• Estruturas de controle.
Diretivas de Compilação
Diretivas de compilação (ou diretivas de pré-processador), como o nome sugere, 
são linhas de código que informam ao compilador as premissas que devem ser con-
sideradas antes do processo de compilação do programa. As principais diretivas são:
12
13
#include
Essa diretiva informa ao pré-processador para incluir um arquivo de cabeçalho 
naquele ponto do programa. Normalmente um arquivo de cabeçalho (header) 
contém os protótipos das funções que serão utilizadas no programa. Por exemplo, 
se o programa utilizar a função printf (escrita de dados), devemos inserir a diretiva 
#include<stdio.h> no início do código para que a função seja reconhecida, pois o 
protótipo da função printf encontra-se no arquivo stdio.h, presente na pasta padrão 
de bibliotecas da linguagem C.
Sintaxe:
• #include <nome_do_arquivo>: (para arquivos que estão na pasta padrão) ;
ou
• #include “nome_do_arquivo”: (para arquivos que estão fora da pasta padrão) .
#define
Essa diretiva informa ao pré-processador que uma determinada constante deverá 
ser substituída por um certo valor ou expressão em todas as ocorrências dessa no 
programa (macro substituição). Por exemplo, considere um programa que utiliza o 
valor do PI radiano (3.14159...) em vários pontos do código. Nesse caso, podemos 
escrever no início do programa a diretiva #define PI 3.14159 e, nas instruções em 
que o PI deve ser empregado, basta apenas escrever o seu identificador (PI).
Sintaxe:
• #idefine identificador valor_do_identificador.
Variáveis
Variáveis são posições de memória RAM que o computador (ou microcon-
trolador) reserva para o armazenamento dos dados manipulados pelo programa. 
Essas posições devem ser reservadas (declaradas) no início do programa ou antes 
da manipulação dessas. O termo “variável” é utilizado devido ao caráter desses 
elementos: os valores armazenados neles podem ser alterados diversas vezes em 
um único processamento. 
Na declaração de uma variável, devemos informar o seu identificador (nome pelo 
qual ela será reconhecida dentro do programa) e o tipo de dado que ela armazenará 
(qualificador de tipo, que pode ser: numérico inteiro, numérico real, caractere etc.).
Para atribuir nomes ou identificadores às variáveis, devemos seguir algumas re-
gras, a saber:
• Os identificadores de variáveis devem conter apenas letras do alfabeto inglês, 
números e underline;
• Não podem ser iniciados por número;
• Não podem ser palavras reservadas da linguagem (vide Tabela 2).
13
UNIDADE Programação Estruturada
Ao “batizarmos” uma variável, ou seja, ao atribuirmos um identificador a uma 
variável, devemos escolher um nome sugestivo, que indique o conteúdo que ela 
receberá. Por exemplo:
• Valor1: → Variável que armazenará o primeiro valor;
• Valor2: → Variável que armazenará o segundo valor;
• Resultado: → Variável que armazenará o resultado de um cálculo qualquer.
Após atribuir o nome, devemos indicar o tipo de dado que a variável receberá 
(qualificador de tipo). A Tabela 1 mostra os qualificadores básicos da linguagem C.
Tabela 1 – Qualificadores básicos de tipos de dados 
Tipo Descrição Tamanho (bits) Faixa
int Números inteiros 16 -32768 a 32767
float Reais de simples precisão 32 Precisão de 7 dígitos
double Reais de dupla precisão 64 Precisão de 15 dígitos
char Caractere 1 -128 a 127
Sintaxe para declaração de variáveis:
qualificador_de_tipo identificador [=valor_inicial]
Exemplos:
int X; 
(declara a variável “X”, definindo-a como numérica inteira)
float nota=0.5; 
(declara a variável “nota”, definindo-a como numérica real e atribuindo a ela o 
valor inicial 0.5)
Tabela 2 – Palavras reservadas da linguagem C
auto bool break case char const
continue default do double else enum
extern float for goto if int
long register return short signed sizeof
static struct switch typedef union unsigned
void volatile while
Operadores Aritméticos
Existem cinco operadores aritméticos em C. Cada operador aritmético está rela-
cionado a uma operação aritmética elementar: adição, subtração, multiplicação e di-
visão. Existe ainda um operador (%) chamado operador de módulo, cujo significado 
é o resto da divisão inteira. Os símbolos dos operadores aritméticos são:
14
15
Tabela 3
Operador Operação 
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Módulo (resto da divisão inteira)
Exemplo :
Algumas expressões aritméticas:
1+2 a-4.0 b*c valor_1/taxa num%2
Os operandos das expressões aritméticas devem ser constantes numéricas ou iden-
tificadores de variáveis numéricas. Os operadores +, -, * e / podem operar números 
de todos os tipos (inteiros ou reais), porém, o operador de módulo (%) somente aceita 
operandos inteiros. 
Exemplo :
Expressões válidas:
Tabela 4
Expressão Resultado
6.4 + 2.1 8.5
7 - 2 5
2.0 * 2.0 4.0
6 / 3 2
10 % 3 1
Operadores Relacionais
Nas expressões que são avaliadas pelas estruturas condicionais, utilizamos opera-
dores de relação (também conhecidos como operadores de comparação), os quais nos 
permitem verificar se um determinado valor é igual ou não a um outro, se é maior ou 
menor, ou seja, os operadores relacionais verificam a relação de magnitude e igualdade 
entre dois valores. A linguagem C nos oferece seis operadores relacionais, a saber:
Tabela 5
Operador Signifi cado
> Maior que
< Menor que
>= Maior ou igual a (não menor que)
<= Menor ou igual a (não maior que)
== Igual a 1
!= Não igual a (diferente de)
15
UNIDADE Programação Estruturada
Operadores Lógicos
São operadores que utilizam a lógica booleana para a construção de expressões 
condicionais. Por exemplo: se eu quiser que uma determinada rotina seja executada 
somente quando os valores de duas variáveis (x e y) forem iguais a zero, eu construo 
a seguinte expressão:
Tabela 6
Pseudolinguagem Linguagem C
Se x = 0 e y = 0 entao ... if (x == 0 && y == 0) { ...
Por outro lado, se eu quiser que uma determinada rotina seja executada quando 
o valor de uma das duas variáveis for igual a zero, ou seja, se x for igual a zero ou y 
for igual a zero, eu construo a seguinte expressão:Tabela 7
Pseudolinguagem Linguagem C
Se x = 0 ou y = 0 entao ... if (x == 0 ¦¦ y == 0) { ...
A Tabela 8 apresenta os três operadores lógicos da linguagem C.
Tabela 8 – Operadores lógicos
Operador Função booleana Significado
&& And (e) Conjunção
|| Or (ou) Disjunção
! Not (não) Negação
Funções Nativas
Chamamos de funções nativas aquelas que pertencem às bibliotecas originais 
da linguagem C (bibliotecas nativas). Essas bibliotecas, que fazem parte do pacote 
da linguagem, são arquivos do tipo header (cabeçalho) que contêm rotinas pré-
-programadas (funções), agrupadas por tipo de operação. Por exemplo, a biblioteca 
STDIO.H contém as funções de entrada e saída de dados (printf, scanf, fprintf, 
fopen etc.). A seguir, estão relacionadas algumas bibliotecas nativas e suas respec-
tivas funções:
STDIO.H
Acrônimo da expressão Standard Input-Output (Entrada e Saída Padrão). Essa 
 biblioteca contém as funções responsáveis pelas entradas e saídas de dados (via tecla-
do, arquivos ou canais de comunicação). Principais funções dessa biblioteca:
16
17
• scanf (formatted scan – varredura formatada): entrada de dados via dispo-
sitivo padrão;
• printf (formatted print – impressão formatada): saída de dados via dispo-
sitivo padrão. 
CONIO.H
Acrônimo da expressão Console Input-Output (entrada e saída via console). Essa 
biblioteca contém as funções complementares de entrada e saída de dados via teclado, 
monitor de vídeo ou canais de comunicação. Principais funções dela:
• getch (get character – obter caractere): entrada de caractere via disposi-
tivo padrão;
• putch (put character – põe caractere): envio de um caractere para o dispo-
sitivo padrão;
• kbhit (key hit – pressionamento de tecla): verifica se uma tecla foi pressionada. 
MATH.H
Math (Matemática), contém um conjunto de funções matemáticas, sendo as 
principais:
• sin (seno); 
• cos (cosseno);
• tan (tangente);
• asin (arco seno);
• acos (arco-cosseno);
• atan (arco-tangente);
• log (logaritmo natural);
• log10 (logaritmo de base 10);
• sqrt (raiz quadrada).
Estruturas de Controle
As estruturas de controle são classificadas em dois grupos: estruturas condicionais 
e estruturas de repetição. As condicionais (também chamadas de estruturas de deci-
são) permitem que o programa faça a escolha do que executar, de acordo com a ava-
liação de uma condição (expressão condicional). Dentro desse grupo, a linguagem C 
nos oferece as funções nativas if e switch. As estruturas de repetição, como o nome 
sugere, permitem que o programa execute um determinado bloco de instruções 
repetidas vezes. Dentro desse grupo, a linguagem C nos oferece as funções nativas 
while, for e do/while. O diagrama apresentado na Figura 1 ilustra o conjunto de 
estruturas de controle da linguagem C.
17
UNIDADE Programação Estruturada
Estruturas de
controle
Estruturas 
condicionais
if switch while for do/while
Estruturas de 
repetição
Figura 1 – Conjunto de estruturas de controle da linguagem C
Estruturas Condicionais
Uma estrutura condicional, ou estrutura de decisão, permite que o programa faça 
a escolha do que executar, de acordo com uma condição. A linguagem C nos oferece 
duas funções nativas para trabalharmos com esse tipo de estrutura: if e switch.
A estrutura if é a mais simples estrutura de controle do C. Essa estrutura permite 
executar um entre dois blocos de instruções. O controle de qual bloco será executado 
é dado por uma condição (expressão lógica ou numérica). Essa estrutura pode se 
apresentar de dois modos diferentes: condicional simples ou composta.
A estrutura de decisão condicional simples permite a execução ou a não execu-
ção de um bloco de instruções de acordo com o resultado da avaliação de uma condi-
ção. Por exemplo, se a expressão condicional for verdadeira, o bloco será executado, 
caso contrário, o bloco não será executado. O fluxograma que ilustra esse tipo de 
estrutura é mostrado na Figura 2.
Condição
InstruçõesFalsa
Verdadeira
Figura 2 – Estrutura condicional simples
Também é possível escrever uma estrutura que execute um entre dois blocos de 
instruções. É o que chamamos de estrutura condicional composta, cujo fluxograma 
é apresentado na Figura 3.
Condição
bloco 2bloco 1
Verdadeira Falsa
Figura 3 – Estrutura condicional composta
18
19
Para ilustrar o uso das estruturas condicionais simples e compostas, construire-
mos dois pequenos programas. O primeiro receberá um número real pelo teclado e, 
se o número for positivo, calculará a sua raiz quadrada, caso contrário, ou seja, se 
o número for negativo ou zero, nada será feito. O segundo programa, receberá um 
número inteiro pelo teclado e, se o número for par, exibirá a mensagem “Número 
par”; caso contrário, exibirá a mensagem “Número ímpar”.
Programa exemplo 1:
Início
�m
Não
Sim
r
n > 0
n
r = √n
Figura 4 – Uso de uma estrutura condicional simples
Programa exemplo 2: 
Início
�m
Não Sim
“par”“ímpar”
n = 0
n
r = n % 2
Figura 5 – Uso de uma estrutura condicional composta
Vimos que o comando if permite que o programa escolha um caminho entre no 
máximo dois caminhos alternativos, de acordo com o resultado da avaliação de uma 
expressão condicional. Porém, existem situações em que desejamos que o programa 
escolha um caminho entre várias alternativas. Nesses casos, podemos utilizar um 
encadeamento de comandos if, conforme podemos observar no fluxograma apre-
sentado na Figura 6.
19
UNIDADE Programação Estruturada
Início
Fim
d
NãoSim
“Domingo”
“Segunda”
“Terça”
“Quarta”
“Quinta”
“Sexta”
“Sábado” “Inválido”
d = 1
NãoSim d = 2
NãoSim d = 3
NãoSim d = 4
NãoSim d = 5
NãoSim d = 6
NãoSim d = 7
Figura 6 – Encadeamento de comandos if
O algoritmo apresentado no fluxograma da Figura 6 mostra a sequência de ins-
truções para o recebimento de um número pelo teclado (representado pela variável 
“d”), o qual é avaliado dentro de um encadeamento de ifs. Em síntese, esse algoritmo 
recebe um número que representa um dia da semana e, em seguida, mostra por 
extenso o nome correspondente a esse dia. Observe que o algoritmo espera receber 
um número entre 1 e 7 (de domingo a sábado, respectivamente). Caso o número 
digitado seja maior que 7, o programa exibirá a mensagem “Inválido”, como pode-
mos notar no fluxograma em questão. O código desse algoritmo em linguagem C é 
apresentado a seguir:
/* Programa exemplo_3
 Mostra o dia da semana por extenso
*/
#include <stdio.h>
main() {
 int d;
 scanf(“%d”,&d); 
 if(d==1) 
 printf(“Domingo”);
 else 
 if(d==2) 
 printf(“Segunda”);
 else
20
21
 if(d==3)
 printf(“Terça”);
 else 
 if(d==4) 
 printf(“Quarta”);
 else
 if(d==5)
 printf(“Quinta”);
 else
 if(d==6)
 printf(“Sexta”);
 else
 if(d==7)
 printf(“Sábado”);
 else
 printf(“Inválido”);
}
Nas situações em que há uma escolha múltipla, pode-se sempre utilizar comandos 
if encadeados, como demonstrado no programa “exemplo_3”. No entanto, a lingua-
gem C tem um comando próprio para esse tipo de situação: o comando switch. 
O programa exemplo_4 apresentado a seguir, faz exatamente a mesma coisa que 
o programa do exemplo anterior, mas utiliza o comando switch em vez da sequência 
encadeada de if. 
/* Programa exemplo_4
 Mostra o dia da semana por extenso usando estrutura switch
*/
#include <stdio.h>
main() {
 int d;
 scanf(“%d”,&d); 
 switch(d) {
 case 1:printf(“Domingo”); break;
 case 2:printf(“Segunda”); break; 
 case 3:printf(“Terça”); break;
21
UNIDADE Programação Estruturada
 case 4:printf(“Quarta”); break;
 case 5:printf(“Quinta”); break;
 case 6:printf(“Sexta”); break; 
 case 7:printf(“Sábado”); break;
 default:printf(“Inválido”);
 }
}
O comando switch funciona do seguinte modo: primeiro, o computador verifi-
ca o valor que está dentrodos parêntesis que aparecem à direita da palavra switch 
(no exemplo, trata-se do valor da variável d). Baseado nesse valor, o computador 
salta para o caso apropriado. Por exemplo, se o valor for 3, o computador salta 
para a instrução que vem após a case 3:. Depois, prossegue com as instruções 
restantes até encontrar a instrução break. Essa instrução faz com que o compu-
tador salte para fora da estrutura switch, isso é, o programa prossegue com a 
instrução que aparece imediatamente após a chave correspondente ao final da 
estrutura switch.
O caso default é opcional e é executado se nenhum dos outros casos ocorrer.
Tudo o que se pode fazer com uma estrutura switch também se pode fazer 
com uma sequência encadeada de if, tal como foi ilustrado no exemplo anterior. 
No entanto, quando se tem muitas opções diferentes, é aconselhável a utilização do 
comando switch, porque isso garante uma maior legibilidade do programa.
Estruturas de Repetição
Estruturas de repetição são recursos da linguagem que permitem a execução de 
uma instrução, ou de um conjunto de instruções, repetidamente e de forma con-
trolada. A linguagem C nos oferece três tipos de comandos dentro dessa categoria: 
while, for e do/while.
Estrutura While
O comando while (enquanto, do inglês) é utilizado nas situações em que 
desejamos que um conjunto de instruções (ou uma única instrução) seja executado 
enquanto uma determinada condição for verdadeira. A sintaxe desse comando é 
apresentada a seguir:
while(condição){
 bloco
}
22
23
onde: 
• condição: é uma expressão lógica ou numérica;
• bloco: é um conjunto de instruções.
Essa estrutura faz com que a condição seja avaliada logo no início. Se a condição 
for verdadeira, o bloco de instruções será executado, e continuará sendo executado, 
repetidamente, enquanto a condição permanecer verdadeira. Caso a condição seja 
falsa, a repetição é terminada, finalizando a estrutura. Observe que nessa estrutura 
o bloco de instruções pode não ser executado nenhuma vez, basta que a condição 
seja inicialmente falsa. O fluxograma dessa estrutura é mostrado na Figura 7.
Condição
Bloco
Verdadeira
Falsa
Figura 7 – Fluxograma que representa uma estrutura de repetição do tipo while
Para exemplificar o uso desse tipo de estrutura, imaginaremos que pretendemos 
fazer um programa para escrever na tela a palavra “Olá” cem vezes. Podemos fazer um 
programa com cem instruções printf(“Olá\n”);, mas isso não seria muito inteligente. 
Uma forma correta para realizar essa tarefa é dizer ao computador para repetir a ins-
trução printf(“Olá\n”); cem vezes. O programa a seguir faz precisamente isso:
/* Programa exemplo_5
 Demonstração da estrutura while
*/
#include <stdio.h>
main(){
 int i;
 i = 0;
 while(i < 100){
 printf(“Olá\n”);
 i++;
 }
} 
23
UNIDADE Programação Estruturada
O programa acima começa por testar a expressão do while. Se a expressão 
(i<=100) for verdadeira, o programa executa a instrução que vem imediatamente 
abaixo (reparar que a instrução tanto pode ser única como ser composta por um 
bloco entre chaves). Depois de executar a instrução, ou o conjunto de instruções de-
limitado pelas chaves, o computador volta a testar a expressão do while e continua 
assim indefinidamente até a expressão se tornar falsa. Nessa altura, o programa 
abandona o ciclo while e executa a instrução que aparece imediatamente após a 
chave que finaliza o ciclo. 
Observe que no exemplo, a variável i serve para controlar a condição do ciclo 
while. Ela assume inicialmente o valor 0 (zero) e, dentro da estrutura while, ela é 
incrementada em 1 (i++), ou seja, no final de cada repetição o seu valor é acrescido 
de 1. Sendo i<100 a expressão avaliada pelo comando while, podemos deduzir que 
o número de repetições será 100 (cem), pois, sendo a variável i incrementada a cada 
repetição, seu valor chegará a 100 após cem repetições. Nesse momento, a estrutura 
será encerra porque a expressão i<100 passará a ser falsa.
Estrutura do/while
A estrutura do/while (faça/enquanto, do inglês) é muito parecida com a estrutura 
while. A diferença é que a condição é avaliada após a execução de cada ciclo de 
 repetição, e não antes, como acontece na estrutura while. A sintaxe desse comando 
é apresentada a seguir:
do{
 bloco
} while(condição);
onde: 
• bloco: é um conjunto de instruções;
• condição: é uma expressão lógica ou numérica.
Essa estrutura faz com que o bloco de instruções seja executado pelo menos uma 
vez. Após a execução do bloco, a condição é avaliada. Se a condição for verdadeira, 
o bloco é executado outra vez; caso contrário, a estrutura é finalizada. A Figura 8 
mostra o fluxograma que a representa.
Bloco
Verdadeira
Falsa
Condição
Figura 8 – Fluxograma que representa uma estrutura de repetição do tipo do/while
24
25
O programa exemplo_6 apresentado a seguir faz a mesma coisa que o pro-
grama exemplo_5, porém, utilizando uma estrutura do/while, em substituição à 
estrutura while.
/* Programa exemplo_6
 Demonstração da estrutura do/while
*/
#include <stdio.h>
main(){
 int i;
 i = 0;
 do{
 printf(“Olá\n”);
 i++;
 }while(i < 100);
} 
Estrutura for
A estrutura for (para, do inglês) é muito semelhante às estruturas de repetição 
vistas anteriormente, entretanto, costuma ser utilizada quando se quer um número 
determinado de ciclos. A contagem dos ciclos é feita por uma variável denominada 
contador. A estrutura for é, às vezes, chamada de estrutura de repetição com con-
tador. Sua sintaxe é a seguinte:
for(inicialização; condição; incremento){
 bloco
}
onde: 
• inicialização: é a expressão de inicialização do contador;
• condição: é a expressão lógica de controle de repetição;
• incremento: é a expressão de incremento do contador;
• bloco: é o conjunto de instruções a ser executado.
Essa estrutura executa um número determinado de repetições usando um conta-
dor de iterações. O contador é inicializado na expressão de inicialização antes da 
primeira iteração – por exemplo: i = 0; ou cont = 20. Então, o bloco será executado 
e, depois de cada iteração, o contador é incrementado de acordo com a expressão 
de incremento – por exemplo: i = i + 1 ou cont = cont-2. Em seguida, a expressão 
25
UNIDADE Programação Estruturada
de condição é avaliada: se a condição for verdadeira, o bloco é executado novamente 
e o ciclo recomeça; se a condição for falsa, encerra-se a estrutura de repetição. Essa 
condição é, em geral, uma expressão lógica que compara o valor do contador com 
um determinado valor limite – por exemplo: i <= 100 ou cont > 0.
O programa exemplo_7 apresentado a seguir realiza o mesmo que os progra-
mas exemplo_5 e exemplo_6, porém, utilizando uma estrutura for para o controle 
das repetições:
/* Programa exemplo_7
 Demonstração da estrutura for
*/
#include <stdio.h>
main(){
 int i;
 for(i=0; i<100; i++} {
 printf(“Olá\n”);
 }
} 
26
27
Material Complementar
Indicações para saber mais sobre os assuntos abordados nesta Unidade:
 Sites
Treinamento em linguagem C
 https://bit.ly/2Yoyjq9
 Livros
Lógica de Programação a construção de algoritmos e estruturas de dados
FORBELLONE, A. L. V.; EBESPACHER, H. F. Lógica de Programação a 
construção de algoritmos e estruturas de dados. 3 ed. São Paulo: Pearson, 2005. 
Treinamento em Linguagem
MIZRAHI, V. V. Treinamento em Linguagem C. 2. ed. São Paulo: Pearson, 2008. 
 Leitura
A problemática do desenvolvimento de software: crise ou calamidade crônica?
https://bit.ly/2zURmih
27
UNIDADE Programação Estruturada
Referências
PRESSMAN, R. S. Engenharia de software: uma abordagem profissional. 8. ed. 
Porto Alegre: AMGH, 2016. (e-book)
SEBESTA, R. W. Conceitos de Linguagens de Programação. 11. ed. Porto Alegre: 
Bookman, 2018.
SOFFNER, R. Algoritmos e Programação em Linguagem C. 1. ed. São Paulo: 
Saraiva, 2013. (e-book)
28