RESUMO LINGUAGEM C

Histria
A linguagem C foi criada por Dennis M. Ritchie e Ken Thompson em 1972, no
laboratrio Bell. Seu desenvolvimento comeou com uma linguagem mais antiga,
chamada BCPL, criada por Martin Richards. Esta linguagem influenciou o
desenvolvimento da linguagem B, criada por Ken Thompson, e posteriormente levou ao
desenvolvimento de C.
A verso de C fornecida com o sistema Unix verso 5 foi o padro da linguagem por
muitos anos. Um grande nmero de implementaes, porm, foi criado, com a
popularidade dos microcomputadores, e isso gerou certa incompatibilidade entre essas
implementaes. Foi baseado nesta situao que em 1983 o ANSI (American National
Standards Institute) estabeleceu um comit para criar um padro para definir a
linguagem C. Atualmente, todos os principais compiladores de C implementam o
padro C ANSI.

Caractersticas

C uma linguagem estruturada

C utiliza funes para dividir o seu cdigo em sub-rotinas, tornando o trabalho do

programador mais eficaz. Voc pode criar bibliotecas, que podero ser compartilhadas
por qualquer programa que utilize suas rotinas. H tambm a possibilidade de dividir o
seu cdigo-fonte em vrios arquivos, onde cada arquivo pode ter rotinas para uma
funo especfica, tornando o desenvolvimento muito mais organizado.

C uma linguagem de mdio nvel

Isto significa que C possui recursos de alto nvel, e ao mesmo tempo permite a
manipulao de bits, bytes e endereos - os elementos mais bsicos para a
funcionalidade de um computador.

C uma linguagem compilada

Uma linguagem de computador pode ser compilada ou interpretada. C compilada, isto

, o compilador da linguagem l o arquivo do cdigo-fonte, processa-o e cria um
arquivo em formato binrio (objeto). Para este arquivo se tornar um programa
executvel, entra em cena o linker, que liga o binrio gerado na compilao do
programa com as bibliotecas da linguagem.
O fato de C ser compilada torna esta linguagem opo certa quando se quer
velocidade. Linguagens interpretadas geralmente so bem mais lentas do que as
compiladas.

COMPILADOR
LINKER
(cdigo-fonte) ------------------> (cdigo-objeto) -----------> (programa executvel)

C uma linguagem portvel

Um programa feito em C pode ser compilado em outras plataformas e funcionar sem

problemas. C foi desenvolvida para ser uma linguagem portvel, e a padronizao feita
pelo ANSI melhorou ainda mais esta caracterstica. claro que se deve seguir certas
prticas para tornar o cdigo portvel para outras plataformas, como evitar o uso de
bibliotecas particulares a uma plataforma especfica, usar diretivas do compilador
quando necessrio, adotar o padro ANSI, etc.

Estrutura bsica de um programa em C

Iremos comear estudando como a estrutura bsica de um programa bem simples em
C, que escrever na tela a mensagem Meu primeiro programa!. A seguir voc tem o
cdigo do programa. As linhas esto numeradas para facilitar o entendimento.
1
2
3
4
5
6

#include <stdio.h>
int main()
{
printf(Meu Primeiro Programa!\n);
}

Agora vamos explicar linha por linha. A linha 1 contm a diretiva #include <stdio.h>, e
serve para incluir as funes de uma biblioteca em seu programa. Neste caso, estamos
incluindo a biblioteca de entrada e sada padro (standard input/output), necessria para
a utilizao da funo printf(). C uma linguagem que diferencia minsculas de
MAISCULAS (case sensitive). As palavras-chave e os comandos da linguagem
devem ser escritos em minsculo. Se voc declarar variveis, funes, tipos, etc,
utilizando caracteres maisculos, no se esquea de referenci-los da forma correta.
A linha 2 no contm nada... Est em branco. Voc pode adicionar linhas em branco,
espaos e tabulaes em seu cdigo para torn-lo mais fcil de ser lido.

A linha 3 contm o incio da funo main(). Esta funo marca o incio da execuo do
programa e deve existir em algum lugar do cdigo para este funcionar corretamente. Se
o seu programa tiver somente uma funo, ela dever ser main(). Este int, antes do
main(), est dizendo que main() deve retornar um valor para o sistema, indicando
sucesso ou falha. Este valor um nmero inteiro, por isso int.

Na linha 4 vemos o caractere abre-chaves, um delimitador de bloco, serve para abrir um

bloco de cdigo. O que estiver dentro do par de chaves pertence funo main(), neste
caso.

Mas na linha 5 que o nosso programa cumpre a sua crucial misso: escrever a
mensagem Meu Primeiro Programa! na tela. O que voc precisa saber agora que a
funo printf() a principal funo para escrita no console (sada padro. O \n um
caractere especial, e serve para pular para a prxima linha, assim que acabar de escrever
a mensagem.
OBS: os comandos em C so terminados com um ; (ponto-e-vrgula). No
esquea.

E finalmente chegamos linha 6, onde encontramos as fecha-chaves, que significa o

fim do bloco de cdigo.
Em C voc tem a liberdade de escrever o seu cdigo em qualquer estilo. Como exemplo
o nosso programa:

#include <stdio.h>
int main() {

printf(Meu Primeiro Programa!\n); }

O compilador aceitar sem problemas se voc escrever seu cdigo assim, tudo em uma
linha. claro que desta forma o cdigo fica muito mais difcil de entender do que da
outra forma, mas o compilador aceita. Tambm uma prtica saudvel e
recomendvel deixar seu cdigo fcil de ser lido e entendido utilizando espaos,
tabulaes e quebras de linha.

Bibliotecas
Uma biblioteca uma coleo de funes. Quando seu programa referencia uma funo
contida em uma biblioteca, o linkeditor (responsvel por ligar o cdigo-fonte) procura
essa funo e adiciona seus cdigos ao seu programa. Desta forma somente as funes
que voc realmente usa em seu programa so acrescentados ao arquivo executvel.
Cada funo definida na biblioteca C padro tem um arquivo de cabealho associada a
ela. Os arquivos de cabealho que relacionam as funes que voc utiliza em seus
programas devem ser includos (usando #include) em seu programa.
H duas razes para isto. Primeiro muitas funes da biblioteca padro trabalham com
seus prprios tipos de dados especficos, aos quais seu programa deve ter acesso. Esses
tipos de dados so definidos em arquivos de cabealho fornecidos para cada funo.
Um dos exemplos mais comuns o arquivo STDIO.H, que fornece o tipo FILE
necessrio para as operaes com arquivos de disco. A segunda razo para incluir
arquivos de cabealho obter os prottipos da biblioteca padro.
Se os arquivos de cabealho seguem o padro C ANSI, eles tambm contm prottipos
completos para as funes relacionadas com o arquivo de cabealho. Isso fornece um
mtodo de verificao mais forte que aquele anteriormente disponvel ao programador

C. Incluindo os arquivos de cabealho que correspondem s funes padres utilizados

pelo seu programa, voc pode encontrar erros potenciais de inconsistncias de tipos.

Na tabela abaixo algumas bibliotecas:

Arquivo de
Cabealho
ASSERT.H
CTYPE.H
ERRNO.H
FLOAT.H
LIMITS.H
LOCALE.H
MATH.H
SETJMP.H
SIGNAL.H
STDARG.H
STDDEF.H
STDIO.H
STDLIB.H
STRING.H
TIME.H

Finalidades
Define a macro assert()
Manipulao de caracteres
Apresentao de erros
Define valores em ponto flutuante dependentes da implementao
Define limites em ponto flutuante dependentes da implementao
Suporta localizao
Diversas definies usadas pela biblioteca de matemtica
Suporta desvios no-locais
Suporta manipulao de sinais
Suporta listas de argumentos de comprimento varivel.
Define algumas constantes normalmente usadas
Suporta e/s com arquivos
Declaraes miscelneas
Suporta funes de string
Suporta as funes de horrio do sistema

Observe que o nome da biblioteca estar entre os sinais de menor e maior (<>). Se o
nome da biblioteca for delimitado pelos sinais de maior e menor, o compilador C
procurar o arquivo especificado no sue diretrio de arquivos de cabealho. Se o
arquivo for encontrado, ser utilizado, se o compilador no o encontrar, ele ir procurar
ento no diretrio atual, ou em um diretrio que voc especificar.
Se o nome da biblioteca for delimitado por aspas duplas (), o compilador procurar o
arquivo no diretrio atual. Se o nome da biblioteca for delimitado por aspas duplas
significa que esta biblioteca foi criada pelo usurio.

Tipos, Variveis e Constantes

Os Tipos de Dados

Em C temos 5 tipos bsicos de dados, de onde todos os outros tipos so derivados. So

eles:
Tipo

Descrio

Tamanho em
bytes

Faixa mnima

char
int
float
double
void

caractere

-127 a 127

nmero inteiro

-32767 a 32767

nmero em ponto flutuante

(real)

seis dgitos de
preciso

nmero em ponto flutuante de

dupla preciso

dez dgitos de
preciso

sem valor

O tamanho em bytes da cada tipo de dado pode variar de acordo com o tipo do
processador, da implementao do compilador, etc. Por exemplo, em Linux um inteiro
possui 4 bytes, enquanto que no DOS um inteiro possui 2 bytes. O que o padro ANSI
estipula apenas a faixa mnima de cada tipo, no o seu tamanho em bytes.
O tipo void usado quando declaramos funes que no retornam nenhum valor,
quando queremos declarar explicitamente que uma funo no possui argumentos, ou
para criar ponteiros genricos.

O que so Variveis?

Para voc poder manipular dados dos mais diversos tipos, necessrio poder
armazen-los na memria e poder referenci-los quando for preciso. para isso que
existe as variveis, que nada mais so do que um espao reservado na memria, e que
possuem um nome para facilitar a referncia. As variveis podem ser de qualquer tipo:
int, char, float, double, void.
Como o prprio nome diz, as variveis podem ter o seu contedo alterado durante a
execuo do programa, ou seja, o programador tem a liberdade de atribuir valores ao
decorrer da execuo.

Declarao de Variveis

Todas as variveis em C devem ser declaradas antes de serem usadas. A forma geral
de declarao de uma varivel a seguinte:
tipo nome_da_variavel;

Exemplos:
Uma varivel de cada vez:
int id;

float aux;

Ou vrias do mesmo tipo em uma nica linha:

int id, obj, n, t;
char c1, c2, c3;

Onde tipo pode ser qualquer tipo vlido da linguagem C, e nome_da_variavel deve ser
um nome dado pelo programador, sendo o primeiro caractere uma letra e os demais,
letras, nmeros ou _.
NUM
PESO
ALUNO_1

CARAC
ID_OBJ
AUX

Lembrando que C diferencia MAISCULAS de minsculas.

No so nomes vlidos de variveis:
1NUM
$AUX

-IDADE
ID@AL

Inicializando Variveis

Inicializar significa atribuir um valor inicial a uma varivel. Em C, podemos inicializar

variveis na declarao:
int n=12;

Neste exemplo, estamos declarando a varivel inteira n e atribuindo o valor 12 a ela. O

sinal de igual (=) em C o operador de atribuio. Ele serve para colocar o valor (do
lado direito) na varivel (lado esquerdo).
Podemos tambm inicializar uma varivel no corpo do programa, aps sua declarao:
int n;
n=12;

Pode-se atribuir tambm variveis a variveis:

num=i;

Neste caso, a varivel num est recebendo o valor da varivel i.

Para fixar melhor, a vai um exemplo de um programa em C contendo variveis:
#include <stdio.h>
int main() {
int NUM1, NUM2, NUM3;
char CH= a;

Incluso de Biblioteca
Inicio da Funo Principal

Declarao de Variveis

Processamento
NUM1= 3;
NUM2= NUM1;
NUM3= 200;
printf(NUM1: %d, NUM2: %d, NUM3: %d, NUM1, NUM2, NUM3);
printf(CH: %c, CH);
Impresso na tela
}

Constantes

Constantes em C so valores fixos, que no mudam durante a execuo. Elas podem ser
de qualquer tipo bsico: inteiras, ponto flutuante, caractere

Na maioria dos casos C escolhe o menor tipo de dado possvel para tratar uma
constante, com exceo das constantes em ponto flutuante, que so tratadas como
double, por default.

Veja um exemplo de programa com constantes:

#include <stdio.h>
int main()
{
char ch= a;
int n= 10;
float f= 10.4;
printf(%c %d %f , ch, n, f);
}

Sada - A Funo printf

Para termos acesso biblioteca que contm as funes, macros e variveis que facilitam
a entrada e sada de dados o programa deve conter a declarao.
#include <stdio.h>
#include stdio.h

A funo printf permite que dados sejam escritos na tela do computador. O formato ao
mesmo tempo de uso simples e bastante flexvel, permitindo que os dados possam ser
apresentados de diversas maneiras.

A forma geral :
printf (controle, arg1, arg2, ...);

onde os argumentos so impressos de acordo com a maneira indicada pelo controle.

Um exemplo simples pode tornar a explicao mais clara.

O programa abaixo (ano.c) imprime o valor da varivel ano.

#include <stdio.h> /* Biblioteca de entrada e sada */
int main( ){ /* Aqui comea o programa principal*/
int ano = 2007; /* Declarei ano como inteiro e j defini seu valor. */
printf(Estamos no ano %d., ano); /* Imprime o valor do ano */

Na tela do computador ser impresso:

Estamos no ano 2007.

O controle, que deve aparecer sempre entre , define como sero impressos os
argumentos. Neste controle podem existir dois tipos de informaes: caracteres comuns
e cdigos de formatao. Os caracteres comuns, como no exemplo (Estamos no ano)
so escritos na tela sem nenhuma modificao. Os cdigos de formatao aparecem
precedidos por um % e so aplicados aos argumentos na ordem em que aparecem. Deve
haver um cdigo de formatao para cada argumento. O cdigo %d indica que o valor
armazenado em ano deve ser impresso na notao inteiro decimal.

Cdigos de Converso

Os cdigos de converso so os seguintes:

Cdigos de Converso para leitura e entrada de dados.

Cdigo
%c
%d
%i

Comentrio
Caractere simples
Inteiro decimal com sinal
Inteiro decimal com sinal

%E
%e
%f
%G
%g
%o
%s
%u
%x
%X
%p
%%

Real em notao cientfica com E

Real em notao cientfica com e
Real em ponto flutuante
Use %E ou %f, o que for mais curto
Use %e ou %f, o que for mais curto
Inteiro em base octal
Cadeia Caracteres
Inteiro decimal sem sinal
Inteiro em base hexadecimal (letras minsculas)
Inteiro em base hexadecimal (letras maisculas)
Ponteiro
Imprime o caractere %

Entre o % e o caractere do cdigo podem ser inseridos os seguintes comandos:

Justificao da sada
Um sinal de menos para especificar que o argumento deve ser ajustado esquerda no
seu campo de impresso.
O programa a seguir (menos.c) ilustra os dois tipos de justificao.

#include <stdio.h>
int main( void)
{
int ano = 2006;
printf(Justificado para direita Ano = %8d\n, ano);
printf(Justificado para esquerda Ano = %-8d\n,

ano);
return 0;
}

Tamanho do Campo

Um nmero inteiro especificando um tamanho de campo onde o argumento ser

impresso. No exemplo acima o nmero especifica que 8 espaos so reservados para
imprimir o resultado.

Especificador de Preciso

O especificador de preciso consiste de um ponto que separa o nmero que define o

tamanho do campo do prximo nmero. Este prximo nmero especifica o mximo
nmero de caracteres de uma string a ser impresso, ou o nmero de dgitos a serem
impressos a direita do ponto em um nmero do tipo float ou double.
No exemplo abaixo (prec.c) o nmero calculado impresso com 3 casas decimais em
um campo de tamanho 9 espaos.

#include <stdio.h>
main()
{
float r = 1.0/3.0;
printf(O resultado e = %9.3f \n, r);
}

Ao executar o exemplo verifique que \n no impresso. A barra inclinada chamada de

sequncia de escape, indicando que o prximo caractere no para ser impresso, mas
representa caracteres invisveis ou caracteres que no esto representados no teclado,
por exemplo. Alguns destes caracteres so:

Cdigo
\n
\t
\b
\f
\0
\xhh
\nnn

Comentrio
Passa para uma nova linha
Tabulao
Retorna um caractere
Salta uma pgina
Caractere nulo
Caractere representado pelo cdigo ASCII hh (hh
em notao hexadecimal)
Representao de um byte em base octal

Entrada - A Funo scanf

A funo scanf pode ser utilizada para entrada de dados a partir do teclado e seu
formato :
scanf(controle, arg1var1, arg2var2, ...);

Uma diferena fundamental existe entre esta funo e a funo printf:

Os argumentos so os endereos das variveis que iro receber os valores lidos

e no, como em printf, as prprias variveis.

A indicao que estamos referenciando um endereo e no a varivel se faz

pelo operador &. Por exemplo, o comando:

scanf(%d %d, &a, &b);

Espera-se que dois valores inteiros sejam digitados no teclado. O primeiro armazenado
na varivel a e o segundo em b.
Usualmente o campo de controle s contm especificaes de converso, que so
utilizadas para interpretar os dados que sero lidos. No entanto outros caracteres podem
aparecer. O campo de controle pode conter:
Especificaes de converso, consistindo do caractere %, um caractere opcional de
supresso da atribuio (caractere *), um nmero opcional para especificar o
tamanho mximo do campo, e um caractere de converso;
Espaos, caracteres de tabulao ou linefeeds (tecla enter) que so ignorados;
Caracteres comuns (no %) que devem casar com o prximo caractere diferente
de branco da entrada.
Para que os valores digitados sejam separados por vrgulas, o comando deveria ser
escrito da seguinte maneira:
scanf(%d, %f, &i, &x);

Observar que deve haver uma correspondncia exata entre os caracteres no brancos
do controle e os caracteres digitados. Neste caso a entrada deveria ser:
35, 46.3

Lendo e Imprimindo Caracteres

Funes getchar e putchar

Para ler e escrever caracteres do teclado, as funes de entrada e sada mais simples so
getchar e putchar que esto na biblioteca stdio.h, so os seguintes:
int getchar(void);
int putchar(int c);

Apesar da funo getchar retornar um parmetro inteiro possvel atribuir este valor a
uma varivel do tipo char porque o cdigo do caractere est armazenado no byte de
ordem mais baixa. O mesmo acontece com a funo putchar que recebe um inteiro, mas
somente o byte de ordem mais baixa passado para a tela do computador.
O programa getcha.c abaixo mostra exemplos de uso destas funes.

#include <stdio.h>
int main ()
{
char c;
int i;
printf(Entre com um caractere entre 0 e 9.\n);
c = getchar();
printf(O caractere lido foi o: );
putchar(c);
}

Funes getch e getche

Na definio original da funo getchar a entrada armazenada at que a tecla ENTER
seja apertada. Com isto caracteres ficam em um buffer esperando para serem tratados.
Em ambientes onde necessrio tratar o caractere imediatamente esta funo pode no
ser til.
Muitos compiladores incluem funes para permitir entrada interativa de dados. As
duas funes mais comuns so getch e getche e seus prottipos, que podem ser
encontrados em conio.h, so os seguintes:
int getch(void);
int getche (void);

A funo getch espera at que uma tecla seja apertada e retorna este valor
imediatamente. O caractere lido no ecoado na tela. A funo getche opera da
mesma maneira, mas ecoa o caractere lido.

Lendo e Imprimindo Strings

Um string em C uma cadeia de caracteres. Para usar strings preciso primeiro definir
um espao para armazen-los. Para isto preciso declarar o tamanho e o tipo do vetor.
Por exemplo:
char nome[40];

/* reserva um espao para armazenar caracteres. */

Quando definir o tamanho do vetor observar que todo string em C termina com o
caractere null (\0), que automaticamente inserido pelo compilador. Portanto o vetor
nome pode armazenar no mximo 39 caracteres.
Aps este passo a varivel nome pode ser usado durante a execuo do programa.

Lendo e Imprimindo strings com scanf e printf

O exemplo stscf.c mostrado abaixo mostra como ler e imprimir um string usando os
comandos scanf e printf respectivamente.
#define DIM 40
/* Definies Constantes*/
#include <stdio.h>
/* Biblioteca usada pelo programa */
void main (void)
{
char nome[DIM];
/* linha de caracteres lidos do teclado */
printf(Por favor, qual o seu nome.);
scanf(%s, &nome);
/* Entrada de dados do vetor */
printf(Eu sou um computador PC, em que posso ajud-lo %s? \n, nome);
}

Caso o nome digitado tenha sido Antonio da Silva, o programa imprimiria somente o
seguinte:
Eu sou um computador PC, em que posso ajud-lo Antonio.

O cdigo de converso para strings %s. Observar que o comando scanf no l o

nome todo, mas encerra a leitura quando encontra um caractere branco. Mas como ler
para um vetor um nome inteiro, ou um string que contenha brancos? Para isto deve-se
usar a funo gets.

Lendo e Imprimindo strings com gets e puts

A funo gets l toda a string at que a tecla ENTER seja teclada, no vetor o cdigo da
tecla ENTER no armazenado, sendo substitudo pelo cdigo null (\0). Caso a
funo scanf do exemplo anterior fosse substituda pela gets o programa imprimiria:
Eu sou um computador PC, em que posso ajud-lo Antonio da Silva.

O comando que substitui o scanf gets(nome).

O prottipo da funo gets o seguinte:
#include<stdio.h>
char *gets (char *str);

A funo puts tem o seguinte prottipo:

#include<stdio.h>
int puts (const char *str);

Ela imprime a string apontada por str. O programa exemplo stput.c, mostrado abaixo,
semelhante ao exemplo anterior com as funes printf substitudas por puts.
Observe que a impresso sempre termina passando para a prxima linha.

#define DIM 40
#include <stdio.h>
void main ( )
{
char nome[DIM]; /* linha de caracteres lidos do teclado */
/* Entrada de dados do vetor */
puts(Entre com o seu nome, por favor.);
gets( nome);
puts(Alo );
puts(nome);
puts(Eu sou um computador PC, em que posso ajud-lo?);
}

Operadores em C
O Operador de Atribuio
O operador de atribuio, (o smbolo de igual =) coloca o valor de uma expresso
(do lado direito) em uma varivel (do lado esquerdo). Uma expresso neste caso pode
ser um valor constante, uma varivel ou uma expresso matemtica mesmo.
um operador binrio, ou seja, trabalha com dois operandos. Exemplos:

Atribuio de uma constante a uma varivel:

n= 10;
ch= a;
fp= 2.51;

Atribuio do valor de uma varivel a outra varivel:

n= num;

Atribuio do valor de uma expresso a uma varivel:

n= (5+2)/4;

Atribuies mltiplas:
x = y = z = 20;

Em uma atribuio, primeiro processado o lado direito. Depois de processado, ento,

o valor atribudo a varivel.
Como voc viu no ltimo exemplo acima, C tambm permite atribuies mltiplas
(como x = y = z = 20;). Neste caso, todas as variveis da atribuio (x, y e z) recebem
o valor mais direita (20).

Os Operadores Aritmticos
Estes so, de longe, os mais usados. Os operadores aritmticos em C trabalham
praticamente da mesma forma que outras linguagens. So os operadores + (adio), (subtrao), * (multiplicao), / (diviso) e % (mdulo ou resto da diviso
inteira), todos esses binrios (de dois operandos). Temos tambm o - unrio, que
muda o sinal de uma varivel ou expresso para negativo. Veja a tabela a seguir:
Operador

Descrio

Exemplo

- unrio

Inverte o sinal de uma expresso

-10, -n, -(5*3+8)

Multiplicao

3*5, num*i

Diviso

2/6, n/(2+5)

Mdulo da diviso inteira (resto)

5%2, n%k

Adio

8+10, exp+num

Subtrao

3-6, n-p

Uma expresso deste tipo:

5+2*3-8/4

avaliada assim: primeiro a multiplicao (2*3), depois a diviso (8/4). Os resultados

obtidos destas duas operaes so utilizados para resolver as duas ltimas operaes:
5+62

Adio e subtrao. Igualzinho matemtica aprendida no primrio...

Tudo isso porque as operaes de multiplicao e diviso tm maior precedncia e so

resolvidos primeiro em uma expresso. Para mudar a ordem de operao, devem-se
usar parnteses. Deve-se tomar cuidado ao construir expresses, pois a falta de
parnteses pode causar inconsistncia (erro) no resultado.

O Operador % equivalente ao mod, e til em vrias situaes. Ele d como

resultado o resto da diviso inteira de dois operandos. Assim, fica fcil, por exemplo,
saber se um nmero mltiplo de outro:

if ((num%3)==0) /* se o resto da diviso entre num e 3 for igual a 0 ... */

printf(Mltiplo de 3\n);

Este apenas um de vrios problemas que podem ser resolvidos com o uso do
operador %.

Operadores Relacionais e Lgicos

Os operadores relacionais e lgicos so usados em testes e comparaes,
principalmente nos comandos de controle e nos laos.
Para entender melhor esses operadores, temos que entender o conceito de verdadeiro
e falso. Em C, verdadeiro qualquer valor diferente de zero, e falso zero. As
expresses que usam operadores relacionais e lgicos retornam 0 para falso e 1 para
verdadeiro.

Os operadores relacionais so 6:
Operador

Ao

<

Menor que

<=

Menor que ou igual

>

Maior que

>=

Maior que ou igual

==

Igual

!=

Diferente

Veja um exemplo do uso de operadores relacionais:

#include <stdio.h>
/* necessrio para printf e scanf */
int main(){
int n;
/* Declarao de uma varivel inteira */
printf(Digite um nmero: );

scanf(%d, &n); /* L o nmero e armazena na varivel n */

if (n < 0) /* Se n for MENOR QUE 0... */
printf(Nmero negativo\n); /* ... escreve isto. */
else { /* Seno... */
printf(Nmero positivo\n); /* ... escreve isto. */
}
}

Tente fazer alguns testes com os outros operadores relacionais. Seja criativo!
Voc o programador.

Os operadores lgicos so 3:
Operador

Ao

Formato da expresso

&&

and (e lgico)

p && q

||

or (ou lgico)

p || q

not (no lgico)

!p

Veja um exemplo, s do bloco if:

if ((n > 0) && (n < 100)) /* se n for > que 0 e n for < que 100 */
printf(Nmero positivo menor que 100\n); /* ...imprime isto */

Outro exemplo:
if ((n == 0) || (n == 1)) /* se n for IGUAL a 0 OU n for igual a 1 ... */
printf(zero ou um\n);
/* ... imprime isto. */

Os parnteses tambm podem ser usados para mudar a ordem de avaliao das
expresses, como no caso das expresses aritmticas.

Operadores de Incremento e Decremento

A linguagem C possui dois operadores que geralmente no so encontrados em outras
linguagens, mas que facilita bastante a codificao: os operadores de incremento(++) e
decremento(--).
O operador ++ soma 1 ao seu operando, similar a operao de:
varivel= varivel+1;

mas muito mais resumido.

O operador - - subtrai 1 de seu operando, tambm similar a:

varivel= varivel-1;

Estes operadores so unrios, e podem ser usados antes da varivel:

++n;

ou depois da varivel:
n++;

A diferena que, se o operador precede o operando (++n), o incremento ou

decremento realizado antes do valor da varivel ser usado. E se o operador vem
depois do operando (n++), o valor da varivel poder ser usado antes de acontecer
operao de incremento ou decremento. Veja estes dois exemplos:

Exemplo 1:
n= 5;
p= ++n;
printf(%d ,p);

/* imprime na tela: 6 */

Exemplo 2:
n= 5;
p= n++;
printf(%d ,p);

/* imprime na tela: 5 */

No exemplo 1, a varivel n incrementada de 1 ANTES de seu valor ser atribudo a p.

No exemplo 2, o valor de n atribudo a p antes de acontecer operao de
incremento. Essa a diferena de se colocar esses operadores antes ou depois da
varivel.

Operadores Aritmticos de Atribuio

Algumas operaes de atribuio podem ser feitas de forma resumida. Por exemplo, a
atribuio:
x= x+10;

pode ser escrita:

x+=10;

A forma geral desse tipo de atribuio :

varivel [operador]= [expresso];

que igual a:
varivel= varivel [operador] [expresso]

Veja essa tabela com exemplos:

Forma longa

Forma resumida

x= x+10

x+=10

x= x-10

x-=10

x= x*10

x*=10

x= x/10

x/=10

x= x%10

x%=10

Se familiarize com essa notao, pois um estilo largamente adotado pelos

profissionais que trabalham com C.

Estruturas de Deciso
Os comandos para tomadas de deciso em C so: if, if ... else, switch e o
operador ternrio (?).

O comando if
O comando if, presente na maioria das linguagens de programao, usado
para a construo de estruturas de deciso simples. A forma geral do comando assim:
if (expresso condicional)
{
comandos;
}

OU
if (expresso condicional)
comando nico;

O comando if avalia a expresso condicional entre parnteses. Se esta expresso for

verdadeira, o(s) comando(s) do bloco de cdigo ser(o) executado(s). Se for falsa, o
bloco de cdigo do if no ser executado, isto , o programa passa batido.
Para comandos if com apenas UM comando, no necessrio delimitar o bloco de
cdigo com chaves ({}). O compilador sabe que quando no existem as chaves
naquele if, somente UM comando far parte do bloco de cdigo.

Agora, vamos ver alguns exemplos:

if (a > b) /* se o a for maior do que o b ... */
printf(a maior que b); /* ... imprime mensagem */

if ((num % 2) == 0) /* se o resto da diviso entre num e 2 for 0 ... */

{
printf(Nmero par); /* ... faa isso */
printf(\n\n);
}

interessante sempre manter o cdigo identado, com tabulaes, para ficar claro de
qual bloco de cdigo determinado comando.

O comando if ... else

Esta construo possui duas partes: um comando if, cujo bloco de cdigo ser
executado se a expresso condicional for verdadeira; e um comando else, que ser
executado caso a mesma expresso seja falsa.
Portanto, agora temos uma bifurcao, e o caminho que o programa trilhar vai
depender do resultado da expresso condicional (verdadeiro ou falso).

Forma geral:

if (expresso condicional)
{
comandos;
}
else {
comandos; }

Se os blocos de cdigo tiverem mais que um comando, deve-se delimit-los com abre
e fecha chaves. Vejam alguns exemplos:

if ((num % 2) == 0)
/* Se o resto da diviso entre num e 2 for 0... */
printf(Nmero par.);
/* ...imprime mensagem nmero par. */
else { /* ... Seno... */
printf(Nmero mpar.); /* ... imprime mensagem nmero mpar. */
}

Neste exemplo, se num % 2 for igual zero (se esta expresso for verdadeira), executa
o primeiro printf(). Caso contrrio (se for falsa), executa o segundo printf().
Dentro de um bloco de cdigo, pode aparecer qualquer comando, at mesmo ifs e
else.
Voc pode at criar construes para decises mltiplas, criando uma espcie de
escada de ifs e else.

O Comando switch
O comando switch usado como alternativa escada de ifs e else's, e torna o cdigo
mais elegante e legvel. Forma geral:

switch (expresso constante)

{
case constante1:
comandos;
break;
case constante2:
comandos;
break; `
case constante3: comandos;
break;
case constante4:
comandos;
break;
default:
comandos;
}

Este comando possui algumas restries. Como a expresso constante, ele s aceita
valores inteiros e caracteres. Como expresso condicional, s so aceitas igualdades
(se a constante1 for igual expresso constante, executa comandos; e assim por
diante).

Para cada case existe um conjunto de comandos que s sero executados caso a
condio seja verdadeira. Se a expresso constante no casar com nenhum case, ento
os comandos do bloco default so executados. O bloco de cdigo dos case NO
PRECISAM ser delimitados com chaves; basta coloc-los, um aps o outro, aps o
rtulo case:
Vamos ver um exemplo para poder clarear:

#include <stdio.h>
int main()
{
float n1, n2;
char op;
printf(*** Calculadora ***\n);
printf(Digite um nmero: );
scanf(%f, &n1);
printf(Digite o operador (+ - * /): );
scanf(%c, &op);
printf(Digite outro nmero: );
scanf(%f, &n2);
switch(op)
{
case +:

/*expresso constante: varivel op (caractere) */

printf(Adio: %.2f\n, n1+n2);
break;

case -:
printf(Subtrao: %.2f\n, n1-n2);
break;
case *:
printf(Multiplicao: %.2f\n, n1*n2);
break;
case /:
if (n2 == 0)
{
printf(Erro: impossvel dividir por zero!\n);
return 1;
}else {
printf(Diviso: %.2f\n, n1/n2);
}
break;
default:
printf(Operador invlido: %c\n, op);
break;
}
}

Um exemplo do switch na prtica. Em cada case, temos o(s) comando(s) e, em

seguida, um comando break. O comando break, quando encontrado, faz a execuo
sair imediatamente do switch. Se usado em loops, faz a execuo do programa parar o
loop e continuar a execuo do restante do cdigo aps o loop.
Imagina se, no lugar do switch, tivssemos que montar uma escada de ifs e elses...
Ficaria mais ou menos assim:
if (op==+)

printf(Adio: %.2f\n, n1+n2);

else if (op==-)
printf(Subtrao: %.2f\n, n1-n2);
else if (op==*)
printf(Multiplicao: %.2f\n, n1*n2);
else if (op==/){
if (n1==0)
printf(Erro: impossvel dividir por zero!\n);
else printf(Diviso: %.2f\n, n1/n2);
} else printf(Operador invlido: %c\n, op);

Usando o switch, neste exemplo, temos 25 linhas de cdigo, enquanto que usando a
construo de ifs e elses temos 11 linhas.
O switch bastante usado em menus, quando o usurio tem que digitar o nmero ou a
letra de alguma opo.

Estruturas de Repetio
Suponhamos que voc queira fazer um programa que l 100 nmeros do teclado e para
cada nmero verifique se mltiplo de 3, imprimindo a resposta para cada um.

Como voc escreveria este programa? Seria assim?

#include <stdio.h>
main(){
int num;
printf(Digite um nmero: );
scanf(%d, &num);
if ((num %3) == 0)
printf( mltiplo de 3\n);
else printf(no mltiplo de 3\n);
printf(Digite um nmero: );
scanf(%d, &num);
if ((num %3) == 0)
printf( mltiplo de 3\n);
else printf(no mltiplo de 3\n);
printf(Digite um nmero: );
scanf(%d, &num);
if ((num %3) == 0)
printf( mltiplo de 3\n);
else printf(no mltiplo de 3\n);

printf(Digite um nmero: );
scanf(%d, &num);
if ((num %3) == 0)
printf( mltiplo de 3\n);
else printf(no mltiplo de 3\n);
printf(Digite um nmero: );
scanf(%d, &num);
if ((num %3) == 0)
printf( mltiplo de 3\n);
else printf(no mltiplo de 3\n);
.
.
.
etc .....................
}

Como voc pode ver, no uma tcnica nada vivel, pois temos que repetir a mesma
sequncia de comandos vrias vezes. Mas no se desespere o C, assim como outras
linguagens, tem vrios comandos que nos ajudam em tarefas repetitivas, como esta.
Estes comandos so conhecidos como estruturas de repetio ou laos de repetio.
Veremos tambm algumas tcnicas bsicas que nos ajudaro a criar programas
iterativos.

O lao for
O lao for uma estrutura de repetio controlada por varivel, onde devemos saber
de antemo a quantidade de iteraes. O lao for tem a seguinte forma geral:
for ( inicializao ; teste condicional ; incremento ou decremento )
{
comandos;
}
OU

for ( inicializao ; teste condicional ; incremento ou decremento )

comando nico;

Veja este exemplo:

#include <stdio.h>
main()
{
int i, num;
for (i=0; i<100; i++)
{
printf(Digite um nmero: );
scanf(%d, &num);

if ((num %3) == 0)
printf( mltiplo de 3\n);
else
printf(no mltiplo de 3\n);
}
}

Veja s o nosso exemplo revisitado, com o uso de for.

Como voc pode ver, o lao for contm 3 expresses entre parnteses, que controlaro
o modo que o nosso lao trabalhar:
Na expresso inicializao, atribumos valor inicial varivel de controle. No exemplo
acima, inicializamos i com 0.
Em teste condicional, temos uma expresso relacional/lgica que definir o critrio de
parada do nosso lao. No nosso //Detector de mltiplos de 3//, o lao ficar repetindo o
bloco de comandos enquanto a varivel i for menor que 100. Quando i tiver o valor
100, o lao no executar mais os comandos do bloco de comandos, e o programa
continuar sua execuo (no nosso caso, executar return0; e depois terminar).
A expresso incremento ou decremento deve dizer para o lao for como a varivel vai
andar, se de 1 em 1, de 2 em 2, de 10 em 10, etc. No nosso programa acima, a
expresso i++ faz a varivel i ser incrementada de 1 em 1.
Trocando em midos, no lao for do nosso programa, a varivel i ser inicializada com
1, andar de 1 em 1, e quando chegar a 100 sair do lao.

Flexibilidade do lao for

As 3 expresses do lao podem conter vrias instrues separadas por vrgula. Vamos
ver um exemplo:
#include <stdio.h>
main()
{
int i, j, num;
for (i=0, j=0; i+j <100; i++, j++)
printf(%d\n, i+j);
return 0;
}

Veja que na inicializao, temos duas variveis sendo atribudas com 0: i e j, separadas
por vrgula. Na parte de incremento, i e j so incrementadas com 1, tambm separadas
por vrgula. Isto torna o lao for bastante flexvel, onde o limite a sua criatividade.
Mas cuidado para no construir laos for monstros, com expresses enormes e de
difcil compreenso...

Alm disso, podemos omitir qualquer uma das expresses do lao for. Por exemplo:

for ( ; i<100; i++)

{
comandos;
}

Nesse caso, no haver a inicializao.

Outro exemplo:
for (i=0; i<100; )
{
comandos;
}

Aqui, no h o incremento. Ele pode ser feito dentro do bloco de cdigo do lao.

Em alguns casos, podemos usar o lao for como um lao infinito. Veja como:
for ( ; ; )
{
comandos;
}

Este um lao for infinito. Sua execuo nunca terminar, a menos que haja um
return ou um break dentro dele.

O lao while
O lao while uma estrutura de repetio que s repetir o bloco de cdigo se a
condio, entre parnteses, for verdadeira. Esta condio pode ser qualquer expresso,
onde falso 0 e verdadeiro diferente de 0. Se a condio for falsa logo no incio do
while, o lao no ser executado.
Forma geral:
while (condio)
{
comandos;
}
OU

while (condio)

comando nico;

Quando o programa chega ao while, ele verifica a condio entre parnteses. Se for
verdadeira, ele executa o bloco de cdigos. Quando termina de executar os comandos
do bloco de cdigo, ele volta para o while novamente, testa a condio de novo e, se for
verdadeira, executa o bloco de cdigo novamente. Faz isso at a condio entre
parnteses ser falsa, momento em que o programa continua a execuo normalmente,
depois do while.
Vamos ver alguns exemplos:
#include <stdio.h>
#include <ctype.h>
main()
{
int cont=0, i= 0;
char ch;
while (i < 10)
{
printf(Digite um caractere: );
scanf(%c, &ch);
getchar();
if (isdigit(ch))
{
cont++;
i++;
}
}
printf(Voc digitou %d caracteres numricos\n, cont);
return 0;
}

Aqui, o programa utiliza a funo isdigit(), presente no arquivo de cabealho ctype.h.

O ctype.h contm funes para teste e converso de caracteres.
Neste programa, o while executar 10 vezes, s terminando quando i chegar ao valor
10. Aqui vemos uma tcnica que usamos muito em vrias aplicaes: um contador. A
varivel cont inicializada com zero; quando, dentro do while, o cara digitar um
caractere numrico, esta varivel incrementada de 1. Ao final da execuo, ela ter o
nmero exato de caracteres numricos que foram digitados.
Outro exemplo:
#include <stdio.h>
int main()
{
int i=0, num, res= 0;
while (i < 5)
{
printf(Digite um nmero: );
scanf(%d, &num);
res= res+num;
i++;

}
printf(Somatria: %d\n, res);
return 0;
}

Neste, outra tcnica bastante utilizada: a somatria de um conjunto de nmeros.

Funciona assim: ao entrar no while, o cara digita um nmero, que ser armazenado na
varivel num. Esse nmero somado com o valor da varivel res (que na primeira
iterao 0) e armazenado em res. Na prxima iterao, o valor da varivel res (a
soma da iterao passada) somada com num e armazenada em res novamente, assim
sucessivamente at acabar o lao. Ao final do lao, o que temos em res a somatria
de todos os nmeros digitados.
Mais uma tcnica: imagine que voc queira somar os nmeros digitados at que seja
digitado um nmero maior que 100. Voc pode criar uma varivel que muda de valor
quando essa condio for satisfeita. o que chamamos de flag. Exemplo:
int num;
int flag= 0;
while (flag == 0)
{
printf(Digite um nmero: );
scanf(%d, &num);
getchar();
if (num > 100)
flag= 1;
/* flag muda de valor (indica que loop deve parar) */
}

Lembrando que estas tcnicas podem ser exploradas em qualquer tipo de lao, desde
que sejam adaptadas para cada situao.
Assim como for, podemos fazer um lao infinito com o while tambm. Basta fazer o
seguinte:
while(1)
/* 1 verdadeiro em C */
{
comandos;
}

claro que em comandos deve haver alguma forma de sair do while, como um break,
um return, um exit(), etc.
OBS: Evite usar comandos como break ou exit() dentro de laos, pois uma prtica
pouco elegante. S use quando no houver outro jeito.

O lao do-while
Diferente do while, que testa a condio antes de executar o seu bloco de cdigo, o dowhile primeiro executa o seu bloco de cdigo para depois testar a condio. Ele til
quando temos que executar no mnimo UMA VEZ o bloco de cdigo do lao.

Forma geral:
do
{
comandos;
} while(condio);

No caso de haver um comando nico, no necessrio delimitar com chaves, mas

recomendvel, para no haver confuso e para deixar o cdigo mais legvel.
Vamos para os exemplos:
#include <stdio.h>
main()
{
int num;
do
{
printf(\n\nDigite um numero: );
scanf(%d, &num);
getchar();
} while ( num < 50 );
return 0;
}

Neste programa, que no faz nada de til, o bloco de cdigo deve ser executado pelo
menos uma vez, j que dependemos do valor da varivel num para processar a
condio, no final do lao. Aqui, o programa s sai do lao quando for digitado algum
nmero maior ou igual a 50.
Agora um exemplo mais prtico:
#include <stdio.h>
main()
{
int opt;
do
{
do
{
printf(**** Menu ****\n);
printf(1) Cadastrar\n);
printf(2) Buscar\n);
printf(3) Exibir Relatrio\n);
printf(4) Sair\n);
printf(Digite sua opo: );
scanf(%d, &opt);
getchar();
} while ((opt < 1) || (opt > 4));/* o cara fica preso at digitar um nmero vlido */
switch(opt)
{

case 1:
break;
case 2:
break;
case 3:
break;
}
} while (opt != 4);
return 0;

cadastra();
busca();
relat();

/* lao principal, s sai quando opt for igual a 4 */

Como voc pode ver, temos dois do-while. O mais externo e principal fica vigiando se o
cara digitou 4 (se quer sair). Caso contrrio, volta e executa tudo novamente.
O lao mais interno uma tcnica usada quando o usurio tem um menu, e tem que
digitar uma opo para definir para que lado o programa vai. No nosso caso, se o
espertinho do usurio digitar algum nmero maior que 4 ou menor que 1 (invlidos), o
lao volta e joga tudo de novo na tela, esperando o esperto do usurio escolher a opo
certa.
As funes cadastra(), busca() e relat() so fictcias e s serviram para ilustrar a
situao.

Laos aninhados
Laos aninhados no so laos dentro de ninhos. So laos dentro de laos.
Exemplo de laos for aninhados:
for ( i = 1 ;i <= 10; i++ )
{
for ( j = 1 ; j <= 10 ; j++ )
{
printf(%d X %d = %d\n, i, j, i*j);
}
printf(\n\n);
ch= getchar();
}

Vejam que poder: com apenas 9 linhas imprimimos as tabuadas de 1 a 10!!

Exemplo de laos while aninhados:

while ( i <= 10 )
{
while ( j <= 10 )
{
printf(%d x %d = %d\n, i, j, i*j);
j++;
}
printf(\n\n);
ch= getchar();

i++;
}

O mesmo exemplo das tabuadas usando while.

A lgica dos laos aninhados a seguinte:
o O lao mais externo entra em execuo;
o So executados os comandos do bloco at que o programa encontra o lao mais
interno;
o O lao mais interno tambm entra em execuo;
o Agora o lao mais interno far todas as iteraes possveis, at acabar;
o Acabando a execuo do lao mais interno, o lao mais externo continua
executando seu bloco de cdigo;
o Quando o ltimo cdigo do bloco de cdigo executado, o lao mais externo
volta, testa e entra em execuo novamente(se a condio for satisfeita);
o A encontra o lao mais interno novamente, que entra em execuo at
terminar;
o E assim vai, at a condio de parada do lao mais externo ser satisfeita (the
end).
Podemos ter vrios laos aninhados, no somente 2. Podemos tambm ter laos for
dentro de while ou do-while, e etc... S tem uma coisa: quanto mais laos aninhados,
mais lento ser seu programa.

Extrado do Material: M06 Introduo a Programao, 2007, SIMES, S.;

FONSECA, S. C. C.; MICRONI, A. D. L.; MICRONI, J. S. C; RODOVALHO, R. S.