RESUMO LINGUAGEM C

Histria
A linguagem C foi criada por Dennis M. Ritchie e Ken Thompson em 1972, no
laorat!rio "ell. #eu desen$ol$imento come%ou com uma linguagem mais antiga,
chamada "C&', criada por Martin Richards. (sta linguagem influenciou o
desen$ol$imento da linguagem ", criada por Ken Thompson, e posteriormente le$ou ao
desen$ol$imento de C.
A $ers)o de C fornecida com o sistema *ni+ $ers)o , foi o padr)o da linguagem por
muitos anos. *m grande n-mero de implementa%.es, por/m, foi criado, com a
popularidade dos microcomputadores, e isso gerou certa incompatiilidade entre essas
implementa%.es. 0oi aseado nesta situa%)o 1ue em 1923 o A4#5 6American 4ational
#tandards 5nstitute7 estaeleceu um comit8 para criar um padr)o para definir a
linguagem C. Atualmente, todos os principais compiladores de C implementam o
padr)o C A4#5.
Caractersticas
C uma linguagem estruturada
C utili9a fun%.es para di$idir o seu c!digo em su:rotinas, tornando o traalho do
programador mais efica9. ;oc8 pode criar iliotecas, 1ue poder)o ser compartilhadas
por 1ual1uer programa 1ue utili9e suas rotinas. <= tam/m a possiilidade de di$idir o
seu c!digo:fonte em $=rios ar1ui$os, onde cada ar1ui$o pode ter rotinas para uma
fun%)o espec>fica, tornando o desen$ol$imento muito mais organi9ado.
C uma linguagem de mdi n!el
5sto significa 1ue C possui recursos de alto n>$el, e ao mesmo tempo permite a
manipula%)o de its, ?tes e endere%os : os elementos mais =sicos para a
funcionalidade de um computador.

C uma linguagem cm"ilada
*ma linguagem de computador pode ser compilada ou interpretada. C / compilada, isto
/, o compilador da linguagem l8 o ar1ui$o do c!digo:fonte, processa:o e cria um
ar1ui$o em formato in=rio 6o@eto7. &ara este ar1ui$o se tornar um programa
e+ecut=$el, entra em cena o linAer, 1ue BligaC o in=rio gerado na compila%)o do
programa com as iliotecas da linguagem.
D fato de C ser compilada torna esta linguagem E op%)o certa 1uando se 1uer
$elocidade. 'inguagens interpretadas geralmente s)o em mais lentas do 1ue as
compiladas.
CDM&5'ADDR '54K(R
6c!digo:fonte7 ::::::::::::::::::F 6c!digo:o@eto7 :::::::::::F 6programa e+ecut=$el7
C uma linguagem "rt#!el
*m programa feito em C pode ser compilado em outras plataformas e funcionar sem
prolemas. C foi desen$ol$ida para ser uma linguagem port=$el, e a padroni9a%)o feita
pelo A4#5 melhorou ainda mais esta caracter>stica. G claro 1ue se de$e seguir certas
pr=ticas para tornar o c!digo port=$el para outras plataformas, como e$itar o uso de
iliotecas particulares a uma plataforma espec>fica, usar direti$as do compilador
1uando necess=rio, adotar o padr)o A4#5, etc.
Estrutura $#sica de um "rgrama em C
5remos come%ar estudando como / a estrutura =sica de um programa em simples em
C, 1ue escre$er= na tela a mensagem BMeu primeiro programaHC. A seguir $oc8 tem o
c!digo do programa. As linhas est)o numeradas para facilitar o entendimento.
1 Iinclude Jstdio.hF
2
3 int main67
K L
, printf6BMeu &rimeiro &rogramaHMnC7N
O P
Agora $amos e+plicar linha por linha. A linha 1 cont/m a direti$a Iinclude Jstdio.hF, e
ser$e para incluir as fun%.es de uma ilioteca em seu programa. 4este caso, estamos
incluindo a ilioteca de entrada e sa>da padr)o 6standard inputQoutput7, necess=ria para
a utili9a%)o da fun%)o printf67. C / uma linguagem 1ue diferencia min-sculas de
MA5R#C*'A# 6case sensiti$e7. As pala$ras:cha$e e os comandos da linguagem de$em
ser escritos em min-sculo. #e $oc8 declarar $ari=$eis, fun%.es, tipos, etc, utili9ando
caracteres mai-sculos, n)o se es1ue%a de referenci=:los da forma correta.
A linha 2 n)o cont/m nada... (st= em ranco. ;oc8 pode adicionar linhas em ranco,
espa%os e taula%.es em seu c!digo para torn=:lo mais f=cil de ser lido.
A linha 3 cont/m o in>cio da fun%)o main67. (sta fun%)o marca o in>cio da e+ecu%)o do
programa e de$e e+istir em algum lugar do c!digo para este funcionar corretamente. #e
o seu programa ti$er somente uma fun%)o, ela de$er= ser main67. (ste int, antes do
main67, est= di9endo 1ue main67 de$e retornar um $alor para o sistema, indicando
sucesso ou falha. (ste $alor / um n-mero inteiro, por isso int.
4a linha K $emos o caractere are:cha$es, um delimitador de loco, ser$e para arir um
loco de c!digo. D 1ue esti$er dentro do par de cha$es pertence E fun%)o main67, neste
caso.
Mas / na linha , 1ue o nosso programa cumpre a sua crucial miss)oS escre$er a
mensagem BMeu &rimeiro &rogramaHC na tela. D 1ue $oc8 precisa saer agora / 1ue a
fun%)o printf67 / a principal fun%)o para escrita no console 6sa>da padr)o. D BMnC / um
caractere especial, e ser$e para pular para a pr!+ima linha, assim 1ue acaar de escre$er
a mensagem.
OBS: os comandos em C so terminados com um ; (ponto-e-vrgula). o
es!ue"a.
( finalmente chegamos E linha O, onde encontramos as fecha:cha$es, 1ue significa o
fim do loco de c!digo.
(m C $oc8 tem a lierdade de escre$er o seu c!digo em 1ual1uer estilo. Como e+emplo
o nosso programaS

Iinclude Jstdio.hF
int main67 L printf6BMeu &rimeiro &rogramaHMnC7N P
D compilador aceitar= sem prolemas se $oc8 escre$er seu c!digo assim, tudo em uma
linha. G claro 1ue desta forma o c!digo fica muito mais dif>cil de entender do 1ue da
outra forma, mas o compilador aceita. Tam/m / uma pr=tica saud=$el e recomend=$el
dei+ar seu c!digo f=cil de ser lido e entendido utili9ando espa%os, taula%.es e 1ueras
de linha.
%i$litecas
*ma ilioteca / uma cole%)o de fun%.es. Tuando seu programa referencia uma fun%)o
contida em uma ilioteca, o linAeditor 6respons=$el por ligar o c!digo:fonte7 procura
essa fun%)o e adiciona seus c!digos ao seu programa. Desta forma somente as fun%.es
1ue $oc8 realmente usa em seu programa s)o acrescentados ao ar1ui$o e+ecut=$el.
Cada fun%)o definida na ilioteca C padr)o tem um ar1ui$o de cae%alho associada a
ela. Ds ar1ui$os de cae%alho 1ue relacionam as fun%.es 1ue $oc8 utili9a em seus
programas de$em ser inclu>dos 6usando &include7 em seu programa.
<= duas ra9.es para isto. &rimeiro muitas fun%.es da ilioteca padr)o traalham com
seus pr!prios tipos de dados espec>ficos, aos 1uais seu programa de$e ter acesso. (sses
tipos de dados s)o definidos em arquivos de cabealho fornecidos para cada fun%)o.
*m dos e+emplos mais comuns / o ar1ui$o STDIO.H, 1ue fornece o tipo 05'(
necess=rio para as opera%.es com ar1ui$os de disco. A segunda ra9)o para incluir
ar1ui$os de cae%alho / oter os prot!tipos da ilioteca padr)o.
#e os ar1ui$os de cae%alho seguem o padr)o C A4#5, eles tam/m cont8m prot!tipos
completos para as fun%.es relacionadas com o ar1ui$o de cae%alho. 5sso fornece um
m/todo de $erifica%)o mais forte 1ue a1uele anteriormente dispon>$el ao programador
C. 5ncluindo os ar1ui$os de cae%alho 1ue correspondem Es fun%.es padr.es utili9ados
pelo seu programa, $oc8 pode encontrar erros potenciais de inconsist8ncias de tipos.
4a taela aai+o algumas iliotecasS
Ar'ui! de
Ca$e(al)
*inalidades
A##(RT.< Define a macro assert67
CTU&(.< Manipula%)o de caracteres
(RR4D.< Apresenta%)o de erros
0'DAT.< Define $alores em ponto flutuante dependentes da implementa%)o
'5M5T#.< Define limites em ponto flutuante dependentes da implementa%)o
'DCA'(.< #uporta locali9a%)o
MAT<.< Di$ersas defini%.es usadas pela ilioteca de matem=tica
#(TVM&.< #uporta des$ios n)o:locais
#5W4A'.< #uporta manipula%)o de sinais
#TDARW.< #uporta listas de argumentos de comprimento $ari=$el.
#TDD(0.< Define algumas constantes normalmente usadas
#TD5D.< #uporta eQs com ar1ui$os
#TD'5".< Declara%.es miscelXneas
#TR54W.< #uporta fun%.es de string
T5M(.< #uporta as fun%.es de hor=rio do sistema
Dser$e 1ue o nome da ilioteca estar= entre os sinais de menor e maior 6JF7. #e o
nome da ilioteca for delimitado pelos sinais de maior e menor, o compilador C
procurar= o ar1ui$o especificado no sue diret!rio de ar1ui$os de cae%alho. #e o
ar1ui$o for encontrado, ser= utili9ado, se o compilador n)o o encontrar, ele ir= procurar
ent)o no diret!rio atual, ou em um diret!rio 1ue $oc8 especificar.
#e o nome da ilioteca for delimitado por aspas duplas 6BC7, o compilador procurar= o
ar1ui$o no diret!rio atual. #e o nome da ilioteca for delimitado por aspas duplas
significa 1ue esta ilioteca foi criada pelo usu=rio.
+i"s, -ari#!eis e Cnstantes
Os Tipos de Dados
(m C temos , tipos =sicos de dados, de onde todos os outros tipos s)o deri$ados. #)o
elesS
#ipo $escri"o
#aman%o em
&'tes
(ai)a mnima
char caractere 1 :127 a 127
int n-mero inteiro K :327O7 a 327O7
float n-mero em ponto flutuante 6real7 K seis d>gitos de precis)o
doule
n-mero em ponto flutuante de
dupla precis)o
2 de9 d>gitos de precis)o
$oid sem $alor : :
D tamanho em ?tes da cada tipo de dado pode $ariar de acordo com o tipo do
processador, da implementa%)o do compilador, etc. &or e+emplo, em 'inu+ um inteiro
possui K ?tes, en1uanto 1ue no DD# um inteiro possui 2 ?tes. D 1ue o padr)o A4#5
estipula / apenas a fai+a m>nima de cada tipo, n)o o seu tamanho em ?tes.
D tipo void / usado 1uando declaramos fun%.es 1ue n)o retornam nenhum $alor,
1uando 1ueremos declarar e+plicitamente 1ue uma fun%)o n)o possui argumentos, ou
para criar ponteiros gen/ricos.
O que so Variveis?
&ara $oc8 poder manipular dados dos mais di$ersos tipos, / necess=rio poder arma9en=:
los na mem!ria e poder referenci=:los 1uando for preciso. G para isso 1ue e+iste as
vari*veis, 1ue nada mais s)o do 1ue um espa%o reser$ado na mem!ria, e 1ue possuem
um nome para facilitar a refer8ncia. As $ari=$eis podem ser de 1ual1uer tipoS int, char,
float, doule, $oid.
Como o pr!prio nome di9, as $ari=$eis podem ter o seu conte-do alterado durante a
e+ecu%)o do programa, ou se@a, o programador tem a lierdade de atriuir $alores ao
decorrer da e+ecu%)o.
Declarao de Variveis
Todas as $ari=$eis em C de$em ser declaradas antes de serem usadas. A forma geral de
declara%)o de uma $ari=$el / a seguinteS
tipo nomeYdaY$aria$elN
(+emplosS
*ma $ari=$el de cada $e9S

int idN
float au+N
Du $=rias do mesmo tipo em uma -nica linhaS

int id, o@, n, tN
char c1, c2, c3N
Dnde tipo pode ser 1ual1uer tipo $=lido da linguagem C, e nomedavariavel de$e ser
um nome dado pelo programador, sendo o primeiro caractere uma letra e os demais,
letras, n-meros ou BYC.
4*M CARAC
&(#D 5DYD"V
A'*4DY1 A*Z
'emrando 1ue C diferencia MA5R#C*'A# de min-sculas.
4)o s)o nomes $=lidos de $ari=$eisS
14*M :5DAD(
[A*Z 5D\A'
Iniciali!ando Variveis
5niciali9ar significa atriuir um $alor inicial a uma $ari=$el. (m C, podemos iniciali9ar
$ari=$eis na declara%)oS
int n]12N
4este e+emplo, estamos declarando a $ari=$el inteira n e atriuindo o $alor 12 a ela. D
sinal de igual 6]7 em C / o operador de atriui%)o. (le ser$e para colocar o $alor 6do
lado direito7 na $ari=$el 6lado es1uerdo7.
&odemos tam/m iniciali9ar uma $ari=$el no corpo do programa, ap!s sua declara%)oS
int nN
n]12N
&ode:se atriuir tam/m $ari=$eis a $ari=$eisS
num]iN
4este caso, a $ari=$el num est= receendo o $alor da $ari=$el i.
&ara fi+ar melhor, a> $ai um e+emplo de um programa em C contendo $ari=$eisS
Iinclude Jstdio.hF

int main67 L
int 4*M1, 4*M2, 4*M3N
char C<] ^a_N

4*M1] 3N
4*M2] 4*M1N
4*M3] 2``N
printf6B4*M1S ad, 4*M2S ad, 4*M3S adB, 4*M1, 4*M2, 4*M37N
printf6BC<S acB, C<7N
P
"onstantes
Constantes em C s)o $alores fi+os, 1ue n)o mudam durante a e+ecu%)o. (las podem ser
de 1ual1uer tipo =sicoS inteiras, ponto flutuante, caractere
4a maioria dos casos C escolhe o menor tipo de dado poss>$el para tratar uma
constante, com e+ce%)o das constantes em ponto flutuante, 1ue s)o tratadas como
doule, por default.
;e@a um e+emplo de programa com constantesS
Iinclude Jstdio.hF

int main67
L
char ch] ^a_N
int n] 1`N
float f] 1`.KN

printf6Bac ad af B, ch, n, f7N

P
Sada . A *un(/ "rint0
&ara termos acesso E ilioteca 1ue cont/m as fun%.es, macros e $ari=$eis 1ue facilitam
a entrada e sa>da de dados o programa de$e conter a declara%)o.
Iinclude Jstdio.hF
Iinclude Bstdio.hC
A fun%)o printf permite 1ue dados se@am escritos na tela do computador. D formato / ao
mesmo tempo de uso simples e astante fle+>$el, permitindo 1ue os dados possam ser
apresentados de di$ersas maneiras.
A forma geral /S
print# $controle% ar&'% ar&(% ...)*
onde os argumentos s)o impressos de acordo com a maneira indicada pelo controle. *m
e+emplo simples pode tornar a e+plica%)o mais clara.
D programa aai+o 6ano.c7 imprime o $alor da $ari=$el ano.
+include ,stdio.h- ./ 0iblioteca de entrada e sa1da /.
int main$ )2 ./ 3qui comea o pro&rama principal/.
int ano 4 (556* ./ Declarei ano como inteiro e 7 de#ini seu valor. /.

print#$89stamos no ano :d.;% ano)* ./ Imprime o valor do ano /.

<
4a tela do computador ser= impressoS
(stamos no ano 2``7.
D controle, 1ue de$e aparecer sempre entre B B, define como ser)o impressos os
argumentos. 4este controle podem e+istir dois tipos de informa%.esS caracteres comuns
e c!digos de formata%)o. Ds caracteres comuns, como no e+emplo (+stamos no ano)
s)o escritos na tela sem nenhuma modifica%)o. Ds c!digos de formata%)o aparecem
precedidos por um a e s)o aplicados aos argumentos na ordem em 1ue aparecem. De$e
ha$er um c!digo de formata%)o para cada argumento. D c!digo ad indica 1ue o $alor
arma9enado em ano de$e ser impresso na nota%)o inteiro decimal.
C!digos de Con$ers)o
Ds c!digos de con$ers)o s)o os seguintesS
C!digos de Con$ers)o para leitura e entrada de dados.
C,digo Coment*rio
ac Caractere simples
ad 5nteiro decimal com sinal
ai 5nteiro decimal com sinal
a( Real em nota%)o cient>fica com (
ae Real em nota%)o cient>fica com e
af Real em ponto flutuante
aW *se a( ou af, o 1ue for mais curto
ag *se ae ou af, o 1ue for mais curto
ao 5nteiro em ase octal
as Cadeia Caracteres
au 5nteiro decimal sem sinal
a+ 5nteiro em ase he+adecimal 6letras min-sculas7
aZ 5nteiro em ase he+adecimal 6letras mai-sculas7
ap &onteiro
aa 5mprime o caractere a
(ntre o a e o caractere do c!digo podem ser inseridos os seguintes comandosS
-usti.ica"o da sada
*m sinal de menos para especificar 1ue o argumento de$e ser a@ustado E es1uerda no
seu campo de impress)o.
D programa a seguir 6menos.c7 ilustra os dois tipos de @ustifica%)o.
Iinclude Jstdio.hF
int main6 $oid7
L
int ano ] 2``ON

printf6BVustificado para direita Ano ] a2dMnC, ano7N
printf6BVustificado para es1uerda Ano ] a:2dMnC,

ano7N
return `N
P
Tamanho do "ampo
*m n-mero inteiro especificando um tamanho de campo onde o argumento ser=
impresso. 4o e+emplo acima o n-mero especifica 1ue 2 espa%os s)o reser$ados para
imprimir o resultado.
9speci#icador de =reciso
O especi.icador de preciso consiste de um ponto !ue separa o n/mero !ue de.ine
o taman%o do campo do pr,)imo n/mero. +ste pr,)imo n/mero especi.ica o
m*)imo n/mero de caracteres de uma string a ser impresso0 ou o n/mero de
dgitos a serem impressos a direita do ponto em um n/mero do tipo #loat ou double.
4o e+emplo aai+o 6prec.c7 o n-mero calculado / impresso com 3 casas decimais em
um campo de tamanho 9 espa%os.
Iinclude Jstdio.hF
main67
L
float r ] 1.`Q3.`N
printf6BD resultado e ] a9.3f MnC, r7N
P
Ao e+ecutar o e+emplo $erifi1ue 1ue Mn n)o / impresso. A arra inclinada / chamada de
se1u8ncia de escape, indicando 1ue o pr!+imo caractere n)o / para ser impresso, mas
representa caracteres in$is>$eis ou caracteres 1ue n)o est)o representados no teclado,
por e+emplo. Alguns destes caracteres s)oS
C,digo Coment*rio
Mn &assa para uma no$a linha
Mt Taula%)o
M Retorna um caractere
Mf #alta uma p=gina
M` Caractere nulo
M+hh
Caractere representado pelo c!digo A#C55 hh 6hh
em nota%)o he+adecimal7
Mnnn Representa%)o de um ?te em ase octal
Entrada . A *un(/ scan0
A fun%)o scanf pode ser utili9ada para entrada de dados a partir do teclado e seu formato
/S
scan#$controle% ar&'var'% ar&(var(% ...)*
*ma diferen%a fundamental e+iste entre esta fun%)o e a fun%)o printfS
Ds argumentos s)o os endere%os das $ari=$eis 1ue ir)o receer os $alores lidos e
n)o, como em printf, as pr!prias $ari=$eis.
A indica%)o 1ue estamos referenciando um endere%o e n)o a $ari=$el se fa9 pelo
operador b. &or e+emplo, o comandoS
scan#$8:d :d;% >a% >b)N
(spera:se 1ue dois $alores inteiros se@am digitados no teclado. D primeiro arma9enado
na $ari=$el a e o segundo em $1
*sualmente o campo de controle s! cont/m especifica%.es de con$ers)o, 1ue s)o
utili9adas para interpretar os dados 1ue ser)o lidos. 4o entanto outros caracteres podem
aparecer. D campo de controle pode conterS
(specifica%.es de con$ers)o, consistindo do caractere a, um caractere
opcional de supress)o da atriui%)o 6caractere c7, um n-mero opcional para
especificar o tamanho m=+imo do campo, e um caractere de con$ers)oN
(spa%os, caracteres de taula%)o ou line#eeds 6tecla enter7 1ue s)o ignoradosN
Caracteres comuns 6n)o a7 1ue de$em casar com o pr!+imo caractere
diferente de ranco da entrada.
&ara 1ue os $alores digitados se@am separados por $>rgulas, o comando de$eria ser
escrito da seguinte maneiraS
scanf6Bad, afC, bi, b+7N
Dser$ar 1ue de$e ha$er uma correspond8ncia e+ata entre os caracteres n)o rancos do
controle e os caracteres digitados. 4este caso a entrada de$eria serS
3,, KO.3
Lend e Im"rimind Caracteres
?un@es &etchar e putchar
1ara ler e escrever caracteres do teclado0 as .un"2es de entrada e sada mais
simples so &etchar e putchar !ue esto na &i&lioteca stdio.h0 so os seguintes:
int getchar6$oid7N
int putchar6int c7N
Apesar da fun%)o getc)ar retornar um parXmetro inteiro / poss>$el atriuir este $alor a
uma $ari=$el do tipo c)ar por1ue o c!digo do caractere est= arma9enado no ?te de
ordem mais ai+a. D mesmo acontece com a fun%)o "utc)ar 1ue recee um inteiro, mas
somente o ?te de ordem mais ai+a / passado para a tela do computador.
D programa getcha.c aai+o mostra e+emplos de uso destas fun%.es.
Iinclude Jstdio.hF
int main 67
L
char cN
int iN
printf6B(ntre com um caractere entre ` e 9.MnC7N
c ] getchar67N
printf6BD caractere lido foi oS B7N
putchar6c7N
P
?un@es &etch e &etche
4a defini%)o original da fun%)o getchar a entrada / arma9enada at/ 1ue a tecla (4T(R
se@a apertada. Com isto caracteres ficam em um uffer esperando para serem tratados.
(m amientes onde / necess=rio tratar o caractere imediatamente esta fun%)o pode n)o
ser -til.
Muitos compiladores incluem fun%.es para permitir entrada interati$a de dados. As duas
fun%.es mais comuns s)o getch e getche e seus prot!tipos, 1ue podem ser encontrados
em conio.h, s)o os seguintesS
int getch6$oid7N
int getche 6$oid7N
A fun%)o getch espera at/ 1ue uma tecla se@a apertada e retorna este $alor
imediatamente. D caractere lido n)o / ecoado na tela. A fun%)o getche opera da mesma
maneira, mas ecoa o caractere lido.
Lend e Im"rimind Strings
*m string em C / uma cadeia de caracteres. &ara usar strings / preciso primeiro definir
um espa%o para arma9en=:los. &ara isto / preciso declarar o tamanho e o tipo do $etor.
&or e+emploS
char nomedK`eN Qc reser$a um espa%o para arma9enar caracteres. cQ
Tuando definir o tamanho do $etor oser$ar 1ue todo string em C termina com o
caractere null 6^M`_7, 1ue / automaticamente inserido pelo compilador. &ortanto o $etor
nome pode arma9enar no m=+imo 39 caracteres.
Ap!s este passo a $ari=$el nome pode ser usado durante a e+ecu%)o do programa.
Lend e Im"rimind strings cm scan0 e "rint0
D e+emplo stscf.c mostrado aai+o mostra como ler e imprimir um string usando os
comandos scanf e printf respecti$amente.
Idefine D5M K` Qc Defini%.es ConstantescQ
Iinclude Jstdio.hF Qc "ilioteca usada pelo programa cQ
$oid main 6$oid7
L
char nomedD5MeN Qc linha de caracteres lidos do teclado cQ
printf6B&or fa$or, 1ual o seu nome.C7N
scanf6BasC, bnome7N Qc (ntrada de dados do $etor cQ
printf6B(u sou um computador &C, em 1ue posso a@ud=:lo asf MnC, nome7N
P
Caso o nome digitado tenha sido Antonio da #il$a, o programa imprimiria somente o
seguinteS
(u sou um computador &C, em 1ue posso a@ud=:lo Antonio.
D c!digo de con$ers)o para strings / as. Dser$ar 1ue o comando scanf n)o l8 o nome
todo, mas encerra a leitura 1uando encontra um caractere ranco. Mas como ler para um
$etor um nome inteiro, ou um string 1ue contenha rancosf &ara isto de$e:se usar a
fun%)o gets.
Aendo e Imprimindo strin&s com &ets e puts
3 .un"o &ets l4 toda a string at5 !ue a tecla +#+6 se7a teclada0 no vetor o c,digo
da tecla +#+6 no 5 arma8enado0 sendo su&stitudo pelo c,digo null (9:;<). Caso
a .un"o scan# do e)emplo anterior .osse su&stituda pela &ets o programa
imprimiria:
(u sou um computador &C, em 1ue posso a@ud=:lo Antonio da #il$a.
D comando 1ue sustitui o scanf / gets(nome).
D prot!tipo da fun%)o gets / o seguinteS
IincludeJstdio.hF
char cgets 6char cstr7N
A fun%)o puts tem o seguinte prot!tipoS
IincludeJstdio.hF
int puts 6const char cstr7N
(la imprime a string apontada por str. D programa e+emplo stput.c% mostrado aai+o, /
semelhante ao e+emplo anterior com as fun%.es "rint0 sustitu>das por "uts. Dser$e
1ue a impress)o sempre termina passando para a pr!+ima linha.
Idefine D5M K`
Iinclude Jstdio.hF
$oid main 6 7
L
char nomedD5MeN Qc linha de caracteres lidos do teclado cQ
Qc (ntrada de dados do $etor cQ
puts6B(ntre com o seu nome, por fa$or.C7N
gets6 nome7N
puts6BAlo B7N
puts6nome7N
puts6B(u sou um computador &C, em 1ue posso a@ud=:lofC7N
P
O"eradres em C
O O"eradr de Atri$ui(/
D operador de atriui%)o, 6o s>molo de igual B]C7 coloca o $alor de uma e+press)o 6do
lado direito7 em uma $ari=$el 6do lado es1uerdo7. *ma e+press)o neste caso pode ser
um $alor constante, uma $ari=$el ou uma e+press)o matem=tica mesmo.
G um operador in=rio, ou se@a, traalha com dois operandos. (+emplosS
Atriui%)o de uma constante a uma $ari=$elS
n] 1`N
ch] ^a_N
fp] 2.,1N
Atriui%)o do $alor de uma $ari=$el a outra $ari=$elS
n] numN
Atriui%)o do $alor de uma e+press)o a uma $ari=$elS
n] 6,g27QKN
Atriui%.es m-ltiplasS
+ ] ? ] 9 ] 2`N
(m uma atriui%)o, primeiro / processado o lado direito. Depois de processado, ent)o, o
$alor / atriu>do a $ari=$el.
Como $oc8 $iu no -ltimo e+emplo acima, C tam/m permite atriui%.es m-ltiplas
6como + ] ? ] 9 ] 2`N7. 4este caso, todas as $ari=$eis da atriui%)o 6+, ? e 97 receem o
$alor mais E direita 62`7.
Os O"eradres Aritmtics
(stes s)o, de longe, os mais usados. Ds operadores aritm/ticos em C traalham
praticamente da mesma forma 1ue outras linguagens. #)o os operadores = (adi"o)0 -
(su&tra"o)0 > (multiplica"o)0 ? (diviso) e @ (m,dulo ou resto da diviso inteira),
todos esses in=rios 6de dois operandos7. Temos tam/m o - un*rio, 1ue muda o sinal
de uma $ari=$el ou e+press)o para negati$o. ;e@a a taela a seguirS
Operador $escri"o +)emplo
: un=rio 5n$erte o sinal de uma e+press)o :1`, :n, :6,c3g27
c Multiplica%)o 3c,, numci
Q Di$is)o 2QO, nQ62g,7
a M!dulo da di$is)o inteira 6resto7 ,a2, naA
g Adi%)o 2g1`, e+pgnum
: #utra%)o 3:O, n:p
*ma e+press)o deste tipoS
, g 2 c 3 : 2 Q K
G a$aliada assimS primeiro a multiplica%)o 62c37, depois a di$is)o 62QK7. Ds resultados
otidos destas duas opera%.es s)o utili9ados para resol$er as duas -ltimas opera%.esS
, g O h 2
Adi%)o e sutra%)o. 5gual9inho E matem=tica aprendida no prim=rio...
Tudo isso por1ue as opera%.es de multiplica%)o e di$is)o t8m maior preced8ncia e s)o
resol$idos primeiro em uma e+press)o. &ara mudar a ordem de opera%)o, de$em:se usar
par8nteses. De$e:se tomar cuidado ao construir e+press.es, pois a falta de par8nteses
pode causar inconsist8ncia 6erro7 no resultado.
D Dperador @ / e1ui$alente ao mod, e / -til em $=rias situa%.es. (le d= como
resultado o resto da di$is)o inteira de dois operandos. Assim, fica f=cil, por e+emplo,
saer se um n-mero / m-ltiplo de outroS
if 66numa37]]`7 Qc se o resto da di$is)o entre num e 3 for igual a ` ... cQ
printf6BM-ltiplo de 3MnC7N
(ste / apenas um de $=rios prolemas 1ue podem ser resol$idos com o uso do operador
@.
O"eradres Relacinais e Lgics
Ds operadores relacionais e l!gicos s)o usados em testes e compara%.es, principalmente
nos comandos de controle e nos la%os.
&ara entender melhor esses operadores, temos 1ue entender o conceito de verdadeiro e
.also. (m C, verdadeiro 5 !ual!uer valor di.erente de 8ero, e .also 5 8ero. As
e+press.es 1ue usam operadores relacionais e l!gicos retornam ` para falso e 1 para
$erdadeiro.
Ds operadores relacionais s)o OS
Operador 3"o
J Menor 1ue
J] Menor 1ue ou igual
F Maior 1ue
F] Maior 1ue ou igual
]] 5gual
H] Diferente
;e@a um e+emplo do uso de operadores relacionaisS
Iinclude Jstdio.hF
Qc necess=rio para printf e scanf cQ

int main67L
int nN Qc Declara%)o de uma $ari=$el inteira cQ
printf6BDigite um n-meroS B7N
scanf6BadC, bn7N Qc '8 o n-mero e arma9ena na $ari=$el n cQ
if 6n J `7 Qc #e n for M(4DR T*( `... cQ
printf6B4-mero negati$oMnC7NQc ... escre$e isto. cQ
else L Qc #en)o... cQ
printf6B4-mero positi$oMnC7N Qc ... escre$e isto. cQ
P
P
Tente fa9er alguns testes com os outros operadores relacionais. #e@a criati$oH
;oc8 / o programador.
Ds operadores l!gicos s)o 3S
Operador 3"o (ormato da e)presso
bb and 6e l!gico7 p bb 1
ii or 6ou l!gico7 p ii 1
H not 6no l!gico7 Hp
;e@a um e+emplo, s! do loco i#S
if 66n F `7 bb 6n J 1``77 Qc se n for F 1ue ` e n for J 1ue 1`` cQ
printf6B4-mero positi$o menor 1ue 1``MnC7N Qc ...imprime isto cQ
Dutro e+emploS
if 66n ]] `7 ii 6n ]] 177 Qc se n for 5W*A' a ` D* n for igual a 1 ... cQ
printf6B9ero ou umMnC7N Qc ... imprime isto. cQ
Ds par8nteses tam/m podem ser usados para mudar a ordem de a$alia%)o das
e+press.es, como no caso das e+press.es aritm/ticas.
O"eradres de Increment e 2ecrement
A linguagem C possui dois operadores 1ue geralmente n)o s)o encontrados em outras
linguagens, mas 1ue facilita astante a codifica%)oS os operadores de incremento6gg7 e
decremento6::7.
D operador == soma 1 ao seu operando, similar a opera%)o deS
$ari=$el] $ari=$elg1N
mas muito mais resumido.
D operador - - sutrai 1 de seu operando, tam/m similar aS
$ari=$el] $ari=$el:1N
(stes operadores s)o un=rios, e podem ser usados antes da $ari=$elS
ggnN
ou depois da $ari=$elS
nggN
A diferen%a / 1ue, se o operador precede o operando 6ggn7, o incremento ou
decremento / reali9ado antes do $alor da $ari=$el ser usado. ( se o operador $em depois
do operando 6ngg7, o $alor da $ari=$el poder= ser usado antes de acontecer E opera%)o
de incremento ou decremento. ;e@a estes dois e+emplosS

(+emplo 1S
n] ,N
p] ggnN
printf6Bad B,p7N Qc imprime na telaS O cQ
(+emplo 2S
n] ,N
p] nggN
printf6Bad B,p7N Qc imprime na telaS , cQ
4o e+emplo 1, a $ari=$el n / incrementada de 1 A4T(# de seu $alor ser atriu>do a p.
4o e+emplo 2, o $alor de n / atriu>do a p antes de acontecer E opera%)o de incremento.
(ssa / a diferen%a de se colocar esses operadores antes ou depois da $ari=$el.
O"eradres Aritmtics de Atri$ui(/
Algumas opera%.es de atriui%)o podem ser feitas de forma resumida. &or e+emplo, a
atriui%)oS
+] +g1`N
pode ser escritaS
+g]1`N
A forma geral desse tipo de atriui%)o /S
$ari=$el doperadore] de+press)oeN
1ue / igual aS

$ari=$el] $ari=$el doperadore de+press)oe
;e@a essa taela com e+emplosS
(orma longa (orma resumida
+] +g1` +g]1`
+] +:1` +:]1`
+] +c1` +c]1`
+] +Q1` +Q]1`
+] +a1` +a]1`
#e familiari9e com essa nota%)o, pois / um estilo largamente adotado pelos
profissionais 1ue traalham com C.
Estruturas de 2ecis/
Ds comandos para tomadas de decis)o em C s)oS if, if ... else, sjitch e o operador
tern=rio 6f7.
O cmand i0
D comando if, presente na maioria das linguagens de programa%)o, / usado para a
constru%)o de estruturas de decis)o simples. A forma geral do comando / assimS
if 6e+press)o condicional7
L
comandosN
P

D*

if 6e+press)o condicional7
comando -nicoN
D comando if a$alia a e+press)o condicional entre par8nteses. #e esta e+press)o for
$erdadeira, o6s7 comando6s7 do loco de c!digo ser=6)o7 e+ecutado6s7. #e for falsa, o
loco de c!digo do if n)o ser= e+ecutado, isto /, o programa Bpassa atidoC.
&ara comandos if com apenas *M comando, n)o / necess=rio delimitar o loco de
c!digo com cha$es 6BLPC7. D compilador sae 1ue 1uando n)o e+istem as cha$es
na1uele if, somente *M comando far= parte do loco de c!digo.
Agora, $amos $er alguns e+emplosS

if 6a F 7 Qc se o a for maior do 1ue o ... cQ
printf6Ba / maior 1ue C7N Qc ... imprime mensagem cQ


if 66num a 27 ]] `7 Qc se o resto da di$is)o entre num e 2 for ` ... cQ
L
printf6B4-mero parC7N Qc ... fa%a isso cQ
printf6BMnMnC7N
P
G interessante sempre manter o c!digo identado, com taula%.es, para ficar claro de
1ual loco de c!digo / determinado comando.
O cmand i0 111 else
(sta constru%)o possui duas partesS um comando i0, cu@o loco de c!digo ser=
e+ecutado se a e+press)o condicional for verdadeiraN e um comando else, 1ue ser=
e+ecutado caso a mesma e+press)o se@a #alsa.
&ortanto, agora temos uma Bifurca%)oC, e o caminho 1ue o programa trilhar= $ai
depender do resultado da e+press)o condicional 6$erdadeiro ou falso7.
0orma geralS
if 6e+press)o condicional7
L
comandosN
P
else L
comandosN P
#e os locos de c!digo ti$erem mais 1ue um comando, de$e:se delimit=:los com are e
fecha cha$es. ;e@am alguns e+emplosS

if 66num a 27 ]] `7 Qc #e o resto da di$is)o entre num e 2 for `... cQ
printf6B4-mero par.C7N Qc ...imprime mensagem Bn-mero parC. cQ
else L Qc ... #en)o... cQ
printf6B4-mero >mpar.C7N Qc ... imprime mensagem Bn-mero >mparC. cQ
P
4este e+emplo, se num a 2 for igual E 9ero 6se esta e+press)o for $erdadeira7, e+ecuta o
primeiro printf67. Caso contr=rio 6se for falsa7, e+ecuta o segundo printf67.
Dentro de um loco de c!digo, pode aparecer 1ual1uer comando, at/ mesmo if_s e else.
;oc8 pode at/ criar constru%.es para decis.es m-ltiplas, criando uma esp/cie de escada
de if_s e else.
O Cmand s3itc)
D comando sjitch / usado como alternati$a E escada de if_s e elseks, e torna o c!digo
mais elegante e leg>$el. 0orma geralS
sjitch 6e+press)o constante7
L
case constante1S comandosN
reaAN
case constante2S comandosN
reaAN l
case constante3S comandosN
reaAN
case constanteKS comandosN
reaAN
defaultS comandosN
P
(ste comando possui algumas restri%.es. Como a e+press)o / constante, ele s! aceita
$alores inteirs e caracteres1 Como e+press)o condicional, s! s)o aceitas igualdades
6se a constante1 for igual E e+press)o constante, e+ecuta comandosN e assim por diante7.
&ara cada case e+iste um con@unto de comandos 1ue s! ser)o e+ecutados caso a
condi%)o se@a $erdadeira. #e a e+press)o constante n)o casar com nenhum case, ent)o
os comandos do loco de0ault s)o e+ecutados. D loco de c!digo dos case 4mD
&R(C5#AM ser delimitados com cha$esN asta coloc=:los, um ap!s o outro, ap!s o
r!tulo caseS
;amos $er um e+emplo para poder BclarearCS
Iinclude Jstdio.hF
int main67
L
float n1, n2N
char opN

printf6Bccc Calculadora cccMnC7N
printf6BDigite um n-meroS B7N
scanf6BafC, bn17N

printf6BDigite o operador 6g : c Q7S B7N
scanf6BacC, bop7N

printf6BDigite outro n-meroS B7N
scanf6BafC, bn27N

sjitch6op7 Qce+press)o constanteS $ari=$el op 6caractere7 cQ
L
case ^g_S
printf6BAdi%)oS a.2fMnC, n1gn27N
reaAN
case ^:_S
printf6B#utra%)oS a.2fMnC, n1:n27N
reaAN
case ^c_S
printf6BMultiplica%)oS a.2fMnC, n1cn27N
reaAN
case ^Q_S
if 6n2 ]] `7
L
printf6B(rroS imposs>$el di$idir por 9eroHMnC7N
return 1N
Pelse L
printf6BDi$is)oS a.2fMnC, n1Qn27N
P
reaAN
defaultS
printf6BDperador in$=lidoS acMnC, op7N
reaAN
P

P
*m e+emplo do s3itc) na pr=tica. (m cada case, temos o6s7 comando6s7 e, em seguida,
um comando $rea4. D comando $rea4, 1uando encontrado, fa9 a e+ecu%)o sair
imediatamente do s3itc). #e usado em loop_s, fa9 a e+ecu%)o do programa parar o loop
e continuar a e+ecu%)o do restante do c!digo ap!s o loop.
5magina se, no lugar do s3itc), ti$/ssemos 1ue montar uma escada de i05s e else5s...
0icaria mais ou menos assimS

if 6op]]_g_7
printf6BAdi%)oS a.2fMnC, n1gn27N
else if 6op]]_:_7
printf6B#utra%)oS a.2fMnC, n1:n27N
else if 6op]]_c_7
printf6BMultiplica%)oS a.2fMnC, n1cn27N
else if 6op]]_Q_7L
if 6n1]]`7
printf6B(rroS imposs>$el di$idir por 9eroHMnC7N
else printf6BDi$is)oS a.2fMnC, n1Qn27N
P else printf6BDperador in$=lidoS acMnC, op7N
*sando o s3itc), neste e+emplo, temos 2, linhas de c!digo, en1uanto 1ue usando a
constru%)o de i05s e else5s temos 11 linhas.
D s3itc) / astante usado em menus, 1uando o usu=rio tem 1ue digitar o n-mero ou a
letra de alguma op%)o.
Estruturas de Re"eti(/
#uponhamos 1ue $oc8 1ueira fa9er um programa 1ue l8 1`` n-meros do teclado e para
cada n-mero $erifi1ue se / m-ltiplo de 3, imprimindo a resposta para cada um.
Como $oc8 escre$eria este programaf #eria assimf
Iinclude Jstdio.hF
main67L
int numN

printf6BDigite um n-meroS B7N
scanf6BadC, bnum7N

if 66num a37 ]] `7
printf6B/ m-ltiplo de 3MnC7N
else printf6Bn)o / m-ltiplo de 3MnC7N

printf6BDigite um n-meroS B7N
scanf6BadC, bnum7N

if 66num a37 ]] `7
printf6B/ m-ltiplo de 3MnC7N
else printf6Bn)o / m-ltiplo de 3MnC7N

printf6BDigite um n-meroS B7N
scanf6BadC, bnum7N

if 66num a37 ]] `7
printf6B/ m-ltiplo de 3MnC7N
else printf6Bn)o / m-ltiplo de 3MnC7N

printf6BDigite um n-meroS B7N
scanf6BadC, bnum7N

if 66num a37 ]] `7
printf6B/ m-ltiplo de 3MnC7N
else printf6Bn)o / m-ltiplo de 3MnC7N

printf6BDigite um n-meroS B7N
scanf6BadC, bnum7N

if 66num a37 ]] `7
printf6B/ m-ltiplo de 3MnC7N
else printf6Bn)o / m-ltiplo de 3MnC7N
.
.
.
etc .....................
P
Como $oc8 pode $er, n)o / uma t/cnica nada $i=$el, pois temos 1ue repetir a mesma
se1u8ncia de comandos $=rias $e9es. Mas n)o se desespere o C, assim como outras
linguagens, tem $=rios comandos 1ue nos a@udam em tarefas repetiti$as, como esta.
(stes comandos s)o conhecidos como estruturas de repetio ou laos de repetio.
;eremos tam/m algumas t/cnicas =sicas 1ue nos a@udar)o a criar programas
iterati$os.

O la( 0r
D la%o 0r / uma estrutura de repeti%)o controlada por $ari=$el, onde de$emos saer de
antem)o a 1uantidade de itera%.es. D la%o 0r tem a seguinte forma geralS

for 6 iniciali9a%)o N teste condicional N incremento ou decremento 7
L
comandosN
P

D*

for 6 iniciali9a%)o N teste condicional N incremento ou decremento 7
comando -nicoN
;e@a este e+emploS
Iinclude Jstdio.hF
main67
L
int i, numN

for 6i]`N iJ1``N igg7
L
printf6BDigite um n-meroS B7N
scanf6BadC, bnum7N

if 66num a37 ]] `7
printf6B/ m-ltiplo de 3MnC7N
else
printf6Bn)o / m-ltiplo de 3MnC7N
P
P
;e@a s! o nosso e+emplo re$isitado, com o uso de 0r.
Como $oc8 pode $er, o la%o 0r cont/m 3 e+press.es entre par8nteses, 1ue controlar)o o
modo 1ue o nosso la%o traalhar=S
4a e+press)o iniciali9a%)o, atriu>mos $alor inicial E $ari=$el de controle. 4o e+emplo
acima, iniciali!amos i com 5.
(m teste condicional, temos uma e+press)o relacionalQl!gica 1ue definir= o crit/rio de
parada do nosso la%o. 4o nosso QQDetector de mBltiplos de CQQ, o la%o ficar= repetindo o
loco de comandos en'uant a !ari#!el i 0r menr 'ue 677. Tuando i ti$er o $alor
677, o la%o n)o e+ecutar= mais os comandos do loco de comandos, e o programa
continuar= sua e+ecu%)o 6no nosso caso, e+ecutar= return78 e depois terminar=7.
A e+press)o increment ou decrement de$e di9er para o la%o 0r como a $ari=$el $ai
BandarC, se / de 1 em 1, de 2 em 2, de 1` em 1`, etc. 4o nosso programa acima, a
e+press)o i99 fa9 a $ari=$el i ser incrementada de 1 em 1.
Trocando em mi-dos, no la%o 0r do nosso programa, a $ari=$el i ser= iniciali9ada com
1, andar= de 1 em 1, e 1uando chegar a 1`` sair= do la%o.
?leDibilidade do lao #or
As 3 e+press.es do la%o podem conter $=rias instru%.es separadas por $>rgula. ;amos
$er um e+emploS
Iinclude Jstdio.hF
main67
L
int i, @, numN

for 6i]`, @]`N ig@ J1``N igg, @gg7
printf6BadMnC, ig@7N
return `N
P
;e@a 1ue na iniciali9a%)o, temos duas $ari=$eis sendo atriu>das com `S i e :, separadas
por $>rgula. 4a parte de incremento, i e : s)o incrementadas com 1, tam/m separadas
por $>rgula. 5sto torna o la%o 0r astante fle+>$el, onde o limite / a sua criati$idade.
Mas cuidado para n)o construir la%os 0r monstros, com e+press.es enormes e de dif>cil
compreens)o...
Al/m disso, podemos omitir 1ual1uer uma das e+press.es do la%o 0r. &or e+emploS
for 6 N iJ1``N igg7
L
comandosN
P
4esse caso, n)o ha$er= a iniciali9a%)o.
Dutro e+emploS
for 6i]`N iJ1``N 7
L
comandosN
P
A1ui, n)o h= o incremento. (le pode ser feito dentro do loco de c!digo do la%o.
(m alguns casos, podemos usar o la%o 0r como um la%o infinito. ;e@a comoS
for 6 N N 7
L
comandosN
P
(ste / um la%o 0r infinito. #ua e+ecu%)o nunca terminar=, a menos 1ue ha@a um return
ou um $rea4 dentro dele.
O la( 3)ile
D la%o 3)ile / uma estrutura de repeti%)o 1ue s! repetir= o loco de c!digo se a
condi%)o, entre par8nteses, for $erdadeira. (sta condi%)o pode ser 1ual1uer e+press)o,
onde #also E 5 e verdadeiro E di#erente de 5. #e a condi%)o for falsa logo no in>cio do
3)ile, o la%o n)o ser= e+ecutado.
0orma geralS

jhile 6condi%)o7
L
comandosN
P

D*
jhile 6condi%)o7
comando -nicoN
Tuando o programa chega ao 3)ile, ele $erifica a condi%)o entre par8nteses. #e for
$erdadeira, ele e+ecuta o loco de c!digos. Tuando termina de e+ecutar os comandos
do loco de c!digo, ele $olta para o 3)ile no$amente, testa a condi%)o de no$o e, se for
$erdadeira, e+ecuta o loco de c!digo no$amente. 0a9 isso at/ a condi%)o entre
par8nteses ser falsa, momento em 1ue o programa continua a e+ecu%)o normalmente,
depois do 3)ile.
;amos $er alguns e+emplosS
Iinclude Jstdio.hF
Iinclude Jct?pe.hF
main67
L
int cont]`, i] `N
char chN
jhile 6i J 1`7
L
printf6BDigite um caractereS B7N
scanf6BacC, bch7N
getchar67N
if 6isdigit6ch77
L
contggN
iggN
P
P
printf6B;oc8 digitou ad caracteres num/ricosMnC, cont7N
return `N
P
A1ui, o programa utili9a a fun%)o isdigit;<, presente no ar1ui$o de cae%alho ctFpe.h. D
ctFpe.h cont/m fun%.es para teste e con$ers)o de caracteres.
4este programa, o 3)ile e+ecutar= 1` $e9es, s! terminando 1uando i chegar ao $alor
1`. A1ui $emos uma t/cnica 1ue usamos muito em $=rias aplica%.esS um contador. A
$ari=$el cnt / iniciali9ada com 9eroN 1uando, dentro do 3)ile, o cara digitar um
caractere num/rico, esta $ari=$el / incrementada de 1. Ao final da e+ecu%)o, ela ter= o
n-mero e+ato de caracteres num/ricos 1ue foram digitados.
Dutro e+emploS
Iinclude Jstdio.hF
int main67
L
int i]`, num, res] `N
jhile 6i J ,7
L
printf6BDigite um n-meroS B7N
scanf6BadC, bnum7N
res] resgnumN
iggN
P
printf6B#omat!riaS adMnC, res7N
return `N
P
4este, outra t/cnica astante utili9adaS a somat!ria de um con@unto de n-meros.
0unciona assimS ao entrar no 3)ile, o cara digita um n-mero, 1ue ser= arma9enado na
$ari=$el num. (sse n-mero / somado com o $alor da $ari=$el res 61ue na primeira
itera%)o / `7 e arma9enado em res. 4a pr!+ima itera%)o, o $alor da $ari=$el res 6a soma
da itera%)o passada7 / somada com num e arma9enada em res no$amente, assim
sucessi$amente at/ acaar o la%o. Ao final do la%o, o 1ue temos em res / a somat!ria de
todos os n-meros digitados.
Mais uma t/cnicaS imagine 1ue $oc8 1ueira somar os n-meros digitados at/ 1ue se@a
digitado um n-mero maior 1ue 1``. ;oc8 pode criar uma $ari=$el 1ue muda de $alor
1uando essa condi%)o for satisfeita. G o 1ue chamamos de 0lag. (+emploS
int numN
int flag] `N
jhile 6flag ]] `7
L
printf6BDigite um n-meroS B7N
scanf6BadC, bnum7N
getchar67N
if 6num F 1``7
flag] 1N Qc flag muda de $alor 6indica 1ue loop de$e parar7 cQ
P
'emrando 1ue estas t/cnicas podem ser e+ploradas em 1ual1uer tipo de la%o, desde
1ue se@am adaptadas para cada situa%)o.
Assim como 0r, podemos fa9er um la%o infinito com o 3)ile tam/m. "asta fa9er o
seguinteS
jhile617 => 6 !erdadeir em C >=
L
comandosN
P
G claro 1ue em comandos de$e ha$er alguma forma de sair do 3)ile, como um $rea4,
um return, um e?it;<, etc.
D"#S ($ite usar comandos como $rea4 ou e?it;< dentro de la%os, pois / uma pr=tica
pouco elegante. #! use 1uando n)o hou$er outro @eito.
O la( d.3)ile
Diferente do jhile, 1ue testa a condi%)o antes de e+ecutar o seu loco de c!digo, o do:
jhile primeiro e+ecuta o seu loco de c!digo para depois testar a condi%)o. (le / -til
1uando temos 1ue e+ecutar no m>nimo *MA ;(n o loco de c!digo do la%o.
0orma geralS
do
L
comandosN
P jhile6condi%)o7N
4o caso de ha$er um comando -nico, n)o / necess=rio delimitar com cha$es, mas /
recomend=$el, para n)o ha$er confus)o e para dei+ar o c!digo mais leg>$el.
;amos para os e+emplosS
Iinclude Jstdio.hF
main67
L
int numN
do
L
printf6BMnMnDigite um numeroS C7N
scanf6BadC, bnum7N
getchar67N
P jhile 6 num J ,` 7N
return `N
P
4este programa, 1ue n)o fa9 nada de -til, o loco de c!digo de$e ser e+ecutado pelo
menos uma $e9, @= 1ue dependemos do $alor da $ari=$el num para processar a condi%)o,
no final do la%o. A1ui, o programa s! sai do la%o 1uando for digitado algum n-mero
maior ou igual a ,`.
Agora um e+emplo mais pr=ticoS
Iinclude Jstdio.hF
main67
L
int optN

do
L
do
L
printf6Bcccc Menu ccccMnC7N
printf6B17 CadastrarMnC7N
printf6B27 "uscarMnC7N
printf6B37 (+iir Relat!rioMnC7N
printf6BK7 #airMnC7N
printf6BDigite sua op%)oS B7N
scanf6BadC, bopt7N
getchar67N
P jhile 66opt J 17 ii 6opt F K77NQc o cara fica preso at/ digitar um n-mero $=lido
cQ
sjitch6opt7
L
case 1S cadastra67N
reaAN
case 2S usca67N
reaAN
case 3S relat67N
reaAN
P
P jhile 6opt H] K7N Qc la%o principal, s! sai 1uando opt for igual a K cQ
return `N
P
Como $oc8 pode $er, temos dois do:jhile. D mais e+terno e principal fica $igiando se o
cara digitou K 6se 1uer sair7. Caso contr=rio, $olta e e+ecuta tudo no$amente.
D la%o mais interno / uma t/cnica usada 1uando o usu=rio tem um menu, e tem 1ue
digitar uma op%)o para definir para 1ue lado o programa $ai. 4o nosso caso, se o
espertinho do usu=rio digitar algum n-mero maior 1ue K ou menor 1ue 1 6in$=lidos7, o
la%o $olta e @oga tudo de no$o na tela, esperando o esperto do usu=rio escolher a op%)o
certa.
As fun%.es cadastra67, usca67 e relat67 s)o fict>cias e s! ser$iram para ilustrar a
situa%)o.
La(s anin)ads
'a%os aninhados n)o s)o la%os dentro de ninhos. #)o la%os dentro de la%os.
(+emplo de la%os for aninhadosS
for 6 i ] 1 Ni J] 1`N igg 7
L
for 6 @ ] 1 N @ J] 1` N @gg 7
L
printf6Bad Z ad ] adMnC, i, @, ic@7N
P
printf6BMnMnC7N
ch] getchar67N
P
;e@am 1ue poderS com apenas 9 linhas imprimimos as tauadas de 1 a 1`HH
(+emplo de la%os jhile aninhadosS
jhile 6 i J] 1` 7
L
jhile 6 @ J] 1` 7
L
printf6Bad + ad ] adMnC, i, @, ic@7N
@ggN
P
printf6BMnMnC7N
ch] getchar67N
iggN
P
D mesmo e+emplo das tauadas usando jhile.
A l!gica dos la%os aninhados / a seguinteS
o D la%o mais e+terno entra em e+ecu%)oN
o #)o e+ecutados os comandos do loco at/ 1ue o programa encontra o la%o mais
internoN
o D la%o mais interno tam/m entra em e+ecu%)oN
o Agora o la%o mais interno far= todas as itera%.es poss>$eis, at/ acaarN
o Acaando a e+ecu%)o do la%o mais interno, o la%o mais e+terno continua
e+ecutando seu loco de c!digoN
o Tuando o -ltimo c!digo do loco de c!digo / e+ecutado, o la%o mais e+terno
$olta, testa e entra em e+ecu%)o no$amente6se a condi%)o for satisfeita7N
o A> encontra o la%o mais interno no$amente, 1ue entra em e+ecu%)o at/ terminarN
o ( assim $ai, at/ a condi%)o de parada do la%o mais e+terno ser satisfeita 6the
end7.
&odemos ter $=rios la%os aninhados, n)o somente 2. &odemos tam/m ter la%os for
dentro de jhile ou do:jhile, e etc... #! tem uma coisaS 1uanto mais la%os aninhados,
mais lento ser= seu programa.
+)trado do AaterialS M`O h 5ntrodu%)o a &rograma%)o, 2``7, #5Mo(#, #.N
0D4#(CA, #. C. C.N M5CRD45, A. D. '.N M5CRD45, V. #. CN RDDD;A'<D, R. #.