Material de Apoio

Introdução à
linguagem C

Material de apoio para a Disciplina Informática 2

Índice
Conteúdo
Introdução ..................................................................................................................................... 3
Exemplo de um Programa ......................................................................................................... 3
Identificadores .......................................................................................................................... 3
Variáveis ................................................................................................................................... 3
Tipos de Variáveis .................................................................................................................... 4
Declaração de Variáveis ........................................................................................................... 4
Inicialização de Variáveis na Declaração ................................................................................. 4
Constantes ................................................................................................................................. 5
Strings ........................................................................................................................................... 6
A função printf .................................................................................................................... 6
Inclusão de Texto na String de Formato ................................................................................... 7
Constantes do tipo String .......................................................................................................... 7
Impressão de Inteiros com "printf" ........................................................................................... 7
Impressão de Expressões aritméticas ........................................................................................ 8
Impressão de Números reais ..................................................................................................... 8
Formato de Impressão dos Números Reais ............................................................................... 8
Variáveis do Tipo String ......................................................................................................... 10
Atribuição com strings ............................................................................................................ 10
Operadores Aritméticos .......................................................................................................... 11
Condições ou Expressões Lógicas .............................................................................................. 12
Operadores Relacionais .......................................................................................................... 12
Operadores Lógicos ................................................................................................................ 12
Precedência de Operadores................................................................................................. 12
Comando IF ................................................................................................................................. 13
Comando IF com BLOCOS .................................................................................................... 13
Aninhamento de Ifs ................................................................................................................. 14
Comando SWITCH................................................................................................................. 15
Atribuição Condicional ........................................................................................................... 16
Comando while ........................................................................................................................... 17
Exemplos ............................................................................................................................ 18
Observação: ........................................................................................................................ 19
Comando do-while ...................................................................................................................... 20
Exemplos ............................................................................................................................ 20
Comando for................................................................................................................................ 22
Exemplos ............................................................................................................................ 23
Observações:....................................................................................................................... 23
Comandos de Desvios ................................................................................................................. 23

2
Introdução à Programação C
Introdução
Exemplo de um Programa
// Exemplo de programa em C
// Isto é uma linha de comentário
main()
{
int a; // declara a variável "a"
a = 3 + 2; // soma 3 com 2
}

 Um programa em C é composto por um conjunto de Funções. A função pela qual o

programa começa a ser executado chama-se main.
 Após cada cada comando em C deve-se colocar um ; (ponto-e-vírgula).
 Um programa em C deve ser Identado para que possa ser lido com mais facilidade.

Identificadores

São os nomes que podem ser dados para variáveis e funções.

Para a escolha destes nomes é necessário seguir alguams regras:

 Um identificador deve iniciar por uma letra ou por um "_" (underscore);

 A partir do segundo caracter pode conter letras, números e underscore;
 Deve-se usar nomes significativos dentro do contexto do programa;
 C é uma linguagem case-sensitive, ou seja, faz diferença entre nomes com letras
maiúsculas e nomes com letras minúsculas. Peso e peso são diferentes;
 Costuma-se usar maiúsculas e minúsculas para separar palavras: "PesoDoCarro";
 Deve ser diferente dos comandos da linguagem;
 Deve ter no máximo 31 caracteres (no caso do TurboC);
 Pode conter números a partir do segundo caracter;

Exemplos:

Idade, Contador, PesoDoCarro,Usuario_1, CorDaPagina, RaioDoCirculo

Variáveis

Uma variável é uma posição de memória que pode ser identificada através de um nome.

Podem ter seu conteúdo alterado por um comando de atribuição.

3
Após a atribuição mudam de valor.

int a,b, SomaGeral;

a = 3; // a recebe o valor 3
b = a * 2; // b recebe o dobro do valor de a
c = a + b + 2; // c recebe 11

Tipos de Variáveis

 Todas as variáveis em C tem um tipo;

 Cada tipo define os valores que a variável pode armazenar;
 Cada tipo ocupa uma certa quantidade de nemória.

Tipo Tamanho Valores Válidos

char 1 byte letras e símbolos: 'a', 'b', 'H', '^', '*','1','0'
int 2 bytes de -32767 até 32767 (apenas números inteiros)
float 4 bytes de -3.4 x 1038 até +3.4 x 10+38com até 6 dígitos de precisão
double 8 bytess de -1.7 x 10308 até +1.7 x 10+308com até 10 dígitos de precisão

Declaração de Variáveis

 Todas as variáveis têm que ser declaradas antes de serem usadas;

 Não há uma inicialização implícita na declaração

// Exemplo de programa em C

#include <stdio.h> // Arquivo de cabeçalho (header)

main()
{
int contador; // declarações simples
float PrecoDoQuilo;
double TaxaDeCambio;
char LetraDigitada;
int IdadeManoel, IdadeJoao, IdadeMaria; // Pode colocar mais de
uma variável na
// na mesma linha
double TaxaDoDolar,
TaxaDoMarco,
TaxaDoPeso, // Também pode trocar de linha no meio
TaxaDoFranco;
.......
}

Inicialização de Variáveis na Declaração

// Exemplo de programa em C

#include <stdio.h> // Arquivo de cabeçalho (header)

4
main()
{
int NroDeHoras = 0; // declara e inicializa com Zero
float PrecoDoQuilo = 10.53; // declara e inicializa com 10.53
double TaxaDoDolar = 1.8,
TaxaDoMarco = 1.956,
TaxaDoPeso = 1.75,
TaxaDoFranco = 0.2;
.......
}

Constantes

Constantes são identificadores que não podem ter seus valores alterados durante a
execução do programa.

Para criar uma constante existe o comando #define que, em geral é colocado no
início do programa-fonte.

Exemplos

#define LARGURA_MAXIMA 50 // Não se coloca ponto-e-vírgula

após o valor
#define NRO_DE_DIAS_DA_SEMANA 7
#define NRO_DE_HORAS_DO_DIA 24
#define VALOR_DE_PI 3.1415
main ()
{
int TotalDeHoras;

TotalDeHoras = 10 * NRO_DE_DIAS_DA_SEMANA * NRO_DE_HORAS_DO_DIA;

......
}

5
Strings

Uma String é uma seqüência de caracteres entre aspas duplas: "exemplo de uma string
em C".

A função printf

A função printf exibe um ou mais dados na tela. Para tanto ele deve receber pelo
menos dois parâmetros, separados por vírgula:

 um string de formato que define, através de caracteres especiais, os tipos dos dados a
serem impressos e suas posições na linha de impressão;
 um dado a ser impresso. Este dado pode ser qualquer um dos dados visto anteriormente.

Por exemplo:

printf("%s","teste");

"%s" : é a string de formato

"teste" : é o dado a ser impresso.

A string de formato define quais os tipos dos dados a serem impressos. O símbolo %s
será substituído pelo dado que vem após a vírgula.
Os dados definem quais os valores a serem impressos.

Se for necessário, um string de formato pode definir que mais de um dado será
impresso. Para tanto, dentro da string de formato deve haver mais de um %, um para
cada dado a ser impresso.
Neste caso, os dados devem vir após a string de formato separados por vírgulas.

Por exemplo:

printf("%s %s","teste1", "outra string");

Isto irá imprimir o string teste1 deixar 1 espaço em branco e imprimir ao lado o
string outra string, assim :

teste1 outra string

#include <stdio.h> // Necessário para usar a função printf

// A função printf exibe um ou mais dados na
tela
main ()
{
printf("%s","Isto é uma string ....\n"); // note o '\n' no final da
string;
printf("%s","Outra string ....");
printf("%s","Terceira string\n");
//Depois de Executar o programa, tecle ALT-F5 para ver o resultado na
tela

6
}

Exercício

Experimente colocar um '\n' entre os %s na string de formato.

printf("%s\n%s","teste1", "outra string");

Inclusão de Texto na String de Formato

É possível incluir um texto dentro da string de formato. Este texto irá aparecer
exatamente como for digitado no programa-fonte.

O exemplo
printf("A aluna %s ficou doente","Maria");
geraria

A aluna Maria ficou doente

como resultado.

Constantes do tipo String

#define UNIVERSIDADE "Pontifícia Universidade Católica do Rio Grande
do Sul"
// deve-se colocar entre aspas
#include <sdtio.h>
#include <conio.h> // necessário para as funções getch
main ()
{
printf("%s", UNIVERSIDADE); // Imprime o nome representado pela
constante
getch(); // espera que o usuário pressione uma tecla
}

Impressão de Inteiros com "printf"

Para imprimir um inteiro com printf usa-se o símbolo %d

// Impressão de Variáveis Inteiras

#include <stdio.h>
#include <conio.h> // necessário para as funções getch
main ()
{
int Contador;
int NroDeFilhos;

Contador = 10;
printf("Valor da Variável: %d\n", Contador); // No momento da
execução sinal %d vai
// ser substituído pelo

7
valor da
// variável Contador
NroDeFilhos = 3;
printf("Maria tem %d filhos", NroDeFilhos); // o inteiro pode
ficar no meio da string
getch(); // espera que o usuário pressione uma tecla
}

Impressão de Expressões aritméticas

// Impressão de Expressões aritméticas
#include <stdio.h>
#include <conio.h> // necessário para as funções getch
main ()
{
int NroDeAndares;
int AlturaPorAndar;

NroDeAndares = 7;
AlturaPorAndar = 3;

printf("Altura Total do Prédio: %d metros",

NroDeAndares*AlturaPorAndar);
// No momento da execução sinal %d vai ser substituído
// pelo valor da multiplicação
getch(); // espera que o usuário pressione uma tecla
}

Impressão de Números reais

// Impressão de números reais
#include <stdio.h>
#include <conio.h> // necessário para as funções getch
main ()
{
float NotaDaP1, NotaDaP2;
float Media;

NotaDaP1 = 6.6; // Atribuição do Valores das médias

NotaDaP2 = 8.2;

Media = (NotaDaP1 + NotaDaP2) / 2.0;

printf("Média Final : %f", Media);

// No momento da execução sinal %f vai ser substituído
// pelo valor da variável Media com SEIS casas decimais
// Média Final : 7.400000
getch(); // espera que o usuário pressione uma tecla
}

Formato de Impressão dos Números Reais

No exemplo acima o resultado da média (7.4) foi impresso com 6 casas decimais
(7.400000).

8
Isto sempre acontece quando se manda imprimir um float da forma como foi feito no
exemplo acima. Isto acontece pois o padrão da função printf é completar o número com
zeros à direita, até que fique com seis casas decimais.

Para formatar de maneira diferente usar-se, junto com o %f uma especificação de

quantas casas decimais se deseja que o número tenha. Especifica-se também o número
total de caracteres do número a ser impresso.

Por exemplo: %6.3f especifica que se quer imprimir um float com 3 casas decimais
e com um tamanho total de 6 caracteres no total.

#include <stdio.h>
#include <conio.h>
main()
{
float NotaDaP1, NotaDaP2;
float Media;

NotaDaP1 = 6.6; // Atribuição do Valores das médias

NotaDaP2 = 8.2;

Media = (NotaDaP1 + NotaDaP2) / 2.0;

printf("Média Final : %6.3f", Media);

// No momento da execução sinal %6.3f vai ser substituído
// pelo valor da variável Media
// Média Final : 7.400
getch(); // espera que o usuário pressione uma tecla

Regras para impressão de um número real

 o número de casas decimais é sempre respeitado. Se for preciso, zeros serão

acrescetados à direita do número
 o tamanho total significa o número de caracteres do número incluíndo o ponto decimal
e um eventual sinal de
menos (-), se for o caso;
 Se a soma do número de caracteres da parte inteira, mais o ponto decimal, mais a
parte fracionária, mais um eventual sinal de menos ainda for menor do que o
tamanho total especificado no formato, então, espaços em branco serão acrescentados à
esquerda da parte real do número.
 Se a soma do número de caracteres da parte inteira, mais o ponto decimal, mais a
parte fracionária, mais um eventual sinal de menos for maior do que o tamanho total
especificado no formato, então, apenas o número de casas decimais é respeitado

Por exemplo:

#include <stdio.h>
#include <conio.h>
main()
{
float Numero;

9
 Numero = -2.5;
printf("1234567890\n");
printf("%7f\n", Numero);
printf("%7.0f\n", Numero);
printf("%7.3f\n", Numero);
printf("%8.3f\n", Numero);
printf("%9.3f\n", Numero);
printf("\n");
printf("%8.4f\n", Numero);
printf("%8.1f\n", Numero);
printf("%6.12f\n", Numero);

getch();
}

// Resultados
1234567890
-2.500000
-2
-2.500
-2.500
-2.500

-2.5000
-2.5
-2.500000000000

Alinhamento de números à DIREITA

Nos exemplos anteriores os números ficavam sempre alinhados a partir da esquerda.

Experimente colocar um sinal de menos logo depois do sinal de % e veja o que
acontece.

printf("%-7.3f\n", Numero);

Variáveis do Tipo String

Uma variável capaz de arrmazenar uma string deve ser declarada informando-se qual o
número máximo de caracteres que ela poderá armazenar.

Exemplo:

char Nome[30]; // isto define que a variável poderá armazenar

uma

// string de até 29 caracteres.

Ao trabalharmos com strings deve-se incluir o arquivo de cabeçalho string.h

Atribuição com strings

As atribuições de valores a strings devem ser feitas através da função strcpy

// Exemplo com strings

10
#include <stdio.h>
#include <conio.h>
#include <string.h> // arquivo de cabeçalho para trabalhar com
strings

main()
{
char Nome[30]; // declara uma string que poderá armazenar até 29
caracteres !!
clsrscr();
strcpy(Nome, "Jose da Silva"); // atribui "Jose da Silva" para a
variável Nome
printf("O funcionário %s foi tranferido", Nome); // no lugar de %s
aparecerá o
// conteúdo da
variável Nome
getch();
}

Operadores Aritméticos
- sinal de menos (unário) Maior precedência (avaliado antes)

* , / multiplicação e divisão
% módulo (reto da divisão)
+ , - soma e subtração Menor precedência (avaliado depois)

Pode-se usar parênteses para alterar a precedência.

Exercício

Crie um progama que organize os dados em uma tabela conforme o exemplo a seguir.
Os dados das células em amarelo deve ser informados através de atribuições dentro do
programa.

Procure usar somente os %f para definir o formato e a posição dos dados.

Não tente preencher os espaços com brancos. Por exemplo, use

printf ("%10d, QuantidadeDeBananas);

ao invés de

printf(" %d", QuantidadeDeBananas);

Produto Preço Unitário Quantidade Preço Total
Banana R$ 2.50 2 R$ 5.00
Uva R$ 6.50 6 R$ 39.00
Pessego R$ 10.22 10 R$ 102.20
Sub-Total R$ 146.20
Imposto (5%) R$ 7.31
Total R$ 153.51

11
Condições ou Expressões Lógicas

A condição na linguagem C é definida como uma expressão que pode ser verdadeira ou falsa.

À este tipo de expressão dá-se o nome de expressão lógica.

Por exemplo, (3 > 2) é uma expressão lógica que possui valor verdadeiro. Por outro lado,
(4 < 1) é uma expressão lógica que possui valor falso.

Os operadores (< e >) usados nos exemplos acima são chamados de operadores relacionais
pois possibilitam saber qual a relação existente entre seus dois operandos. Além destes dois
existem mais 4 operadores relacionais, que podem ser vistos na tabela seguir:

Operadores Relacionais
== Igual a
!= Diferente
>= Maior ou igual
> Maior que
< Menor que
<= Maior ou igual

Além dos operadores relacionais, existem os chamados operadores lógicos ou "conectivos

lógicos". Estes, servem para conectar duas expressões relacionais. Os operadores lógicos da
linguagem C são apresentados na tabela a seguir:

Operadores Lógicos
|| OU lógico
&& E lógico
! Negação

Estes operadores OU e E devem ser sempre usados entre duas expressões relacionais, como
por exemplo:

((2 > 1) || (3 < 7)) : resultado VERDADEIRO

((3 < 2) && (2 == 2)) : resultado FALSO
((5 !=0) || (1 < 2)) : resultado VERDADEIRO

O operador de Negação deve ser usado antes de uma expressão relacional, como por
exemplo:

!(2 > 1): resultado VERDADEIRO

!(1 < 0): resultado FALSO

Precedência de Operadores
! Operador de negação Executado
- menos unário (sinal) Antes
* / % Operadores Multiplicativos

12
 + - Operadores aditivos
< > <= >= == Relacionais
!=
&& AND lógico Executado
|| OR lógico Depois

Comando IF

O comando IF serve para alterar o fluxo de execução de um programa em C baseado no

valor, verdadeiro ou falso, de uma expressão lógica.

Formato 1:

if (expr_log)
comando1; // executado se "expr_log" for verdadeira
comando2; // executado sempre independente da condição

Formato 2:

if (expr_log)
comando1; // executado se "expr_log" for verdadeira
else comando2; // executado se "expr_log" for falsa
comando3; // executado sempre, independente
// do resultado do teste

Comando IF com BLOCOS

Formato 3:

if (expr_log)
{
comando1; // executados se "expr_log" for verdadeira
comando2;
comando3;
}
else
{
comando4; // executado se "expr_log" for falsa
comando5;
comando6;
}
comando7; // executado sempre independente da condição
comando8; // executado sempre independente da condição

13
Aninhamento de Ifs

Exemplo 1: sem blocos e sem ELSE

if (expr_log)
if (expr_log2)
comando2; // executado se "expr_log" e
// "expr_log2" forem AMBAS verdadeiras
comando3; // executado sempre

Exemplo 2: sem blocos, o ELSE é sempre do IF anterior

if (expr_log)
if (expr_log2)
comando2; // executado se "expr_log" e
// "expr_log2" forem AMBAS verdadeiras
else comando3; // executado se "expr_log" for VERD
// e se "expr_log2" for FALSA
comando4; // executado sempre

Exemplo 3: O ELSE é sempre do IF anterior dentro do BLOCO

if (expr_log)
{
if (expr_log2)
comando2;
}
else comando3; // executado se "expr_log" for FALSO
// pertence ao primeiro IF
comando4; // executado sempre

Exemplo 4:

if (expr_log)
{
comando1; // executado se expr_log for VERDADEIRA
comando11;
if (expr_log2)
{
comando2; // executado se expr_log e expr_log2
comando21; // forem ambas VERDADEIRAS
}
else
{
comando3; // executado se expr_log for VERDADEIRA
comando31; // e expr_log2 for FALSA
}
comando4; // executado se expr_log for VERDADEIRA
}
else
{

14
 comando5; // executado se expr_log for FALSA
comando51;
if (expr_log3)
{
comando6; // executado se expr_log for FALSA
comando61; // e expr_log3 for VERDADEIRA
}
else
{
comando7; // executado se expr_log for FALSA
comando71; // e expr_log3 for FALSA
}
comando8; // executado sempre que expr_log for FALSA
}
comando9; // executado sempre

Comando SWITCH

int op;

printf("Digite a sua opção\n");

scanf ("%d",&op);
switch (op)
{

case VALOR1:
comando1; // executa estes comandos se
comando11; // op for igual a VALOR1
comando111;
break;
case VALOR2:
comando2; // executa estes comandos se
comando22; // op for igual a VALOR2
comando222;
break;
default:
comando3; // executa estes comandos se
comando33; // op for diferente de VALOR1 e
comando333; // de VALOR2

Observações

 O parâmetro do switch deve ser int ou char

 O valor após o case dever ser uma CONSTANTE
 Muito Cuidado: A falta do break faz o controle passar ao próximo case

15
Atribuição Condicional

a = (a>5)? 10 : 50;

Este comando é equivalente a

if(a>5)
a = 10;
else a = 50;

16
Comando while
O comando while permite que um certo trecho de programa seja executado ENQUANTO uma
certa condição for verdadeira. A forma do comando while é a seguinte:

while (condição)
{
// comandos a serem repetidos
// comandos a serem repetidos
}
// comandos após o 'while'

Repetindo, enquanto a condição for verdadeira (diferente de 0), comando é executado.

Quando o programa chega na linha que contém o teste do comando while, ele verifica se a
expressão de teste é verdadeira. Se for, o programa executa o comando uma vez e torna a testar
a expressão, até que a expressão seja falsa. Somente quando isso ocorrer, o controle do
programa passa para a linha seguinte ao laço.

Se, na primeira vez que o programa testar a expressão, ela for falsa, o controle do programa
passa para a linha seguinte ao laço, sem executar o comando nenhuma vez.

O corpo de um laço while pode ter um único comando terminado por ponto-e-vírgula,vários
comandos entre chaves ou ainda nenhuma instrução, mantendo o ponto-e-vírgula.

O funcionamento passo a passo é o seguinte:

1. Testa a condição;
2. Se a condição for falsa então pula todos os comandos do bloco subordinado ao while e
passa a executar os comandos após o bloco do while.
3. Se condição for verdadeira então executa cada um dos comandos do bloco
subordinado ao while.
4. Após executar o último comando do bloco do while volta ao passo 1.

O comando while deve ser usado sempre que:

 não soubermos exatamente quantas vezes o laço deve ser repetido;

 o teste deva ser feito antes de iniciar a execução de um bloco de comandos;
 houver casos em que o laço não deva ser repetido nenhuma vez.

17
Exemplos

main()
{
int contador;
char continua;

contador = 0;
continua = 's';
while (continua == 's') // enquanto for igual a 's'
{
// comandos a serem repetidos
printf("Repentindo....\n");
contador = contador + 1;
printf("Tecle 's' se deseja continuar\n");
continua = getch();
}
if (contador == 0)
printf("O bloco NAO foi repetido.");
else printf("O bloco foi repetido %d vezes", contador);

getch();

// Programa que calcula a idade média de um grupo de pessoas.

// A finalização da entrada de números é dada por um -1

int soma, quantidade, idade;

float media;

soma = 0;
quantidade = 0;
idade = 0;

while (idade != -1)

{
// comandos a serem repetidos

printf("Idade da pessoa %d. (tecle -1 se quiser encerrar).\n",

quantidade+1);
scanf("%d", &idade);

if (idade >=0)
{
soma = soma + idade;
quantidade = quantidade + 1;
}
}

// Faz o calculo da media de idade

18
if (quantidade >0)
{
media = (float) soma / quantidade;
printf("A media de idade das %d pessoas eh: %5.2f", quantidade,
media);
}
else printf("Nenhum dado foi informado.");

Observação:
Tenha atenção especial com o teste do comando while. As variáveis usadas no teste devem ter
sido inicializadas antes do teste.

19
Comando do-while
O comando do-while permite que um certo trecho de programa seja executado ENQUANTO
uma certa condição for verdadeira. A forma do comando do-while é a seguinte:

do
{
// comandos a serem repetidos
// comandos a serem repetidos
} while (condição);

// comandos após o 'do-while'

O laço do-while é bastante parecido com o laço while. A diferença é que no laço do-while o
teste da condição é executado somente depois do laço ser processado. Isso garante que o laço
será executado pelo menos uma vez.

O funcionamento passo a passo é o seguinte:

1. Executa os comandos dentro do bloco do-while;

2. Testa a condição;
3. Se a condição for falsa então executa o comando que está logo após o bloco
subordinado ao do-while .
4. Se condição for verdadeira então volta ao passo 1.

O comando do-while deve ser usado sempre que:

 que não soubermos exatamente quantas vezes o laço deve ser repetido;
 o teste deva ser feito depois da execução de um bloco de comandos;
 o bloco de comandos deve se executado pelo menos 1 vez;

Exemplos

int continua, contador;

contador = 0;
// nao precisamos inicializar a variável 'continua'
pois o teste é feito

20
 // depois
do
{
// comandos a serem repetidos
printf("Repentindo....\n");
contador = contador + 1;
printf("Tecle 's' se deseja continuar\n");
continua = getch();
} while (continua == 's')
printf("O bloco foi repetido %d vezes", contador);

// Programa que calcula a idade média de um grupo de pessoas.

// A finalização da entrada de números é dada por um -1
main()
{
int soma, quantidade, idade;
float media;
soma = 0;
quantidade = 0;

do {
printf("Idade da pessoa %d. (tecle -1 se quiser encerrar).\n",
quantidade+1);
scanf("%d", &idade);
if (idade >=0)
{
soma = soma + idade;
quantidade = quantidade + 1;
}
} while (idade != -1);

// Faz o calculo da media de idade

if (quantidade > 0)
{
media = (float) soma / quantidade;
printf("A media de idade das %d pessoas eh: %5.2f", quantidade,
media);
}
else printf("Nenhum dado foi informado.");
getch();
}

21
Comando for
O comando for permite que um certo trecho de programa seja executado um determinado
número de vezes.
A forma do comando for é a seguinte:

for (comandos de inicialização;condição de

teste;incremento/decremento)
{
// comandos a serem repetidos
// comandos a serem repetidos
}

// comandos após o 'for'

Observe a estrutura:

Inicialização Teste Atualização

for (contador = 1; contador <= 3; contador = contador+1)

O funcionamento é o seguinte:

1. Executa os comandos de inicialização;

2. Testa a condição;
3. Se a condição for falsa então executa o comando que está logo após o bloco
subordinado ao for .
4. Se condição for verdadeira então executa os comandos que estão subordinados ao for;
5. Executa os comandos de incremento/decremento;
6. Volta ao passo 2.

O comando for deve ser usado sempre que:

 soubermos exatamente quantas vezes o laço deve ser repetido;

 o teste deva ser feito antes da execução de um bloco de comandos;
 houver casos em que o laço não deva ser repetido nenhuma vez.

22
Exemplos

int contador;

for (contador = 0; contador < 10; contador = contador+1)

{
printf("Contador : %d\n",contador);
}

printf("Valor do Contador após o laço: %d\n",contador);

int contador;

for (contador = 10; contador > 0; contador = contador-1)

{
printf("Valor do Contador após o laço: %d\n",contador);
}

printf("Valor do Contador após o laço: %d\n",contador);

Observações:

1. Os comandos de inicialização são executados apenas 1 vez;

2. O contador é incrementado/decrementado sempre ao final da execução do bloco;
3. O teste é feito sempre antes do início da execução do bloco de comandos.

Comandos de Desvios
Os laços em C possuem dois comandos de desvios: break e continue. Estes comandos
funcionam com todos os comandos de repetição.

O comando break encerra o laço no ponto em que for executado.

// Este programa le NO MAXIMO 3 números positivos

// Caso um número negativo seja digitado no meio da
seqüência o laço é
// encerrado de imediato

#include <stdio.h>
#include <conio.h>

main()
{
int contador, numero;
for (contador = 1; contador <= 3; contador =
contador+1)
{
scanf("%d",&numero);
if (numero < 0)
break; // encerra o laço neste ponto !!!

23
 }
printf ("Foram digitados %d numeros validos",
contador-1);
getch();
}

O comando continue desvia o fluxo para o início do laço.

#include <stdio.h>
#include <conio.h>

main()
{
int contador, numero;

for (contador = 1; contador <= 5; contador =

contador+1)
{
printf("Inicio do laco. Passo %d\n", contador);

if ((contador % 2) == 0)
{
printf("Terminado antes do tempo....\n");
continue;
}
printf ("Final do Laco. Passo %d\n", contador);
}
getch();
}

RESULTADO:

Inicio do laco. Passo 1

Final do Laco. Passo 1
Inicio do laco. Passo 2
Terminado antes do tempo....
Inicio do laco. Passo 3
Final do Laco. Passo 3
Inicio do laco. Passo 4
Terminado antes do tempo....
Inicio do laco. Passo 5
Final do Laco. Passo 5

24
Bibliografia
SCHILDT, Herbert. C Completo e Total. Makron Books, São Paulo, 1996. WIENER, Richard.

PINHO, Márcio Sarroglia. Material de consulta de Linguagem C.

http://www.inf.pucrs.br/~pinho/LaproI/

MIZRAHI, V.V., Treinamento em linguagem C - Curso completo. Módulos 1 e 2. São Paulo:

McGraw Hill, 1990

25