Você está na página 1de 165

Centro Tecnolgico de Mecatrnica

Fundamentos de
Linguagem C
ou
Tudo que voce precisa saber sobre C para no passar vergonha!
Caxias do Sul, novembro de 1997
Conselho Regional do SENAI - RS
Presidente
Dagoberto ima !odo"
Conselheiros
#itulares Su$lentes
Deomedes Ro%ue #alini &ala"r '(lio )osia*+
Enio ,*io S*heln &aldomiro -o*hese da Cunha
Astor .ilton S*hmitt /os( Carlos Cerveri
Diretoria SENAI - SR
Diretor Regional
/os( 0ort(a
Diretor Tcnico
1aulo 2ernando 1resser
Diretor Administrativo e Financeiro
Adalberto ui3 enhard
4
A$resenta56o
7 texto %ue segue ( um resumo dos to$i*os 8undamentais sobre a linguagem C9
C ( uma linguagem $oderosa, robusta, 8lexivel e madura9 Conhe*er todos os seus detalhes,
tru%ues e armadilhas re%uer um estudo *riterioso e $ro8undo9 .as o C ( uma linguagem de sintaxe
sim$les e elegante %ue $ermite ra$ido entendimento $elo $rogramador ini*iante9 Desde sua *ria*ao, o C
tornou-se uma linguagem $o$ular tanto entre $rogramadoere $ro8issionais %uanto ini*iantes9
Neste *ontexto, $ro*uramos abordar os to$i*os essen*iais da linguagem %ue nos $ermite es*rever
um $rograma *om$leto e util9
Es$eramos ter al*an5ados os ob:etivos $ro$ostos, e em $r;ximas edi5<es, a$rimora-las9
Adalberto A9 Dornelles 29

=

>
19 2undamentos da inguagem C
Neste *a$itulo ser6o vistos os 8undamentos da linguagem C9 7 *on*eito de linguagem de
$rograma56o, linguagens de alto e baixo n?vel, linguagens gen(ri*as e es$e*i8i*as9 Ser@ visto um $ou*o
do hist;ri*o da *ria56o da linguagem e a des*ri56o das *ara*ter?sti*as mais im$ortantes da linguagem C9
2inalmente, ser@ visto o as$e*to geral de um *;digo 8onte es*rito em C9
1.1 Linguagens de Programao
Am programa de *om$utador ( um *on:unto instrues %ue re$resentam um algoritmo $ara a
resolu56o de algum $roblema9 Estas instru5<es s6o escritas atrav(s de um *on:unto de cdigos Bs?mbolos
e $alavrasC9 Este *on:unto de *;digos $ossui regras de estrutura56o l;gi*a e sint@ti*a $r;$ria9 Di3emos
%ue este *on:unto de s?mbolos e regras 8ormam uma linguagem de programao9
1.1.1 Eem!los de c"digos.
Existem muitas linguagens de $rograma56o9 1odemos es*rever um algoritmo $ara resolu56o de
um $roblema $or interm(dio de %ual%uer linguagem9 A seguir mostramos alguns exem$los de tre*hos de
*;digos es*ritos em algumas linguagens de $rograma56o9

Eem!loD tre*ho de um algoritmo es*rito em Pseudo#linguagem %ue re*ebe um n,mero num e
es*reve a tabuada de 1 a 1E $ara este valorD
leia num
para n de 1 at 10 passo 1 faa
tab num * n
imprime tab
fim faa
Eem!loD tre*ho do mesmo $rograma es*rito em linguagem CD
scanf(&num);
F
for(n = 1; n <= 10; n++){
tab = num * n;
printf(\n %d, tab);
};
Eem!loD tre*ho do mesmo $rograma es*rito em linguagem $asicD
10 input num
20 for n = 1 to 10 step 1
30 let tab = num * n
40 print chr$ (tab)
50 next n
Eem!loD tre*ho do mesmo $rograma es*rito em linguagem FortranD
read (num);
do 1 n = 1:10
tab = num * n
write(tab)
10 continue
Eem!loD tre*ho do mesmo $rograma es*rito em linguagem Assem%l& $ara IN#E GEGGD
MOV CX,0
IN AX,PORTA
MOV DX,AX
LABEL:
INC CX
MOV AX,DX
MUL CX
OUT AX, PORTA
CMP CX,10
JNE LABEL
1.1.' Linguagens de %aio e alto n(vel.
H
1odemos dividir, generi*amente, as linguagens de $rograma56o em dois grandes gru$osD as
linguagens de baixo nvel e as de alto nvelD
Linguagens de %aio n(vel) S6o linguagens voltadas $ara a m@%uina, isto (, s6o es*ritas usando
as instru5<es do mi*ro$ro*essador do *om$utador9 S6o generi*amente *hamadas de linguagens Assembly9
VantagensD 1rogramas s6o exe*utados *om maior velocidade de $ro*essamento9 7s $rogramas
o*u$am menos espao na mem;ria9
DesvantagensD Em geral, $rogramas em Assembl" tem $ou*a portabilidade, isto (, um *;digo
gerado $ara um ti$o de $ro*essador n6o serve $ara outro9 C;digos Assembl" n6o s6o estruturados,
tornando a programao mais di8?*il9
Linguagens de alto n(vel) S6o linguagens voltadas $ara o ser humano9 Em geral utili3am sintaxe
estruturada tornando seu *;digo mais leg?vel9 Ne*essitam de compiladores ou interpretadores $ara gerar
instru5<es do mi*ro$ro*essador9 Inter$retadores 8a3em a inter$reta56o de cada instru56o do $rograma
8onte exe*utando-a dentro de um ambiente de $rograma56o, $asic e AutoL*+P $or exem$lo9
Com$iladores 8a3em a tradu56o de todas as instru5<es do $rograma 8onte gerando um $rograma
exe*ut@vel9 Estes $rogramas exe*ut@veis B*.exeC $odem ser exe*utados 8ora dos ambientes de
$rograma56o, C e Pascal $or exem$lo9 As linguagens de alto n?vel $odem se distinguir %uanto a sua
a$li*a56o em genricas *omo C, Pascal e $asic ou especficas *omo Fortran B*@l*ulo matem@ti*oC,
,P++ Bsimula56oC, L*+P BinteligIn*ia arti8i*ialC ou CL*PPER Bban*o de dadosC9
Vantagens: 1or serem *om$iladas ou inter$retadas, tem maior portabilidade $odendo ser
exe*utados em varias $lata8ormas *om $ou%u?ssimas modi8i*a5<es9 Em geral, a $rograma56o torna-se
mais 8@*il $or *ausa do maior ou menor grau de estrutura56o de suas linguagens9
Desvantagens: Em geral, as rotinas geradas Bem linguagem de ma%uinaC s6o mais gen(ri*as e
$ortanto mais *om$lexas e $or isso s6o mais lentas e o*u$am mais mem;ria9
1.' Linguagem C
7
A linguagem C ( uma linguagem de alto nvel genrica! 2oi desenvolvida por $rogramadores
para $rogramadores tendo *omo meta *ara*ter?sti*as de 8lexibilidade e $ortabilidade9 7 C ( uma
linguagem %ue nas*eu :untamente *om o advento da teoria de linguagem estruturada e do computador
pessoal9 Assim tornou-se ra$idamente uma linguagem J$o$ularK entre os $rogramadores9 7 C 8oi usado
$ara desenvolver o sistema o$era*ional -.*/, e ho:e esta sendo usada $ara desenvolver novas
linguagens, entre elas a linguagem C00 e 1ava9
1.'.1 Caracter(sticas do C
Entre as $rin*i$ais *ara*ter?sti*as do C, $odemos *itarD
H9> 7 C ( uma linguagem de alto n?vel *om uma sintaxe bastante estruturada e 8lex?vel tornando sua
$rograma56o bastante sim$li8i*ada9
H9F 1rogramas em C s6o *om$ilados, gerando $rogramas exe*ut@veis9
H9H 7 C *om$artilha re*ursos tanto de alto %uanto de baixo n?vel, $ois $ermite a*esso e $rograma56o
direta do mi*ro$ro*essador9 Com isto, rotinas *u:a de$endIn*ia do tem$o ( *r?ti*a, $odem ser
8a*ilmente im$lementadas usando instru5<es em Assembl"9 1or esta ra36o o C ( a linguagem
$re8erida dos $rogramadores de a$li*ativos9
H97 7 C ( uma linguagem estruturalmente sim$les e de grande $ortabilidade9 7 *om$ilador C gera
*;digos mais enxutos e velo3es do %ue muitas outras linguagens9
H9G Embora estruturalmente sim$les B$ou*as 8un5<es intr?nse*asC o C n6o $erde 8un*ionalidade $ois
$ermite a in*lus6o de uma 8arta %uantidade de rotinas do usu@rio9 7s 8abri*antes de *om$iladores
8orne*em uma am$la variedade de rotinas $r(-*om$iladas em bibliote*as9
1.'.' 2ist"rico
1345) Denis "itc#ie desenha uma linguagem a $artir do $CPL nos laborat;rios da $ell %elep#ones &nc9
Chama a linguagem de $9
1346) $rian 'erning#am :unta-se a "itc#ie $ara a$rimorar a linguagem9 A nova vers6o *hama-se C9
1elas suas *ara*ter?sti*as de $ortabilidade e estrutura56o :@ se torna $o$ular entre os
$rogramadores9
71365) A linguagem ( $adroni3ada $elo American (ational )tandard &nstituteD surge o A.+* C9
L1335) A $orland &nternational *o, 8abri*ante de *om$iladores $ro8issionais es*olhe o C e o Pascal
*omo linguagens de trabalho $ara o seu &ntegrated Development +nviroment BAmbiente Integrado
de DesenvolvimentoCD surge o Tur%o C9
G
7133') 7 C se torna $onto de *on*ordMn*ia entre te;ri*os do desenvolvimento da teoria de ,b-ect
,riented .rogramming B$rograma56o orientada a ob:etosCD surge o C009
1.8 Estrutura de um !rograma em C
Am $rograma em C ( *onstitu?do deD
H99 um *abe5alho *ontendo as diretivas de com!ilador onde se de8inem o valor de *onstantes
simb;li*as, de*lara56o de vari@veis, in*lus6o de bibliote*as, de*lara56o de rotinas, et*9
H91E um blo*o de instru5<es !rinci!al e outros blo*os de rotinas9
H911 do*umenta56o do $rogramaD *oment@rios9
Programa Eem!lo) 7 ar%uivo e0101.cpp *ont(m um $rograma $ara *al*ular a rai3
%uadrada de um n,mero real $ositivoD
1.8.1 Con9unto de caracteres
Am $rograma 8onte em C ( um teto no :ormatado es*rito em um editor de textos usando um o
*on:unto $adr6o de *ara*teres ASCII9 A seguir est6o os *ara*teres utili3ados em CD
Caracteres v;lidos)
a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
1 2 3 4 5 6 7 8 9 0
+ - * / \ = | & ! ? # % ( ) { } [ ] _ ` . , : < >
Caracteres no v;lidos)
@ $
7s *ara*teres a*ima s6o v@lidos a$enas em strings9 <e9a seo '.1.=.
1.8.' Coment;rios
9
Em C, *oment@rios $odem ser es*ritos em %ual%uer lugar do texto $ara 8a*ilitar a inter$reta56o do
algoritmo9 1ara %ue o *oment@rio se:a identi8i*ado *omo tal, ele deve ter um /* antes e um */ de$ois9
7bserve %ue no exem$lo e0101.cpp todo o *abe5alho esta dentro de um *oment@rio9
Eem!lo)
/* esta e uma linha de comentrio em C */
>%servao) 7 CNN $ermite %ue *oment@rios se:am es*ritos de outra 8ormaD *olo*ando um //
em uma linha, o *om$ilador entender@ %ue tudo %ue estiver a direita do s?mbolo ( um *oment@rio9
7bserve no $rograma exem$lo e0101.cpp as linhas de *oment@rios *olo*adas a direita dos *omandos9
Eem!lo)
// este e um comentrio valido apenas em C++
1.8.8 Diretivas de Com!ilao
Em C, existem *omandos %ue s6o $ro*essados durante a com!ilao do $rograma9 Estes
*omandos s6o generi*amente *hamados de diretivas de compilao9 Estes *omandos in8ormam ao
*om$ilador do C basi*amente %uais s6o as constantes sim%"licas usadas no $rograma e %uais %i%liotecas
devem ser anexadas ao $rograma exe*ut@vel9 A diretiva #include di3 ao *om$ilador $ara in*luir na
*om$ila56o do $rograma outros ar%uivos9 !eralmente estes ar%uivos *ontem bibliote*as de 8un5<es ou
rotinas do usu@rio9 &oltaremos a trabalhas esta diretiva *om mais detalhe no *a$?tulo F9 A diretiva
#define di3 ao *om$ilador %uais s6o as *onstantes simb;li*as usadas no $rograma9 &eremos sobre esta
diretiva no *a$itulo 49
1.8.= Declarao de vari;veis
Em C, *omo na maioria das linguagens, as vari@veis devem ser de*laradas no ini*io do $rograma9
Estas vari@veis $odem ser de v@rios ti$osD int BinteiroC, float Breal de sim$les $re*is6oC e outras %ue
ser6o vistas no *a$itulo 49 No exem$lo a*ima num, raiz, inf e sup s6o de*laradas *omo vari@veis
reais, en%uanto i ( de*larada *omo uma vari@vel inteira9
1.8.? Entrada e sa(da de dados
1E
Em C existem varias maneiras de 8a3er a leitura e es*rita de in8orma5<es9 Estas o$era5<es s6o
*hamadas de o$era5<es de entrada e sadia9 &eremos no *a$itulo = algumas 8un5<es de entrada e sadia de
in8orma5<es via te*lado e tela9 7utras 8un5<es de leitura e es*rita em ar%uivos, sadia gr@8i*a, 8un5<es de
mani$ula56o de mouse entrada e sadia de in8orma5<es via $ortas serial e $aralela ser6o vistas em
*a$?tulos $osteriores9 No exem$lo a*ima printf ( uma 8un56o de es*rita na tela, scanf ( uma 8un56o
de leitura de te*lado9
1.8.@ Estruturas de controle
A linguagem C $ermite uma am$la variedade de estruturas de *ontrole de 8luxo de
$ro*essamento9 Estas estruturas ser6o vistas em detalhes nos *a$?tulos > e F9 Duas estruturas das
estruturas b@si*as Bde*is6o e re$eti56oC s6o muito semelhantes as estruturas usadas nas 1seudo-linguagem
algor?tmi*asD
Estrutura de Deciso) 1ermite dire*ionar o 8luxo l;gi*o $ara dois blo*os distintos de instru5<es
*on8orme uma *ondi56o de *ontrole9
Pseudo-linguagem Linguagem C
se condio if(condio){
ento bloco 1 bloco 1;
seno bloco 2 }else{
fim se bloco 2;
};
Estrutura de Re!etio) 1ermite exe*utar re$etidamente um blo*o de instru5<es ate %ue uma
*ondi56o de *ontrole se:a satis8eita9

Pseudo-linguagem Linguagem C
faa do{
bloco bloco;
at condio }while(condio);
11
14
49 Constantes e &ari@veis
Neste *a$itulo veremos *omo os dados *onstantes e vari@veis s6o mani$ulados $ela linguagem C9
7 %ue s6o *onstantes inteiras, reais, *ara*teres e strings9 Ouais s6o as regras de atribui56o de nomes a
vari@veis e %uais s6o os ti$os de dados %ue 7 C $ode mani$ular9 &eremos tamb(m *omo s6o de*laradas as
vari@veis e as *onstantes simb;li*as usadas em um $rograma9
'.1 Constantes
7 C $ossui %uatro ti$os b@si*os de *onstantesD inteiras, de !onto :lutuante, caracteres e strings9
Constantes inteiras e de $onto 8lutuante re$resentam n,meros de um modo geral9 Cara*teres e strings
re$resentam letras e agru$amentos de letras B$alavrasC9
'.1.1 Constantes inteiras
Ama *onstante inteira ( um n,mero de valor inteiro9 De uma 8orma geral, *onstantes inteiras s6o
se%PIn*ias de d?gitos %ue re$resentam n,meros inteiros9 N,meros inteiros $odem ser es*ritos no 8ormato
decimal Bbase 1EC, headecimal Bbase 1HC ou octal Bbase GC9
Ama *onstante inteira decimal ( 8ormada $or uma se%PIn*ia de d?gitos de*imaisD 0, 1, 2,
3, 4, 5, 6, 7, 8, 99 Se a *onstante tiver dois ou mais d?gitos, o $rimeiro no $ode ser 09 Na
verdade, $ode ser 0 mas o *om$ilador *onsiderar@ esta *onstante *omo octal e n6o de*imal9
Eem!lo) A seguir s6o mostradas algumas *onstantes inteiras de*imais v@lidas9
0 3 -45 26338 -7575 1010
Eem!lo) Algumas *onstantes inteiras de*imais inv@lidas9
1. (ponto)
1,2 (vrgula)
045 (primeiro dgito 0: no constante decimal)
212-22-33 (caracter ilegal: -)
Ama *onstante inteira headecimal ( 8ormada $or uma se%PIn*ia de d?gitos de*imaisD 0, 1,
2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F (ou a, b, c, d, e)9 Ama *onstante
1=
hexade*imal deve *ome5ar $or 0x9 Neste *aso, os d?gitos hexade*imais $odem ser min,s*ulos ou
mai,s*ulos9
Eem!lo) A seguir s6o mostrados algumas *onstantes inteiras hexade*imais v;lidas9
0x0 0x3 0x4f5a 0x2FFE OxABCD 0xAaFf
Eem!lo) Algumas *onstantes inteiras hexade*imais inv;lidas9
0x3. (ponto)
0x1,e (vrgula)
0x ff (espao)
FFEE (no comea com 0x: no constante hexadecimal)
0Xfg34 (caracter ilegal: g)
Ama *onstante inteira octal ( 8ormada $or uma se%PIn*ia de d?gitos o*taisD 0, 1, 2, 3, 4,
5, 6, 79 A *onstante o*tal deve ter o $rimeiro digito 0 $ara %ue o *om$ilador a identi8i%ue *omo tal
Eem!lo) A seguir s6o mostrados algumas *onstantes o*tais v;lidas9
00 -03 045 02633 07575 -0101
Eem!lo) Algumas *onstantes inteiras o*tais inv;lidas9
010. (ponto)
01,2 (vrgula)
0 4 (espao)
45 (primeiro digito no 0: no constante octal)
01784 (caracter ilegal: 8)
'.1.' Constantes de !onto :lutuante
N,meros reais Bn6o inteirosC s6o re$resentados em base 1E, $or n,meros *om um $onto de*imal
e Bo$*ionalmenteC um ex$oente9 Am n,mero $onto 8lutuante deve ter um $onto de*imal %ue n6o $ode ser
substitu?do $or uma v?rgula9 Am n,mero de $onto 8lutuante $ode ser es*rito em nota56o *ient?8i*a9 Neste
*aso o x10 ( substitu?do $or e ou E9 7 n,mero 1.23e4 re$resenta 1.23 x 10
4
ou 123009
Eem!lo) N,meros de $onto 8lutuante v@lidos9
0.234 125.65 .93 1.23e-9 -1.e2 10.6e18 -.853E+67
A 8orma de re$resenta56o de um n,mero real em C ( bastante 8lex?vel9
1>
Eem!lo) 7 n,mero =1> $ode ser re$resentado $or %ual%uer uma das seguintes 8ormasD
314. 3.14e2 +3.14e+2 31.4e1 .314E+3 314e0
'.1.8 Constantes caracteres
Ama *onstante *ara*ter ( uma letra ou s?mbolo *olo*ado entre as!as sim!les9
Eem!lo) Abaixo est6o re$resentados algumas *onstantes *ara*teres9
'a' 'b' 'X' '&' '{' ' '
Embora se:am visualiAados *omo letras e s?mbolos as *onstantes *ara*teres s6o arma3enadas
internamente $elo *om$utador *omo um n,mero inteiro entre E e 4FF9 7 *ara*ter 'A' $or exem$lo, tem
valor 659 7s valores num(ri*os dos *ara*teres est6o $adroni3ados em uma tabela *hamada de American
)tandard *ode for &nformation &nterc#ange %able ou sim$lesmente tabela A)*&&9 <e9a a!Bndice $.
Certos *odigos de *ontrole da tabela ASCII B*omo o line feedC ou *ara*teres es$e*iaiss B*omo 'C
$ossuem re$resenta56o es$e*ial no C9 Esta re$resenta*ao *hama-se seCDBncia de esca!e re$resentada $or
uma barra invertida B\C e um caracter9 Se%uen*ias de es*a$e s6o inter$retadas *omo *ara*teres sim$les9
Abaixo segue uma lista das $rin*i$ais se%uen*ias de es*a$e usadas no C9
Controle/Caracter Sequencia de escape Valor ASCII
nulo (null) \0 00
campainha (bell) \a 07
1F
retrocesso (backspace) \b 08
tabulacao horizontal \t 09
nova linha (new line) \n 10
tabulacao vertical \v 11
alimentacao de folha (form feed) \f 12
retorno de carro (carriage return) \r 13
aspas (") \" 34
apostrofo (') \' 39
interrogacao (?) \? 63
barra invertida (\) \\ 92
'.1.= Constantes strings
Ama *onstante string *onsiste de um *on:unto de *ara*teres *olo*ados entre as!as du!las9
Embora as instru5<es do C usem a$enas os *ara*teres do *on:unto $adr6o ASCII, as *onstantes *ara*ter e
string $odem *onter *ara*teres do *on:unto estendido ASCIID , , , u, 999
Eem!lo) Abaixo seguem algumas *onstantes strings v@lidas9
Oba!
Caxias do Sul
A resposta :
Joo Carlos da Silveira
a
isto uma string
1H
'.' *denti:icadores
Identi8i*adores s6o os nomes das vari@veis e 8un5<es usadas no $rograma9 1or exem$lo raiz e
MAX s6o nomes de vari@veis utili3adas no $rograma e0101.cpp9
'.'.1 Regras de sintae
7s identi8i*adores devem seguir as seguintes regras de *onstru56oD
H914 7s identi8i*adores devem *ome5ar $or uma letra Ba - z , A - ZC ou um underscore
B _ C9
H91= 7 resto do identi8i*ador deve *onter a$enas letras, underscores ou d?gitos B0 - 9C9 .o
!ode *onter outros *ara*teres9 Em C, os identi8i*adores $odem ter at( =4 *ara*teres9
H91> Em C, letras mai,s*ulas s6o di:erentes de letras min,s*ulasD 1or exem$loD MAX, max,
Max s6o nomes di8erentes $ara o *om$ilador9 Esta $ro$riedade ( *hamada de case sensibility9
Eem!lo) os nomes abaixo s6o v@lidosD
abc, y24, VetorPontosMovimentoRobo, nota_1, TAM_MAX.
Eem!lo) os nomes abaixo n6o s6o v@lidosD
3dia, vetor-1, pao&leite, iterao.
'.'.' Palavras reservadas
Existem *ertos nomes %ue no !odem ser usados *omo identi8i*adores9 S6o *hamadas as
palavras reservadas e s6o de uso restrito da linguagem C B*omandos, estruturas, de*lara5<es, et*9C9 7
*on:unto de $alavras reservadas usadas em C ( o seguinteD
asm auto break case cdecl char
class const continue _cs default delete
do double _ds else enum _es
extern _export far _fastcall float for
friend goto huge if inline int
interrupt _loadds long near new operator
pascal private protected public register return
_saveregs _seg short signed sizeof _ss
static struct switch template this typedef
17
union unsigned virtual void volatile while
Eem!lo) N6o ( $oss?vel de*larar estes *on:unto de vari@veisD
do, re, mi, fa, sol, la, si
old, new
Dos *on:untos a*ima, do e new s6o $alavras reservadas9
'.8 Ti!os de dados
Em C, *omo na maioria das linguagens, os dados s6o divididos ti$osD inteiro, real, *ara*ter, et*9
Esta divis6o se deve basi*amente ao n,mero de bytes reservados $ara *ada dado9 Cada ti$o de dado
$ossui um intervalo de valores $ermitidos9
'.8.1 Ti!os %;sicos
Abaixo segue uma lista dos ti$os b@si*os de dados $ermitidos em C9 7s ti$os char e int s6o
inteiros e os ti$os float e double s6o de $onto 8lutuante9
Tipo Tamanho Intervalo Uso
char 1 byte -128 a 127 n,mero muito $e%ueno e *ara*ter ASCII
int 2 bytes -32768 a 32767 *ontador, *ontrole de la5o
float 4 bytes 3.4e-38 a 3.4e38 real B$re*is6o de 7 d?gitosC
double 8 bytes 1.7e-308 a 1.7e308 *ient?8i*o B$re*is6o de 1F d?gitosC
'.8.' Declarao de vari;veis
1ara %ue se $ossa usar uma vari@vel em um $rograma, necess;rio 8a3er uma declarao de
vari/vel antes9 A de*lara56o de vari@veis sim$lesmente in8orma ao $ro*essador %uais s6o os nomes
utili3ados $ara arma3enar dados vari@veis e %uais s6o os ti$os usados9 Deste modo o $ro*essador $ode
alocar BreservarC o es$a5o ne*ess@rio na mem;ria $ara a mani$ula56o destas vari@veis9 Q $oss?vel
de*larar mais de uma vari@vel ao mesmo tem$o, basta se$ar@-las $or v?rgulas B,C9
1G
+intae) A sintaxe $ara de*lara56o de vari@veis ( a seguinteD
tipo variavel_1 [, variavel_2, ...]
7nde tipo ( o ti$o de dado e variavel_1 ( o nome da vari@vel a ser de*larada9 Se houver
mais de uma vari@vel, seus nomes s6o se$arados $or v?rgulas9
Eem!lo) De*lara56o das vari@veisD
int i;
int x,y,z;
char letra;
float nota_1,nota_2,media;
double num;
No exem$lo a*ima, i, x, y e z 8oram de*laradas vari@veis inteiras9 Assim elas $odem arma3enar
valores inteiros de -=47HG at( =47H79 Do mesmo modo letra 8oi de*larada *omo vari@vel *ara*ter
$odendo re*eber valores de -14G at( 147 ou *ara*teres do *on:unto $adr6o ASCII9 As vari@veis nota_1,
nota_2 e media 8oram de*laradas *omo $onto 8lutuante ti$o 8loat e num *omo $onto 8lutuante ti$o
double9
A de*lara56o de vari@veis ( 8eita, em geral, dentro de uma rotina9 1or exem$lo, a rotina $rin*i$al
main()9 Deste modo se di3 %ue est@ se 8a3endo uma de*lara56o de vari@veis locais9 &ari@veis lo*ais
$odem ser re8eren*iadas a$enas dentro da rotina dentro da %ual 8oi de*larada, neste *aso a rotina
main()9
Eem!lo) 7bserve o uso da de*lara56o de vari@veis no tre*ho de $rograma abaixoD
void main(){
float raio, area; // declaracao de variaveis
raio = 2.5;
rea = 3.14 * raio * raio;
}
No exem$lo a*ima, as vari@veis area e raio 8oram de*laradas *omo vari@veis lo*ais ti$o
float9 Assim o $ro*essador 8a3 a alo*a56o de dois es$a5os Bendere5osC de > b"tes *ada $ara arma3enar
as in8orma5<es, um $ara *ada vari@vel9 Na ter*eira linha, o $ro*essador *olo*a no endere5o alo*ado $ara
raio o valor 2.59 De$ois, na %uarta linha, o $ro*essador *olo*a o resultado da *onta B19.625C no
endere5o de rea9
19
Q $oss?vel 8a3er a de*lara56o de vari@veis :ora de uma rotina9 Neste *aso di3-se %ue se 8e3 a
de*lara56o de vari@veis globais9 7 uso de vari@veis globais ( ex$li*ado na sess6o R9R9
'.8.8 Ti!os modi:icados
Al(m dos ti$os de dados *itados a*ima existem outros ti$os de dados ditos modi:icados9 Em C
existem dois modi8i*adoresD o modi8i*ador long e o modi8i*ador unsigned9 #i$i*amente o
modi8i*ador long aumenta o n,mero de b"tes usados $ara o registro do n,mero9 1or *onse%PIn*ia o
intervalo de validade do n,mero 8i*a aumentado signi8i*ativamente9 7 modi8i*ador unsigned, usado
somente em inteiros, $ermite %ue um %it usado $ara guardar o sinal do n,mero se:a usado $ara guardar o
valor do n,mero9 Em *onse%PIn*ia disto o intervalo do n,mero 8i*a dobrado, $or(m somente $ermite o
uso de n,meros $ositivos9
Tipo Tamanho !"#tes$ Intervalo
unsigned char 1 0 a 255
unsigned int 2 0 a 65 535
long int 4 -2 147 483 648 a 2 147 483 647
unsigned long int 4 0 a 4 294 967 295
long double 10 3.4e-4932 a 1.1e4932
'.8.= +trings.
Ama string ( um *on:unto ordenado de *ara*teres %ue $ode ser arma3enado sob 8orma de um
vetor um $onteiro9 Estas estruturas de dados ser6o vistas em detalhe nos *a$itulo R e R9 1or en%uanto, nos
basta saber *omo de*larar e arma3enar um *on:unto *ara*ter em uma vari@vel9
+intae) 1ara de*lararmos uma vari@vel $ara re*eber um *on:unto *ara*ter devemos es*reverD
char* var;
Eem!lo) No exem$lo seguinte a vari@vel nome 8oi de*larada *omo *on:unto *ara*ter e em
seguida re*ebe uma *onstante string9
char* nome;
nome = "Joo Carlos de Oliveira Andrade";

4E
'.8.? *nicialiAao de vari;veis.
Ouando se 8a3 a declarao de uma vari@vel est@ se determinando %ue ti$o de dado ela vai
re*eber9 Q $oss?vel, em C, de*larar uma vari@vel e :@ arma3enar nela um valor ini*ial9 Chamamos este
$ro*edimento de inicialiAao de uma vari@vel9
+intae) A sintaxe $ara a ini*iali3a56o de vari@veis (D
tipo var_1 = valor_1 [, var_2 = valor_2, ...] ;
7nde tipo ( o ti$o de dado, var_1 ( o nome da vari@vel a ser ini*iali3ada e valor_1 ( o
valor ini*ial da vari@vel9
Eem!lo) Ini*iali3a56o de vari@veisD
int i = 0, j = 100;
float num = 13.5;
char* titulo = " Programa Teste ";
No exem$lo a*ima, i e j 8oram de*laradas vari@veis ti$o int9 7 valor ini*ial de i ( 0 e o de j
( 1009 Do mesmo modo num 8oi de*larada *omo vari@vel float *om valor ini*ial de 13.59 #ambem a
variavel titulo 8oi de*larada *omo um *on:unto *ara*ter e re*ebeu *omo *onteudo ini*ial a string "
Programa Teste "9
'.8.@ Converso de ti!o ECastingF
Algumas ve3es %ueremos, momentaneamente, modi8i*ar o ti$o de dado re$resentado $or uma
vari@vel, isto (, %ueremos %ue o dado se:a a$resentado em um ti$o di8erente do %ual a vari@vel 8oi
ini*ialmente de*larada9 1or exem$loD de*laramos uma vari@vel *omo int e %ueremos,
momentaneamente, %ue seu *onte,do se:a a$resentado *omo float9 Este $ro*edimento ( *hamado de
converso de ti!o ou casting Bmoldagem, em inglIsC9
+intae) A sintaxe da instru56o de *onvers6o de ti$o (D
(tipo) varivel
onde tipo ( o nome do ti$o ao %ual %ueremos *onverter o dado arma3enado em varivel9
Eem!lo) observe a *onvers6o de ti$o 8eita no exem$lo abaixoD
41
int num;
float valor = 13.0;
num = (int)valor % 2;
No exem$lo a*ima a vari@vel valor 8oi de*larada ini*ialmente *omo sendo do ti$o float
re*ebendo o valor ini*ial 13.09 ogo em seguida o *onte,do de valor ( *onvertido $ara o ti$o int $ara
reali3ar a o$era56o m;dulo B%C *om o inteiro 49 A%ui a *onvers6o ( ne*ess@ria $ois a o$era56o m;dulo
somente $ode ser 8eita *om inteiros9 Q im$ortante salientar %ue a *onvers6o de ti$o ( 8eita *om o dado
arma3enado em uma vari@vel mas a vari;vel *ontinua tendo o seu ti$o original9 No exem$lo a*ima a
vari@vel valor e os dados nela arma3enados *ontinuam sendo do ti$o float a$;s a *onvers6o9

&eremos na seo 8.1 uma ex$li*a56o mais detalhada do uso da *onvers6o de ti$os9
'.= Constantes +im%"licas
.uitas ve3es identi8i*amos uma *onstante num(ri*a $or um s?mboloD 1i S =,1>1F9 $or exem$lo9
1odemos de8inir um nome simb;li*o $ara esta *onstante, isto (, $odemos de8inir uma constante
sim%"lica %ue re$resente valor9
'.=.1 Constantes de:inidas !elo !rogramador
7 $rogramador $ode de8inir *onstantes simb;li*as em %ual%uer $rograma9
+intae) A sintaxe da instru56o de de8ini56o de uma *onstante simb;li*a (D
#define nome valor
7nde #define ( uma diretiva de *om$ila56o %ue di3 ao *om$ilador $ara tro*ar as o*orrIn*ias
do texto nome $or valor9 7bserve %ue no h; no 8inal da instru56o $ois trata-se de um *omando $ara
o *om$ilador e n6o $ara o $ro*essador9 A instru56o #define deve ser es*rita antes da instru56o de
de*lara56o da rotina $rin*i$al9
Eem!lo) a seguir de8inimos algumas *onstantes simb;li*as9
#define PI 3.14159
44
#define ON 1
#define OFF 0
#define ENDERECO 0x378
void main(){
...
No exem$lo a*ima, de8inimos PI *omo 3.141599 Isto signi8i*a %ue todas as o*orrIn*ias do
texto PI ser@ tro*ado $or 3.141599 Assim se es*revemos uma instru56oD
rea = PI * raio * raio;
o *om$ilador vai inter$retar esta instru56o *omo se 8osse es*rita assimD
rea = 3.14159 * raio * raio;
1oder?amos es*rever estas instru5<es assimD
float pi = 3.14159;
rea = pi * rea * rea;
$or(m este ti$o de instru56o tem duas desvantagensD 1rimeiro, reserva > b"tes de mem;ria
desne*essariamente9 Segundo, esta instru56o ( exe*utada mais lentamente $ois o $ro*essador $re*isa
a*essar a mem;ria $ara veri8i*ar %ual ( o valor de pi9
7bserve tamb(m %ue no exem$lo de8inimos os nomes simb;li*os *om letras mai,s*ulas9 Isto no
necess;rio, $odemos $er8eitamente de8inir nomes simb;li*os usando letras min,s*ulas, $or(m 8a3 $arte
do :arg6o dos $rogramadores C usar letras mai,s*ulas $ara de8inir *onstantes simb;li*as9
7 uso da diretiva #define n6o se restringe a$enas ao a$resentado a*ima, $odemos us@-la $ara
de8inir macro instruGes9 N6o veremos o uso de ma*ros neste texto, $ro*ure mais detalhes na
bibliogra8ia re*omendada9
'.=.' Constantes !r#de:inidas
4=
Em alguns *om$iladores C, algumas *onstantes simb;li*as :@ est6o $r(-de8inidas9 Estas
*onstantes em geral de8inam alguns valores matem@ti*os B, T4, e, et*9C, limites de ti$os et*9 A seguir segue
uma tabela *ontendo algumas Bexistem muitas outrasC *onstantes simb;li*as $r(-de8inidas no *om$ilador
#urbo CNN da -orland9
%i"lioteca Constante Valor Si&nificado
math.h M_PI 3.14159...
math.h M_PI_2 1.57079... /2
math.h M_PI_4 0,78539... /4
math.h M_1_PI 0,31830... 1/
math.h M_SQRT2 1,41421... 2
conio.h BLACK 0 valor da cor (preto)
conio.h BLUE 1 valor da cor (azul)
conio.h GREEN 2 valor da cor (verde)
conio.h CYAN 3 valor da cor (cyan)
conio.h RED 4 valor da cor (vermelho)
conio.h MAGENTA 5 valor da cor (magenta)
limits.h INT_MAX 32767 limite superior do tipo int
limits.h INT_MIN -32768 limite inferior do tipo int
Cada uma das *onstantes a*ima esta de8inida em uma bibliote*a9 Ama bibliote*a, em C, ( um
ar%uivo $r(-*om$ilado *hamado ar%uivo #eader B*abe5alho, em inglIsC! Em *ada bibliote*a est6o
agru$adas *onstantes e 8un5<es semelhantes Bve:a se56o =9794C9 1or exem$lo, *onstantes e 8un5<es
matem@ti*as est6o guardadas na bibliote*a math.h Bmat#ematical functionsC, *onstantes e 8un5<es de
mani$ula56o te*lado e monitor est6o guardadas na bibliote*a conio.h Bconsole input and outputC9 1ara
%ue se $ossa usar a *onstante simb;li*a em um $rograma ( $re*iso incluir a bibliote*a na *om$ila56o do
$rograma9
+intae) A sintaxe de in*lus6o de bibliote*as ( a seguinteD
#include <nome_bib>
onde nome_bib ( o nome da bibliote*a %ue se dese:a in*luir9 Esta instru56o deve ser es*rita
antes do $rograma $rin*i$al9
Eem!lo) 7 $rograma abaixo usa a *onstante $rede8inida .U1I $ara *al*ular a @rea de um dis*o
*ir*ular9
#include <math.h>
4>
void main(){
float area, raio = 5.0;
rea = M_PI * raio * raio;
}
4F
4H
=9 7$eradores, Ex$ress<es e 2un5<es
Am $rograma tem *omo *ara*ter?sti*a 8undamental a *a$a*idade de $ro*essar dados9 1ro*essar
dados signi8i*a reali3ar o$era5<es *om estes dados9 As o$era5<es a serem reali3adas *om os dados $odem
ser determinadas $or o!eradores ou :unGes9 7s o$eradores $odem ser de atribui56o, aritm(ti*os, de
atribui56o aritm(ti*a, in*rementais, rela*ionais, l;gi*os e *ondi*ionais9
Eem!lo) o s?mbolo + ( um operador %ue re$resenta a o$era56o aritm(ti*a de adi56o9 7
identi8i*ador sqrt() ( uma funo %ue re$resenta a o$era56o de extrair a rai3 %uadrada de um n,mero9
Ama e!resso ( um arran:o de o$eradores e o$erandos9 A *ada ex$ress6o v@lida ( atribu?do um
valor num(ri*o9
Eem!lo) 4 + 6 ( uma ex$ress6o *u:o valor ( 109 A ex$ress6o sqrt(9.0) tem valor 3.09
8.1 >!erador de Atri%uio
A o$era56o de atribui56o ( a o$era56o mais sim$les do C9 Consiste de atribuir valor de uma
e!resso a uma vari;vel9
+intae) A sintaxe da o$era56o de atribui56o ( a seguinteD
identificador = expresso;
onde identificador ( o nome de uma vari@vel e expresso ( uma ex$ress6o v@lida Bou
outro identi8i*adorC9
Eem!lo) A seguir s6o mostradas algumas atribui5<es v@lidasD
a = 1;
delta = b * b - 4. * a * c;
i = j;
7bserve %ue o s?mbolo de atribui56o B = C no tem o mesmo signi8i*ado %ue o usual da
matem@ti*a %ue re$resenta a igualdade de valores9 Este s?mbolo, em C, re$resenta a atribui56o do valor
47
*al*ulado em expresso a vari@vel identificador9 Em $seudo-linguagem o o$erador de
atribui56o ( re$resentado *omo 9 #amb(m n6o se $ode *on8undir o o$erador de atribui56o B = C *om o
o$erador rela*ional de igualdade B == C %ue ser@ visto na se56o =9F919
7bserve-se tamb(m %ue o o$erando es%uerdo deve ser um identi8i*ador de vari@vel, isto (, no
!ode ser uma *onstante ou ex$ress6o9
Eem!lo) A seguir s6o mostradas algumas atribui5<es inv@lidasD
1 = a; // constante!
b + 1 = a; // expresso!

8.1.1 Converso de ti!o.
Se os dois o$erandos de uma atribui56o no so do mesmo ti$o, o valor da ex$ress6o ou o$erador
da direita ser; convertido $ara o ti$o do identi8i*ador da es%uerda9
Eem!lo) Algumas atribui5<es *om *onvers6o de ti$oD
int i;
float r;
i = 5; // valor de i: 5
r = i ; // valor de r: 5.0
A vari@vel i 8oi ini*iali3ada *om o valor 59 Ao 8inal da ter*eira instru56o, r re*ebe o valor
5.09

Nestas *onvers<es $odem o*orrer altera5<es dos valores *onvertidos se o o$erando da es%uerda
8or de um ti$o %ue utili3e menor numero de b"tes %ue o o$erando da direita9
Eem!lo) Algumas atribui5<es *om *onvers6o de ti$o e $erda de in8orma56oD
int i;
float r = 654.321;
i = r; // truncamento!

A$;s a exe*u56o deste tre*ho de $rograma o valor da vari@vel i ser@ 654 $ois seu valor 8oi
trun*ado durante a *onvers6o9
4G
1ode-se di3er %ue as *onvers<es $oten*ialmente $erigosas Bonde h@ $ossibilidade de $erda de
in8orma56oC s6oD
char int float double
7bserve %ue o *om$ilador C ao en*ontrar esta o$era56o no gera nenhum aviso de aten56o $ara
o $rogramador9 Assim este detalhe $ode gerar um erro de $rograma56o BbugC %ue $asse desa$er*ebido ao
$rogramador inex$eriente9 Q $oss?vel di3er %ue a linguagem C $ossui ti$os Jma*iosK Bsoft typesC $ois a
o$era56o *om vari@veis de ti$os di8erentes ( $er8eitamente $oss?vel9 Esta *ara*ter?sti*a do C se *ontra$<e
a algumas linguagens em %ue isto n6o ( $oss?vel B2ortran, $or exem$loC9 Estas linguagens $ossuem ti$os
JdurosK B#ard typesC9
8.1.' Limites do intervalo do ti!o de dado.
#amb(m ( im$ortante observar %ue os ti$os em C tem intervalos bem de8inidos e os resultados
das o$era5<es devem res$eitar estes intervalos9 Se a uma vari@vel 8or atribu?do um valor %ue este:a 8ora
dos seus limites ent6o este valor ser@ alterado9
Eem!lo) 7bserve as ex$ress<es abaixo, assuma %ue i se:a uma vari@vel do ti$o int9
i = 4999; // o valor de i e' 4999
i = 4999 + 1; // o valor de i e' 5000
i = 5000 + 30000; // o valor de i e' -30536

7 valor de 35000 ultra$assou o limite su$erior do ti$o int B32767C9
Q im$ortante observar %ue em C, ao *ontr@rio de outras linguagens, a ultra$assagem do limite de
um ti$o no inter!retado como erro. Isto $ode a*arretar resultados ines$erados $ara o $rogramador
desatento9
49
8.1.8 Atri%uio mHlti!la.

E $oss?vel atribuir um valor a muitas vari@veis em uma ,ni*a instru56o9 A esta o$era56o d@-se o
nome de atri%uio mHlti!la9
+intae) A sintaxe da atribui56o m,lti$la ( seguinteD
var_1 = [var_2 = ... ] expresso;
onde var_1, var_2, 999 s6o os identi8i*adores de vari@veis e expresso ( uma ex$ress6o
v@lida9
7bserve %ue na atribui56o m,lti$la as o$era5<es o*orrem da direita $ara a esCuerda, isto (,
ini*ialmente o valor de expresso ( atribu?do a var_2 e de$ois o valor de var_2 ( atribu?do a
var_19 Deve-se tomar *uidado *om as *onvers<es de ti$o e limites de intervalo $ara atribui5<es de ti$os
di8erentes9
Eem!lo) 7bserve a instru56o de atribui56o m,lti$la abaixoD as vari@veis inteiras i, j e k
s6o todas ini*iali3adas *om o valor 19 E as vari@veis de du$la $re*is6o max e min s6o ini*iali3adas
*om o valor 0.0D
int i, j, k;
double max, min;
i = j = k = 1;
max = min = 0.0;
Programa Eem!lo) 7 ar%uivo e0301.cpp tra3 um $rograma $ara visuali3ar alguns as$e*tos
rela*ionados *om o o$erador de atribui56o9 Exe*ute o $rograma $asso-a-$asso e observe o valor das
vari@veis9
8.' >!eradores Aritmticos
Existem *in*o o$eradores aritm(ti*os em C9 Cada o$erador aritm(ti*os est@ rela*ionado ao uma
o$era56o aritm(ti*a elementarD adi56o, subtra56o, multi$li*a56o e divis6o9 Existe ainda um o$erador B 'C
*hamado o$erador de m"dulo *u:o signi8i*ado ( o resto da divis6o inteira9 7s s?mbolos dos o$eradores
aritm(ti*os s6oD
=E
(perador (perao
+ adi56o9
- subtra56o9
* multi$li*a56o
/ divis6o
% m;dulo Bresto da divis6o inteiraC
+intae) A sintaxe de uma ex$ress6o aritm(ti*a (D
operando operador operando
onde operador ( um dos caracteres mostrados a*ima e operando ( uma constante ou um
identi8i*ador de vari;vel9

Eem!lo) Algumas ex$ress<es aritm(ti*asD
1+2 a-4.0 b*c valor_1/taxa num%2
N6o existe em C, *omo existe em outras linguagens, um o$erador es$e*?8i*o $ara a o$era56o de
$oten*ia56o Ba
b
C9 Existe, $or(m, uma 8un56o de bibliote*a Bpow!$C %ue reali3a esta o$era56o9 &e:a a
se56o =97 adiante9 Embora as o$era5<es do C se:am semelhantes as o$era5<es aritm(ti*as usuais da
matem@ti*a, alguns detalhes s6o es$e*?8i*os da linguagem, e devem ser observados9
8.'.1 RestriGes de o!erandos.
7s o$erandos dos o$eradores aritm(ti*os devem ser *onstantes num(ri*as ou identi8i*adores de
vari@veis num(ri*as9 7s o$eradores +, -, *, / $odem o$erar n,meros de todos os ti$os Binteiros ou
reaisC $or(m o o$erador ' somente a*eita o$erandos inteiros9
Eem!lo) Ex$ress<es v@lidas
)*presso Valor
6.4 + 2.1 8.5
7 - 2 5
=1
2.0 * 2.0 4.0
6 / 3 2
47 % 2 1
Ama restri56o ao o$erador de divis6o B/C ( %ue o denominador deve ser di8erente de 3ero9 Se
alguma o$era56o de divis6o $or 3ero 8or reali3ada o *orrera um erro de eecuo do $rograma Brun0time
errorC, o $rograma ser@ abortado e a mensagem divide error ser@ exibida9
Eem!lo) A ex$ress6o abaixo ( inv@lida $ois o $rimeiro o$erando n6o ( um numero inteiro9
)*presso Valor
6.4 % 3 invalido!
1odemos *ontornar o $roblema do o$erador inteiro da o$era56o modulo usando o arti8?*io da
*onvers6o de ti$o BcastingC mostrada na se56o 49=9>D
Eem!lo) 7bserve o tre*ho de $rograma abaixoD
int num;
float valor = 13.0;
num = valor % 2; // invlido!
num = (int)valor % 2; // vlido!
7bserve %ue usamos a *onvers6o de ti$o $ara %ue o dado arma3enado em valor 8osse
trans8ormado no ti$o int assim a o$era56o m;dulo $ode ser e8etuada9
8.'.' Converso de ti!o.
7 resultado de uma o$era56o aritm(ti*a de!ende dos ti$os dos o$erandos9 Se os o$erandos s6o
do mesmo ti$o o resultado ser@ do mesmo ti$o9 Se os o$erando 8orem de ti$os di:erentes ent6o haver@
uma converso de ti$o tal %ue o ti$o %ue o*u$a menos es$a5o de mem;ria ser@ *onvertido $ara o ti$o
%ue o*u$a mais es$a5o de mem;ria e o resultado ser@ deste ti$o9 Em geralD
char int float double
Esta ( uma regra geral, alguns *om$iladores $odem ter outras regras de *onvers6o9
Eem!lo) 7bserve as *onvers<es de ti$o abaixoD
)*presso Valor Converso
6 + 2.0 8.0 int float
7.000000 - 2.0000000000000 5.000000000000000 float double
2 * 3.000000000000000 6.000000000000000 int double
=4
7bserve %ue estas *onvers<es $odem gerar resultados sur$reendentes $ara o $rogramador
desatento9
Eem!lo) 7bserve as ex$ress<es abaixo9 Assuma %ue as vari@veis num_i, num_f, den_i e
den_f s6o ini*iali3adas *omoD
int num_i = 7 , den_i = 2 ;
float num_f = 7.0, den_f = 2.0;
)*presso Valor (perandos +esultado
num_f / den_f 3.5 float / float float
num_f / den_i 3.5 float / int float
num_i / den_f 3.5 int / float float
num_i / den_i 3 int / int int

7bserve %ue no exem$lo a*ima o valor da ,ltima ex$ress6o ( , e n6o ,-.9 Isto o*orre $or%ue
*omo os dois o$erandos s6o ti$o int o resultado e *onvertido $ara o ti$o int e o*orre o trun*amento9 7
trun*amento da divis6o inteira ( 8eito de modo a obter o menor valor absoluto9
Em C *ara*teres s6o arma3enados na mem;ria *omo n,meros inteiros e $or isso o$era5<es
aritm(ti*as s6o $ermitidas *om ti$os char9 7s valores usados s6o os *orres$ondentes da tabela ASCII9
Eem!lo) 7bserve as ex$ress<es abaixoD
)*presso Valor Converso
'A' + 1 'B' 65 + 1 66
'A' + 'B' '' 65 + 66 131
'A' + 32 'a' 65 + 32 97
8.'.= PrecedBncia de o!eradores.
Ouando mais de um o$erador se en*ontram em uma ex$ress6o aritm(ti*a as o$era5<es s6o
e8etuadas uma de *ada ve3 res$eitando algumas regras de $re*edIn*iaD Estas regras de $re*edIn*ia s6o as
mesmas da matem@ti*a elementar9

==
7s o$eradores de multi$li*a56o B*C, divis6o B/C e m;dulo B%C tem $re*edIn*ia sobre os
o$eradores de adi56o B+C e subtra56o B-C9 Entre o$eradores de mesma $re*edIn*ia as o$era5<es s6o
e8etuadas da esCuerda $ara a direita9 &e:a a tabela =919
Eem!lo) 7bserve, nas ex$ress<es abaixo, o seu valor e a ordem das o$era5<es e8etuadasD
)*presso Valor (rdem
1 + 2 - 3 0 + -
24 - 3 * 5 9 * -
4 - 2 * 6 / 4 + 1 2 * / - +
6 / 2 + 11 % 3 * 4 11 / % * +
A ordem de $re*edIn*ia dos o$eradores $ode ser %uebrada usando-se $arIntesesD ( )9 7s
$arInteses s6o, na verdade, o$eradores de mais alta $re*edIn*ia e s6o exe*utados $rimeiro9 1arInteses
internos s6o exe*utados $rimeiro %ue $arInteses externos9
Eem!lo) 7bserve, nas ex$ress<es abaixo, o seu valor e a ordem das o$era5<es e8etuadasD
)*presso Valor (rdem
1 + (2 - 3) 0 - +
(24 - 3) * 5 105 - *
(4 - 2 * 6) / 4 + 1 -1 * - / +
6 / ((2 + 11) % 3) * 4 24 + % / *

7bserve %ue os o$eradores e os o$erandos deste exem$lo s6o os mesmos do exem$lo anterior9 7s
valores, $or(m, s6o di8erentes $ois a ordem de exe*u56o das o$era5<es 8oi modi8i*ada $elo uso dos
$arInteses9
Programa Eem!lo) 7 ar%uivo e0302.cpp tra3 um $rograma $ara visuali3ar alguns as$e*tos
rela*ionados *om os o$eradores aritm(ti*os9 Exe*ute o $rograma $asso-a-$asso e observe o valor das
vari@veis9
8.8 >!eradores de Atri%uio Aritmtica
.uitas ve3es %ueremos alterar o valor de uma vari@vel reali3ando alguma o$era56o aritm(ti*a
*om ela9 Como $or exem$loD i = i + 1 ou val = val * 29 Embora se:a $er8eitamente $oss?vel
es*rever estas instru5<es, 8oi desenvolvido na linguagem C uma instru5<es otimiAadas *om o uso de
o$eradores ditos o!eradores de atri%uio aritmtica9 7s s?mbolos usado s6o B+=, -=, *=, /= ,
%=C9 Deste modo as instru5<es a*ima $odem ser res*ritas *omoD i += 1 e val *= 2,
res$e*tivamente9
=>
+intae) A sintaxe da atribui56o aritm(ti*a ( a seguinteD
var += exp;
var -= exp;
var *= exp;
var /= exp;
var %= exp;
onde var ( o identi8i*ador da vari@vel e exp ( uma ex$ress6o v@lida9 Estas instru5<es s6o
e%uivalentes as seguintesD
var = var + exp;
var = var - exp;
var = var * exp;
var = var / exp;
var = var % exp;
Eem!lo) 7bserve as atribui5<es aritm(ti*as abaixo e suas instru5<es e%uivalentesD
Atri"uio aritmtica Instruo equivalente
i += 1; i = i + 1;
j -= val; j = j - val;
num *= 1 + k; num = num * (1 + k);
troco /= 10; troco = troco / 10;
resto %= 2; resto = resto % 2;
7 o$erador de atribui56o aritm(ti*a tem $re*edIn*ia menor %ue os outros o$eradores at( a%ui
dis*utidos9 &e:a a tabela =919
Programa Eem!lo) 7 ar%uivo e0303.cpp tra3 um $rograma $ara visuali3ar alguns as$e*tos
rela*ionados *om os o$eradores de atribui56o aritm(ti*a9 Exe*ute o $rograma $asso-a-$asso e observe o
valor das vari@veis9
8.= >!eradores *ncrementais
Em $rograma56o existem instru5<es muito *omuns *hamadas de incremento e decremento9 Ama
instru56o de in*remento adiciona uma unidade ao *onte,do de uma vari@vel9 Ama instru56o de
de*remento su%trai uma unidade do *onte,do de uma vari@vel9
=F
Existem, em C, o$eradores es$e*?8i*os $ara reali3ar as o$era5<es de in*remento B++C e
de*remento B--C9 Eles s6o generi*amente *hamados de o!eradores incrementais9
+intae) A sintaxe dos o$eradores in*rementais ( a seguinteD
instruo equivalente
++ var var = var + 1
var ++ var = var + 1
-- var var = var - 1
var -- var = var - 1
onde var ( o nome da vari@vel da %ual se %uer in*rementar ou de*rementar um unidade9
7bserve %ue existe duas sintaxes $oss?veis $ara os o$eradoresD $ode-se *olo*ar o o$erador I
esCuerda ou ; direita da vari@vel9 Nos dois *asos o valor da vari@vel ser@ in*rementado Bou
de*rementadoC de uma unidade9 1or(m se o o$erador 8or *olo*ado ; esCuerda da vari@vel, o valor da
vari@vel ser@ in*rementado Bou de*rementadoC antes %ue a vari@vel se:a usada em alguma outra o$era56o9
Caso o o$erador se:a *olo*ado I direita da vari@vel, o valor da vari@vel ser@ in*rementado Bou
de*rementadoC de!ois %ue a vari@vel 8or usada em alguma outra o$era56o9
Eem!lo) 7bserve o 8ragmento de *;digo abaixo e note o valor %ue as vari@veis re*ebem a!"s a
exe*u56o da instru56oD
valor das vari/veis
int a, b, c, i = 3; // a: ? b: ? c: ? i: 3
a = i++; // a: 3 b: ? c: ? i: 4
b = ++i; // a: 3 b: 5 c: ? i: 5
c = --i; // a: 3 b: 5 c: 4 i: 4
7s o$eradores in*rementais s6o bastante usados $ara o *ontrole de la5os de re$eti56o, %ue ser6o
vistos na se56o RR9 Q im$ortante %ue se *onhe5a exatamente o e8eito sutil da *olo*a56o do o$erador, $ois
isto $ode enganar o $rogramador inex$eriente9
7s o$eradores in*rementais tem a mais alta $re*edIn*ia entre todos, sendo su$erados a$enas
$elos $arInteses %ue tem $re*edIn*ia ainda maior9 &e:a a tabela =919
Programa Eem!lo) 7 ar%uivo e0304.cpp tra3 um $rograma $ara visuali3ar alguns as$e*tos
rela*ionados *om os o$eradores in*rementais9 Exe*ute o $rograma $asso-a-$asso e observe o valor das
vari@veis9
8.? >!eradores Relacionais e L"gicos
=H
A *have $ara a 8lexibilidade de um algoritmo ( a tomada de de*is<es atrav(s da avalia56o de
*ondi5<es de *ontrole9 Ama *ondi5<es de *ontrole ( uma e!resso l"gica %ue ( avaliadas *omo
verdadeira ou :alsa9 Ama ex$ress6o l;gi*a ( *onstru?da *om o!eradores relacionais e l"gicos9
8.?.1 >!eradores relacionais
7$eradores rela*ionais veri8i*am a rela56o de magnitude e igualdade entre dois valores9 S6o seis
os o$eradores rela*ionais em CD
(perador Si&nificado
> maior que
< menor que
>= maior ou igual a (no menor que)
<= menor ou igual a (no maior que)
== igual a
!= no igual a (diferente de)
+intae) A sintaxe das ex$ress<es l;gi*as (D
expresso_1 operador expresso_2
onde expresso_1 e expresso_2 s6o duas ex$ress<es num(ri*as %uais%uer, e operador
( um dos o$eradores rela*ionais9
Ao *ontr@rio de outras linguagens, em C no eistem ti$os l;gi*os, $ortanto o resultado de uma
ex$ress6o l;gi*a ( um valor numricoD uma ex$ress6o avaliada verdadeira re*ebe o valor 1, uma
ex$ress6o l;gi*a avaliada :alsa re*ebe o valor 09
Se os o$erandos 8orem de ti!os di:erentes haver@ uma *onvers6o de ti$o antes da avalia56o da
ex$ress6o9 Esta *onvers6o de ti$o ( 8eita de a*ordo *om a regra mostrada na se56o =94949
Eem!lo) 7bserve as ex$ress<es l;gi*as abaixo e veri8i%ue o resultado de sua avalia56o9 Admita
%ue i e j s6o vari@veis int *u:os valores s6o 5 e -3, res$e*tivamente9 As vari@veis r e s s6o float
*om valores 7.3 e 1.7, res$e*tivamente9
)*presso Valor
i == 7 0
r != s 1
=7
i > r 0
6 >= i 1
i < j 0
s <= 5.9 1
7s o$eradores rela*ionais de igualdade B== e !=C tem $re*edIn*ia menor %ue os de magnitude
B>, <, >= e <=C9 Estes, $or sua ve3, tem $re*edIn*ia menor %ue os o$eradores aritm(ti*os9 7$eradores
rela*ionais de mesma $re*edIn*ia s6o avaliados da es%uerda $ara a direita9 &e:a a tabela =919
Eem!lo) 7bserve as ex$ress<es l;gi*as abaixo e veri8i%ue o resultado de sua avalia56o9 Admita
%ue m e n s6o vari@veis ti$o int *om valores 4 e 1, res$e*tivamente9
)*presso Valor (rdem de (perao
m + n == 5 1 + ==
m != 2 * n > m 1 * > !=
6 >= n < 3 - m 0 - >= <
m == n <= m > m 0 <= > !=
8.?.' >!eradores l"gicos
S6o trIs os o$eradores l;gi*os de CD &&, || e !9 Estes o$eradores tem a mesma signi8i*a56o
dos o$eradores l;gi*os -ooleanos AND, 7R e N7#9
+intae) A sintaxe de uso dos o$eradores l;gi*osD
expr_1 && expr_2
expr_1 || expr_2
!expr
onde expr_1 , expr_2 e expr s6o ex$ress<es %uais%uer9
7bserve %ue os o$eradores l;gi*os atuam sobre ex$ress<es de %uais%uer valores9 1ara estes
o$eradores todo valor num(ri*o di8erente de 0 ( *onsiderado 19
Eem!lo) A seguir ( mostrado o valor l;gi*o de uma ex$ress6o %ual%uerD
Expresso Valor lgico
0 0
=G
1 1
1.0 1
0.4 1
-5.2 1
onde expr_1 , expr_2 e expr s6o ex$ress<es %uais%uer9
7 resultado da o$era56o l;gi*a && ser@ 1 somente se os dois o$erandos 8orem 1, *aso *ontr@rio
o resultado ( 09 7 resultado da o$era56o l;gi*a || ser@ 0 somente se os dois o$erandos 8orem 0, *aso
*ontr@rio o resultado ( 19 7 resultado da o$era56o l;gi*a ! ser@ 0 se o o$erandos 8or 1, e 1 se o
o$erando 8or 09 Abaixo mostra-se o resultado das $oss?veis *ombina5<es entre os o$erandos $ara *ada
o$erador l;gi*oD
Operador 00: op12 op13 +es
op_1 && op_2 1 1 1
1 0 0
0 1 0
0 0 0
Operador 44: op12 op13 +es
op_1 || op_2 1 1 1
1 0 1
0 1 1
0 0 0
Operador 5: op +es
!op 1 0
0 1
7 7$erador && tem $re*edIn*ia sobre o o$erador ||9 Estes dois tIm $re*edIn*ia menor %ue os
o$eradores rela*ionais9 7 o$erador V tem a mesma $re*edIn*ia %ue os o$eradores in*rementais9 &e:a a
tabela =919
Eem!lo) 7bserve as ex$ress<es l;gi*as abaixo e veri8i%ue o resultado de sua avalia56o9 Admita
%ue a, b e c s6o vari@veis ti$o int *om valores 0, 1 e 2, res$e*tivamente9
)*presso Valor (rdem de (perao
a && b 0
=9
c > b || a < c 1 > < ||
a + b && !c - b 1 ! + - &&
!b && c || a 0 ! && ||
Programa Eem!lo) 7 ar%uivo e0305.cpp tra3 um $rograma $ara visuali3ar alguns as$e*tos
rela*ionados *om os o$eradores l;gi*os e rela*ionais9 Exe*ute o $rograma $asso-a-$asso e observe o
valor das vari@veis9
8.@ >!erador Condicional
7 o$erador *ondi*ional B?:C ( usado em ex$ress<es *ondi*ionais9 Ama ex$ress6o *ondi*ional
$ode ter dois valores di8erentes de$endendo de uma *ondi56o de *ontrole9
+intae) A sintaxe de uma ex$ress6o *ondi*ional (D
condio ? expresso_1 : expresso_2
onde expresso_1 e expresso_2 s6o duas ex$ress<es %uais%uer, e condio ( uma
ex$ress6o l;gi*a %ue ser@ avaliada $rimeiro9 Se o valor de condio 8or 1, isto (, verdadeiro, ent6o a
ex$ress6o *ondi*ional assumir@ o valor de expresso_19 Caso *ontrario assumir@ o valor de
expresso_29 Ama ex$ress6o *ondi*ional ( e%uivalente a uma estrutura de de*is6o sim$lesD
se condio
ento expressao_1
seno expressao_2
fim se
Eem!lo) 7bserve as ex$ress<es *ondi*ionais abaixo e veri8i%ue o resultado de sua avalia56o9
Admita %ue i, j e k s6o vari@veis ti$o int *om valores 1, 2 e 3, res$e*tivamente9
)*presso Valor
i ? j : k 2
j > i ? ++k : --k 4
k == i && k != j ? i + j : i - j -1
i > k ? i : k 3
>E
7 o$erador *ondi*ional tem baixa $re*edIn*ia, $re*edendo, a$enas, aos o$eradores de atribui56o9
&e:a a tabela =919
Programa Eem!lo) 7 ar%uivo e0306.cpp tra3 um $rograma $ara visuali3ar alguns as$e*tos
rela*ionados *om o o$erador *ondi*ional9 Exe*ute o $rograma $asso-a-$asso e observe o valor das
vari@veis9
8.4 FunGes de %i%lioteca
Ama 8un56o ( um su%#!rograma Btamb(m *hamado de rotinaC9 Esta 8un56o recebe in8orma5<es,
as processa e retorna outra in8orma56o9 1or exem$lo, $odemos ter uma 8un56o %ue re*eba um valor
num(ri*o, *al*ule seu logaritmo de*imal e retorne o valor obtido9 Existem dois ti$os de 8un5<esD funes
de biblioteca e funes de usu/rio9 2un5<es de bibliote*a s6o 8un5<es es*ritas $elos 8abri*antes do
*om$ilador e :@ est6o $r(-*om$iladas, isto (, :@ est6o es*ritas em *;digo de m@%uina9 2un5<es de usu@rio
s6o 8un5<es es*ritas $elo $rogramador9 Nesta se56o trataremos somente das 8un5<es de bibliote*a,
8un5<es de usu@rio ser6o vistas no *a$?tulo R9
8.4.1 > uso de :unGes
Antes de usar uma 8un56o ( $re*iso saber *omo a 8un56o esta de*larada, isto (, %uais s6o os
$arMmetros %ue a 8un56o re*ebe e %uais s6o os $ara metros %ue a 8un56o retorna9 Estas in8orma5<es est6o
*ontidas no manual do usu@rio do *om$ilador ou em sua do*umenta56o on0line9
+intae) A sintaxe de de*lara56o de uma 8un56o (D
tipo_ret nome(tipo_1, tipo_2, ...)
onde nome ( o nome da 8un56o, tipo_1, tipo_2, 999 s6o os ti$os Be %uantidadeC de $arMmetros
de entrada da 8un56o e tipo_ret ( o ti$o de dado de retorno da 8un56o9 Al(m dos ti$os usuais vistos na
se56o 49=, existe ainda o ti$o void Bva3io, em inglIsC %ue signi8i*a %ue a%uele $arMmetro ( inexistente9
Eem!lo) A 8un56o cos() da bibliote*a math.h ( de*larada *omoD
double cos(double);
>1
Isto signi8i*a %ue a 8un56o tem um $arMmetro de entrada e um $arMmetro de sa?da, ambos s6o do
ti$o double9
Eem!lo) A 8un56o getch() da bibliote*a conio.h ( de*larada *omoD
int getch(void);
Isto signi8i*a %ue a 8un56o n6o tem $arMmetros de entrada e tem um $arMmetro int de sa?da9
1ara $odermos usar um 8un56o de bibliote*a devemos incluir a bibliote*a na *om$ila56o do
$rograma9 Esta in*lus6o ( 8eita *om o uso da diretiva #include *olo*ada antes do $rograma $rin*i$al,
*omo visto na se*ao 49>949
Eem!lo) Assim $odemos usar a 8un56o no seguinte tre*ho de $rogramaD
#include <math.h> // incluso de biblioteca
void main(){ // inicio do programa principal
double h = 5.0; // hipotenusa
double co; // cateto oposto
double alfa = M_PI_4; // angulo: /4
co = h * cos(alfa); // calculo: uso da funcao cos()
} // fim do programa
As 8un5<es tem alta $re*edIn*ia, sendo mais baixa a$enas %ue os $arInteses9 A tabela =91 mostra
as $re*edIn*ias de todos os o$eradores estudados neste *a$?tulo9
8.4.' As %i%liotecas dis!on(veis e algumas :unGes interessantes
A seguir segue uma lista de todas as bibliote*as dis$on?veis no *om$ilador %urbo *11 2!3
$orlandD Ao longo do texto veremos o uso de muitas 8un5<es *obrindo uma boa $arte destas bibliote*as,
$or(m o leitor %ue dese:ar tornar-se W8luenteW na linguagem C $ode Be deveC estud@-las *om $ro8undidade9
alloc.h assert.h bcd.h bios.h complex.h
>4
conio.h ctype.h dir.h dirent.h dos.h
errno.h fcntl.h float.h fstream.h generic.h
graphics.h io.h iomanip.h iostream.h limits.h
locale.h malloc.h math.h mem.h process.h
setjmp.h share.h signal.h stdarg.h stddef.h
stdio.h stdiostr.h stdlib.h stream.h string.h
strstrea.h sys\stat.h sys\timeb.h sys\types.h time.h
values.h
&e:amos algumas 8un*oes dis$oniveis nas bibliote*as C9

$i%lioteca math.h
int a"s(int i);
double fa"s(double d);
Cal*ula o valor absoluto do inteiro i e do real d, res$e*tivamente9
double sin(double arco);
double cos(double arco);
double tan(double arco);
double asin(double arco);
double acos(double arco);
double atan(double arco);
2un5<es trigonometri*as do Mngulo arco, em radianos9
double ceil(double nm);
double floor(double nm);
2un*oes de arredondamento $ara inteiro9
ceil() arredonda $ara *ima9 Ex9 ceil(3.2) == 3.0;
floor() arredonda $ara baixo9 Ex9 floor(3.2) == 4.0;
double lo&(double nm);
double lo&26(double nm);
2un*oes logaritmi*asD log() ( logaritmo natural Bbase eC, log10() ( logaritmo
de*imal Bbase 1EC9
double pow(double base, double exp);
1oten*ia*aoD pow(3.2,5.6) S =94
F9H
9
>=
double sqrt(double nm);
Rai3 %uadradaD sqrt(9.0) = 3.0.
$i%lioteca stdli%.h
int random(int nm);
!era um n,mero inteiro aleat;rio entre 0 e nm - 19
Programa Eem!lo) 7 ar%uivo e0307.cpp tra3 um $rograma $ara visuali3ar alguns as$e*tos
rela*ionados *om 8un5<es de bibliote*a9 Exe*ute o $rograma $asso-a-$asso e observe o valor das
vari@veis9
>>
8.6 PrecedBncia entre os o!eradores do C
A tabela =91 mostra a ordem de $re*edIn*ia de todos os o$eradores estudados neste *a$?tulo9 7s
o$eradores de maior $re*edIn*ia s6o os !arBnteses e as *hamadas de :unGes9 7s o$eradores de menor
$re*edIn*ia s6o os o o$eradores de atri%uio9
Categoria >!eradores Prioridade
$arInteses
( )
interno externo
8un56o
nome()
E D
in*remental, l;gi*o
++ -- !
E D
aritm(ti*o
* / %
E D
aritm(ti*o
+ -
E D
rela*ional
< > <= >=
E D
rela*ional
== !=
E D
l;gi*o
&&
E D
l;gi*o
||
E D
*ondi*ional
?:
E D
atribui56o
= += -= *= /= %=
E D
Tabela 3.1: .reced4ncia dos operadores! 5aior preced4ncia no topo menor preced4ncia na base!
>F
>H
>9 Entrada e Sa?da
1ara %ue um $rograma torne-se minimamente 8un*ional ( $re*iso %ue ele re*eba dados do meio
externo Bte*lado, mouse, $ortas de *omuni*a56o, drives de dis*o, et*9C e emita o resultado de seu
$ro*essamento de volta $ara o meio externo Bmonitor, im$ressora, alto-8alante, $ortas de *omuni*a56o,
drives de dis*o, et*9C9 De outro modoD um $rograma deve tro*ar in8orma5<es *om o meio externo9 Em C,
existem muitas 8un5<es $r(-de8inidas %ue tratam desta tro*a de in8orma5<es9 S6o as 8un5<es de entrada e
sa(da do C9 Nos exem$los mostrados nos *a$?tulos anteriores 8oram vistas algumas 8un5<es de entrada
Bscanf(), getch()C e algumas 8un5<es de sa?da Bprintf()C9 Neste *a$?tulo veremos, em detalhe,
estas e outras 8un5<es de modo a $ermitir es*rever um $rograma *om$leto em C9
.ostraremos, nas duas se5<es ini*iais as mais im$ortantes 8un5<es de entrada e sa?da de dados
em CD as 8un5<es printf() e scanf()9 A $artir do estudo destas 8un5<es ( $oss?vel es*rever um
$rograma $ro$riamente dito *om entrada, $ro*essamento e sa?da de dados9
>91 Sa?da 8ormatadaD printf()
$i%lioteca) stdio.h
Declarao) int printf (const char* st_contr [, lista_ar!]);
Pro!"sito) A 8un56o printf() Bprint formatedC im$rime dados da lista de argumentos
lista_ar! 8ormatados de a*ordo *om a string de *ontrole st_contr9 Esta 8un56o retorna um valor
inteiro re$resentando o n,mero de *ara*teres im$ressos9
Esta 8un56o im$rime dados num(ri*os, *ara*teres e strings9 Esta8un56o ( dita de sa?da 8ormatada
$ois os dados de sa?da $odem ser 8ormatados Balinhados, *om n,mero de d?gitos vari@veis, et*9C9
+intae) A string de controle ( uma m@s*ara %ue es$e*i8i*a B8ormataC o %ue ser@ im$resso e de
%ue maneira ser@ im$resso9
Eem!lo) 7bserve no exem$lo abaixo as instrues de sa?da 8ormatada e os res$e*tivos
resultados9
>7
Instruo Sa7da
printf(Ola', Mundo!); Ola', Mundo!
printf(linha 1 \nlinha 2 ); linha 1
linha 2
7bserve %ue na $rimeira instru56o, a sa?da ( exatamente igual a string de *ontrole9 /@ na segunda
instru56o a im$ress6o se deu em duas linhas9 Isto se deve ao \n %ue re$resenta o *;digo ASCII $ara
%uebra de linha Bve:a se56o 4919=C9
Nesta mas*ara ( $oss?vel reservar es$a5o $ara o valor de alguma vari@vel usando especificadores
de formato9 Am es$e*i8i*ador de 8ormato mar*a o lugar e o :ormato de im$ress6o das vari@veis *ontidas
na lista vari;veis9 Deve haver um es$e*i8i*ador de 8ormato $ara *ada vari@vel a ser im$ressa9 #odos os
es$e*i8i*adores de 8ormato *ome5am *om um %9
Eem!lo) 7bserve no exem$lo abaixo as instrues de sa?da 8ormatada e os res$e*tivos
resultados9 Admita %ue idade se:a uma vari@vel int *ontendo o valor 29 e %ue tot e din se:am
vari@veis float *u:o valores s6o, res$e*tivamente, 12.3 e 15.09
Instruo8
printf(Tenho %d anos de vida,idade);
Sa7da8
Tenho 29 anos de vida
Instruo8
printf(Total: %f.2 \nDinheiro: %f.2 \nTroco: %f.2,tot,din,din-tot);
Sa7da8
Total: 12.30
Dinheiro: 15.00
Troco: 2.70

De$ois do sinal %, seguem-se alguns modi8i*adores, *u:a sintaxe ( a seguinteD
% [fla!] [taman"o] [.preciso] tipo
[flag]
9usti:icao de sa(da) E>!cionalF
-
:usti8i*a56o X es%uerda9
>G
+
*onvers6o de sinal Bsa?da sem$re *om sinalD N ou -C
<espao>
*onvers6o de sinal Bsa?das negativas *om sinal, $ositivas sem sinalC
[tamanho]
es!eci:icao de tamanho E>!cionalF
n
$elo menos n d?gitos ser6o im$ressos Bd?gitos 8altantes ser6o *om$letados $or
bran*osC9
0n
$elo menos n d?gitos ser6o im$ressos Bd?gitos 8altantes ser6o *om$letados $or
3erosC9
[.preciso]
es!eci:icador de !recisoJ d(gitos a direita do !onto decimal. E>!cionalF
(nada)
$adr6oD H d?gitos $ara reais9
.0
nenhum digito de*imal9
.n
s6o im$ressos n d?gitos de*imais9
Tipo
caracter de converso de ti!o EReCueridoF
d
inteiro de*imal
o
inteiro o*tal
x
inteiro hexade*imal
f
$onto 8lutuanteD [-]dddd.dddd9
e
$onto 8lutuante *om ex$oenteD [-]d.dddde[+/-]ddd
c
*ara*ter sim$les
s
string
Programa Eem!lo) 7 ar%uivo e0401.cpp *ont(m um $rograma %ue ilustra o uso da 8un56o
printf() usando v@rias *ombina5<es de strings de controle e especificadores de formato9 Exe*ute o
$rograma $asso-a-$asso e veri8i%ue a sa?da dos dados9
>94 eitura 8ormatadaD scanf()
$i%lioteca) stdio.h
Declarao) int scanf(const char* st_contr [, end_var, ...]);
Pro!"sito) A 8un56o scanf() Bscan formatedC $ermite a entrada de dados num(ri*os, *ara*teres
e YstringsY e sua res$e*tiva atribui56o a vari@veis *u:os endere5os s6o end_var9 Esta 8un56o ( dita de
entrada 8ormatada $ois os dados de entrada s6o 8ormatados $ela string de controle st_contr9 a um
determinado ti$o de vari@vel Bint, float, char, 999C9
+intae) 7 uso da 8un56o scanf() ( semelhante ao da 8un56o printf()9 A 8un56o lI da
entrada $adr6o Bem geral, te*ladoC uma lista de valores %ue ser6o 8ormatados $ela string de *ontrole e
arma3enados nos endere5os das vari@veis da lista9 A string de *ontrole ( 8ormada $or um *on:unto de
es$e*i8i*adores de 8ormato, *u:a sintaxe ( a seguinteD
>9
% [*] [taman"o] tipo
9
indicador de su!resso E>!cionalF
<presente>
Se o indi*ador de su$ress6o estiver $resente o *am$o n6o ( lido9 Este su$ressor (
,til %uando n6o %ueremos ler um *am$o de dado arma3enado em ar%uivo9
<ausente>
7 *am$o ( lido normalmente9
Tamanho
es!eci:icador de tamanhoE>!cionalF
n
Es$e*i8i*a n *omo o numero m@ximo de *ara*teres $ara leitura do *am$o9
<ausente>
Cam$o de %ual%uer tamanho9
Tipo
de:ine o ti!o de dado a ser lido EReCueridoF
d
inteiro de*imal BintC
f
$onto 8lutuante BfloatC
o
inteiro o*tal BintC
x
inteiro hexade*imal BintC
i
inteiro de*imal de %ual%uer 8ormatoBintC
u
inteiro de*imal sem sinal Bunsigned intC
s
string Bchar*)
c
*ara*ter BcharC
A lista de vari@veis ( o *on:unto de Bendere5osC de vari@veis $ara os %uais ser6o $assados os
dados lidos9 &ari@veis sim$les devem ser $re*edidos $elo *ara*ter &. &e:a mais sobre endere5os na se56o
R9R &ari@veis string e vetores n6o s6o $re*edidos $elo *ara*ter &. &e:a mais sobre strings e vetores na
se56o R9R
Programa eem!loD 7 ar%uivo e0402.cpp *ont(m um $rograma %ue ilustra o uso da 8un56o
scanf() na leitura de dados9 Exe*ute o $rograma $asso-a-$asso e veri8i%ue *omo os es$e*i8i*adores de
8ormato agem sobre os dados digitados9
>9= Entrada de *ara*ter individualD getchar()
$i%lioteca) stdio.h
Declarao) int getchar(void);
Pro!"sito) A 8un56o getchar() Bget c#aracterC lI um *ara*ter individual da entrada $adr6o
Bem geral, o te*ladoC9 Se o*orrer um erro ou uma *ondi56o de Yfim0de0ar6uivoY durante a leitura, a 8un56o
retorna o valor da *onstante simb;li*a EOF Bend of fileCde8inida na bibliote*a stdio.h9 Esta 8un56o
$ermite uma 8orma e8i*iente de dete*56o de 8inais de ar%uivos9
FE
Esta 8un56o ( dita line buffered, isto (, n6o retorna valores at( %ue o *ara*ter de *ontrole line feed
B\nC se:a lido9 Este *ara*ter, normalmente, ( enviado $elo te*lado %uando a te*la [enter] (
$ressionada9 Se 8orem digitados v@rios *ara*teres, estes 8i*ar6o arma3enados no buffer de entrada at( %ue
a te*la [enter] se:a $ressionada9 Ent6o, *ada *hamada da 8un56o getchar() ler@ um *ara*ter
arma3enado no buffer9
>9> Sa?da de *ara*ter individualD putchar()
$i%lioteca) stdio.h
Declarao) int putchar(int c);
Pro!"sito) Esta 8un56o putchar() Bput c#aracterC im$rime um *ara*ter individual c na sa?da
$adr6o Bem geral o monitor de v?deoC9
Programa Eem!lo) 7 $rograma e0403.cpp mostra o uso das 8un5<es getchar() e
putchar() em um $rograma %ue lI *ara*teres do te*lado e os reim$rime *onvertidos $ara mai,s*ulos9
>9F eitura de te*ladoD getch(), getche()
$i%lioteca) conio.h
Declarao) int getch(void);
int getche(void);
Pro!"sito) Estas 8un5<es 8a3em a leitura dos *;digos de te*lado9 Estes *;digos $odem
re$resentar te*la s de *ara*teres BA, y, *, 8, et*9C, te*las de *omandos B Zenter[, Zdelete[, ZPage Up[,
ZF1[, et*9C ou *ombina56o de te*las BZAlt[ N ZA[, ZShift[ N ZF1[, ZCtrl[ N ZPage Down], et*9C9
Ao ser exe*utada, a 8un56o getch() Bget c#aracterC aguarda %ue uma te*la Bou *ombina56o de
te*lasC se:a $ressionada, re*ebe do te*lado o *;digo *orres$ondente e retorna este valor9 A 8un56o
getche()Bget c#aracter and ec#oeC tamb(m es*reve na tela, %uando $oss?vel, o *ara*ter
*orres$ondente9
F1
C"digo A+C**D ao ser $ressionada uma te*la *orres$ondente a um *ara*ter ASCII, o te*lado
envia um *;digo ao YbufferY de entrada do *om$utador e este *;digo ( lido9 1or exem$lo, se a te*la A 8or
$ressionada o *;digo 65 ser@ arma3enado no buffer e lido $ela 8un56o9
C"digo Es!ecialD ao serem $ressionadas *ertas te*las Bou *ombina56o de te*lasC %ue n6o
*orres$ondem a um *ara*ter ASCII, o te*lado envia ao YbufferY do *om$utador dois *;digos, sendo o
$rimeiro sem!re E9 1or exem$lo, se a te*la ZF1[ 8or $ressionada os valores 0 e 59 ser6o arma3enados e a
8un56o deve ser *hamada duas veAes $ara ler os dois *;digos9
Programa eem!lo) 7 ar%uivo e0404.cpp mostra um $rograma $ara a leitura de te*lado9 Este
$rograma usa a 8un56o getch() $ara re*onhe*er te*las e *ombina56o de te*las9
Programa eem!lo) 7 ar%uivo e0405.cpp mostra um $rograma $ara a leitura de te*lado
usando a 8un56o getche()9
>9H Es*rita 8ormatada em *oresD cprintf()
$i%lioteca) conio.h
Declarao) int cprintf (const char* st_contr [, lista_ar!]);
Pro!"sito) Esta 8un56o cprintf() Bcolor print formatedC $ermite a sa?da de dados num(ri*os,
*ara*teres e strings usando *ores9 7 uso da 8un56o cprintf()( semelhante a printf()$or(m
$ermite %ue a sa?da se:a a *ores9 1ara %ue a sa?da se:a *olorida ( ne*ess@rio de8inir as *ores de 8undo e de
letra $ara a im$ress6o antes do uso da 8un56o9
Cores !:odo Te*to$
Cor Constante Valor ;undo <etra
Preto BLACK 0 ok ok
Azul BLUE 1 ok ok
Verde GREEN 2 ok ok
F4
Cian CYAN 3 ok ok
Vermelho RED 4 ok ok
Magenta MAGENTA 5 ok ok
Marrom BROWN 6 ok ok
Cinza Claro LIGHTGRAY 7 ok ok
Cinza Escuro DARKGRAY 8 -- ok
Azul Claro LIGHTBLUE 9 -- ok
Verde Claro LIGHTGREEN 10 -- ok
Cian Claro LIGHTCYAN 11 -- ok
Vermelho Claro LIGHTRED 12 -- ok
Magenta Claro LIGHTMAGENTA 13 -- ok
Amarelo YELLOW 14 -- ok
Branco WHITE 15 -- ok
Piscante BLINK 128 -- ok
Estas de8ini5<es s6o 8eitas $elas 8un5<es texcolor() e textbackground() *u:a sintaxe (D
textcolor(cor_de_letra);
textbackground(cor_de_fndo);
onde cor_de_letra e cor_de_fndo s6o n,meros inteiros re8erentes as *ores da $alheta
$adr6o B1H *ores, modo textoC9 Estes valores de *or s6o re$resentadas $or *onstantes simb;li*as de8inidas
na bibliote*a conio.h9 1ara se usar uma letra $is*ante deve-se adi*ionar o valor 128 ao valor da *or de
letra9 Alguns valores de *or n6o $odem ser usados *omo *or de 8undo9 A rela56o a*ima mostra as *ores,
suas *onstantes simb;li*as e onde $odem ser usadasD
Eem!lo) 7 tre*ho de $rograma abaixo im$rime uma mensagem de alerta em amarelo $is*ante
sobre 8undo vermelho9
#include <conio.h>
...
textbackground(RED);
textcolor(YELLOW + BLINK);
cprintif( Alerta: Vrus Detectado! );
...
Programa Eem!lo) 7 $rograma do ar%uivo e0406.cpp mostra todas as *ombina5<es
$oss?veis de im$ress6o *olorida em modo texto9
F=
>97 Sa?da sonoraD sound(), delay(), nosound()
$i%lioteca) dos.h
DeclaraGes) void sound(unsigned fre#);
void delay(unsigned tempo);
void nosound(void);
Pro!"sito) A 8un56o sound() ativa o alto-8alante do 1C *om uma 8re%PIn*ia fre# B'3C9 A
8un56o delay() reali3a uma $ausa Baguarda intervalo de tem$oC de dura56o tempo BmilisegundosC9 A
8un56o nosound() desativa o alto-8alante9
Programa Eem!lo) 7 uso destas 8un5<es ( muito sim$les mas $rodu3 resultados interessantes9
No ar%uivo e0407.cpp temos um exem$lo do uso de sons em $rogramas9
>9G im$e3a de telaD clrscr(), clreol()
$i%lioteca) conio.h
DeclaraGes) void clrscr(void);
void clreol(void);
Pro!"sito) A 8un56o clrscr() Bclear screenC lim$a a :anela de tela e $osi*iona o *ursor na
$rimeira linha e $rimeira *oluna da :anela B*anto su$erior es%uerdo da :anelaC9 A 8un56o clreol()
Bclear to end of lineC lim$a uma linha desde a $osi56o do *ursor at( o 8inal da linha mas n6o modi8i*a a
$osi56o do *ursor9 Ambas 8un5<es $reen*hem a tela *om a *or de 8undo de8inida $ela 8un56o
textbacground()9
>99 1osi*ionamento do *ursorD gotoxy()
$i%lioteca) conio.h
DeclaraGes) void gotoxy(int pos_x, int pos_$);
Pro!"sito) Em modo texto $adr6o, a tela ( dividida em uma :anela de 4F linhas e GE *olunas9 A
8un56o gotoxy() $ermite $osi*ionarmos o *ursor em %ual%uer $osi56o (pos_x,pos_y) da tela9
F>
Sendo %ue a $osi56o B1,1C *orres$onde ao *anto su$erior es%uerdo da tela e a $osi56o BGE,4FC *orres$onde
ao *anto in8erior direito9 Como as 8un5<es printf() e cprintf() es*revem a $artir da $osi56o do
*ursor, $odemos es*rever em %ual%uer $osi56o da tela9
>91E Redimen*ionamento de :anelaD window()
$i%lioteca) conio.h
DeclaraGes) void window(int es#, int sp, int dir, int inf);
Pro!"sito) Esta 8un56o $ermite rede8inir a :anela de texto9 As *oordenadas esq e sup de8inem o
*anto su$erior es%uerdo da nova :anela, en%uanto as *oordenadas inf e dir de8inem o *anto in8erior
direito da nova :anela9 1ara reativar a :anela $adr6o es*reve-se a instru56o window(1,1,80,25)9
Ouando uma :anela ( de8inida, o texto %ue 8i*ar 8ora da :anela 8i*a *ongelado at( %ue se rede8ina a :anela
original9
>911 .onitora56o de te*ladoD kbhit()
$i%lioteca) conio.h
DeclaraGes) int kbhit(void);
Pro!"sito) Esta 8un56o B7eyboard #ittingC $ermite veri8i*ar se uma te*la 8oi $ressionada ou n6o9
Esta 8un56o veri8i*a se existe algum *;digo no buffer de te*lado9 Se houver algum valor, ela retorna um
n,mero n6o nulo e o valor arma3enado no buffer $ode ser lido *om as 8un5<es getch() ou getche()9
Caso nenhuma te*la se:a $ressionada a 8un56o retorna E9 7bserve %ue, ao *ontr@rio de getch(), esta
8un56o no aguarda %ue uma te*la se:a $ressionada9
Programa Eem!lo) 7 ar%uivo eE>EG9*$$ *ont(m um $rograma $ara exem$li8i*ar o uso das
8un5<es clrscr(), clreol(), gotoxy(), window(), kbhit().
FF
F9 Estruturas de Controle
Estruturas de *ontrole $ermitem *ontrolar a se%PIn*ia das a5<es l;gi*as de um $rograma9
-asi*amente, existem dois ti$os de estruturas de *ontroleD estruturas de re!etio e estruturas de
deciso9 A estrutura de re$eti56o $ermite %ue um blo*o de instru5<es se:a exe*utado re$etidamente uma
%uantidade *ontrolada de ve3es9 A estrutura de de*is6o $ermite exe*utar um entre dois ou mais blo*os de
instru5<es9 Neste *a$?tulo estudaremos em detalhe as instru5<es do C %ue $ermitem im$lementar estas
estruturas9
F91 Condi56o de *ontrole
Em todas as estruturas, existe $elo menos uma ex$ress6o %ue 8a3 o *ontrole de Cual blo*o de
instru5<es ser@ exe*utado ou Cuantas veAes ele ser@ exe*utadoD ( o %ue *hamamos de condio de
controle9 Ama *ondi56o de *ontrole ( uma ex$ress6o l;gi*a ou aritm(ti*a *u:o resultado $ode ser
*onsiderado verdadeiro ou 8also9 Con8orme vimos na se56o =9F, a linguagem C n6o $ossui, entretanto,
vari@veis ou *onstantes l;gi*as, $ossui somente ex$ress<es num(ri*as, assim %uando uma e!resso
numrica se en*ontra em uma condio de controle, ela ser@ *onsiderada :alsa se seu valor 8or igual a
Aero, e verdadeira se seu valor 8or di:erente de Aero9
Eem!lo) 7bserve nas *ondi5<es abaixo, seu valor num(ri*o e seu signi8i*ado l;gi*o9 Considere
as vari@veis int i = 0, j = 3;
condio valor numrico si&nificado l=&ico
(i == 0) 1 verdadeiro
(i > j) 0 falso
(i) 0 falso
(j) 3 verdadeiro
Este 8ato deve 8i*ar *laro $ois, nas estruturas %ue estudaremos neste *a$?tulo, %uando 8or dito %ue
uma *ondi56o ( :alsa ou verdadeira %uer se di3er %ue seu valor e igual a 3ero ou di:erente de 3ero9
F94 Estrutura do...while
FH
Esta ( uma estrutura b@si*a de re$eti56o *ondi*ional9 1ermite a exe*u56o de um blo*o de
instru5<es re$etidamente9 Sua sintaxe ( a seguinteD
+intae)
do{
bloco
}while(condio);
ondeD condio ( uma ex$ress6o l;gi*a ou num(ri*a9
bloco ( um *on:unto de instru5<es9
Esta estrutura 8a3 *om %ue o blo*o de instru5<es se:a exe*utado $elo menos uma ve39 A$;s a
exe*u56o do blo*o, a *ondi56o ( avaliada9 Se a *ondi56o ( verdadeira o blo*o ( exe*utado outra ve3,
*aso *ontr@rio a re$eti56o ( terminada9 78luxograma desta estrutura ( mostrada na 8igura F91D
bloco
condio? V
F
Figura 5.1: 8luxograma da estrutura do...%"ile!
Eem!lo) No tre*ho abaixo, a leitura de um n,mero ( 8eita dentro de um la5o de re$eti56o
*ondi*ional9 A leitura ( re$etida *aso o n,mero lido se:a negativo9
do{
puts("Digite um nmero positivo:");
scanf("%f",&num);
}while(num <= 0.0);
Programa eem!lo) No ar%uivo e0501.cpp existe um $rograma %ue *al*ula o 8atorial de um
n,mero9 Este $rograma ilustra o uso da estrutura do...while9
F7
F9= Estrutura while
A estrutura de re$eti56o *ondi*ional while ( semelhante a estrutura do...while9 Sua
sintaxe ( a seguinteD
+intae)
while(condio){
bloco
}
ondeD condio ( uma ex$ress6o l;gi*a ou num(ri*a9
bloco ( um *on:unto de instru5<es9
Esta estrutura 8a3 *om %ue a *ondi56o se:a avaliada em $rimeiro lugar9 Se a *ondi56o (
verdadeira o blo*o ( exe*utado uma ve3 e a *ondi56o ( avaliada novamente9 Caso a *ondi56o se:a :alsa a
re$eti56o ( terminada sem a exe*u56o do blo*o9 7bserve %ue nesta estrutura, ao *ontr@rio da estrutura
do...while, o blo*o de instru5<es $ode n6o ser exe*utado nenhuma ve3, basta %ue a *ondi56o se:a
ini*ialmente 8alsa9 7 8luxograma desta estrutura ( mostrada na 8igura F94D
bloco
condio?
V
F
Figura 5.2: 8luxograma da estrutura %"ile.
Eem!lo) No tre*ho abaixo, *al*ula-se a $re*is6o BC do $ro*essador aritm(ti*o do 1C9 A vari@vel
eps tem seu valor dividido $or 2 en%uanto o $ro*essador *onseguir distinguir entre 1 e 1N9 A$;s a
exe*u56o do la5o, o valor de eps *ont(m a $re*is6o da m@%uina9
eps = 1.0;
FG
while(1.0 + eps > 1.0){
eps /= 2.0;
}
Programa eem!lo) No ar%uivo e0502.cpp existe um $rograma %ue *al*ula a rai3 %uadrada
de um n,mero real $ositivo usando o m(todo de Ne\ton9 Este $rograma ilustra o uso da estrutura
while9
F9> Estrutura for
A estrutura for ( muito semelhante as estruturas de re$eti56o vistas anteriormente, entretanto
*ostuma ser utili3ada %uando se %uer um n,mero determinado de *i*los9 A *ontagem dos *i*los ( 8eita $or
uma vari@vel *hamada de contador9 A estrutura for (, as ve3es, *hamada de estrutura de re!etio com
contador9 Sua sintaxe ( a seguinteD
+intae)
for(iniciali&ao; condio' incremento){
bloco
}
ondeD iniciali&ao ( uma ex$ress6o de ini*iali3a56o do *ontador9
condio ( uma ex$ress6o l;gi*a de *ontrole de re$eti56o9
incremento ( uma ex$ress6o de in*remento do *ontador9
bloco ( um *on:unto de instru5<es a ser exe*utado9
Esta estrutura exe*uta um n,mero determinado de re$eti5<es usando um *ontador de itera5<es9 7
*ontador ( ini*iali3ado na ex$ress6o de iniciali&ao antes da $rimeira itera56o9 1or exem$loD
i = 0; ou cont = 20;9 Ent6o o blo*o ( exe*utado e de!ois de *ada itera56o, o *ontador (
in*rementado de a*ordo *om a ex$ress6o de incremento9 1or exem$loD i++ ou cont -= 29
Ent6o a ex$ress6o de *ondi56o ( avaliadaD se a *ondi56o 8or verdadeira, o bloco ( exe*utado
novamente e o *i*lo re*ome5a, se a *ondi56o ( 8alsa termina-se o la5o9 Esta *ondi56o (, em geral, uma
ex$ress6o l;gi*a %ue determina o ultimo valor do *ontador9 1or exem$loD i <= 100 ou cont > 09
Eem!lo) No tre*ho abaixo, o *ontador i ( ini*iali3ado *om o valor 19 7 blo*o ( re$etido
en%uanto a *ondi56o i <= 10 8or verdadeira9 7 *ontador ( in*rementado *om a instru56o i++9 Esta
estrutura, deste modo, im$rime os n,meros 1, 2, ..., 9, 109
F9
for(i=1; i<=10; i++){
printf(" %d",i);
}
Q interessante notar %ue a mesma estrutura l;gi*a $ode ser im$lementada usando as estruturas
for ou do...whileD
Eem!lo) As seguintes instru5<es s6o $lenamente e%uivalentesD
i = 0; for(i = 0; i <= 100; i++){
do{ bloco
bloco }
i++;
}while(i <= 100);
1odem existir mais de uma ex$ress6o de iniciali&ao e de incremento na estrutura
for9 Estas ex$ress<es devem ser se$aradas $or v?rgula B,C9 .as no !ode haver mais de uma ex$ress6o
de condio9 1or exem$loD for(i=0, j=10; i<10; i++, j--){...}
Programa eem!lo) No ar%uivo e0503.cpp existe um $rograma %ue *al*ula a am$litude de
um *on:unto de valores9 Este $rograma exem$li8i*a o uso da estrutura for...
F9F Estrutura de de*is6o if...else
A estrutura if...else ( a mais sim$les estrutura de *ontrole do C9 Esta estrutura $ermite
exe*utar um entre v@rios blo*os de instru5<es9 7 *ontrole de %ual blo*o ser@ exe*utado ser@ dado $or uma
condio Bex$ress6o l;gi*a ou num(ri*aC9 Esta estrutura $ode se a$resentar de modos ligeiramente
di8erentes9 Nesta se56o vamos a$resentar se$aradamente *ada uma das $ossibilidades de sintaxe9
?.?.1 Deciso de um %loco !if---$
A estrutura de de*is6o de um blo*o $ermite %ue se exe*ute Bou n6oC um blo*o de instru5<es
*on8orme o valor de uma *ondi56o se:a verdadeiro ou 8also9 7 8luxograma desta estrutura ( mostrada na
8igura F9=9
HE
condio
bloco
V
F
Figura 5.3: 8luxograma da estrutura de deciso if...
+intae) De*is6o *om um blo*oD
if(condio){
bloco
}
ondeD condio ( uma ex$ress6o l;gi*a ou num(ri*a9
bloco ( um *on:unto de instru5<es9
Se a *ondi56o verdadeira, o bloco ( exe*utado9 Caso *ontr@rio, o blo*o n6o ( exe*utado9
Eem!lo) No tre*ho abaixo, se o valor lido 8or maior %ue 1E, ent6o o seu valor ( rede8inido *omo
1E9 7bserve %ue o blo*o *onstitui-se de um ,ni*a instru56o9
printf("Digite o nmero de repeties: (mximo 10)";
scanf("%d",&iter);
if(iter > 10){
iter = 10;
}
Programa Eem!lo) 7 ar%uivo e0504.cpp mostra um $rograma %ue utili3a a estrutura
if... $ara emitir um sinal sonoro ao im$rimir um n,mero m,lti$lo de >9
?.?.' Deciso de dois %locos !if---else$
#amb(m ( $oss?vel es*rever uma estrutura %ue exe*ute um entre dois blo*os de instru5<es9 A
8igura F9> mostra o 8luxograma *orres$ondente a esta estrutura de de*is6o9
H1
condio?
bloco 1 bloco 2
Figura 5.4: 8luxograma da estrutura de deciso if...else
+intaeD De*is6o de dois blo*osD
if(condio){
bloco 1;
}else{
bloco 2;
}
ondeD condio ( uma ex$ress6o l;gi*a ou num(ri*a9
bloco 1 e bloco 2 s6o *on:untos de instru5<es9
Se a condio 8or verdadeira o bloco 1 ( exe*utado9 Caso *ontr@rio, o bloco 2 (
exe*utado9
Eem!lo) No tre*ho abaixo, se o valor de raiz*raiz 8or maior %ue num o valor de raiz
ser@ atribu?do a max, *aso *ontrario, ser@ atribu?do a min9
if(raiz*raiz > num){
max = raiz;
}else{
min = raiz;
}
Programa Eem!lo) 7 ar%uivo e0505.cpp mostra um $rograma %ue utili3a a estrutura
if...else $ara determinar o ti$o de ra?3es de uma e%ua56o de segundo grau9
?.?.8 Deciso de mHlti!los %locos !if---else if---$
H4
#amb(m ( $oss?vel es*rever uma estrutura %ue exe*ute um entre m,lti$los blo*os de instru5<es9
A 8igura F9F mostra o 8luxograma *orres$ondente a esta estrutura de de*is6o9
Condio
1?
bloco 1
Condio
2?
bloco 2
Condio
3?
bloco 3
. . .
. . .
V
F
V
F
V
F
Figura 5.5: 8luxograma da estrutura de deciso if...else if.
+intaeD De*is6o de m,lti$los blo*osD
if(condio 1){
bloco 1;
...
}else if(condio (){
bloco (;
}else{
bloco )
}
ondeD condio 1, condio 2, ... s6o ex$ress<es l;gi*as ou num(ri*as9
bloco 1 , bloco 2,... s6o *on:untos de instru5<es9
Se a *ondi56o 1 8or verdadeira o bloco 1 ( exe*utado9 Caso *ontrario, a *ondi56o 4 (
avaliada9 Se a *ondi56o 4 8or verdadeira o bloco 2 ( exe*utado9 Caso *ontrario, a *ondi56o = (
avaliada e assim su*essivamente9 Se nenhuma *ondi56o ( verdadeira bloco ) ( exe*utado9 7bserve
%ue a$enas um dos blo*os ( exe*utado9
H=
Eem!lo) No tre*ho abaixo, uma determinada a56o ( exe*utada se o valor de num 8or $ositivo,
negativo ou nulo9
if(num > 0){
a = b;
}else if(num < 0){
a = b + 1;
}else{
a = b - 1;
}
Programa Eem!lo) 7 ar%uivo e0506.cpp mostra um $rograma %ue utili3a a estrutura
if...else if $ara determinar se um n,mero ( maior, menor ou igual a outro9
F9H Estrutura switch...case
A estrutura switch...case ( uma estrutura de de*is6o %ue $ermite a exe*u56o de um
*on:unto de instru5<es a $artir $ontos di8erentes *on8orme o resultado de uma ex$ress6o inteira de
*ontrole9 7 resultado deste ex$ress6o ( *om$arado ao valor de *ada um dos r;tulos, e as instru5<es s6o
exe*utadas a $artir desde r;tulo9 A 8igura F9H mostra o 8luxograma l;gi*o desta estrutura9
H>
conjunto 1
conjunto N
conjunto 2
conjunto D
...
e!re""o
rotulo 1
rotulo N
rotulo D
rotulo 2

Figura 5.6: 8luxograma da estrutura s%itc"...case.
+intaeD Esta estrutura $ossui a seguinte sintaxeD
switch(expresso){
case r*tlo_1:
con+nto_1
case r*tlo_2:
con+nto_2
...
case r*tlo_n:
con+nto n
[default:
con+nto d]
}
HF
ondeD
expresso ( uma ex$ress6o inteira9
r*tlo_1,r*tlo_2,...r*tlo_n e r*tlo_d s6o *onstantes inteiras9
con+nto 1, con+nto 2, ..., con+nto n e con+nto d s6o
*on:untos de instru5<es9
7 valor de expresso ( avaliado e o 8luxo l;gi*o ser@ desviado $ara o *on:unto *u:o r*tlo
( igual ao resultado da ex$ress6o e todas as instru5<es a%aio deste r;tulo ser6o exe*utadas9 Caso o
resultado da ex$ress6o 8or di8erente de todos os valores dos r;tulos ent6o con+nto d ( exe*utado9
7s r;tulos devem ser ex$ress<es *onstantes inteiras di:erentes entre si9 7 r;tulo default ( o$*ional9
Esta estrutura ( $arti*ularmente ,til %uando se tem um *on:unto de instru5<es %ue se deve
exe*utar em ordem, $or(m se $ode *ome5ar em $ontos di8erentes9
Eem!lo) 7 tre*ho abaixo ilustra o uso da instru56o switch em um menu de sele56o9 Neste
exem$lo, o $rograma ini*iar@ o $ro*esso de usinagem de uma $e5a em um $onto %ual%uer de$endendo do
valor lido9
int seleo;
puts("Digite estagio de usinagem:");
scanf("%d",&selecao);
switch(seleo){
case 1:
// desbaste grosso...
case 2:
// desbaste fino...
case 3:
// acabamento...
case 4:
// polimento...
}
Programa Eem!lo) 7 ar%uivo e0507.cpp mostra um $rograma %ue utili3a a estrutura
switch $ara determinar o valor de um lan*he9
HH
F97 Interru$56o e desvioD break, continue, goto, exit()
As instru5<es vistas anteriormente $odem so8rer desvios e interru!Ges em sua se%PIn*ia l;gi*a
normal atrav(s do uso *ertas instru5<es9 As instru5<es %ue veremos a seguir devem ser usadas *om muita
$ar*im]nia, $ois 8ogem da l;gi*a estruturada tem a tendIn*ia de tornar um $rograma in*om$reens?vel9
?.4.1 A instruo break.
Esta instru56o serve $ara terminar a exe*u56o das instru5<es de um la5o de re$eti56o Bfor,
do...while, whileC ou $ara terminar um *on:unto switch...case9
Ouando em um la5o de re$eti56o, esta instru56o 8or5a a interru$56o do la5o inde$endentemente
da *ondi56o de *ontrole9
Eem!lo) No tre*ho abaixo um la5o de re$eti56o lI valores $ara o *@l*ulo de uma m(dia9 7 la5o
$ossui uma *ondi56o de *ontrole sem$re verdadeira o %ue, a $rin*i$io, ( um erroD la5o in8inito9 1or(m, a
sa?da do la5o se d@ $ela instru56o break %ue ( exe*utada %uando um valor negativo ( lido9
puts("digite valores:");
do{
puts("valor:");
scanf("%f",&val);
if(val < 0.0){
break; // sada do lao
}
num++;
soma += val;
}while(1); // sempre verdadeiro
printf("mdia: %f",soma/num);
Eem!lo) No exem$lo a*ima, o uso da instru56o break $oderia ter sido evitado, *omo segueD
puts("digite valores:");
do{
puts("valor:");
scanf("%f",&val);
if(val >= 0.0){
H7
num++;
soma += val;
}
}while(val >= 0.0);
printf("mdia: %f",soma/num);
7 outro uso da instru56o break, em estruturas switch...case, serve $ara se$arar os
*on:untos de instru5<es em *ada case9
Eem!lo) Estrutura switch...case *om a instru56o breakD
int tipo;
puts("Selecione o sabor de sua pizza:");
puts("Muzzarela Calabreza Alho&Oleo:");
tipo = getch();
switch(tipo){
case M:
// prepara pizza muzzarela...
case C:
// prepara pizza calabreza...
case A:
// prepara pizza Alho&Oleo...
default:
puts("Opcao incorreta");
}
Programa Eem!lo) 7 ar%uivo e0508.cpp mostra um $rograma %ue utili3a a estrutura
switch *om a instru56o break $ara simular um $iano no te*lado do *om$utador9
?.4.' A instruo continue.
Esta instru56o o$era de modo semelhante a instru56o break dentro de um la5o de re$eti56o9
Ouando exe*utada, ela $ula as instru5<es de um la5o de re$eti56o sem sair do la5o9 Isto (, a instru56o
8or5a a avalia56o da *ondi56o de *onttrole do la5o9
HG
Eem!lo) No tre*ho abaixo revemos um la5o de re$eti56o lI valores $ara o *@l*ulo de uma
m(dia9 Se (val < 0.0) ent6o o $rograma salta diretamente $ara a *ondi56o de *ontrole, sem exe*utar
o resto das instru5<es9
puts("digite valores:");
do{
puts("valor:");
scanf("%f",&val);
if(val < 0.0){ // se val negativo...
continue; // ...salta para...
}
num++; // se (val < 0.0) estas instrues
soma += val; // no so executadas!
}while(val >= 0.0); // ...fim do lao
printf("mdia: %f",soma/num);
?.4.8 A instruo goto.
Esta instru56o ( *hamada de desvio de 8luxo9 A instru56o desvia o $rograma $ara um r;tulo
B$osi56o identi8i*adaC no $rograma9 S6o raros os *asos onde a instru56o goto ( ne*ess@ria, no entanto, h@
*ertas *ir*unstMn*ias, onde usada *om $rudIn*ia, ela $ode ser ,til9
+intae) A sintaxe da instru56o goto ( a seguinteD
goto r*tlo;
...
r*tlo:
...
onde r*tlo ( um identi8i*ador v@lido9
Eem!lo) No tre*ho abaixo revemos um la5o de re$eti56o lI valores $ara o *@l*ulo de uma
m(dia9 2oram usadas duas instru5<es goto.
puts("digite valores:");
inicio: // rtulo
puts("valor:");
scanf("%f",&val);
if(val < 0.0){ // se val negativo...
goto fim; // ...salta para fim
H9
}
num++; // se (val < 0.0) estas instrues
soma += val; // no so executadas!
goto inicio; // salta para inicio
fim: // rtulo
printf("mdia: %f",soma/num);
?.4.= A :uno exit().
Esta 8un56o Bn6o instru56oC exit() , da bibliote*a stdlib.h, ( uma 8un56o %ue termina a
exe*u56o de um $rograma9 Normalmente um $rograma ( terminado %uando se exe*uta a ,ltima sua
instru56o, $or(m $ode-se terminar a exe*u56o do $rograma a %ual%uer momento *om o uso desta 8un56o9
A 8un56o exit() tem a seguinte de*lara56oD void exit(int status)9 7nde o argumento
da 8un56o ( um valor inteiro %ue ser@ $assado $ara o Sistema 7$era*ionalD Bvari@vel de sistema
errorlevel no D7SC9
Eem!lo) No tre*ho abaixo revemos um la5o de re$eti56o lI valores $ara o *@l*ulo de uma
m(dia9 2oi usado a 8un56o exit $ara terminar a exe*u56o do $rograma9
puts("digite valores:");
do{
puts("valor:");
scanf("%f",&val);
if(val < 0.0){ // se val negativo...
printf("mdia: %f",soma/num); // imprime resultado
exit(0); // termina programa
}
num++; soma += val;
}while(1);
7E
71
H9 2un5<es
2un5<es Btamb(m *hamadas de rotinas, ou su%#!rogramasC s6o a essIn*ia da $rograma56o
estruturada9 2un5<es s6o segmentos de $rograma %ue exe*utam uma determinada tare8a es$e*?8i*a9 /@
vimos o uso de 8un5<es nos *a$?tulos anterioresD 8un5<es :@ $roviden*iadas $elas bibliote*as-$adr6o do C
B*omo sqrt(), toupper(), getch() ou putchar()C9
Q $oss?vel ao $rogramador, alem disso, es*rever suas $r;$rias rotinas9 S6o as *hamadas de
:unGes de usu;rio ou rotinas de usu@rio9 Deste modo $ode-se segmentar um $rograma grande em v@rios
$rogramas menores9 Esta segmenta56o ( *hamada de modulariAao e $ermite %ue *ada segmento se:a
es*rito, testado e revisado individualmente sem alterar o 8un*ionamento do $rograma *omo um todo9
1ermite ainda %ue um $rograma se:a es*rito $or v@rios $rogramadores ao mesmo tem$o, *ada um
es*revendo um segmento se$arado9 Neste *a$?tulo, veremos *omo es*rever 8un5<es de usu@rio em C9
H91 Estrutura das 8un5<es de usu@rio
A estrutura de uma 8un56o de usu@rio ( muito semelhante a estrutura dos $rogramas %ue
es*revemos at( agora9 Ama 8un56o de usu@rio *onstitui-se de um %loco de instruGes %ue de8inem os
$ro*edimentos e8etuados $ela 8un56o, um nome $elo %ual a *hamamos e uma lista de argumentos
$assados a 8un56o9 Chamamos este *on:unto de elementos de de:inio da :uno9
Eem!lo) o *;digo mostrado abaixo ( uma 8un56o de8inida $elo usu@rio $ara *al*ular a m(dia
aritm(ti*a de dois n,meros reaisD
float media2(float a, float b){
float med;
med = (a + b) / 2.0;
return(med);
}
No exem$lo a*ima de8inimos uma 8un56o *hamada media2 %ue re*ebe dois argumentos ti$o
floatD a e b. A m(dia destes dois valores ( *al*ulada e arma3enada na vari@vel med de*larada
internamente9 A 8un56o retorna, $ara o $rograma %ue a *hamou, um valor tamb(m do ti$o floatD o valor
da vari@vel med9 Este retorno de valor ( 8eito $ela 8un56o return()%ue termina a exe*u56o da 8un56o e
retorna o valor de med $ara o $rograma %ue a *hamou9
74
De$ois de de8inimos um 8un56o, $odemos us@-la dentro de um $rograma %ual%uer9 Di3emos %ue
estamos 8a3endo uma chamada a 8un56o9
Eem!lo) No exem$lo abaixo *hamamos a 8un56o media2() dentro de um $rograma $rin*i$alD
void main(){
float num_1, num_2, med;
puts(Digite dois nmeros:);
scanf(%f %f, &num_1, &num_2);
med = media2(num_1, num_2); // chamada a funo
printf(\nA media destes nmeros e %f, med);
}
H94 De8ini56o de 8un5<es
De modo 8ormal, a sintaxe de uma 8un56o ( a seguinteD
tipo_de_retorno nome_da_fno(tipo_1 ar!_1, tipo_2 ar!_2, ...){
[bloco de instr,es da fno]
}

A $rimeira linha da 8un56o *ont(m a declarao da 8un56o9 Na de*lara56o de uma 8un56o se
de8ine o nome da 8un56o, seu ti!o de retorno e a lista de argumentos %ue re*ebe9 Em seguida, dentro de
*haves {}, de8inimos o blo*o de instru5<es da 8un56o9
7 ti!o de retorno da 8un56o es$e*i8i*a %ual o ti$o de dado retornado $ela 8un56o, $odendo ser
%ual%uer ti$o de dado mostrado na se56o 49=D int, float, et*9 Se a 8un56o n6o retorna nenhum valor
$ara o $rograma %ue a *hamou devemos de8inir o retorno *omo void, ou se:a um retorno ausente9 Se
nenhum ti$o de retorno 8or es$e*i8i*ado o *om$ilador entender@ %ue o retorno ser@ ti$o int9
&ale notar %ue existe a$enas um valor de retorno $ara 8un5<es em C9 .o $odemos 8a3er o
retorno de dois ou mais valores *omo em algumas linguagens Bno .atabD [media,desvio] =
estat(a, b, c, d, e)C9 1or(m isto n6o ( um limita56o s(ria $ois o uso de $onteiros B*a$9 RC
*ontorna o $roblema9
1or ser um identi8i*ador, o nome da :uno segue as mesmas regras de de8ini56o de
7=
identi8i*adores Bve:a se56o 494C9
A lista de argumentos da 8un56o es$e*i8i*a %uais s6o os valores %ue a 8un56o re*ebe9 As
vari@veis da lista de argumentos s6o mani$uladas normalmente no *or$o da 8un56o Bve:a se56o H9F
adianteC9
A *hamada de uma 8un56o termina *om a instru56o return() %ue trans8ere o *ontrole $ara o
$rograma *hamador da 8un56o9 Esta instru56o tem duas 8inalidadesD determina o :im l"gico da rotina e o
valor de retorno da 8un56o9 7 argumento de return() ser@ retornado *omo valor da 8un56o9
H9= o*ali3a56o das 8un5<es
Existem basi*amente duas $osi5<es $oss?veis $ara es*revermos o *or$o de uma 8un56oD ou antes
ou de!ois do $rograma $rin*i$al9 1odemos ainda es*rever uma 8un56o no mesmo arCuivo do $rograma
$rin*i$al ou em arCuivo se!arado9
@.8.1 Cor!o da :uno antes do !rograma !rinci!al Eno mesmo arCuivoF
Ouando es*revemos a de8ini56o de uma 8un56o antes do $rograma $rin*i$al e no mesmo ar%uivo
deste, nenhuma outra instru56o ( ne*ess@ria9 A sintaxe geral $ara isto ( a seguinteD
+intae) Ama 8un56o es*rita antes do $rograma $rin*i$alD
tipo nomef(...){ // definio da funo
[corpo de fno]
}
void main(){ // programa principal
...
var = nomef(...) // chamada da funo
...
}
Eem!lo) 2un56o media2() es*rita antes do $rograma $rin*i$al9
float media2(float a, float b){ // funo
float med;
7>
med = (a + b) / 2.0;
return(med);
}
void main(){ // programa principal
float num_1, num_2, med;
puts(Digite dois nmeros:);
scanf(%f %f, &num_1, &num_2);
med = media2(num_1, num_2); // chamada da funo
printf(\nA media destes nmeros e %f, med);
}
Programa eem!lo) No ar%uivo e0601.cpp existe um $rograma %ue *al*ula o maior valor
entre dois n,meros digitados9 Este $rograma 8a3 uso da 8un56o max()es*rita $elo usu@rio9
@.8.' Cor!o da :uno depois do !rograma !rinci!al Eno mesmo arCuivoF
Ouando es*revemos a de8ini56o de uma 8un56o de!ois do $rograma $rin*i$al e no mesmo
ar%uivo deste, devemos in*luir um !rot"ti!o da 8un56o *hamada9 Am $rot;ti$o ( uma instru56o %ue
de8ine o nome da 8un56o, seu ti$o de retorno e a %uantidade e o ti$o dos argumentos da 8un56o9 7
$rot;ti$o de uma 8un56o indi*a ao *om$ilador %uais s6o as 8un5<es usadas no $rograma $rin*i$al os ti$o9
A sintaxe geral $ara isto ( a seguinteD
+intae) Ama 8un56o es*rita de$ois do $rograma $rin*i$alD
void main(){ // programa principal
tipo nomef(...); // prottipo da funo
...
var = nomef(...) // chamada a funo
...
}
tipo nomef(...){ // definio da funo
[corpo de fno]
}
Eem!lo) 2un56o media2() es*rita de$ois do $rograma $rin*i$al9
void main(){ // programa principal
float media2(float,float); // prottipo de media2()
7F
float num_1, num_2, med;
puts(Digite dois nmeros:);
scanf(%f %f, &num_1, &num_2);
med = media2(num_1, num_2); // chamada a funo
printf(\nA media destes nmeros e %f, med);
}
float media2(float a, float b){ // funo media2()
float med;
med = (a + b) / 2.0;
return(med);
}
7bserve %ue o $rot;ti$o de uma 8un56o nada mais ( %ue a declarao da 8un56o sem o seu *or$o9
7bserve ainda %ue na lista de argumentos do $rot;ti$o $odem ser es*ritos a$enas os ti!os dos
argumentos9
Programa eem!lo) No ar%uivo e0602.cpp existe um $rograma %ue *al*ula o maior valor
entre dois n,meros digitados9 Este $rograma 8a3 uso da 8un56o max()es*rita $elo usu@rio9
@.8.8 Cor!o da :uno escrito em arquivo separado
Em C, *omo em muitas outras linguagens, ( $ermitido %ue o usu@rio *rie uma 8un56o em um
arCuivo e um $rograma %ue a *hame em outro arCuivo distinto9 Esta 8a*ilidade $ermite a *ria56o de
%i%liotecas de usu;rioD um *on:unto de ar%uivos *ontendo 8un5<es es*ritas $elo usu@rio9 Esta
$ossibilidade ( uma grande vantagem utili3ada em larga es*ala $or $rogramadores $ro8issionais9
Ouando es*revemos a de8ini56o de uma 8un56o em arCuivo se!arado do $rograma $rin*i$al
devemos incluir este ar%uivo no *on:unto de ar%uivos de com!ilao do $rograma $rin*i$al9 Esta
in*lus6o ( 8eita *om a diretiva #include9 Esta diretiva, vista nas se5<es 49>94 e =9791, instrui o
*om$ilador $ara in*luir na *om$ila56o do $rograma outros ar%uivos %ue *ontem a de8ini56o das 8un5<es
de usu@rio e de bibliote*a9
+intae) A sintaxe de in*lus6o de 8un5<es de usu@rio ( a seguinteD
#include pat" // incluso da funo
7H
void main(){ // programa principal
...
var = nomef(...) // chamada a funo
...
}
Na diretiva #include, indi*amos entre as$as du$las o *aminho de lo*ali3a56o do ar%uivo onde
est@ de8inida a 8un56o *hamada9
Eem!lo) A 8un56o media2() est@ es*rita em um ar%uivo se$arado9
#include c:\tc\userbib\stat.h // incluso da funo
void main(){ // programa principal
float num_1, num_2, med;
puts(Digite dois nmeros:);
scanf(%f %f, &num_1, &num_2);
med = media2(num_1, num_2); // chamada a funo
printf(\nA media destes nmeros e %f, med);
}
Programa eem!lo) No ar%uivo e0603.cpp existe um $rograma %ue *al*ula o maior valor
entre dois n,meros digitados9 Este $rograma 8a3 uso da 8un56o max()es*rita $elo usu@rio no ar%uivo
e0604.cpp9
>%servao) Am ar%uivo $ode *onter a de8ini56o de uma ou mais 8un5<es9 Em geral, %uando o
ar%uivo $ossui a$enas uma 8un56o ele ( nomeado *om o mesmo nome da 8un56o e extens6o *.cpp ou
*.c9 1or exem$lo, $oder?amos de8inir a 8un56o media() no ar%uivo media.cpp9 Ouando um ar%uivo
$ossui a de8ini56o de mais de uma 8un56o, ele ( nomeado *om a extens6o *.h ou *.lib9 1or exem$loD
$oder?amos *riar um *on:unto de 8un5<es estat?sti*as *hamadas media(), dsvpd(), moda(),
max(), min(), et*9 de8inindo-as em um ar%uivo *hamado stat.h9
H91F 'ierar%uia de 2un5<es
Sem$re ( $oss?vel %ue um $rograma $rin*i$al *hame uma 8un56o %ue $or sua ve3 *hame outra
8un56o999 e assim su*essivamente9 Ouando isto a*onte*e di3emos %ue a 8un56o *hamadora tem hierar%uia
maior Bou su$eriorC a 8un56o *hamada9 7u %ue a 8un56o *hamadora est@ em um n?vel hier@r%ui*o su$erior
a 8un56o *hamada9
77
Ouando isto o*orre, devemos ter o *uidado de de8inir Bou in*luirC as 8un5<es em ordem *res*ente
de hierar%uia, isto (, uma 8un56o chamada ( es*rita antes de uma 8un56o chamadora9 Isto se deve ao
8ato de %ue o *om$ilador deve *onhe*er uma 8un56o antes de %ue *hamada se:a *om$ilada9
Programa eem!lo) No ar%uivo e0605.cpp existe um :ogo de J-ac7potK %ue ilustra o uso de
v@rias rotinas $or um $rograma $rin*i$al9 7bserve tamb(m %ue estas 8un5<es *hamam-se umas as outras9
Neste $rograma exem$lo, os n?veis hier@r%ui*os das 8un5<es $odem ser *olo*ados da seguinte
maneiraD
main()
regras() abertura() sorte() plim_plim() saida() simnao()
imprimec() roleta()
pinta() bip()
No exem$lo a*ima temos um $rimeiro n?vel onde se en*ontra a 8un56o mainBC Zo $rograma
$rin*i$al tamb(m ( uma 8un56o[ %ue *hama as 8un5<es x, ", 39 A 8un56o x $or sua ve3 *hamas as 8un5<es
s, r, e t9 7bserve %ue neste exem$lo os $rot;ti$os das 8un5<es est6o *olo*ados de modo a %ue as 8un5<es
de menor hierar%uia s6o es*ritas antes das 8un5<es de maior hierar%uia9
H9F Regra de es*o$o $ara vari@veis
A regra de es*o$o de8ine o Km%ito de validade de vari@veis9 Em outras $alavras de8ine onde as
vari@veis e 8un5<es s6o re*onhe*idas9 Em C, uma vari@vel s; $ode ser usada a$;s ser declarada Bver
se56o 49=94C9 Isto $or %ue o $ro*essador deve reservar um lo*al da mem;ria $ara arma3enar os valores
atribu?dos X vari@vel9 1or(m o lo*al, do $rograma, onde uma vari@vel ( de*larada de8ine ainda seu esco!o
de validade9 Ama vari@vel $ode ser local, glo%al ou :ormal de a*ordo *om o lo*al de de*lara56o9
<ari;veis Locais) Ama vari@vel ( dita local, se 8or de*larada dentro do %loco de uma 8un56o9
Ama vari@vel lo*al tem validade a$enas dentro do blo*o onde ( de*larada, isto signi8i*a %ue $odem ser
a$enas a*essadas e modi8i*adas dentro de um blo*o9 7 es$a5o de mem;ria alo*ado $ara esta vari@vel (
criado %uando a exe*u56o do blo*o ( ini*iada e destru(do %uando en*errado, assim vari@veis de mesmo
nome mas de*laradas em blo*os distintos, s6o $ara todos os e8eitos, vari@veis distintas9
7G

Eem!lo)
float media2(float a, float b){
float med;
med = (a + b) / 2.0;
return(med);
}
void main(){
float num_1, num_2, med;
puts(Digite dois nmeros:);
scanf(%f %f, &num_1, &num_2);
med = media2(num_1, num_2);
printf(\nA media destes nmeros e %f, med);
}
No exem$lo a*ima, med ( uma vari@vel lo*al de8inida $ela 8un56o media()9 7utra vari@vel
med ( tamb(m de8inida $ela 8un56o main()9 1ara todos os e8eitos estas vari@veis s6o distintas9
<ari;veis Formais) Ama vari/vel formal ( uma vari@vel lo*al de*larada na lista de !arKmetros
de uma 8un56o9 Deste modo, tem validade a$enas dentro da 8un56o onde ( de*larada, $or(m serve de
su$orte $ara os valores $assados $elas 8un5<es9 As variaveis 8ormais na declarao da 8un56o e na
chamada da 8un56o $odem ter nomes distintos9 A ,ni*a exigIn*ia ( de %ue se:am do mesmo ti$o9
1or serem vari@veis lo*ais, os valores %ue uma 8un56o $assa $ara outra n6o s6o alterados $ela
8un56o *hamada9 Este ti$o de $assagem de argumentos ( *hamado de !assagem !or valor $ois os valores
das vari@veis do $rograma *hamador s6o *o$iados $ara as *orres$ondentes vari@veis da 8un56o *hamada9
&eremos no *a$itulo R *omo alterar os valores das vari@veis do $rograma *hamador9 Chamaremos esta
$assagem de !assagem !or endereo9
No exem$lo a*ima, a e b s6o $arMmetros 8ormais de*larados na 8un56o media4BC9 7bserve %ue a
8un56o ( *hamada *om os valores de num_1 e num_29 .esmo %ue os valores de a e b 8ossem alterados
os valores de num_1 e num_2 n6o seriam alterados9
<ari;veis ,lo%ais) Ama vari@vel ( dita global, se 8or de*larada :ora do %loco de uma 8un56o9
Ama vari@vel global tem validade no es*o$o de todas as 8un5<es, isto (, $ode ser a*essadas e modi8i*ada
$or %ual%uer 8un56o9 7 es$a5o de mem;ria alo*ado $ara esta vari@vel ( criado no momento de sua
de*lara56o e destru(do a$enas %uando o $rograma ( en*errado9

79
Eem!lo) Aso de vari@veis globais9
float a, b, med;
void media2(void){
med = (a + b) / 2.0;
}
void main(){
puts(Digite dois nmeros:);
scanf(%f %f, &a, &b);
media2();
printf(\nA media destes nmeros e %f, med);
}
No exem$lo a*ima, a, b, med s6o vari@veis globais de8inidas 8ora dos blo*os das 8un5<es
media() e main()9 Deste modo ambas as 8un5<es tem $leno a*esso as vari@veis, $odendo ser
a*essadas e modi8i*adas $or %uais%uer uma das 8un5<es9 Assim n6o ( ne*ess@rio a $assagem de
$arMmetros $ara a 8un56o9
H9H Re*ursividade
A re*ursividade talve3 se:a a mais im$ortante vantagem das 8un5<es em C9 Recurso ( o
$ro*esso $elo %ual uma 8un56o *hama a si mesma re$etidamente um numero 8inito de ve3es9 Este
re*urso ( muito ,til em alguns ti$os de algoritmos *hamados de algoritmos recursivos9
&e:amos um exem$lo cl/ssico $ara es*lare*ermos o *on*eitoD *al*ulo do :atorial de um n,mero9
A de8ini56o de 8atorial (D
n! = n . (n-1) . (n-2) . ... . 3 . 2 . 1
0! = 1
onde n ( um numero inteiro $ositivo9 Ama $ro$riedade B8a*ilmente veri8i*@velC dos 8atoriais ( %ueD
n! = n . (n-1)!
Esta $ro$riedade ( *hamada de $ro$riedade re*ursivaD o 8atorial de um numero $ode ser *al*ulado atrav(s
do 8atorial de seu ante*essor9 7ra, $odemos utili3ar esta $ro$riedade $ara es*revermos uma rotina
re*ursiva $ara o *al*ulo de 8atoriais9 1ara *riarmos uma rotina re*ursiva, em C, basta *riar uma *hamada a
$r;$ria 8un56o dentro dela mesma, *omo no exem$lo a seguir9
GE
Programa eem!lo) No ar%uivo e0606.cpp existe uma rotina re*ursiva $ara o *al*ulo de
8atoriais9
Ama 8un56o re*ursiva *ria a *ada *hamada um novo *on:unto de vari@veis lo*ais9 N6o existe
ganho de velo*idade ou es$a5o de mem;ria signi8i*ativo *om o uso de 8un5<es re*ursivas9 #eori*amente
uma algoritmo re*ursivo $ode ser es*rito de 8orma iterativa e vi*e-versa9 A $rin*i$al vantagem destes
algoritmos ( %ue algumas *lasses de algoritmos Zde inteligIn*ia arti8i*ial, simula56o num(ri*a, bus*a e
ordena56o em arvore binaria, et*9[ s6o mais 8a*ilmente im$lementadas *om o uso de rotinas re*ursivas9 7
estudo deste ti$o de algoritmo est@, $or(m, al(m do al*an*e deste texto9
G1
79 &etores
Neste *a$?tulo estudaremos o *on*eito de vetor, sua de*lara56o e uso9 Como s6o usados vetores
em argumentos de 8un5<es9 E, ainda, *omo trabalhar *om vetores de mais de uma dimens6o9
791 Introdu56o
Em muitas a$li*a5<es %ueremos trabalhar *om *on:untos de dados %ue s6o semelhantes em ti!o9
1or exem$lo o *on:unto das alturas dos alunos de uma turma, ou um *on:unto de seus nomes9 Nestes
*asos, seria *onveniente $oder *olo*ar estas in8orma5<es sob um mesmo *on:unto, e $oder re8eren*iar
*ada dado individual deste *on:unto $or um n,mero ?ndi*e9 Em $rograma56o, este ti$o de estrutura de
dados ( *hamada de vetor Bou array, em inglIsC ou, de maneira mais 8ormal estruturas de dados
homogBneas9
Eem!lo) A maneira mais sim$les de entender um vetor ( atrav(s da visuali3a56o de um lista, de
elementos *om um nome *oletivo e um ?ndi*e de re8erIn*ia aos valores da lista9
n nota
0 8.4
1 6.9
2 4.5
3 4.6
4 7.2
Nesta lista, n re$resenta um n,mero de re8erIn*ia e nota ( o nome do *on:unto9 Assim $odemos
di3er %ue a 4
a
nota ( 6.9 ou re$resentar nota[1] = 6.9
Esta n6o ( a ,ni*a maneira de estruturar *on:unto de dados9 #amb(m $odemos organi3ar dados
sob 8orma de tabelas9 Neste *aso, *ada dado ( re8eren*iado $or dois ?ndi*es e di3emos %ue se trata de um
vetor %idimensional Bou matriAC
1
9 &etores de mais de uma dimens6o ser6o vistos na se56o 79F9
794 De*lara56o e ini*iali3a56o de vetores
4.'.1 Declarao de vetores
1 Alguns autores $re8erem *hamar todos os ti$os de estruturas homogIneas, n6o im$ortando o numero de ?ndi*es de re8erIn*ia
Bou dimens<esC de vetores9 7utros $re8erem *hamar de matri9es9 7utros ainda distinguem vetores Buma dimens6oC de matri9es
Bmais de uma dimens6oC, et*9 N6o vamos entrar no m(rito da %uest6o Bexistem boas :usti8i*ativas $ara todas as inter$reta5<esC e,
nesta a$ostila, vamos usar a $rimeira nomen*laturaD toda estrutura homogInea de dados ser@ *hamada de vetor9
G4
Em C, um vetor ( um *on:unto de vari@veis de um mesmo ti!o %ue $ossuem um nome
identi8i*ador e um ?ndi*e de re8erIn*ia9
+intae) A sintaxe $ara a de*lara56o de um vetor ( a seguinteD
tipo nome[tam];
ondeD
tipo ( o ti!o dos elementos do vetorD int, float, double 999
nome ( o nome identi8i*ador do vetor9 As regras de nomen*latura de vetores s6o as mesmas
usadas em vari@veis Bse56o 49491C9
tam ( o tamanho do vetor, isto (, o n,mero de elementos %ue o vetor $ode arma3enar9
)em!lo) &e:a as de*lara5<es seguintesD
int idade[100]; // declara um vetor chamado 'idade' do tipo
// 'int' que recebe 100 elementos.
float nota[25]; // declara um vetor chamado 'nota' do tipo
// 'float' que pode armazenar 25 nmeros.
char nome[80]; // declara um vetor chamado 'nome' do tipo
// 'char' que pode armazenar 80 caracteres.
Na de*lara56o de um vetor estamos reservando es$a5o de mem;ria $ara os elementos de um
vetor9 A %uantidade de mem;ria Bem bytesC usada $ara arma3enar um vetor $ode ser *al*ulada *omoD
#antidade de mem*ria = taman"o do tipo - taman"o do vetor
Assim, no exem$lo anterior, a %uantidade de mem;ria utili3ada $elos vetores (, res$e*tivamente,
200(2x100), 100(4x25) e 80(80x1) bytes9
4.'.' Re:erBncia a elementos de vetor
Cada elemento do vetor ( re8eren*iado $elo nome do vetor seguido de um (ndice inteiro9 7
!rimeiro elemento do vetor tem ?ndi*e 0 e o Hltimo tem ?ndi*e tam-19 7 ?ndi*e de um vetor deve ser
inteiro9
Eem!lo) Algumas re8erIn*ias a vetoresD
G=
#define MAX 5
int i = 7;
float valor[10]; // declarao de vetor
valor[1] = 6.645;
valor[MAX] = 3.867;
valor[i] = 7.645;
valor[random(MAX)] = 2.768;
valor[sqrt(MAX)] = 2.705; // NO vlido!
4.'.' *nicialiAao de vetores
Assim *omo $odemos ini*iali3ar vari@veis B$or exem$loD int j = 3;C, $odemos ini*iali3ar
vetores9
+intae) A sintaxe $ara a ini*iali3a56o dos elementos de um vetor (D
tipo nome[tam] = {lista de valores};
ondeD
lista de valores ( uma lista, se$arada $or v?rgulas, dos valores de *ada elemento do
vetor9
)em!lo) &e:a as ini*iali3a5<es seguintes9 7bserve %ue a ini*iali3a56o de nota gera o vetor do
exem$lo do in?*io desta se56o9
int dia[7] = {12,30,14,7,13,15,6};
float nota[5] = {8.4,6.9,4.5,4.6,7.2};
char vogal[5] = {'a', `e', `i', `o', `u'};
7$*ionalmente, $odemos ini*iali3ar os elementos do vetor enumerando-os um a um9
Eem!lo) 7bserve %ue estas duas ini*iali3a5<es s6o $oss?veisD
int cor_menu[4] = {BLUE,YELLOW,GREEN,GRAY};
ou
int cor_menu[4];
cor_menu[0] = BLUE;
cor_menu[1] = YELLOW;
cor_menu[2] = GREEN;
cor_menu[3] = GRAY;
G>
Programa Eem!lo) 7 ar%uivo e0701.cpp *ont(m um $rograma %ue mostra o uso de vetoresD
de*lara56o, ini*iali3a56o, leitura e es*rita de elementos999
79= #amanho de um vetor e segmenta56o de mem;ria
4.8.1 Limites
Na linguagem C, devemos ter *uidado *om os limites de um vetor9 Embora na sua de*lara56o,
tenhamos de8inido o tamanho de um vetor, o C n6o 8a3 nenhum teste de veri8i*a56o de a*esso a um
elemento dentro do vetor ou n6o9
1or exem$lo se de*laramos um vetor *omo int valor[5], teori*amente s; tem sentido
usarmos os elementos valor[0], ..., valor[4]9 1or(m, o C n6o a*usa erro se usarmos
valor[12] em algum lugar do $rograma9 Estes testes de limite devem ser 8eitos logicamente dentro do
$rograma9
Este 8ato se deve a maneira *omo o C trata vetores9 A mem;ria do mi*ro*om$utador ( um es$a5o
B8?si*oC $arti*ionado em $or5<es de 1 byte9 Se declaramos um vetor *omo int vet[3], estamos
reservando H bytes B= segmentos de 4 bytesC de mem;ria $ara arma3enar os seus elementos9 7 $rimeiro
segmento ser@ reservado $ara vet[0], o segundo segmento $ara vet[1] e o ter*eiro segmento $ara
vet[2]9 7 segmento ini*ial ( *hamado de segmento %ase, de modo %ue vet[0] ser@ lo*ali3ado no
segmento base9 Ouando a*essamos o elemento vet[i], o $ro*essador a*essa o segmento lo*ali3ado em
%ase0i9 Se i 8or igual a 2, estamos a*essando o segmento %ase0' ou vet[2]Bo ultimo segmento
reservado $ara o vetorC9 1or(m, se i 8or igual a 7, estamos a a*essando segmento %ase04 %ue no :oi
reservado $ara os elementos do vetor e %ue $rovavelmente est@ sendo usado $or uma outra vari@vel ou
*ont(m in8orma56o es$,ria BlixoC9
7bserve %ue a*essar um segmento 8ora do es$a5o destinado a um vetor $ode destruir
in:ormaGes reservadas de outras vari@veis9 Estes erros s6o di8?*eis de dete*tar $ois o *om$ilador n6o
gera nenhuma mensagem de erro999 A solu56o mais ade%uada ( sem$re avaliar os limites de um vetor
antes de mani$ul@-lo9
A $rin*?$io este 8ato $oderia $are*er um de8eito da linguagem, mas na verdade trata-se de um
re*urso muito $oderoso do C9 1oder mani$ular sem restri5<es todos os segmentos de mem;ria ( uma
8lexibilidade a$re*iada $elos $rogramadores9
GF
Programa Eem!lo) 7 ar%uivo e0702.cpp *ont(m um $rograma %ue mostra o a*esso de
elementos dentro e 8ora de um vetor9 Note %ue o *om$ilador n6o a*usa nenhum erro de sintaxeV
4.8.' Tamanho !arametriAado
Na linguagem C n6o ( $oss?vel, usando a sintaxe des*rita a*ima, de*larar um vetor *om tamanho
vari;vel9
Eem!lo) 7 tre*ho de *;digo seguinte 8a3 uma de*lara56o errada de vetor9
...
int num;
puts("Quantos nmeros?");
scanf("%d, &num);
float valor[num]; // declarao de vetor (errado!)
...
.as ( $oss?vel de*larar um vetor *om tamanho !arametriAadoD usando uma constante
sim%"lica9 De*laramos uma *onstante simb;li*a B$arMmetroC *om a diretiva #define no *abe5alho do
$rograma e de$ois de*laramos o vetor *om esta *onstante simb;li*a *omo tamanho do vetor9 Deste modo
$odemos alterar o n,mero de elementos do vetor antes de %ual%uer com!ilao do $rograma9 Esta ( uma
maneira sim$les de administrar o es$a5o de mem;ria usado $elo $rograma, e tamb(m testar os limites de
um vetor9
Programa Eem!lo) 7 ar%uivo e0703.cpp *ont(m um $rograma %ue mostra a de*lara56o de
um vetor *om tamanho $arametri3ado9 .ostra tamb(m o uso deste $arMmetro *omo teste de limite do
vetor9 Com$ile este $rograma *om outros valores $ara o $arMmetro MAX e veri8i%ue %ue a exe*u56o do
$rograma ( alterada automati*amente9
No *a$itulo seguinte, se56o R, ser@ vista uma maneira de de*lararmos um vetor *om um n,mero
vari@vel de elementos, usando $onteiros9 Este ti$o de de*lara56o ( *hamada de alocao din:mica de
memria!
79> 1assando &etores $ara 2un5<es
GH
&etores, assim *omo vari@veis, $odem ser usados *omo argumentos de 8un5<es9 &e:amos *omo se
de*lara uma 8un56o %ue re*ebe um vetor e *omo se $assa um vetor $ara uma 8un56o9
+intae) Na passagem de vetores $ara 8un5<es usamos a seguinte sintaxeD
nome_da_fno(nome_do_vetor)
ondeD
nome_da_fno ( o nome da 8un56o %ue se est@ *hamando9
nome_do_vetor ( o nome do vetor %ue %ueremos $assar9 Indi*amos a!enas o nome do vetor,
sem ?ndi*es9
+intae) Na declarao de 8un5<es %ue re*ebem vetoresD
tipo_fno nome_fno(tipo_vetor nome_vetor[]){
...
}
ondeD
tipo_fno ( o ti$o de retorno da 8un56o9
nome_fno ( o nome da 8un56o9
tipo_vetor ( o ti$o de elementos do vetor9
nome_vetor ( o nome do vetor9 7bserve %ue de$ois do nome do vetor temos um ?ndi*e va3io
[] $ara indi*ar %ue estamos re*ebendo um vetor9
Eem!lo) 7bserve o exem$lo abaixoD
Na de*lara56o da 8un56oD
float media(float vetor[],float N){ // declarao da funo
...
}
Na *hamada da 8un56oD
void main(){
float valor[MAX]; // declarao do vetor
...
med = media(valor, n); // passagem do vetor para a funo
...}
Programa Eem!lo) 7 ar%uivo e0704.cpp *ont(m um $rograma %ue mostra a $assagem de
vetores $ara 8un5<es9
G7
Ateno) Ao *ontr@rio das vari@veis *omuns, o *onte,do de um vetor !ode ser modi:icado $ela
8un56o *hamada9 Isto signi8i*a %ue $odemos $assar um vetor $ara uma 8un56o e alterar os valores de seus
elementos9 Isto o*orre $or%ue a $assagem de vetores $ara 8un5<es ( 8eita de modo es$e*ial dito
.assagem por endereo9 Ama abordagem mais detalhada deste $ro*edimento ser@ 8eita no *a$?tulo R
sobre $onteiros9
1ortanto devemos ter *uidado ao mani$ularmos os elementos de um vetor dentro de uma 8un56o
$ara n6o modi8i*a-los $or des*uido9
Programa Eem!lo) 7 ar%uivo e0705.cpp *ont(m um $rograma %ue mostra a modi8i*a56o de
um vetor $or uma 8un56o9 Neste *aso a modi8i*a56o ( dese9ada $ois %ueremos ordenar os elementos do
vetor9
79F &etores .ultidimensionais
&etores $odem ter mais de uma dimens6o, isto (, mais de um ?ndi*e de re8erIn*ia9 1odemos ter
vetores de duas, trIs, ou mais dimens<es9 1odemos entender um vetor de duas dimens<es B$or exem$loC
asso*iando-o aos dados de um tabela9
Eem!lo) Am vetor bidimensional $ode ser visuali3ado atrav(s de uma ta%ela9
nota 0 1 2
0 8.4 7.4 5.7
1 6.9 2.7 4.9
2 4.5 6.4 8.6
3 4.6 8.9 6.3
4 7.2 3.6 7.7
Nesta tabela re$resentamos as notas de F alunos em = $rovas di8erentes Bmatem@ti*a, 8?si*a e
%u?mi*a, $or exem$loC9 7 nome nota ( o nome do *on:unto, assim $odemos di3er %ue a nota do = aluno
na 4
oa
$rova ( 6.4 ou re$resentar nota[2,1] = 6.4
4.?.1 Declarao e inicialiAao
GG
A de*lara56o e ini*iali3a56o de vetores de mais de uma dimens6o ( 8eita de modo semelhante aos
vetores unidimensionais9
+intae) A sintaxe $ara de*lara56o de vetores multidimensionais (D
tipo nome[tam_1][tam_2]...[tam_N]={{lista},{lista},...{lista}};
ondeD
tipo ( o ti$o dos elementos do vetor9
nome ( o nome do vetor9
[tam_1][tam_2]...[tam_N] ( o tamanho de *ada dimens6o do vetor9
{{lista},{lista},...{lista}} s6o as listas de elementos9
Eem!lo) ve:a algumas de*lara5<es e ini*iali3a5<es de vetores de mais de uma dimens6o9
7bserve %ue a ini*iali3a56o de nota gera a tabela do exem$lo do in?*io desta se56o9
float nota[5][3] = {{8.4,7.4,5.7},
{6.9,2.7,4.9},
{4.5,6.4,8.6},
{4.6,8.9,6.3},
{7.2,3.6,7.7}};
int tabela[2][3][2] = {{{10,15}, {20,25}, {30,35}},
{{40,45}, {50,55}, {60,65}};
Neste exem$lo, nota ( um vetor duas dimens<es ([][])9 Este vetor ( *om$osto de F vetores
de = elementos *ada9 tabela ( vetor de trIs dimens<es ([][][])9 Este vetor ( *om$osto de 4 vetores
de = sub-vetores de 4 elementos *ada9
4.?.' Passagem de vetores multidimensionais !ara :unGes
A sintaxe $ara passagem de vetores multidimensionais $ara 8un5<es ( semelhante a $assagem de
vetores unidimensionaisD *hamamos a 8un56o e $assamos o nome do vetor, sem ?ndi*es9 A ,ni*a
mudan5a o*orre na de*lara56o de 8un5<es %ue re*ebem vetoresD
+intae) Na declarao de 8un5<es %ue re*ebem vetoresD
tipo_f fno(tipo_v vetor[tam_1][tam_2]...[tam_n]){
...
G9
}
7bserve %ue de$ois do nome do vetor temos os ?ndi*es *om *ontendo os tamanhos de *ada
dimens6o do vetor9
Eem!lo) 7bserve o exem$lo abaixoD
Na de*lara56o da 8un56oD
int max(int vetor[5][7],int N, int M){ // declarao da funo
...
}
Na *hamada da 8un56oD
void main(){
int valor[5][7]; // declarao do vetor
...
med = media(valor, n); // passagem do vetor para a funo
...
}
Programa Eem!lo) 7 ar%uivo e0706.cpp *ont(m um $rograma %ue mostra a mani$ula56o
de vetores bidimensionaisD leitura de elementos, es*rita, $assagem $ara 8un5<es, et*9
>%servaGes) Algumas observa5<es a res$eito de vetores multidimensionais $odem ser 8eitasD
H91H Do mesmo modo %ue vetores unidimensionais, os vetores multidimensionais $odem ter
seus elementos modi8i*ados $ela 8un56o *hamada9
H917 7s ?ndi*es dos vetores multidimensionais, tamb(m *ome5am em 09 1or exem$loD
vet[0][0], ( o $rimeiro elemento do vetor9
H91G Embora uma tabela n6o se:a a ,ni*a maneira de visuali3ar um vetor bidimensional,
$odemos entender o !rimeiro ?ndi*e do vetor *omo o ?ndi*e de linhas da tabela e o segundo
?ndi*e do vetor *omo ?ndi*e das colunas9
9E
91
G9 Endere5os e 1onteiros
Neste *a$?tulo veremos a de8ini56o e os $rin*i$ais usos de $onteiros9 &eremos as o$era5<es
8undamentais *omo $onteiros , a estreita rela56o de $onteiros vetores e strings e ainda a alo*a56o
dinMmi*a de mem;ria e a $assagem de 8un5<es $ara 8un5<es *om o uso de $onteiros99
991 Introdu56o
#oda in8orma56o Bdado arma3enado em vari@vel sim$les ou vetorC %ue mani$ulamos em um
$rograma est@ arma3enado na mem;ria do *om$utador9 Cada in8orma56o ( re$resentada $or um *erto
*on:unto de bytes B&er *a$?tulo 4C9 1or exem$loD *ara*ter BcharCD 1 byte, inteiro BintCD 4 bytes, et*9
Cada um destes *on:untos de bytes, %ue *hamaremos de %loco, tem um nome e um endereo de
lo*ali3a56o es$e*i8i*a na mem;ria9
Eem!lo) 7bserve a instru56o abaixoD
int num = 17;
ao inter$retar esta instru56o, o $ro*essador $ode es$e*i8i*arD
.ome da in8orma56oD num
Ti!o de in8orma56oD int
Tamanho do %loco Bn,mero de bytes o*u$ados $ela in8orma56oCD 2
<alor da in8orma56oD 17
Endereo da in8orma56o Blo*ali3a56o do $rimeiro byteCD 8F6F:FFF2 Bhexade*imalC
Em geral, interessa ao !rogramador a$enas os nomes simb;li*os %ue re$resentam as
in8orma5<es, $ois ( *om estes nomes %ue s6o reali3adas as o$era5<es do seu algoritmo9 1or(m, ao
!rocessador interessa os endere5os dos blo*os de in8orma56o $ois ( *om estes endere5os %ue vai
trabalhar9
Programa Eem!lo) 7 ar%uivo e0801.cpp *ont(m um $rograma *om instru5<es $ara
ins$e*ionar o endere5o de uma vari@vel, usando o re*urso &nspect do #urbo CNN9 7bserve %ue o endere5o
mostrado *orres$onde ao !rimeiro byte do blo*o, mesmo %ue o blo*o o*u$e mais de um byteD No *aso,
um 8loat o*u$a um blo*o de > bytes9
94
G94 1onteiros
1onteiros s6o vari@veis %ue *ont(m endere5os9 Neste sentido, estas vari@veis apontam $ara algum
determinado endere5o da mem;ria9 Em geral, o $onteiro a$onta $ara o endere5o de alguma vari@vel
de*larada no $rograma9
6.'.1 Declarao de !onteiros.
Ouando de*laramos um $onteiro, devemos de*lar@-lo *om o mesmo ti$o Bint, *har, et*9C do blo*o
a ser a$ontado9 1or exem$lo, se %ueremos %ue um $onteiro a$onte $ara uma vari@vel int Bblo*o de 4
b"tesC devemos de*lar@-lo *omo int tamb(m9
+intae) A sintaxe da de*lara56o de um $onteiro ( a seguinteD
tipo_ptr *nome_ptr_1;
ou
tipo_ptr* nome_ptr_1, nome_ptr_2, ...;
ondeD
tipo_ptr : ( o ti$o de blo*o $ara o %ual o $onteiro a$ontar@9
* : ( um o$erador %ue indi*a %ue nome_ptr ( um $onteiro9
nome_ptr_1, nome_ptr_2,.... s6o os nomes dos $onteiros Bos nomes dos $onteiros
obede*em as mesmas regras da se56o 49491C
Eem!lo) &e:a as seguintes instru5<esD
int *p;
float* s_1, s_2;
A $rimeira instru56o de*lara um $onteiro *hamado p %ue a$onta $ara um inteiro9 Este $onteiro
a$onta $ara o !rimeiro endere5o de um blo*o de dois bytes9 Sem$re ( ne*ess@rio de*larar o ti$o do
$onteiro9 Neste *aso di3emos %ue de*laramos um $onteiro ti$o int9
A segunda instru56o de*lara dois $onteiros Bs_1 e s_2C do ti$o float9 7bserve %ue o ^ est@
:usta$osto ao ti$oD assim todos os elementos da lista ser6o de*larados $onteiros9
6.'.' >!eradores 0 e 9
9=
Ouando trabalhamos *om $onteiros, %ueremos 8a3er duas *oisas basi*amenteD
H919 *onhe*er endereo de uma vari@vel_
H94E *onhe*er o conteHdo de um endere5o9
1ara reali3ar estas tare8as a linguagem C nos $roviden*ia dois o$eradores es$e*iaisD
H941 o o$erador de endereoD &
H944 o o$erador de conteHdoD *
7 o$erador de endereo E0F determina o endere5o de uma vari@vel Bo $rimeiro byte do blo*o
o*u$ado $ela vari@velC9 1or exem$lo, &val determina o endere5o do blo*o o*u$ado $ela vari@vel val9
Esta in8orma56o n6o ( totalmente nova $ois :@ a usamos antesD na 8un56o scanf()9
Eem!lo) Ouando es*reve-se a instru56oD
scanf("%d", &num);
estamos nos re8erimos endereo do blo*o o*u$ado $ela vari@vel num9 A instru56o signi8i*aD
Wleia o buffer do teclado transforme o valor lido em um valor inteiro ;< bytes= e o arma9ene no bloco
locali9ado no endereo da vari/vel num>9
Eem!lo) 1ara se atribuir a um $onteiro o endere5o de uma vari@vel es*reve-seD
int *p, val=5; // declarao de ponteiro e varivel
p = &val; // atribuio
7bserve %ue o $onteiro p deve ser de*larado anteriormente *om o mesmo ti$o da vari@vel $ara a
%ual ele deve a$ontar9
7 o$erador conteHdo B*C determina o *onte,do BvalorC do dado arma3enado no endere5o de um
blo*o a$ontado $or um $onteiro9 1or exem$lo, *p determina *onte,do do blo*o a$ontado $elo $onteiro $9
De 8orma resumidaD o o$erador B*C determina o *onte,do de um endere5o9
Eem!lo) 1ara se atribuir a uma vari@vel o *onte,do de um endere5o es*reve-seD
int *p = 0x3f8, val; // declarao de ponteiro e varivel
val = *p; // atribuio
>%servaGes)
9>
H94= 7 o$erador endereo B&C somente $ode ser usado em uma ,ni*a vari@vel9 N6o $ode ser
usado em ex$ress<es *omo, $or exem$lo, &(a+b)9
H94> 7 o$erador conteHdo B*C somente $ode ser usado em vari@veis $onteiros9
Programa Eem!lo) 7 ar%uivo e0802.cpp *ont(m um $rograma %ue mostra *omo se
mani$ulam $onteiros e vari@veis9 Como se trans$ortam in8orma5<es entre $onteiros e vari@veis9
G9= 7$era5<es elementares *om $onteiros
1onteiros s6o vari@veis es$e*iais e obede*em a regras es$e*iais9 Deste modo, existem uma s(rie
de o$era5<es Baritm(ti*as, l;gi*as, et*9C envolvendo $onteiros %ue s6o $ermitidas e outras n6o9 A seguir
s6o desta*adas algumas o$era5<es %ue $odem ser exe*utadas *om $onteiros9
H94F A um $onteiro $ode ser atribu?do o endere5o de uma vari@vel *omum9
Eem!lo) 7bserve o tre*ho abaixoD
...
int *p;
int s;
p = &s; // p recebe o endereo de s
...
H94H Am $onteiro $ode re*eber o valor de outro $onteiro, isto (, $ode re*eber o endere5o
a$ontado $or outro $onteiro, desde %ue os $onteiros se:am de mesmo ti$o9
Eem!lo) 7bserve o tre*ho abaixoD
...
float *p1, *p2, val;
p1 = &val; // p1 recebe o endereo de val...
p2 = p1; // ...e p2 recebe o contedo de p2 (endereo de val)
H947 Am $onteiro $ode re*eber um endere5o de mem;ria diretamente9 Am endere5o ( um
numero inteiro9 Em geral, na 8orma hexade*imal B0x....C9 Nesta atribui56o devemos, em
geral, 8or5ar uma *onvers6o de ti$o usando casting $ara o ti$o de $onteiro de*larado9
Eem!lo) 7bserve o tre*ho abaixoD
9F
...
int *p1;
float p2
p1 = 0x03F8; // endereo da porta serial COM1
p2 = (float)0x0FF6; // casting
...
H94G A um $onteiro $ode ser atribu?do o valor nulo usando a *onstante simb;li*a NULL
Bde*larada na bibliote*a stdlib.hC9 Am $onteiro *om valor NULL n6o a$onta $ara lugar
nenhumV Algumas 8un5<es a utili3am $ara registrar uma atribui56o ilegal ou sem su*esso Bver
8un56o malloc() adianteC
Eem!lo) 7bserve o tre*ho abaixoD
#include <stdlib.h>
...
char *p;
p = NULL;
...
H949 Ama %uantidade inteira $ode ser adi*ionada ou subtra?da de um $onteiro9 A adi56o de um
inteiro n a um $onteiro p 8ar@ *om %ue ele a$onte $ara o endere5o do n0simo blo*o seguinte9
Eem!lo) 7bserve o tre*ho abaixoD
...
double *p, *q, var;
p = &var
q = ++p; // q aponta para o bloco seguinte ao ocupado por var
p = q - 5;// p aponta para o quinto bloco anterior a q
...
H9=E Dois $onteiros $odem ser *om$arados Busando-se o$eradores l;gi*osC desde %ue se:am de
mesmo ti$o9
Eem!lo) 7bserve o tre*ho abaixoD
...
if(px == py){ // se px aponta para o mesmo bloco que py ...
if(px > py){ // se px aponta para um bloco posterior a py ...
if(px != py){ // se px aponta para um bloco diferente de py ...
if(px == NULL) // se px nulo...
...
9H
Programa Eem!lo) 7 ar%uivo e0803.cpp *ont(m um $rograma %ue mostra *omo se utili3am
algumas o$era5<es elementares *om $onteiros *om $onteiros9
G9> 1onteiros, endere5os e 8un5<es
1or%ue usar $onteirosR A $rimeira vantagem da utili3a56o de $onteiros em $rogramas talve3
este:a rela*ionada a sua utili3a56o *omo argumentos de 8un5<es9
6.=.1 Passagem de dados !or valor ou !or re:erencia
No *a$?tulo H Bse56o H9FC a8irma-se %ue o valor de uma vari@vel var de uma 8un56o fun_1()
$assada $ara uma outra 8un56o fun_2() no $odem ser alterado $ela 8un56o fun_2()9 De 8ato, isto (
verdade se $assamos o valor da vari@vel var $ara a 8un56o fun_2()9 .as o valor de var $ode ser
alterado $or fun_2() $assamos seu endereo.
No $rimeiro *aso, di3emos %ue a $assagem de dados de uma 8un56o $ara outra o*orreu $or valor9
No segundo *aso, di3emos %ue houve uma $assagem $or re:erBncia9 &e:amos em detalhe uma de8ini56o
destes ti$os de $assagem de dados entre 8un5<esD
Passagem !or <alor) A $assagem $or valor signi8i*a %ue $assamos de uma 8un56o $ara outra o
valor de uma vari@vel, isto (, a 8un56o *hamada re*ebe um *;$ia do valor da vari@vel9 Assim %ual%uer
altera56o deste valor, $ela 8un56o *hamada, ser@ uma altera56o de uma *;$ia do valor da vari@vel9 7 valor
original na 8un56o *hamadora no alterado $ois o valor original e *o$ia 8i*am em blo*os de mem;ria
di8erentes9
Passagem !or Re:erencia) A $assagem $or re8eren*ia signi8i*a %ue $assamos de uma 8un56o
$ara outra o endereo de uma vari@vel, isto (, a 8un56o *hamada re*ebe sua localiAao na mem;ria
atrav(s de um $onteiro9 Assim %ual%uer altera56o no *onte,do a$ontado $elo do $onteiro ser@ uma
altera56o no *onte,do da vari@vel original9 7 valor original alterado9
+intae) A sintaxe da $assagem de endere5o ( a seguinteD
H9=1 na 8un56o *hamadaD
tipof nomef(tipop nomep){
ondeD
97
tipof ( o ti$o de retorno da 8un56o9
nomef ( o nome da 8un56o *hamada9
tipop ( o ti$o do $onteiro Bigual ao ti$o da vari@vel $assadaC9
nomep ( o nome do $onteiro9
H9=4 na 8un56o *hamadoraD
...
nomef(end_var);
...
ondeD
nomef ( o nome da 8un56o *hamada9
end_var ( o endere5o da vari@vel $assada *omo argumento9
Eem!lo) 7bserve o exem$lo abaixoD
void troca(int *p1, int *p1){ // declarao da funo
// Observe: ponteiros
int temp; // varivel temporria
temp = *p1; // temp recebe o contedo apontado por p1
*p1 = *p2; // o contedo de p1 recebe o contedo de p2
*p2 = temp; // o contedo de p2 recebe o valor de temp
}
void main(){ // programa principal
int a,b; // declarao das variveis
scanf("%d %d",&a,&b); // leitura das variveis
troca(&a,&b); // passagem dos endereos de a e b
printf("%d %d",a,b); // imprime valores (trocados!)
}
Neste exem$lo temos uma 8un56o troca() %ue tro*a entre si os valores de duas vari@veis9 Esta
8un56o re*ebe os endereos das vari@veis $assadas $ela 8un56o main(), arma3enando-os nos $onteiros
p1 e p29 Dentro da 8un56o, tro*a-se os conteHdos dos endere5os a$ontados9
Programa Eem!lo) 7 ar%uivo e0804.cpp *ont(m um $rograma %ue mostra a di8eren5a entre
a $assagem de dados $or valor e $assagem $or re8eren*ia9
6.=.' Retorno de dados em :unGes
9G
A !assagem !or re:erencia $ermite %ue B8ormalmenteC uma 8un56o retorne %uantos valores se
dese:ar9 Dissemos no *a$?tulo H Bse56o H94C %ue uma 8un56o somente $ode retornar um valor9 Isto
*ontinua sendo valido $ois o C assim de8ine 8un5<es9 1orem *om o uso de $onteiros $ode-se *ontornar
esta situa56o9 &e:amosD
Imagine %ue %ueremos es*rever uma 8un56o stat() *om a 8inalidade de *al*ular a media aritmtica e o
desvio padro de um *on:unto de dados9 7bserveD o retorno destes dados n6o $oder ser via instru56o
return() $ois isto n6o ( $ermitido9 A solu56o ( *riar Bna 8un56o main(), $or exem$loC duas vari@veis
$ara arma3enar os valores dese:ados Bmed e desvio, $or exem$loC e ent6o $assar os endere5os destas
vari@veis $ara a 8un56o stat()9 A 8un56o re*ebe esses endere5os e os arma3ena em $onteiros Bpm e pd,
$or exem$loC9 Em seguida, 8a3 os *@l*ulos ne*ess@rios, arma3enando-os nos endere5os re*ebidos9 Ao
t(rmino da exe*u56o da 8un56o os valores de med e desvio ser6o atuali3ados automati*amente9 Este
re*urso ( bastante utili3ado $or $rogramadores $ro8issionais9
Programa Eem!lo) 7 ar%uivo e0805.cpp *ont(m um $rograma %ue mostra o ?retorno@ de
v@rios dados de uma 8un56o9 Na verdade trata-se da $assagem de valores $or re8eren*ia9
6.=.8 Ponteiro como argumento de :uno
7bserve %ue nos exem$los a*ima, a $assagem de endere5os 8oi 8eita atrav(s do operador
endereo B&C9 #amb(m ( $oss?vel $assar um endere5o atrav(s de um $onteiro :@ %ue o *onte,do de um
$onteiro um endere5o9
Eem!lo) 7bserve o tre*ho de $rograma abaixo9
...
float *p, x;
p = &x;
fno(p); // passagem do ponteiro com o endereo de x.
...
Programa Eem!lo) 7 ar%uivo e0806.cpp *ont(m um $rograma %ue mostra a $assagem de
endere5o $ara uma 8un56o usando um $onteiro9 7bserve a sintaxe alternativa $ara a 8un56o scanf()V
G9F 1onteiros, vetores e strings
99
6.?.1 Ponteiros e vetores
No *a$itulo 7 8oi mostrado %ue na $assagem de vetores $ara 8un5<es es$e*i8i*a-se a$enas o nome
do vetor e %ue modi8i*a5<es nos elementos do vetor dentro da 8un56o *hamada alteram os valores do
vetor no $rograma *hamador Bse56o 79>C9 Isto se deve ao 8ato de %ue, na linguagem C, vetores s6o
intimamente rela*ionados a !onteiros9
Em C, o nome de um vetor ( tratado *omo o endereo de seu $rimeiro elemento9 Assim ao se
$assar o nome de um vetor $ara uma 8un56o est@ se $assando o endere5o do $rimeiro elemento de um
*on:unto de endere5os de mem;ria9
1or exem$lo, se vet ( um vetor, ent6o vet e &vet[0] re$resentam o mesmo endereo9 E
mais, $odemos a*essar o endere5o de %ual%uer elemento do vetor do seguinte modoD &vet[i] e
e%uivalente a (vet + i)9 A%ui deve-se ressaltar %ue (vet + i) n6o re$resenta uma adio
aritm(ti*a normal mas o endereo do i0simo elemento do vetor vet Bendere5o *ontado a $artir do
endere5o ini*ial vet[0]C9
Do mesmo modo %ue se $ode a*essar o endereo de *ada elemento do vetor $or $onteiros,
tamb(m se $ode a*essar o valor de *ada elemento usando $onteiros9 Assim vet[i] ( e%uivalente a
*(vet + i)9 A%ui se usa o o$erador *onte,do B*C a$li*ado ao endere5o do i0simo elemento do vetor
vet9
Programa Eem!lo) 7 ar%uivo e0807.cpp *ont(m um $rograma %ue mostra a e%uivalIn*ia
entre $onteiros e vetores9
6.?.' Ponteiros e strings
Como dissemos, vagamente na se56o 49=9>, uma string ( um con-unto ordenado de caracteres9
1odemos, agora, di3er muito maisD Em C, uma string ( um vetor unidimensional de elementos *ara*teres
ASCII, sendo o ultimo destes elementos o *ara*ter es$e*ial '\0'9
+intae) As duas maneiras mais *omuns de de*lararmos uma string s6oD
char nome[tam];
1EE
ou
char *nome;
ondeD
nome ( o nome do vetor de *ara*teres e
tam seu tamanho9
7bserve %ue sendo um vetor, uma string $ode ser de*larada tamb(m *omo um $onteiro9 Alias a
segunda de*lara56o re$resenta :ustamente isto9 Sabendo isto $odemos reali3ar uma grande variedade de
mani$ula5<es *om strings e *ara*teres9 Existe uma bibliote*a $adr6o C *hamada string.h %ue
$roviden*ia algumas 8un5<es de mani$ula56o de strings muito ,teis9
Programa Eem!lo) 7 ar%uivo e0808.cpp *ont(m um $rograma %ue mostra algumas
o$era5<es usando-se strings Bvetores e $onteirosC9
G9H Alo*a56o DinMmi*a de .em;ria
7s elementos de um vetor s6o arma3enados seCDencialmente na mem;ria do *om$utador9 Na
de*lara56o de um vetor, B$or exem$loD int vet[10]C ( dito ao $ro*essador reservar BalocarC um *erto
numero de blo*os de mem;ria $ara arma3enamento dos elementos do vetor9 1orem, neste modo de
de*lara56o, n6o se $ode alo*ar um numero vari@vel de elementos Bve:a se56o 79=94C9
A linguagem C $ermite alo*ar dinami*amente Bem tem$o de exe*u56oC, blo*os de mem;ria
usando $onteiros9 Dada a intima rela56o entre $onteiros e vetores, isto signi8i*a %ue $odemos de*larar
dinami*amente vetores de tamanho vari@vel9 Isto ( dese:@vel *aso %ueiramos $ou$ar mem;ria, isto ( n6o
reservar mais mem;ria %ue o ne*ess@rio $ara o arma3enamento de dados9
1ara a alo*a56o de mem;ria usamos a 8un56o malloc()Bmemory allocationC da bibliote*a
alloc.h9 A 8un56o malloc() reserva, se%Pen*ialmente, um *erto numero de blo*os de mem;ria e
retorna, $ara um $onteiro, o endere5o do $rimeiro blo*o reservado9
+intae) A sintaxe geral usada $ara a alo*a56o dinMmi*a ( a seguinteD
pont = (tipo *)malloc(tam);
1E1
ondeD
pont ( o nome do $onteiro %ue re*ebe o endere5o do es$a5o de mem;ria alo*ado9
tipo ( o ti$o do endere5o a$ontado Bti$o do $onteiroC9
tam ( o tamanho do es$a5o alo*adoD numero de bytes9
A sintaxe seguinte, $orem, ( mais *laraD
pont = (tipo*)malloc(nm*sizeof(tipo));
ondeD
nm ( o numero de elementos %ue %ueremos $oder arma3enar no es$a5o alo*ado9
Eem!lo) Se %ueremos de*larar um vetor *hamado vet, ti$o int, *om num elementos $odemos
usar o tre*ho abaixoD
...
int *vet; // declarao do ponteiro
vet = (int*)malloc(num*2); // alocao de num blocos de 2 b$tes
...
ou ainda
...
int *vet; // declarao do ponteiro
vet = (int*) malloc(num * sizeof(int));
...
Caso n6o se:a $oss?vel alo*ar o es$a5o re%uisitado a 8un56o malloc() retorna a *onstante
simb;li*a NULL9
+intae) 1ara liberar Bdesalo*arC o es$a5o de mem;ria se usa a 8un56o free(), *u:a sintaxe ( a
seguinteD
free(pont);
ondeD
pont ( o nome do $onteiro %ue *ontem o endere5o do ini*io do es$a5o de mem;ria reservado9
1E4
Programa Eem!lo) 7 ar%uivo e0809.cpp *ont(m um $rograma %ue mostra *omo se utili3a a
Alo*a56o DinMmi*a de .em;ria9
G97 1onteiros $ara 2un5<es
At( agora usamos $onteiros $ara a$ontar $ara endere5os de mem;ria onde se en*ontravam as
vari@veis BdadosC9 Algumas ve3es ( ne*ess@rio a$ontar $ara 8un5<es, isto (, a$ontar $ara o endere5o de
mem;ria %ue *ontem o ini*io das instru5<es de uma 8un56o9 Ouando assim $ro*edemos, di3emos %ue
usaremos ponteiros para funes9
H9== Ponteiros como chamada de :uno.
Am uso de $onteiros $ara 8un5<es ( $assar uma 8un56o *omo argumento de outra 8un56o9 .as
tamb(m se $ode usar $onteiros $ara 8un5<es ao inv(s de 8un5<es nas *hamadas normais de 8un5<es9
+intae) A sintaxe de de*lara56o de $onteiro $ara 8un5<es ( a seguinteD
tipo_r (*nome_p)(lista);
ondeD
tipo_r ( o ti$o de retorno da 8un56o a$ontada9
nome_p ( o nome do $onteiro %ue a$ontara $ara a 8un56o9
lista ( a lista de argumentos da 8un56o9
Eem!lo) Su$onha %ue temos uma 8un56o ( de*larada *omoD
float fun(int a, int b){
...
}
o $onteiro *orres$ondente ser@D
float (*pt)(int,int);
7bserve %ue o $onteiro $ara 8un56o deve ser de*larado entre $arInteses9 7bserve tamb(m %ue o
$onteiro e a 8un56o retornam o mesmo ti$o de dado e %ue tem os mesmos argumentos9
+intae) 1ara atribuirmos o endere5o de uma 8un56o $ara um $onteiro usamos a seguinte sintaxeD
1E=
pont = &fno;
ondeD
pont ( o nome do $onteiro9
fno ( o nome da 8un56o9
Se um $onteiro *ontem o endere5o de uma 8un56o, ele $ode ser usado no lugar da *hamada da
8un56o9
Eem!lo) o tre*ho de $rograma abaixo usa um $onteiro $ara *hamar uma 8un56oD
float fun(int a,int b){
...
}
void main(void){
float temp;
float (*pt)(int,int);
pt = &fun;
temp = (*pt)(10,20); // equivale a: temp = fun(10,20);
...
}
Programa Eem!lo) 7 ar%uivo e0810.cpp *ont(m um $rograma %ue mostra *omo se utili3a o
$onteiro $ara 8un56o9
6.4.' Passando uma :uno como argumento de outra :uno.
7utra utili3a56o de $onteiros $ara 8un5<es ( na $assagem de uma :uno *omo argumento $ara
outra 8un56o9 1ara %ue isso o*orra ne*essitamosD
H9=> Na de*lara56o da :uno a ser !assadaD
iC Nada de es$e*ial, a$enas a de8ini56o normalD
tipo nome_p(lista){
...
1E>
}
Eem!lo)
float soma(float a,float b){
...
}
H9=F Na :uno rece!toraD
iC De*larar o !onteiro %ue re*ebe a :uno !assada na lista de argumentosD
tipo nome_r(..., tipo (*pt)(lista), ...){
Eem!lo)
float grad(float x, float y, float (*p)(float,float)){
iiC Asar o $onteiro $ara 8un5<es nas *hamadas da 8un56o $assadaD
var = (*pt)(lista);
Eem!lo)
valor = (*p)(x,y);
H9=H Na 8un56o $rin*i$alD
iC 1assar o nome da 8un56o *hamada $ara a 8un56o re*e$toraD
var = nome_g(... , nome_p , ...);
Eem!lo)
g = grad(x,y,soma);
Programa Eem!lo) 7 ar%uivo e0811.cpp *ont(m um $rograma %ue mostra *omo se utili3a
$onteiros na $assagem de 8un5<es
1EF
A$Indi*e A9 #abela ASCII
As tabelas mostradas neste a$Indi*e re$resentam os 4FH *;digos usados nos *om$utadores da
8am?lia I-.9 Esta tabela re8ere-se ao American )tandard *ode for &nformation &nterc#ange B*;digo
$adr6o ameri*ano $ara tro*a de in8orma5<esC, %ue ( um *on:unto de n,meros re$resentando *ara*teres ou
instru5<es de *ontrole usados $ara tro*a de in8orma5<es entre *om$utadores entre si, entre $eri8(ri*os
Bte*lado, monitor, im$ressoraC e outros dis$ositivos9 Estes *;digos tem tamanho de 1 b"te *om valores de
00h a FFh BE a 4FF de*imalC9 1odemos dividir estes *;digos em trIs *on:untosD *ontrole, $adr6o e
estendido9
7s $rimeiros =4 *;digos de 00h at( 1Fh BE a =1 de*imalC, 8ormam o con9unto de controle
ASCII9 Estes *;digos s6o usados $ara *ontrolar dis$ositivos, $or exem$lo uma im$ressora ou o monitor
de v?deo9 7 *;digo 0Ch Bform feedC re*ebido $or ima im$ressora gera um avan5o de uma $@gina9 7
*;digo 0Dh Bcarriage returnC ( enviado $elo te*lado %uando a te*la EN#ER ( $ressionada9 Embora exista
um $adr6o, alguns $ou*os dis$ositivos tratam di8erentemente estes *;digos e ( ne*ess@rio *onsultar o
manual $ara saber exatamente *omo o e%ui$amento lida *om o *;digo9 Em alguns *asos o *;digo tamb(m
$ode re$resentar um *ara*ter im$rim?vel9 1or exem$lo o *;digo E1h re$resenta o *ara*ter B#appy faceC9
7s 9H *;digos seguintes de 20h a 7Fh B=4 a 147 de*imalC 8ormam o con9unto !adro ASCII9
#odos os *om$utadores lidam da mesma 8orma *om estes *;digos9 Eles re$resentam os *ara*teres usados
na mani$ula56o de textosD *;digos-8onte, do*umentos, mensagens de *orreio eletr]ni*o, et*9 S6o
*onstitu?dos das letras do al8abeto latino Bmin,s*ulo e mai,s*uloC e alguns s?mbolos usuais9
7s restantes 14G *;digos de 80h at( FFh B14G a 4FF de*imalC 8ormam o con9unto estendido
ASCII9 Estes *;digos tamb(m re$resentam *ara*teres im$rim?veis $orem *ada 8abri*ante de*ide *omo e
%uais s?mbolos usar9 Nesta $arte do *;digo est6o de8inidas os *ara*teres es$e*iaisD , , , u 999
1EH
De*9 'ex9 Controle
0 00h NUL ((ll)
1 01h SOH (/tart of 0eadin!)
2 02h STX (/tart of 1ext)
3 03h ETX (2nd of 1ext)
4 04h EOT (2nd of 1ransmision)
5 05h ENQ (2n#ir$)
6 06h ACK (3c4no%led!e)
7 07h BEL (5ell)
8 08h BS (5ac4space)
9 09h HT (0ori&ontal 1ab)
10 0Ah LF (6ine 7eed)
11 0Bh VT (8ertical 1ab)
12 0Ch FF (7orm 7eed)
13 0Dh CR (9arria!e :etrn)
14 0Eh SO (/"ift ;t)
15 0Fh SI (/"ift <n)
16 10h DLE (=ata 6in4 2scape)
17 11h DC1 (=evice control 1)
18 12h DC2 (=evice control 2)
19 13h DC3 (=evice control >)
20 14h DC4 (=evice control ?)
21 15h NAK ((e!ative 3c4no%led!e)
22 16h SYN (/$nc"ronos <dle)
23 17h ETB (2nd 1ransmission 5loc4)
24 18h CAN (9ancel)
25 19h EM (2nd of @edia)
26 1Ah SUB (/bstitte)
27 1Bh ESC (2scape)
28 1Ch FS (7ile /eparator)
29 1Dh GS (Arop /eparator)
30 1Eh RS (:ecord /eparator)
31 1Fh US (Bnit /eparator)
1E7
Cara*ter De*9 'ex9
<espao> 32 20h
!
33 21h
"
34 22h
#
35 23h
$
36 24h
%
37 25h
&
38 26h
'
39 27h
(
40 28h
)
41 29h
*
42 2Ah
+
43 2Bh
,
44 2Ch
-
45 2Dh
.
46 2Eh
/
47 2Fh
0
48 30h
1
49 31h
2
50 32h
3
51 33h
4
52 34h
5
53 35h
6
54 36h
7
55 37h
8
56 38h
9
57 39h
:
58 3Ah
;
59 3Bh
<
60 3Ch
=
61 3Dh
>
62 3Eh
?
63 3Fh
`
64 40h
A
65 41h
B
66 42h
C
67 43h
1EG
Cara*ter De*9 'ex9
D
68 44h
E
69 45h
F
70 46h
G
71 47h
H
72 48h
I
73 49h
J
74 4Ah
K
75 4Bh
L
76 4Ch
M
77 4Dh
N
78 4Eh
O
79 4Fh
P
80 50h
Q
81 51h
R
82 52h
S
83 53h
T
84 54h
U
85 55h
V
86 56h
W
87 57h
X
88 58h
Y
89 59h
Z
90 5Ah
[
91 5Bh
\
92 5Ch
]
93 5Dh
^
94 5Eh
_
95 5Fh
`
96 60h
a
97 61h
b
98 62h
c
99 63h
d
100 64h
e
101 65h
f
102 66h
g
103 67h
1E9
Cara*ter De*9 'ex9
h
104 68h
i
105 69h
j
106 6Ah
k
107 6Bh
l
108 6Ch
m
109 6Dh
n
110 6Eh
o
111 6Fh
p
112 70h
q
113 71h
r
114 72h
s
115 73h
t
116 74h
u
117 75h
v
118 76h
w
119 77h
x
120 78h
y
121 79h
z
122 7Ah
{
123 7Bh
|
124 7Ch
}
125 7Dh
~
126 7Eh
<delete> 127 7Fh
128 80h
u
129 81h

130 82h

131 83h
a
132 84h

133 85h

134 86h

135 87h

136 88h

137 89h

138 8Ah

139 8Bh
11E
Cara*ter De*9 'ex9

140 8Ch

141 8Dh

142 8Eh

143 8Fh

144 90h

145 91h

146 92h

147 93h

148 94h

149 95h

150 96h

151 97h

152 98h

153 99h

154 9Ah

155 9Bh

156 9Ch

157 9Dh

158 9Eh

159 9Fh

160 A0h

161 A1h

162 A2h

163 A3h

164 A4h

165 A5h

166 A6h

167 A7h

168 A8h

169 A9h

170 AAh

171 ABh

172 ACh

173 ADh

174 AEh

175 AFh
111

176 B0h
Cara*ter De*9 'ex9

177 B1h

178 B2h
179 B3h
180 B4h

181 B5h

182 B6h

183 B7h

184 B8h

185 B9h
[
186 BAh

187 BBh
"
188 BCh
"
189 BDh

190 BEh

191 BFh
'
192 C0h
+
193 C1h

194 C2h
]
195 C3h

196 C4h
]
197 C5h
]
198 C6h
]
199 C7h
"
200 C8h

201 C9h
"
202 CAh

203 CBh
[
204 CCh
=
205 CDh
[
206 CEh
=
207 CFh
"
208 DOh

209 D1h
_
210 D2h
"
211 D3h
114

212 D4h

213 D5h
Cara*ter De*9 'ex9
_
214 D6h
[
215 D7h
]
216 D8h
'
217 D9h

218 DAh

219 DBh

220 DCh
g
221 DDh
_
222 DEh
P
223 DFh
c
224 E0h

225 E1h
L
226 E2h
n
227 E3h
Z
228 E4h
o
229 E5h

230 E6h
:
231 E7h
I
232 E8h
O
233 E9h
O
234 EAh
5
235 EBh

236 ECh
o
237 EDh
238 EEh
O
239 EFh

240 F0h

241 F1h
`
242 F2h

243 F3h
]
244 F4h
]
245 F5h
-
246 F6h
-
247 F7h
11=

248 F8h

249 F9h

250 FAh
Cara*ter De*9 'ex9
\
251 FBh

252 FCh

253 FDh
254 FEh
255 FFh
11>
Entre os *ara*teres da tabela ASCII estendidos os mais ,teis est6o, talve3, os *ara*teres de desenho de
%uadro em linhas sim$les e du$lasD os *ara*teres de B3h at( DAh B179 a 41G de*imalC9 Como a visuali3a56o deste
*on:unto ( di8?*il, o desenho abaixo $ode auxiliar nesta tare8aD
196 194 205 203
218 191 201 = 187
179 ] 186 [
195 ] ] ] 180 204 [ [ 185
197 206
192 ' + ' 217 200 " " " 188
193 202
209 210
213 184 214 _ _ 183

198 ] ] 181 199 ] [ 182
216 215
212 = 190 211 " " " 189
207 208
Figura B.1: *aracteres de desen#o de 6uadro e seus respectivos cdigos A)&&!
A$Indi*e -9 Exer*?*ios de $rograma56o
Ca$?tulo >D 2un5<es de Entrada e Sa?da
H9=7 2a5a um $rograma %ue leia 4 n,meros reais e im$rima a m(dia aritm(ti*a entre eles9
H9=G 2a5a um $rograma es*reva na tela o *ara*ter ASCII e o res$e*tivo *;digos hexade*imal de um valor
de*imal digitado $elo usu@rio9 ZSugest6oD Ase a 8un56o putchar()$ara es*rever os *ara*teres[9
H9=9 2a5a um $rograma %ue leia um angulo Bem grausC e im$rima o valor do seno, coseno e tangente
deste angulo9
H9>E Altere o $rogramas =.' e =.8 $ara %ue utili3em e8eitos de im$ress6o *olorida9
H9>1 7 volume de um es8era de raio " (
V " =
>
=
=

9 2a5a um $rograma %ue leia um numero R e im$rima


o volume da es8era *orres$ondente9
H9>4 2a5a um $rograma %ue leia uma 8rase e res*reva esta 8rase *entrali3ada no to$o da tela9
Ca$?tulo FD Estruturas de Controle
H9>= 2a5a um $rograma %ue leia = n,meros e im$rima o n,mero de maior valor absoluto9
H9>> 2a5a um $rograma es*reva na tela todos os *ara*teres ASCII, os res$e*tivos *;digos de*imais e
hexade*imais9
H9>F 2a5a um $rograma %ue im$rima os 1E $rimeiros n,meros $rimos9
H9>H 2a5a um $rograma %ue im$rima os n,meros ?m$ares no intervalo 8e*hado [a, b] Ba e b
es*olhidos $elo usu@rioC9
H9>7 2a5a um $rograma %ue leia uma 8rase digitada e im$rima um relat;rio *ontendoD o n,mero de
$alavras, o n,mero de vogais e o n,mero de letras digitadas9
H9>G Altere o $rograma =.1 $ara %ue o usu@rio determine a %uantidade de n,meros mani$ulados9
H9>9 2a5a um $rograma %ue im$rima os N $rimeiros n,meros da s(rie de 2ibona**iD 1, 1, 2, 3,
5, 8, 13,... A 8;rmula de re*orrIn*ia $ara esta s(rie (
n n n
i i i
= +
1 4
$ara
i 4
$ois
n n
E 1
1 = =
9
H9FE Altere o $rograma ?.1 $ara %ue o usu@rio determine a %uantidade de n,meros mani$ulados9
H9F1 Altere o $rograma ?.8 $ara %ue o usu@rio determine a %uantidade de n,meros mani$ulados9
H9F4 2a5a um $rograma %ue leia os trIs $arMmetros a, b, * de uma e%ua56o de segundo grau e es*reva
suas ra?3es Breais ou *om$lexasC9
H9F= 2a5a um $rograma %ue exe*ute um $rote56o de tela do seguinte modoD Ao ini*iar o $rograma, um
*ara*ter Bou outro %ual%uerC $er*orra a tela em dire5<es aleat;rias a$agando os *ara*teres de 8undo9
Ao se $ressionar %ual%uer te*la o texto de 8undo rea$are*e e o $rograma termina9 Ase as 8un5<es
gettext() e puttext()9
H9F> 2a5a um $rograma %ue $e5a $ara o usu@rio adivinhar um n,mero es*olhido aleatoriamente entre 1 e
1EE9 Se o usu@rio digitar um n,mero errado, o $rograma res$onde o novo intervalo do n,mero
$ro*urado9 Se o usu@rio a*ertou o n,mero $ro*urado, o $rograma di3 %uantos $al$ites 8oram dados9
1or exem$loD
O nmero procurado est entre 1 e 100:
Palpite: 45
O nmero procurado est entre 1 e 44:
Palpite: 27
O nmero procurado est entre 28 e 44:
Palpite: 36
Parabns! Voc acertou o nmero em 3 tentativas.
H9FF 2a5a um $rograma %ue leia um valor inteiro de E a 1EEE es*reva o seu valor $or extenso9 1or
exem$loD
Digite valor: 279
Extenso: duzentos e setenta e nove.
H9FH 2a5a um $rograma %ue *olo%ue um *ara*ter no *entro da tela e $ermita o movimenta56o deste *om
o uso das setas9
H9F7 Im$lemente um arastrob $ara o *ara*ter do $rograma ?.1=9 Sugest6oD use os *ara*teres de
$reen*himentoD 17Hd, 177d, 17Gd e 419d9
H9FG 2a5a um $rograma %ue desenhe um :anela *om bordas Bsim$les ou du$lasC em uma $osi56o
*entrali3ada da tela9 1inte o interior da :anela *om alguma *or di8erente do 8undo da tela9 ZSugest6oD
Ase o la5o for... $ara es*rever as bordas e a 8un56o clrscr() $ara $intar o interior da :anela[9
Ca$?tulo HD 2un5<es
H9F9 Crie um 8un56o float round(float r) %ue 8a5a o arredondamento de n,meros reaisD 1or
exem$loD 5 = round(5.4), 7 = round(6.5)9
H9HE Crie uma 8un56o int sim_nao(void) %ue es$era o usu@rio $ressionar as te*las [s] ou [n]
retornando 1 ou E res$e*tivamente9 Se o usu@rio $ressionar %ual%uer outra te*la um som Bde
advertIn*iaC de A3 B9 $or <A3 ms ( emitido9
H9H1 #rans8orme o $rograma do exer*?*io ?.1@ em uma 8un56o *om a seguinte de*lara56oD int
borda(esq, sup, dir, inf, corf, corb) onde esq, sup, dir, inf s6o as
$osi5<es das bordas, corf, corb as *ores do 8undo e da borda da :anela res$e*tivamente9 A 8un56o
retorna 1 se houve algum erro na $assagem dos $arMmetros B esq > dir, $or exem$loC e 0 *aso
*ontr@rio9
H9H4 2a5a uma 8un56o %ue determine se trIs n,meros a, b, c 8ormam um triMngulo ou n6o9 A 8un56o
deve ter a seguinte de*lara56o int tringulo(float a, float b, float c) onde o
valor de retorno tem o seguinte signi8i*adoD
0: no forma tringulo,
1: tringulo qualquer,
2: tringulo issceles,
3: tringulo equiltero.
H9H= 2a5a uma 8un56o %ue determine se um determinado numero ( $rimo ou n6o9 A 8un56o deve ter a
seguinte de*lara56o int primo(int N) onde N ( o valor a ser testado9 A 8un56o deve retornar 1
se N ( $rimo e 0 *aso *ontr@rio9 ZSugest6oD Altere o $rograma do exer*?*io ?.8[9
H9H> #rans8orme o $rograma do exer*?*io ?.4 em uma 8un56o int fib(int n) %ue retorna o n-(simo
numero de 2ibona**i9
H9HF A mdia elptica
4
Bou aritm(ti*o-geom(tri*aC de dois n,meros $ositivos a e b Za C b[, ( *al*ulada
do seguinte modoD Chamando
a a b
n n n +
=
1
e
b a b
n n n +
= +
1
4 B C T
res$e*tivamente as m(dias
geom(tri*a e aritm(ti*a desses n,meros obtemos uma se%PIn*ia de n,meros a
E
, a
1
, a
4
, 999 e b
E
, b
1
, b
4
, 999
tal %ue
a a a b b b
E 1 4 4 1 E
< < < < < <
9 7 limite desta se%PIn*ia (
m a b = =

9 1or exem$loD a
m(dia el?$ti*a de 4 e 7 ( 5.5932... 2a5a uma 8un56o double elip(double a, double
b) %ue *al*ule a m(dia el?$ti*a de a e b9 ZSugest6oD Ase um la5o while(a < b)...[9
H9HH 7 maior divisor *omum dos inteiros $ositivos a e b, %ue abreviamos *omo mdc;a b=, ( o maior
n,mero m tal %ue m ( divisor tanto de a %uanto de b9 1or exem$loD D E mdc;<3FG=, H E mdc;<FH=9 7
valor de m $ode ser *al*ulado *om o seguinte algoritmo re*ursivo
=
, de +uclidesD
se a > b ento mdc(a, b) igual a
b se resto(a, b) 0
mdc(b, resto(a, b)) caso contrrio.
2a5a uma 8un56o recursiva $ara o *@l*ulo do m@ximo divisor *omum de dois n,meros9
H9H7 Caso :@ n6o tenha 8eito assim, trans8orme a 8un56o iterativa do exer*?*io @.@ em uma 8un56o
recursiva9
Ca$?tulo 7D &etores
H9HG Es*reva um $rograma %ue leia um vetor de N n,meros inteiros,(N<=100), inverta a ordem dos
elementos do vetor e im$rima o vetor invertido9 1or exem$lo o vetorD {1, 3, 5, 7} ter@ seus
elementos invertidosD {7, 5, 3, 1}9 >%servao) Q ne*ess@rio inverter os elementos do vetor9
N6o basta im$rimi-los em ordem inversaV
H9H9 Es*reva um $rograma %ue leia um vetor a de N n,meros reais, (N<=100),e um outro real k e
*onstrua e im$rima um outro vetor b *u:os elementos s6o os res$e*tivos elementos de a
multi$li*ados $or k9 Por eem!lo) a = {1,2,3}, k = 5, b = {5,10,15}9
H97E Es*reva duas 8un5<esD uma %ue leia um vetor v de n n,meros inteiros, (n<=100), e outra %ue
escreva este vetor9 A de*lara56o destas 8un5<es devem ser, res$e*tivamenteD void le_vet(int
v, int n) e void escreve_vet(int v, int n)9
H971 Es*reva um $rograma %ue leia um vetor gabarito de 10 elementos9 Cada elemento de
gabarito *ontem um numero inteiro 1, 2, 3, 4 ou 5 *orres$ondente as o$5<es *orretas de
uma $rova ob:etiva9 Em seguida o $rograma deve ler um vetor resposta, tamb(m de 10
4 Des*oberta $elo matem@ti*o alem6o *arl 8! Iauss9 &er I.A, E9 9, Meu ro!essor de Mate"#ti$a,R, $914=
= &er S.I#', /9 D9 %esign and &nalysis o! &lgorit'"s, -ostonD 1)S-cent 1ub9 Co9 19G9 $9474
elementos inteiros, *ontendo as res$ostas de um aluno9 7 $rograma deve *om$arar os dois vetores e
es*rever o numero de a*ertos do aluno9
H974 Es*reva uma 8un56o int min_vet(float v[], int n) re*eba um vetor e retorne o
?ndi*e do menor elemento deste vetor9
H97= Es*reva uma 8un56o int remove_dup(float v[], int n) re*eba um vetor e veri8i%ue
a existIn*ia de elementos du$li*ados9 Caso n6o existam elementos du$li*ados retorne 09 Caso
existam, remova estes elementos Bdeixando a$enas umC e retorne o n,mero de elementos removidos9
H97> Es*reva uma 8un56o void insert(float v[], int n, float valor, int pos)
%ue 8a5a a insero de valor na $osi56o pos do vetor v, deslo*ando os demais elementos9
H97F #rans8orme o programa do exem$lo e0705.cpp em uma funo void ordem(int v,
int n) %ue ordene os elementos de um vetor v de n elementos inteiros9
H97H Es*reva uma 8un56o int merge(float r[], float s[], float v[], int n,
int m) re*eba um vetor r de n elementos e outro vetor s de m elementos e *onstrua um vetor v
*om os elementos de r e s, ordenado e no du!licado9 A 8un56o deve retornar o tamanho do vetor
v *onstru?do9 Sugest6oD Atili3e as 8un5<es dos exer*?*ios 79H, 797 e 79G9
H977 A 8un56o do exer*?*io 799 $ode ser entendida *omo uma 8un56o %ue retorna a uni6o entre dois
*on:untos9 Es*reva uma 8un56o int intersec(float r[], float s[], float v[],
int n, int m) %ue *onstrua um vetor v *om a interseo entre r e s, ordenados9 A 8un56o
deve retornar o tamanho do vetor v *onstru?do9
H97G Es*reva uma 8un56o void desordem(int v, int n) %ue desordene os elementos de um
vetor v Bn6o ne*essariamente ordenadoC de n elementos inteiros9 Sugest6oD use o seguinte algoritmoD
para i de n-1 at 0 faa
j valor aleatrio entre 0 e i
v[i] v[j]
fim faa
>%servao) Esta rotina $ode ser usada $ara simular o $ro*esso de embaralhar as *artas de um baralho9
H979 Es*reva uma 8un56o int find(char v[], char t[], int m, int n) %ue re*eba
um vetor v de m elementos e um vetor t de n elementos Bn < mC9 Esta 8un56o deve veri8i*ar a
o*orrIn*ia do $adr6o t em v ou n6o9 Se houver, deve retornar a $osi56o ini*ial da $rimeira
o*orrIn*ia9 Por eem!lo) se v={As bananas do Panam so bacanas} e p={anas}
deve retornar 69 Caso n6o ha:a o*orrIn*ia, retorne -19 >%servao) Algoritmos *omo esses s6o
usados em editores de texto
>
9
H9GE 7 !roduto escalar entre dois vetores $ode ser de8inido
F
*omoD
e u v u v
i i
i
n
= =
=


E
, onde u
i
e v
i
s6o os elementos do vetor9 Es*reva uma 8un56o float prod_esc(float u, float v,
int n) %ue re*eba dois vetores u e v de n elementos reais e retorne o valor do $roduto es*alar
entre eles9
H9G1 7 cdigo 5orse 8oi muito usado no tem$o do tel(gra8o $ara transmitir mensagens9 Neste sistema
*ada s?mbolo Bletra, numero ou sinal de $ontua56oC ( enviado $or 8io em uma serie de $ulsos
el(tri*os *urtos ou longos Bpontos ou traosC *on8orme a tabela abaixoD
> &er o algoritmo de cnuth-.orris-1ratt em S.I#' Bo$9 Cit9C, $ 49>
F &er S1IE!E, .9 R9, &n#lise (etorial, S6o 1auloD .*!ra\-'ill9 197H, $9 4=9
a .- " -... c -.-. d -.. e . f ..-.
& --. h .... i .. > .--- ? -.- l .-..
m -- n -. o --- p .--. q --.- r .-.
s ... t - u ..- v ...- w .-- * -..-
# -.-- @ --.. 2 .---- 3 ..--- , ...-- A ....-
. ..... B -.... C --... D ---.. E ----. 6 -----
- .-.-.- F ..--.. , --..-- 8 ---...
Es*reva um $rograma %ue leia uma 8rase digitada $elo usu@rio e emita $elo alto-8alante do 1C o som
*orres$ondente a uma transmiss6o *om$leta em *;digo .orse9 +ugesto) Crie uma tabela
cdigo[40][5] em %ue *ada linha re$resente um sinal *ontendo os n,meros 1 B$ontoC, 4 Btra5oC
ou E B8im do *;digoC9
H9G4 Existe um $roblema 8amoso no xadre3 *hamado .roblema das J damasD *onsiste em dis$or sobre
o tabuleiro Bde G x G *asasC do :ogo um *on:unto de 6 damas de tal 8orma %ue nenhuma dama 8i%ue
na mesma lin#a, coluna ou diagonal %ue outra9 Es*reva um $rograma %ue *al*ule $elo menos uma
solu56o deste $roblema9 +ugesto) *rie um vetor tab[8][8] *ontendo 0 $ara uma *asa va3ia e 1
$ara uma *asa o*u$ada9 Es*reva uma 8un56o %ue crie as *on8igura5<es e outra rotina %ue teste a
solu56o9
H9G= As $o$ulares *al*uladoras B. BBeKllet0.ac7ardC usam a nota56o R1N B"everse .olis# (otationC
$ara o *@l*ulo de ex$ress<es num(ri*as9 Este ti$o de nota56o torna mais 8@*il o *@l*ulo de
ex$ress<es *om$lexas9 Cada valor digitado ( guardado em uma !ilha de dados e *ada tecla de
o!erao e8etua uma o$era56o entre os ,ltimos dois valores da $ilha9 1or exem$lo, $ara e8etuar a
ex$ress6o 2+5*3 digitamosD
[C] ;colocamos o primeiro valor na pil#a=
[enter] [>] ;deslocamos C para a < posio da pil#a e colocamos > para o F
ao
valor na pil#a=
[-] ;efetuamos a multiplicao dos dois valores o valor 1C aparece na F
a
posio da pil#a=
L2] ;deslocamos FC para a <
a
posio da pil#a e colocamos > para o F
o
valor na pil#a=
[D] ;adicionamos 2 ao resultado FH aparece na F
a
posio da pil#a=!
Es*reva um $rograma %ue simule uma calculadora RP. de > o$era5<es B+,-,*,/C utili3ando vetores
$ara re$resentar a $ilha de dados9
H9G> "everse ( o nome de um antigo :ogo de tabuleiro, %ue $ode ser 8a*ilmente im$lementado em um
*om$utadorD *onsiste de um tabuleiro de 3x3 *asas, *om um dis*o bran*o ou $reto dis$ostos,
ini*ialmente, de modo aleat;rio em *ada *asa9
[1][2][3]
[4][5][6]
[7][8][9]
Ao sele*ionar uma das *asas o :ogador reverte a *or do dis*o da%uela *asa e de algumas *asas vi3inhas
*on8orme o es%uema a*ima9 7 ob:etivo do :ogo ( reverter todas as *asas $ara uma mesma *or9
Es*reva um $rograma %ue simule o tabuleiro do :ogo de "everse9
Ao pressionar +everte8
[1] [1],[2] e [4]
[2] [2],[1] e [3]
[3] [3],[2] e [6]
[4] [4],[1] e [7]
[5] [5],[2],[4],[6] e [8]
[6] [6],[3] e [9]
[7] [7],[4] e [8]
[8] [8],[7] e [9]
[9] [9],[6] e [8]
H9GF Caso :@ n6o tenha 8eito assim, Res*reva o $rograma do exer*?*io 791 tornando-a re*ursiva9
H9GH Es*reva uma 8un56o %ue re*eba duas matri3es de ordem m e *onstrua o $roduto matri*ial entre
eles9
Ca$?tulo GD 1onteiros
H9G7 Res*reva a 8un56o round() do exer*?*io @.1 $ara %ue re*eba o endere5o da vari@vel a ser
arredondada9 A nova 8un56o deve ter a seguinte de*lara56o void round(float *r) e deve
arredondar o $r;$rio numero $assado9
H9GG Es*reva uma 8un56o void troca(int *a, int *b) %ue $ermuta entre si os valores de a
e b9
H9G9 Es*reva uma 8un56o void stat(float vet, int N, float *med, float
*dsvpd) %ue re*eba um vetor de n,meros reais vet, seu tamanho N e *al*ule a m(dia aritm(ti*a
med e o desvio $adr6o
H
dsvpd destes valores9
H99E Es*reva uma 8un56o void extremos(float vet, int N, float *max, float
*min) %ue re*eba um vetor de n,meros reais vet, seu tamanho N e determine o maior e o menor
Bmax e minC destes valores9
H991 Res*reva o $rograma do exem$lo 4.1 $ara %ue, usando alo*a56o dinMmi*a de mem;ria , *onstrua
um vetor de N elementos, sendo N digitado $elo usu@rio9
H994 Es*reva um $rograma %ue, usando alo*a56o dinMmi*a de mem;ria, *onstrua um vetor de N
elementos gerados aleatoriamente no intervalo [0,10], sendo N digitado $elo usu@rio9 Em seguida
este $rograma deve *hamar a 8un56o remove_dup() do exer*?*io 4.@. Q ne*ess@ria alguma
modi8i*a56o no *;digo desta 8un56oR
H99= Es*reva uma rotina void graf(float a float b, float (*pf)(float)) %ue
re*ebe um endere5o de uma 8un56o no $onteiro pf, os valores de extremos a e b e desenhe o gr@8i*o
da 8un56o a$ontado $or pf9
H &er !I7&ANNI, /9 R9, -7N/7RN7, /9 R9, Mate"#ti$a, vol9 =, S6o 1auloD 2#D, s9d9 $9 =4E9
A$Indi*e C9 1rogramas
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6262-cpp
Proposito: Calcula a raiz quadrada de um numero real
positivo maior que 1.0 com precisao PREC (0.00001).
999999999999999999999999999999999999999999999999999999999999999/
#define MAX 100 // numero maximo de iteracoes
#define PREC 0.000001 // precisao da raiz
void main(){ // inicia programa principal...
float num // numero do qual se quer saber a raiz quadrada
float raiz; // aproximacao para raiz de num
float inf, sup; // intervalo que contem a raiz procurada
do{
printf("\n\nDigite um numero real positivo: ");
scanf("%f",&num;
}while(num <= 1.0); // aceita somente positivo maior que 1.0!
inf = 0.0; // inicializa intervalo inicial de busca
sup = num;
i = 0; // inicializa contador
do{ // faca...
i = i + 1; // incrementa contador
raiz = 0.5 * (inf + sup); // faz estimativa de raiz
if(raiz*raiz > num){ // se chute foi alto...
sup = raiz; // baixa limite superior
}else{ // ...senao...
inf = raiz; // sobe limite inferior
};
}while( (sup-inf) > PREC && i < MAX); // enquanto
intervalo grande
raiz = 0.5 * (inf + sup); // estima a raiz
printf("Raiz: %f +- %f",raizPREC); // imprime o valor
da raiz
}; // fim do programa
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6,62-cpp
Proposito: Operadores de atribuicao.
999999999999999999999999999999999999999999999999999999999999999/
void main(){
// declaracao de variaveis
char c;
int i,j,k;
float f,g,h;
double d;
// Atribuicoes validas
c = 'A';
i = 7;
f = 10.0;
d = 4.32464869714159;
// atribuicoes invalidas
// 12 = i; // costante
// f + d = d + f; // expressao
// Conversao de tipo sem perda de informacao
i = c; // valor ASCII de 'A' e' 65
f = i;
d = f;
// Conversao de tipo com perda de informacao
d = 74.5461836294756;
f = d;
i = f;
i = 2.999999; //Truncamento!
// Estouro dos limites de um tipo
i = 30000;
i = i + 1000;
i = i + 1000;
i = i + 1000; // Passou do limite!
// Atribuicao multipla
i = j = k = 4;
f = g = h = 6.8;
// Atribuicao multipla sem perda de informacao
d = f = i = 20;
// Atribuicao multipla com perda de informacao
i = f = d = 3.09571648723667;
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6,63-cpp
Proposito: Operadores Aritmeticos
999999999999999999999999999999999999999999999999999999999999999/
void main(){
char c1, c2;
int i1, i2;
float f1, f2, f3;
// Expressoes validas
i1 = 10 + 50 - 2;
i2 = i1 % 3;
f1 = 3.8 * 2.1;
f2 = 53.5 / f1;
// Expressao invalida
// i1 = f1 % 2; // O operador % so' aceita inteiros!
f1 = f1 / 0.0; // O divisor e' zero!
// Casting
i1 = (int)f1 % 2; // Obseserve que f1 continua sendo float
// somente o valor foi convertido.
// Conversao de tipo
i1 = 17;
i2 = 4;
f1 = 17.0;
f2 = 4.0;
// operandos resultado
f3 = f1 / f2; // float / float float
f3 = f1 / i2; // float / int float
f3 = i1 / f2; // int / float float
f3 = i1 / i2; // int / int int Resultado truncado!
f3 = (float)i1 / (float)i2; // Resultado correto!
// Operando caracter
c1 = 65; // valor ASCII
c2 = 'M';
c1 = c1 + 1;
c2 = c2 + 32;
// Precedencia de operadores: Verifique o resultado
i1 = 3 - 5 * 7 % 2;
i2 = 40 / 2 / 2 / 2;
f1 = 4.0 * 3.0 - 6.0 / 2.0 + 2.0;
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6,6,-cpp
Proposito: Operadores de atribuicao aritmetica
999999999999999999999999999999999999999999999999999999999999999/
void main(){
char c;
int i,j;
float r,s;
i = 0;
j = 100;
r = -3.47;
s = 546.764;
c = 'A';
// Operadores arimeticos
c += 2; // c = c + 2
i -= 4; // i = i - 4
j %= 7; // j = j % 7
r *= 7.9; // r = r * 7.9
s /= r - 1.5; // s = s / (r - 1.5)
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6,6A-cpp
Proposito: Operadores incrementais
999999999999999999999999999999999999999999999999999999999999999/
void main(){
int i = 0, j = 10;
float f = -5.0;
char c = 'Z';
// Incremento
do{
i++;
j--;
f++;
c--;
}while(i < 10);
// Posicao do operador:
// Observe que...
i = 0;
j = i++; // atribui e depois incrementa
// ... e' diferente de:
i = 0;
j = ++i; // incrementa e depois atribui
// Precedencia:
i = j++ * 3;
j = 4 % --i;
}
/999999999999999999999999999999999999999999999999999999999999999
Programa: e0305.cpp
Proposito: Operadores Relacionais e Logicos
999999999999999999999999999999999999999999999999999999999999999/
void main(){
char c,d;
int i,j;
float r,s;
int valor_logico;
// Operadores Relacionais
i = 5;
j = 6;
r = 2.3;
s = 6.1;
c = 'A';
d = 'a';
// Tipos iguais
valor_logico = (i == j);
valor_logico = (r != s);
valor_logico = (i > 3);
valor_logico = (c < d); // obs: 'A' = 65 'a' = 97
valor_logico = (4 >= j);
valor_logico = (i-5 > j*3);
valor_logico = (2.6 != 4.8);
valor_logico = (c == 'w'); // Obs.: 'w' = 119
// Tipos diferentes
valor_logico = (r <= i);
valor_logico = (j == 2.3);
// Operadores Logicos
valor_logico = r==s && c<d;
valor_logico = i>45 || r!=s;
valor_logico = !(c != d);
// Quando termina a repeticao abaixo?
i = 0;
r = 1.0;
do{
r /= 2.0;
}while( r > 1e-8 && i++ < 50);
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6,6B-cpp
Proposito: Operadores Condicionais
999999999999999999999999999999999999999999999999999999999999999/
void main(){
int i,j,max1,max2;
float r,s;
// A seguinte atribuicao...
r = (i==j) ? 34.9 : 88.4;
// e' equivalente a...
if(i==j){
s = 34.9;
}else{
s = 88.4;
};
// Aplicacao simples
// Para nao escrever...
if(i > j){
max1 = i;
}else{
max1 = j;
};
// pode-se escrever...
max2 = (i > j) ? i : j;
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6,6C-cpp
Proposito: Funcoes de Biblioteca
999999999999999999999999999999999999999999999999999999999999999/
// Exercicio: O programa abaixo foi escrito usando varias funcoes
// disponiveis do C. Procure, na ajuda on-line, informacoes sobre
// as funcoes usadas...
#include <conio.h> // inclusao das bibliotecas
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <dos.h>
#include <stdlib.h>
#include <math.h>
void main(){
char* titulo = "* * * P r o g r a m a E x e m p l o * * *";
char tecla; // tecla pressionada pelo usuario
int tam; // tamanho do titulo
int col; // coluna inicial de impressao do titulo
int cont; // flag de continuacao do laco
float num; // numero aleatorio
float val; // valor calculado
do{ // inicia laco repetitivo...
// *********************
// 1 Titulo Centralizado
// *********************
clrscr(); // limpa a tela
tam = strlen(titulo); // calcula o tamanho do titulo.
col = 40 - tam / 2; // calcula a coluna de inicio
gotoxy(col,1); // posiciona o cursor
printf(titulo); // imprime o titulo
// ******************
// 2 Numero aleatorio
// ******************
randomize(); // inicia gerador aleatorio
num = (float)random(1000) / 100.0; // gera numero
printf("\n\n Numero: %f",num); // imprime escolha
getch(); // pausa
// ********************
// 3 Faz algumas contas
// ********************
val = sin(num); // seno
printf("\n sin( %f ) = %f",num,val); // imprime
getch(); // pausa
val = ceil(num); // arredonda para cima
printf("\n ceil( %f ) = %f",num,val); // imprime
getch(); // pausa
val = floor(num); // arredonda para baixo
printf("\n floor( %f ) = %f",num,val); // imprime
getch(); // pausa
val = log(num); // logaritmo natural
printf("\n ln( %f ) = %f",num,val); // imprime
getch(); // pausa
val = sqrt(num); // raiz quadrada
printf("\n sqrt( %f ) = %f",num,val); // imprime
getch(); // pausa
// ***********
// 4 Continua?
// ***********
printf("\n Continua ? "); // imprime mensagem
tecla = getch(); // recebe caracter do teclado
tecla = toupper(tecla); // transforma em maiusculo
cont = (tecla == 'S') ? 1 : 0; // se for 'S' continua
}while(cont); // ... fim do laco de repeticao
// *******
// 5 Saida
// *******
clrscr(); // limpa tela
sound(440); // emite um som de 300 Hz...
delay(100); // ... por 100 ms...
nosound(); // ... e para.
printf("\n Volte Sempre!"); // mensagem
} // fim do programa
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6A62-cpp
Proposito: Uso da funcao printf().
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h> // biblioteca da funcao printf()!
#include <conio.h> // biblioteca da funcao clrscr()
void main(){
int i = 12;
int j = -35;
int k = 9386;
float r = 5.83;
float s = -82.3;
float t = 5467.75;
char letra = 'a';
char* nome = "Teste";
clrscr(); // limpa tela
// somente texto
printf("Texto Exemplo"); // sem quebra de linha
printf("Texto Exemplo");
printf("Texto Exemplo");
printf("Texto Exemplo");
printf("\nTexto Exemplo"); // com quebra de linha
printf("\nTexto Exemplo");
printf("\nTexto Exemplo");
printf("\nTexto Exemplo");
// formato caracter
printf("\n%c",letra);
printf("\n%c",'b');
// formato string
printf("\n%s",nome);
// texto e numero sem formatacao
printf("\nJoaozinho tem %d amiguinhos!",i);
printf("\nConsumo Medio: %f kWh",r);
// Uso dos modificadores de formato
printf("\n\nJustificacao a direita");
printf("\n %6d %12f",i,r);
printf("\n %6d %12f",j,s);
printf("\n %6d %12f",k,t);
printf("\n\nJustificacao a esquerda");
printf("\n %-6d %-12f",i,r);
printf("\n %-6d %-12f",j,s);
printf("\n %-6d %-12f",k,t);
printf("\n\nCom sinal");
printf("\n %+6d %+12f",i,r);
printf("\n %+6d %+12f",j,s);
printf("\n %+6d %+12f",k,t);
printf("\n\nCom zeros");
printf("\n %06d %012f",i,r);
printf("\n %06d %012f",j,s);
printf("\n %06d %012f",k,t);
printf("\n\nSem decimais, Com 3 decimais");
printf("\n %6.0f %8.3f", r,r);
printf("\n %6.0f %8.3f", s,s);
printf("\n %6.0f %8.3f", t,t);
printf("\n\nDecimal, Hexa, Octal");
printf("\n %6d %6X %6o",i,i,i);
printf("\n %6d %6X %6o",k,k,k);
printf("\n %6d %6X %6o",k+1,k+1,k+1);
printf("\n\nPadrao, Cientifico");
printf("\n %11f %e", r,r);
printf("\n %11f %e", s,s);
printf("\n %11f %e", t,t);
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6A63-cpp
Proposito: Uso da funcao scanf()
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h> // biblioteca das funcoes scanf() e printf()
void main(){
char* nome;
int cod;
float preco;
int dia,mes,ano;
// leitura individual
printf("\nDigite o nome do item: "); // texto de aviso (prompt)
scanf("%s",nome); // leitura do dado
printf("Digite o codigo do item: ");
scanf("%d",&cod);
printf("Digite o preco do item: ");
scanf("%f",&preco);
// leitura conjunta
printf("\nDigite o nome, codigo e preco do item: ");
scanf("%s %d %f",nome,&cod,&preco);
// leitura conjunta com supressao
printf("\nDigite o nome, codigo e preco do item: ");
scanf("%s %d %*f",nome,&cod,&preco); // apos a leitura,'preco'
nao e' alterado
// leitura segmentada
printf("\nDigite sua data de nascimento (ddmmaa): ");
scanf("%2d %2d %2d",&dia,&mes,&ano);
printf("\nVoce nasceu em %d de %d de 19%d!",dia,mes,ano);
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6A6,-cpp
Proposito: Uso das funcoes ao getchar() e putchar()
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
void main(){
char c; // declara caracter
printf("\nDigite uma frase:\n");
do{ // faz...
c = getchar(); // leitura do 'buffer'
if(c >= 97 && c <= 122){ // se c e' minusculo...
c -= 32; // ...transforma em maiusculo
}
putchar(c); // impressao dos caracteres maiusculos
}while (c != '\n'); // ...enquanto nao e' [enter]
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6A6A-cpp
Proposito: Uso da funcao getch()
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
void main(){
int c,d; // codigos
printf("\n Pressione uma tecla ou combinacao de teclas:");
printf("\n Pressione [esc] para terminar! ");
do{ // faz...
c = getch(); // leitura do primeiro codigo.
if(c == 0){ // se for codigo extendido...
d = getch(); // le segundo codigo.
printf("\n %3d %3d codigo extendido",c,d);
// imprime codigo extendido
}else{
printf("\n %3d codigo normal",c);
// imprime codigo normal
};
}while (c != 27); // ...enquanto nao for [esc]
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6A6.-cpp
Proposito: Uso da funcao getche()
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
#include <conio.h>
void main(){
int n = 0; // contador de letras
char c; // caracter digitado
printf("\nDigite uma frase:\n");
do{ // faz...
c = getche(); // leitura do caracter
n++; // incrementa contador
}while (c != '\r'); // ...enquanto nao for [enter]
printf("\nVoce digitou %d caracteres!",n-1);
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6A6B-cpp
Proposito: Uso das funcoes cprintf(), textbackground() e
textcolor()
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
void main(){
int cl; // cor de letra
int cf; // cor de fundo
clrscr(); // limpa tela
cf = BLACK; // cor de fundo preta
do{ // faz...
textbackground(cf); // ativa cor de fundo
cl = BLACK; // cor de letra preta
do{ // faz...
textcolor(cl); // ativa cor de texto
cprintf(" Teste "); // imprime teste de cor
}while(++cl <= WHITE); // enquanto nao e' ultima cor de
letra
}while(++cf <= LIGHTGRAY); // enquanto nao e' ultima cor de
fundo
cf = BLACK;
do{
textbackground(cf);
cl = BLACK;
do{
textcolor(cl + BLINK); // ativa letra piscante
cprintf(" Teste ");
}while(++cl <= WHITE);
}while(++cf <= LIGHTGRAY);
textbackground(BLACK); // ativa fundo padrao
textcolor(LIGHTGRAY); // ativa letra padrao
getch();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6A6C-cpp
Proposito: Uso das funcoes sound(), delay() e
nosound()
999999999999999999999999999999999999999999999999999999999999999/
#include <dos.h>
#include <conio.h>
#include <stdio.h>
#define T 250
void main(){
clrscr();
textbackground(BLUE);
textcolor(WHITE + BLINK);
cprintf("Hino do Gr`mio");
printf("\nAt, a p, nos iremos,...");
sound(660);delay(2*T);
sound(550);delay(T);
sound(495);delay(T);
sound(440);delay(2*T);
sound(495);delay(T);
sound(550);delay(T);
sound(495);delay(2*T);
sound(330);delay(6*T);
printf("\b\b\b para o que der e vier.");
sound(660);delay(2*T);
sound(550);delay(T);
sound(495);delay(T);
sound(440);delay(2*T);
sound(495);delay(T);
sound(550);delay(T);
sound(495);delay(6*T);
printf("\nMas o certo, , que ns estaremos...");
sound(550);delay(T);
sound(594);delay(T);
sound(660);delay(2*T);
sound(634);delay(T);
sound(660);delay(T);
sound(704);delay(2*T);
sound(660);delay(T);
sound(704);delay(T);
sound(844);delay(2*T);
sound(734);delay(4*T);
printf("\b\b\b com o Gr`mio, onde o Gr`mio estiver!");
sound(550);delay(T);
sound(594);delay(T);
sound(660);delay(2*T);
sound(734);delay(T);
sound(660);delay(T);
sound(495);delay(2*T);
sound(594);delay(T);
sound(550);delay(T);
sound(440);delay(4*T);
nosound();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6A6D-cpp
Proposito: Uso das funcoes clrscr(), clreol(),
gotoxy(), window() e kbhit()
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <string.h>
#include <stdlib.h>
#include <dos.h>
void main(){
int esq,sup,dir,inf; // bordas
char* tit = "Teste de video: Blocos coloridos"; // titulo
char* rpe = "Pressione alguma tecla para terminar"; // rodape
clrscr(); // limpa tela
textbackground(BLUE); // seleciona cor de fundo de linha
textcolor(WHITE); // cor de letra
gotoxy(1,1); // posiciona cursor no canto esquerdo
clreol(); // desenha fundo de linha
gotoxy(40 - strlen(tit)/2, 1); // posiciona cursor
cprintf("%s",tit); // escreve titulo centralizado
gotoxy(1,25); // posiciona cursor no canto esquerdo
clreol(); // desenha fundo de linha
gotoxy(40 - strlen(rpe)/2, 25); // posiciona cursor
cprintf("%s",rpe); // escreve rodape centralizado
do{
delay(100); // pausa pra nao ficar muito ligeiro
esq = 1 + random(80); // esq <- [1 , 80]
dir = esq + random(81-esq); // dir <- [esq, 80]
sup = 2 + random(23); // sup <- [ 2, 24]
inf = sup + random(25-sup); // inf <- [sup, 24]
window(esq,sup,dir,inf); // define janela
textbackground(random(8));
// seleciona cor de fundo aleatoria
clrscr(); // preenche janela com cor
}while(!kbhit());
window(1,1,80,25); // restaura janela
textbackground(BLACK); // restaura cor de fundo
clrscr(); // limpa tela
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6.62-cpp
Proposito: Uso da estrutura do...while
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
void main(){
unsigned int i,n,fat;
do{ // leitura do numero
puts("\nDigite um inteiro entre 0 e 10: ");
scanf("%u",&n);
}while(n < 0 || n > 10); // repete a leitura se n < 0 e n > 10
fat = 1;
i = 1; // contador de iteracoes
do{ // calculo do fatorial
fat *= i; // fat = fat * i
}while(i++ <= n); // repete multiplicacao se i < n
printf("\n %u! = %u",n,fat);
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6.63-cpp
Proposito: Uso da estrutura while
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h> // inclusao de bibliotecas
#include <math.h>
#include <conio.h>
#define TOL 1.0e-14 // tolerancia
void main(){ // calculo da raiz quadrada pelo metodo de Newton
double num; // numero do qual se quer saber a raiz quadrada
double raiz,raiz_ant; // estimativas da raiz
puts("\nDigite um numero positivo: ");
scanf("%lf",&num);
raiz_ant = 0.0; // estimativas
raiz = num;
while(fabs(raiz - raiz_ant) > TOL){ // enquanto pouca precisao
raiz_ant = raiz; // salva estimativa anterior
raiz = 0.5*(raiz_ant + num/raiz_ant); // nova estimativa
}
printf("\nsqrt(%.1f) = %.14f",num,raiz); // imprime valores
getch();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6.6,-cpp
Proposito: Uso da estrutura for...
999999999999999999999999999999999999999999999999999999999999999/
// calculo da amplitude de um conjunto de valores.
#include <conio.h>
#include <stdio.h>
void main(){
int i; // contador de iteracao
int num; // numero de valores lidos
float val; // valor lido
float max,min; // valor maximo, valor minim
clrscr();
puts("Digite numeros reais...");
puts("Quantos valores? ");
scanf("%d",&num); // leitura do numero de valores
for(i = 1; i <= num; i++){ // laco iterativo para i de 1 a num
printf("%d valor: ",i); // leitura dos valores
scanf("%f",&val); //
if(i == 1){ // se 1a leitura...
max = min = val; // inicializa valores
} //
max = val > max ? val : max; // calcula maximo
min = val < min ? val : min; // calcula minimo
} // fim do laco
printf("\nAmplitude: [%.3f , %.3f]",min,max); // imprime min,max
getch();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6.6A-cpp
Proposito: Uso da estrutura if...
999999999999999999999999999999999999999999999999999999999999999/
#include <dos.h> // inclusao de bibliotecas
#include <conio.h>
#include <stdio.h>
void main(){
int i; // contador
clrscr();
puts("Jogo do Pim!");
for(i = 1; i <= 20; i++){ // para i de 1 a 20...
printf("\n%2d...",i); // imprime numero
if(i%4 == 0){ // se multiplo de 4...
sound(600); // Pim!
delay(50); //
nosound(); //
} // fim se
delay(500); // espera
}
puts("Oba! Ganhei o premio!");
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6.6.-cpp
Proposito: Uso da estrutura if...else
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
void main(){
float a,b,c; // parametros de ax^2+bx+c=0
float delta; // descriminante: b^2-4ac
puts("\nBaskara");
puts("Digite valores para a, b, c: ");
scanf("%f %f %f",&a,&b,&c); // leitura dos parametros
delta = b * b - 4. * a * c; // calculo do discriminante
printf("Descriminante: %f", delta);
if(delta >= 0.0){ // se delta e' positivo...
puts(" Raizes Reais"); // raizes reais
}else{ // ...senao...
puts(" Raizes Complexas"); // raizes complexas
}
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6.6B-cpp
Proposito: Uso da estrutura if...else if
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
void main(){
int palpite; // palpite do usuario
int numero; // numero do computador
randomize(); // inicializador do geredor aleatorio
numero = random(10); // escolhe numero aleatorio
puts("\nEscolhi um numero. Adivinha qual e'?\n");
scanf("%d",&palpite); // leitura do palpite
if(palpite > numero){ // se chute alto...
puts("Chute alto!"); // mensagem
}else if(palpite < numero){ // ...senao se chute baixo...
puts("Chute baixo!"); // mensagem
}else{ // senao acertou
puts("Acertou!"); // mensagem
}
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6.6C-cpp
Proposito: Uso da estrutura switch
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
#include <conio.h>
void main(){
int tipo;
float preco = 0.0;
clrscr();
puts("*** Turbo Cao Lanches *** \nFaca seu pedido!");
puts("1: Da Casa \n2: Completo \n3: Simples \n4: Economico");
do{
printf("\nPedido: ");
scanf("%d",&tipo);
}while(tipo != 1 && tipo != 2 && tipo != 3 && tipo != 4);
printf("\nSeu pedido:\n");
switch (tipo) {
case 1:
puts("- bacon");
puts("- ovo frito");
preco += 0.60;
case 2:
puts("- queijo ralado");
puts("- maionese");
preco += 0.50;
case 3:
puts("- milho");
puts("- ervilha");
preco += 0.20;
case 4:
puts("- salsicha");
puts("- pao");
puts("- molho");
preco += 1.0;
}
printf("\nTotal: $ %.2f Bom Apetite!",preco);
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6.6D-cpp
Proposito: Uso da estrutura switch com break
999999999999999999999999999999999999999999999999999999999999999/
#include <dos.h>
#include <stdio.h>
#include <conio.h>
#define DO 264 // definicao de escala musical
#define RE 297
#define MI 330
#define FA 352
#define SOL 396
#define LA 440
#define SI 495
void main(){
int tecla;
clrscr();
puts("Digite teclas [z] [x] [c] [v] [b] [n] [m] para notas");
puts("ou [esc] para sair");
do{
tecla = getch(); // leitura do teclado
switch(tecla){ // conforme o valor de tecla...
case 'z': // se tecla = 'z'
sound(DO); // nota do
break; // cai fora do switch...
case 'x':
sound(RE);
break;
case 'c':
sound(MI);
break;
case 'v':
sound(FA);
break;
case 'b':
sound(SOL);
break;
case 'n':
sound(LA);
break;
case 'm':
sound(SI);
break;
}
delay(200); // toca por 200 ms
nosound(); // desliga auto-falante
}while(tecla != 27); // repete enquanto tecla != [esc]
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6B62-cpp
Proposito: Funcao de usuario escrita antes de programa
principal
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
float max(float a, float b){ // funcao max()
if(a > b){
return(a);
}else{
return(b);
}
}
void main(){ // programa principal
float num1,num2,m;
clrscr();
puts("*** Valor maximo de dois reais ***");
puts("Digite dois numeros:");
scanf("%f %f",&num1,&num2);
m = max(num1,num2); // chamada da funcao
printf("O maior valor e': %f",m);
getch();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6B63-cpp
Proposito: Funcao de usuario escrita depois de programa
principal
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
void main(){ // programa principal
float max(float,float); // prototipo da funcao max()
float num1, num2;
clrscr();
puts("*** Valor maximo de dois reais ***");
puts("Digite dois numeros");
scanf("%f %f",&num1,&num2);
printf("O maior valor e': %f",max(num1,num2)); // chamada a
funcao
getch();
}
float max(float a, float b){ // funcao max()
if(a > b){
return(a);
}else{
return(b);
}
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6B6,-cpp
Proposito: Programa principal. Funcao em arquivo separado
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
#include "k:\curso_c\e0604.cpp" // inclusao de funcao
void main(){ // programa principal
float num1, num2;
clrscr();
puts("*** Valor maximo de dois reais ***");
puts("Digite dois numeros");
scanf("%f %f",&num1,&num2);
printf("O maior valor e': %f",max(num1,num2)); // chamada a funcao
getch();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6B6A-cpp
Proposito: Funcao de usuario. Programa principal em
e0603.cpp
999999999999999999999999999999999999999999999999999999999999999/
float max(float a, float b){ // funcao max()
if(a > b){
return(a);
}else{
return(b);
}
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6B6.-cpp
Proposito: Uso de varias funcoes de usuario.
999999999999999999999999999999999999999999999999999999999999999/
// **********************************
// 1 inclusao de bibliotecas padrao C
// **********************************
#include <dos.h>
#include <string.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
// **************
// 2 rotina bip()
// **************
void bip(int tipo){
int i; // contador de iteracao
switch (tipo){ // seleciona tipo de som...
case 0: // giro da roleta
sound(100);
delay(5);
break;
case 1: // parada da roleta
sound(200);
delay(100);
break;
case 2: // moedas caindo
sound(3000);
delay(20);
}
nosound();
}
// ****************
// 3 rotina pinta()
// ****************
void pinta(int figura,int status, int linha, int coluna){
switch (figura){ // seleciona figura...
case 1: // happy face
if(status == 0){ // se roleta girando...
textcolor(LIGHTGRAY); // cor normal
}else{
textcolor(YELLOW+BLINK); // cor da figura
}
gotoxy(coluna,linha++); // posiciona cursor
cprintf(" ##### ");
gotoxy(coluna,linha++);
cprintf(" #*****# ");
gotoxy(coluna,linha++);
cprintf("#*******#");
gotoxy(coluna,linha++);
cprintf("#**#*#**#");
gotoxy(coluna,linha++);
cprintf("#*******#");
gotoxy(coluna,linha++);
cprintf("#*#***#*#");
gotoxy(coluna,linha++);
cprintf("#**###**#");
gotoxy(coluna,linha++);
cprintf(" #*****# ");
gotoxy(coluna,linha++);
cprintf(" ##### ");
break;
case 2: // copa
if(status == 0){ // se roleta girando...
textcolor(LIGHTGRAY); // cor normal
}else{
textcolor(RED); // cor da figura
}
gotoxy(coluna,linha++); // posiciona cursor
cprintf(" ### ### ");
gotoxy(coluna,linha++);
cprintf("#***#***#");
gotoxy(coluna,linha++);
cprintf("#*******#");
gotoxy(coluna,linha++);
cprintf("#*******#");
gotoxy(coluna,linha++);
cprintf("#*******#");
gotoxy(coluna,linha++);
cprintf(" #*****# ");
gotoxy(coluna,linha++);
cprintf(" #***# ");
gotoxy(coluna,linha++);
cprintf(" #*# ");
gotoxy(coluna,linha++);
cprintf(" # ");
break;
case 3: // ouro
if(status == 0){ // se roleta girando...
textcolor(LIGHTGRAY); // cor normal
}else{
textcolor(BLUE); // cor da figura
}
gotoxy(coluna,linha++); // posiciona cursor
cprintf(" # ");
gotoxy(coluna,linha++);
cprintf(" #*# ");
gotoxy(coluna,linha++);
cprintf(" #***# ");
gotoxy(coluna,linha++);
cprintf(" #*****# ");
gotoxy(coluna,linha++);
cprintf("#*******#");
gotoxy(coluna,linha++);
cprintf(" #*****# ");
gotoxy(coluna,linha++);
cprintf(" #***# ");
gotoxy(coluna,linha++);
cprintf(" #*# ");
gotoxy(coluna,linha++);
cprintf(" # ");
break;
case 4: // espada
if(status == 0){ // se roleta girando...
textcolor(LIGHTGRAY); // cor normal
}else{
textcolor(GREEN); // cor da figura
}
gotoxy(coluna,linha++);
cprintf(" # ");
gotoxy(coluna,linha++);
cprintf(" #*# ");
gotoxy(coluna,linha++);
cprintf(" #***# ");
gotoxy(coluna,linha++);
cprintf(" #*****# ");
gotoxy(coluna,linha++);
cprintf("#*******#");
gotoxy(coluna,linha++);
cprintf("#*******#");
gotoxy(coluna,linha++);
cprintf("#**###**#");
gotoxy(coluna,linha++);
cprintf(" ## # ## ");
gotoxy(coluna,linha++);
cprintf(" # ");
break;
case 5: // pau
if(status == 0){ // se roleta girando...
textcolor(LIGHTGRAY); // cor normal
}else{
textcolor(CYAN); // cor da figura
}
gotoxy(coluna,linha++);
cprintf(" ### ");
gotoxy(coluna,linha++);
cprintf(" #***# ");
gotoxy(coluna,linha++);
cprintf(" #***# ");
gotoxy(coluna,linha++);
cprintf(" #*# ");
gotoxy(coluna,linha++);
cprintf(" ##***## ");
gotoxy(coluna,linha++);
cprintf("#*******#");
gotoxy(coluna,linha++);
cprintf("#**###**#");
gotoxy(coluna,linha++);
cprintf(" ## # ## ");
gotoxy(coluna,linha++);
cprintf(" # ");
};
textcolor(LIGHTGRAY); // cor padrao
};
// *******************
// 4 rotina imprimec()
// *******************
void imprimec(int linha,char* texto){
int col,tam;
textcolor(WHITE); // cor de letra
textbackground(BLUE); // cor de fundo
gotoxy(1,linha); // posiciona o cursor
clreol(); // limpa linha(imprime fundo)
tam = strlen(texto); // calcula o tamanho do texto
col = 40 - tam / 2; // calcula a coluna de inicio
gotoxy(col,linha); // posiciona o cursor
cprintf("%s",texto); // imprime o texto
textcolor(LIGHTGRAY); // cor de letra original
textbackground(BLACK); // cor de fundo original
};
// *****************
// 5 rotina regras()
// *****************
void regras(){
clrscr();
imprimec(1,"J a c k p o t !");
imprimec(10,"Regras:");
imprimec(11,"- Pressione [enter] para rodar a roleta.");
imprimec(12,"- Pressione [esc] para sair.");
imprimec(13,"- Quanto maior o numero de CARAS FELIZES, maior seu
premio!");
getch();
clrscr();
}
// ****************
// 6 Rotina Saida()
// ****************
void saida(void){
imprimec(12,"Vencedores nao usam drogas!");
delay(2000);
textcolor(LIGHTGRAY);
textbackground(BLACK);
clrscr();
}
// *****************
// 7 rotina roleta()
// *****************
void roleta(int naipe1,int naipe2,int naipe3,int naipe4,int naipe5){
int volta1=2,volta2=4,volta3=8,volta4=16,volta5=32,tempo=25;
do{
if(volta1 > 1){
pinta(random(4)+2,0,5,6);
bip(0);
volta1--;
}else if(volta1 == 1){
pinta(naipe1,1,5,6);
bip(1);
volta1--;
}
delay(tempo);
if(volta2 > 1){
pinta(random(4)+2,0,5,21);
bip(0);
volta2--;
}else if(volta2 == 1){
pinta(naipe2,1,5,21);
bip(1);
volta2--;
}
delay(tempo);
if(volta3 > 1){
pinta(random(4)+2,0,5,36);
bip(0);
volta3--;
}else if(volta3 == 1){
pinta(naipe3,1,5,36);
bip(1);
volta3--;
}
delay(tempo);
if(volta4 > 1){
pinta(random(4)+2,0,5,51);
bip(0);
volta4--;
}else if(volta4 == 1){
pinta(naipe4,1,5,51);
bip(1);
volta4--;
}
delay(tempo);
if(volta5 > 1){
pinta(random(4)+2,0,5,66);
bip(0);
volta5--;
}else if(volta5 == 1){
pinta(naipe5,1,5,66);
bip(1);
volta5--;
}
delay(tempo);
}while(volta5 > 0);
}
// *******************
// 8 rotina abertura()
// *******************
void abertura(){
imprimec(1,"J a c k P o t !"); // titulo
roleta(1,1,1,1,1); // caras felizes
imprimec(25,"T e n t e s u a S o r t e !"); // rodape
getch(); // aguarda
}
// *****************
// 9 rotina simnao()
// *****************
int simnao(){
int tecla,resp;
do{
tecla = getch(); // leitura do teclado
switch (tecla){
case 13: // pressionou [enter]?
resp = 1;
break;
case 27: // pressionou [esc]?
resp = 0;
break;
default: // pressionou qq outra coisa?
printf("\a");
};
}while(tecla != 13 && tecla != 27); // nao sai enquanto tecla !
= [enter] ou [esc]
return(resp);
};
// ****************
// 10 rotina sorte()
// ****************
int sorte(int f1,int f2,int f3,int f4,int f5){
int lucro,cont = 0;
if(f1 == 1){cont++;};
if(f2 == 1){cont++;};
if(f3 == 1){cont++;};
if(f4 == 1){cont++;};
if(f5 == 1){cont++;};
switch (cont) {
case 0:
lucro = 0;
break;
case 1:
lucro = 1;
break;
case 2:
lucro = 5;
break;
case 3:
lucro = 20;
break;
case 4:
lucro = 50;
break;
case 5:
lucro = 250;
};
return(lucro);
};
// ********************
// 11 rotina plim_plim()
// ********************
int plim_plim(int total,int lucro){
do{
if(lucro > 0){
lucro--;
total++;
bip(2);
delay(50+random(100));
};
gotoxy(1,25);
clreol();
printf("Dinheiro: $ %d",total);
}while(lucro > 0);
textcolor(7);
textbackground(0);
return(total);
};
// ********************
// 12 programa principal
// ********************
void main(){
int fig1,fig2,fig3,fig4,fig5; // figuras geradas na roleta
int lucro = 0; // valor recebido na roleta
int moedas = 10; // dinheiro disponivel
randomize(); // inicializa gerador aleatorio
regras(); // anuncia regras
abertura(); // abertura do programa
do{ // joga...
fig1 = random(5)+1; // gera figuras da roleta
fig2 = random(5)+1;
fig3 = random(5)+1;
fig4 = random(5)+1;
fig5 = random(5)+1;
roleta(fig1,fig2,fig3,fig4,fig5); // gira a roleta
lucro = sorte(fig1,fig2,fig3,fig4,fig5); // calcula ganho
na roleta
moedas = plim_plim((moedas-2),lucro); // despeja moedas
}while(simnao() && moedas); // . enquanto desejar e tiver moedas
if(moedas <= 0){ // se nao tem mais moedas...
imprimec(25,"Sinto muito, mas seu dinheiro acabou!");
getch(); // aguarda
}
saida(); // termina
}
// * * * * f i m d o p r o g r a m a p r i n c p a l ! * * * *
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama e*emplo e6B6B-cpp
999999999999999999999999999999999999999999999999999999999999999/
// ******************
// programa principal
// ******************
#include <conio.h>
#include <stdio.h>
void main(){ // declaracao da funcao principal
long double n,f; // declaracao de variaveis
long double fat(unsigned n); // declaracao da funcao fat()
clrscr();
do{ // leitura do numero
puts("Digite um numero positivo para o calculo do
fatorial");
printf("numero: ");
scanf("%Lf",&n);
}while(n < 0.0 || n > 1000.0);
f = fat(n); // chamada a funcao fat()
printf("\n%.0Lf! = %Le",n,f); // impressao do resultado
};
// ************
// rotina fat()
// ************
long double fat(unsigned n){// declaracao da funcao
long double valor; // fdeclaracao de variavel temporaria
if(n == 0.0){ // se fim da recursao...
valor = 1.0; // ... calcula ultimo valor.
}else{ // senao...
valor = n * fat(n-1.0); // ... chama fat(n-1).
};
return(valor); // retorna valor.
};
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6C62-cpp
Proposito: Manipula vetores
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
#include <ctype.h>
void main(){
int total[5] = {0,0,0,0,0}; // inicializacao por lista
char letra[80]; // declaracao de vetor
char vogal[5]; // declaracao de vetor
vogal[0]='a'; // inicializacao por elemento
vogal[1]='e';
vogal[2]='i';
vogal[3]='o';
vogal[4]='u';
int i,j; // contadores
clrscr();
puts("Digite uma frase de teste:");
i=0;
do{ // faz a leitura das teclas...
letra[i] = tolower(getche()); // i-esimo elemento de 'letra'
recebe tecla
for(j=0; j<=4; j++){ // para todas as vogais...
if(letra[i] == vogal[j]){ // se tecla digitada e'
vogal...
total[j]++; // incrementa i-esimo contador
}
}
}while(letra[i++] != '\r'); // ... enquanto nao for [enter]
puts("\nTotal de vogais digitadas:");
for(i=0; i<=4; i++){ // para todas as vogais...
printf("%c: %d \n",vogal[i],total[i]); // imprime totais
}
getch(); // pausa
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6C63-cpp
Proposito: Mostra acesso de elementos dentro e fora
de um vetor
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
void main(){
int i;
int val[5]; // declaracao do vetor 'val' de 5 elementos
// ********************
// 1 Leitura de valores
// ********************
clrscr();
puts("Digite alguns numeros inteiros:");
for(i = 0; i <= 4; i++){ // somente 5 valores sao lidos
printf("%d valor: ",i+1); // chamada do valor
scanf("%d",&val[i]); // o valor e' lido
}
// **********************
// 2 Impressao de valores
// **********************
clrscr();
puts("Estes sao os valores lidos: ");
for(i = 0; i <= 4 ; i++){ // acesso a elementos DENTRO do vetor!
printf("val[%d]: %d\n",i,val[i]); // impressao dos valores
}
puts("\n...Mas nada impede o acesso a estes valores: ");
for(i = -5; i <= -1 ; i++){ // acesso a elementos FORA do vetor!
printf("val[%d]: %d\n",i,val[i]); // impressao dos valores
}
for(i = 5; i <= 10 ; i++){ // acesso a elementos FORA do vetor!
printf("val[%d]: %d\n",i,val[i]); // impressao dos valores
}
getch();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6C6,-cpp
Proposito: Mostra declaracao de vetor com tamanho
parametrizado
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#define MAX 5 // definicao do parametro MAX
// Experimente alterar este valor!
void main(){
int i=3;
int valor[MAX]; // declaracao do vetor usando MAX
randomize();
clrscr();
printf("Calculo de %d numeros aleatorios:",MAX);
for(i = 0; i <= MAX-1; i++){ // somente MAX valores so
calculados
valor[i] = 1+random(100);
printf("\n%3d: %d",i+1,valor[i]); // o valor e' impresso
}
getch();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6C6A-cpp
Proposito: Mostra a passagem de vetores para funcoes.
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
#define MAX 50
// ********************
// 1 Programa principal
// ********************
void main(){
int i,n;
float med,idade[MAX]; // declaracao do vetor idade
float media(float[],int); // prototipo de funcao
// > prototipo de vetor!
// ********************
// 1.1 Leitura de dados
// ********************
clrscr();
do{
printf("\nDigite o numero de alunos na turma: ");
scanf("%d",&n);
}while(n < 1 || n > MAX); // teste de limites!
printf("\nDigite as idades dos alunos:\n");
for(i=0 ; i<=(n-1) ; i++){
printf("%d aluno: ",i+1);
scanf("%f",&idade[i]); // leitura dos elementos do vetor
}
// *********************************************
// 1.2 Calculo da media e impressao de resultado
// *********************************************
med = media(idade,n); // passagem do vetor idade para a funcao
printf("\nMedia: %.1f",med); // resultado
getch(); // pausa
}
// ****************
// 2 rotina media()
// ****************
float media(float v[],int num){ // declaracao da funcao
int i;
float soma = 0.0;
for(i = 0; i <= num-1; i++){
soma += v[i]; // calcula soma
}
return(soma/num); // retorna media
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6C6.-cpp
Proposito: Mostra a modificacao de elementos de um
vetor passado como argumento de uma funcao.
999999999999999999999999999999999999999999999999999999999999999/
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#define MAX 150
// ********************
// 1 Programa principal
// ********************
void main(){
int i; // contador de iteracao
int n; // numero de elementos do vetor
int num[MAX]; // declaracao do vetor 'num' de MAX elementos
void ordem(int[],int); // prototipo da funcao de ordenamento
randomize(); // inicializa gerador aleatorio
// ********************
// 1.1 Entrada de dados
// ********************
clrscr();
do{
puts("\nDigite a quantidade de numeros a ordenar: ");
scanf("%d",&n);
}while(n < 1 || n > MAX);
// *********************************
// 1.2 Geracao de numeros aleatorios
// *********************************
puts("Gerando lista de numeros aleatorios...");
for(i = 0; i <= n-1; i++){
num[i] = random(100); // gera numero aleatorio
printf("%2d ",num[i]); // imprime vetor gerado
delay(50);
}
// *************************
// 1.3 Ordenacao e impressao
// *************************
ordem(num,n); // passagem do vetor idade para a funcao
puts("\nValores ordenados:");
for(i=0 ; i<=(n-1) ; i++){
printf("%2d ",num[i]); // imprime vetor ordenado
delay(50);
}
getch();
}
// ****************
// 2 rotina ordem()
/999999999999999999999999999999999999999999999999999999999999999
// :etodo8 (rdenacao %olha-
// Referencia: MANZANO,J.A.N.G.,OLIVEIRA,J.F., Algoritmos: Logica para
desenvolvimento de programacao,Sao Paulo? Erica, 1996 [p.121]
// "O mais simples e mais ineficiente algoritmo desenvolvido pela
humaninade"
999999999999999999999999999999999999999999999999999999999999999/
void ordem(int valor[],int num){ // declaracao da funcao
int t; // contador de trocas
int temp; // armazenador temporario para troca
int i; // contador de iteracao
do{ // ordena...
t = 0; // nenhuma troca ainda
for(i = 0; i <= num-2; i++){ // para todos os elementos do
vetor...
if(valor[i] > valor[i+1]){ // se fora de ordem...
temp = valor[i]; // troca...
valor[i] = valor[i+1];
valor[i+1] = temp;
t++; //conta troca
}
}
}while(t); // ...enquanto houver trocas
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6C6B-cpp
Proposito: Mostra a manipulacao de vetores de 2
dimensoes.
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
#define MAX 5
// ********************
// 1 Programa principal
// ********************
void main(){
int a[MAX][MAX];// vetor bidimensional!!
int n,m; // numero de linhas(n) e colunas(m) da matriz
int c,l; // contadoes de iteracao
void impmtz(int[MAX][MAX],int,int); // funcao de impressao de
matriz
void transp(int[MAX][MAX],int,int); // funcao de transposicao de
matriz
// titulo
clrscr();
puts("Transposicao de Matrizes");
// leitura da ordem da matriz
do{
puts("Digite o numero de LINHAS da matriz:");
scanf("%d",&n);
}while(n < 1 || n > MAX);
do{
puts("Digite o numero de COLUNAS da matriz:");
scanf("%d",&m);
}while(m < 1 || m > MAX);
// leitura dos elementos da matriz
puts("Digite os elementos (INTEIROS) da matriz:");
for(l = 0 ; l <= n-1 ; l++){
for(c = 0 ; c <= m-1 ; c++){
printf("\na[%d][%d]: ",l+1,c+1);
scanf("%d",&a[l][c]);
// > elemento do vetor
}
}
// impressao da matriz original
clrscr();
puts("Matriz original:");
impmtz(a,n,m);
// transposicao
transp(a,n,m);
// impressao da matriz transposta
puts("Matriz Transposta:");
impmtz(a,m,n);
getch(); // pausa
}
// *****************
// 2 rotina impmtz()
// *****************
void impmtz(int matriz[MAX][MAX], int max_lin,int max_col){
int i,j;
for(i = 0 ; i <= max_lin-1 ; i++){ // para todas as linhas...
puts("\n"); // quebra linha
for(j = 0 ; j <= max_col-1 ; j++){ // para todas as
colunas...
printf("%3d ",matriz[i][j]); // imprime elemento
}
}
puts("\n");
}
// *****************
// 3 rotina transp()
// *****************
void transp(int matriz[MAX][MAX], int max_lin,int max_col){
int i,j,temp;
for(i = 0 ; i <= max_lin-1 ; i++){ // para todas as linhas...
for(j = i ; j <= max_col-1 ; j++){ // para todas as
colunas j >= i
temp = matriz[i][j]; // troca: m[i][j] <-
> m[j][i]
matriz[i][j] = matriz[j][i];
matriz[j][i] = temp;
}
}
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama e*emplo e6C6C-cpp
Cap.8 ex. 07 Vetores
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
#define MAX 10
void main(){
int a[MAX][MAX]; // <- vetor bidimensional!!
int n,c,l,temp;
// titulo
clrscr();
puts("Transposicao de Matrizes");
// leitura da ordem da matriz
do{
puts("Digite a ordem do sistema:");
scanf("%d",&n);
}while(n<1 || n > MAX);
// leitura dos elementos da matriz
puts("Digite os elementos da matriz:");
for(l = 0 ; l <= n-1 ; l++){
for(c = 0 ; c <= n-1 ; c++){
printf("\na[%d][%d]: ",l+1,c+1);
scanf("%d",&a[l][c]);
};
};
// impressao da matriz original
clrscr();
puts("Matriz original:");
for(l = 0 ; l <= n-1 ; l++){
for(c = 0 ; c <= n-1 ; c++){
gotoxy(1+c*5,l+3);
printf("%4d",a[l][c]);
};
};
// transposicao da matriz
for(l = 0 ; l <= n-1 ; l++){
for(c = l ; c <= n-1 ; c++){
temp = a[l][c];
a[l][c] = a[c][l];
a[c][l] = temp;
};
};
// impressao da matriz tranposta
puts("\n\nMatriz transposta:");
for(l = 0 ; l <= n-1 ; l++){
for(c = 0 ; c <= n-1 ; c++){
gotoxy(1+c*5,l+6+n);
printf("%4d",a[l][c]);
};
};
};
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6D62-cpp
Proposito: Verifica endereco de variavel.
999999999999999999999999999999999999999999999999999999999999999/
// execute este programa passo a passo (Run / Step Over)
void main(){
float Num = 3.14159; // <--- EXECUTE esta instrucao, mas...
} // <--- NAO saia do programa!
/*
- ABRA a janela de INSPECAO DE VARIAVEL: Debug/Inspect
- COLOQUE (Num) como parametro e veja que a seguinte janela aparece:
Variavel
Janela de Inspecao ---- Inspecting Num
| | /-->8F90:FFF2
Endereco ----| -float 3.14159 Valor
(Segmento:Bloco)
Tipo de Variavel
*/
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6D63-cpp
Proposito: Mostrar manipulacao de ponteiros
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
#include <conio.h>
void main(){
float a,b; // declaramos duas variaveis reais
float *p; // declaramos um ponteiro real
clrscr();
puts("Digite um numero real (a): ");
scanf("%f",&a);
// > armazenamos o numero lido no ENDERECO de (a)
p = &a; // atribuimos ao ponteiro (p) o endereco de (a)
b = *p; // atribuimos a (b) o conteudo do endereco apontado
por (p)
// Isto equivale a: b = a;
printf("\n a: %.2f \tConteudo de a", a);
printf("\n &a: %X \tEndereco de a",&a);
printf("\n p: %X \tConteudo de p (endereco apontado por p)",
p);
printf("\n &p: %X \tEndereco de p",&p); //
printf("\n *p: %.2f \tConteudo do endereco apontado por p",*p);
printf("\n b: %.2f \tConteudo de b", b);
printf("\n &b: %X \tEndereco de b",&b);
puts("\n\nPressione alguma tecla para continuar...");
getch();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6D6,-cpp
Proposito: Operacoes com ponteiros
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
#include <conio.h>
void main(){
char *pi,*pf,*p; // declaracao de ponteiro
// *******************
// 1 Selecao de janela
// *******************
clrscr();
textcolor(YELLOW);
gotoxy(1,1);
cprintf("Descarregando o conteudo da memoria: (Segmento de
Dados)");
gotoxy(1,25);
cprintf("Pressione BARRA DE ESPACO para pausa...");
window(1,2,80,24);
textcolor(LIGHTGRAY);
// ***********************************
// 2 Descarregando conteudo da memoria
// ***********************************
pi = (char*)0x0000; // primeiro endereco da memoria (atribuicao
direta)
pf = (char*)0xFFFF; // ultimo endereco
p = pi; // inicializa ponteiro (atribuicao de ponteiro)
do{
++p; // incrementa contador (incremento de ponteiro)
if( *p != '\a'){ // nao imprime sinal sonoro...
cprintf("%c", *p); // imprime caracter do bloco de
memoria
}
if(kbhit()){ // se tecla pressionada...
getch(); // limpa buffer
getch(); // espera para seguir
}
}while(p < pf); //ate' ultimo endereco (comparacao de ponteiros)
// ************************************
// 3 Termina e restaura cores originais
// ************************************
window(1,1,80,25);
gotoxy(1,25);
clreol();
textcolor(CYAN);
cprintf("\aOk!");
getch();
textcolor(LIGHTGRAY);
clrscr();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6D6A-cpp
Proposito: Verificar a diferenca entre passagem de
dados por VALOR e por REFERENCIA.
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
#include <conio.h>
// ********************
// 1 programa principal
// ********************
void main(){
void funcao_1(int); // prototipo da funcao_1
void funcao_2(int*); // prototipo da funcao_2
int a = 5; // declaramos uma variavel inteira
clrscr();
puts("\n\nPressione alguma tecla para continuar a cada
passo...");
getch();
printf("\nvalor da variavel ANTES de chamar a funcao_1");
printf("\na: %d",a);
funcao_1(a); // passagem por VALOR
// |-> passa valor
getch();
printf("\nvalor da variavel DEPOIS de chamar a funcao_1");
printf("\na: %d (NAO ALTEROU!)",a);
getch();
printf("\n\nvalor da variavel ANTES de chamar a funcao_2");
printf("\na: %d",a);
funcao_2(&a); // passagem por REFERENCIA
// |-> passa endereco
getch();
printf("\nvalor da variavel DEPOIS de chamar a funcao_2");
printf("\na: %d (ALTEROU!)",a);
getch();
}
// **********
// 2 funcao_1
// **********
void funcao_1(int v){
// |-> declaracao de VARIAVEL
getch();
printf("\nvalor da variavel ao CHEGAR na funcao_1");
printf("\na: %d",v);
v = v + 1; // alterando o valor da variavel
getch();
printf("\nvalor da variavel ao SAIR na funcao_1");
printf("\na: %d",v);
}
// **********
// 3 funcao_2
// **********
void funcao_2(int *p){
// |-> declaracao de PONTEIRO
getch();
printf("\nvalor da variavel ao CHEGAR na funcao_2");
printf("\na: %d",*p);
*p = *p + 1; // alterando o conteudo do ponteiro
getch();
printf("\nvalor da variavel ao SAIR na funcao_2");
printf("\na: %d",*p);
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6D6.-cpp
Proposito: Passagem por referencia.
999999999999999999999999999999999999999999999999999999999999999/
#include <ctype.h>
#include <conio.h>
#include <stdio.h>
// ********************
// 1 programa principal
// ********************
void main(){
void analiza(char,int*,int*,int*,int*,int*);
char letra; // letra digitada
int vog = 0; // numero de vogais
int con = 0; // numero de consoantes
int dig = 0; // numero de digitos
int esp = 0; // numero de espacos
int out = 0; // numero de outros caracteres
clrscr();
puts("Digite uma frase:");
// *********************
// 1.1 Leitura e analize
// *********************
do{
letra = getche();
analiza(letra,&vog,&con,&dig,&esp,&out); // passagem de
enderecos
}while(letra != '\r');
// *************
// 1.2 Relatorio
// *************
printf("\n\nVogais: %2d",vog); // impresao de resultados
printf("\nConsoantes: %2d",con);
printf("\nNumeros: %2d",dig);
printf("\nEspacos: %2d",esp);
printf("\nOutros: %2d",out);
puts("\n\nPressione alguma tecla para continuar...");
getch();
}
// ******************
// 2 Rotina analiza()
// ******************
void analiza(char l,int *pv,int *pc,int *pd,int *pe,int *po){
// |-> |-> |-> |-> |-> ponteiros
l = toupper(l);
if(l == 'A' || l == 'E' || l == 'I' || l == 'O' || l == 'U'){
(*pv)++; // contando vogais
}else if(l >= 'A' && l <= 'Z'){
(*pc)++; // contando consoantes
}else if(l >= '0' && l <= '9'){
(*pd)++; // contando digitos
}else if(l == ' '){
(*pe)++; // contando espacos
}else{
(*po)++; // contando outros sinais
}
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6D6B-cpp
Proposito: Ponteiro como argumento de funcao.
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
#include <math.h>
// ********************
// 1 Programa principal
// ********************
void main(){
void round(float *); // prototipo de funcao
float num; // declarando uma variavel real
float *p = &num; // declarando um ponteiro real (com o
endereco de num)
clrscr();
printf("Digite um numero real para se arredondado: ");
scanf("%f",p);
// > observe a sintaxe alternativa para scanf("%f",&num);
round(p);
// > observe a passagem do ponteiro com o endereco de num
printf("\nNumero Arredondado: %.2f ",*p);
// |-> conteudo do endereco apontado
getch();
}
// ****************
// 2 rotina round()
// ****************
void round(float *q){
// > recebe ponteiro
*q = floor(*q + 0.5); // arredonda para baixo ou para cima!
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6D6C-cpp
Proposito: Mostrar equivalencia entre ponteiros e
vetores.
999999999999999999999999999999999999999999999999999999999999999/
#include <conio.h>
#include <stdio.h>
void main(){
float vet[5] = {1.1,2.2,3.3,4.4,5.5}; // declarando uma vetor
real
int i; // declarando um contador (DEVE ser inteiro!)
clrscr();
// *****************************
// 1. Impressao de uma tabelinha
// *****************************
printf("cont. valor valor endereco
endereco");
for(i = 0 ; i <= 4 ; i++){
printf("\ni = %d" ,i); // contador
printf(" vet[%d] = %.1f" ,i, vet[i] ); // valor (com
vetor)
printf(" *(vet + %d) = %.1f",i, *(vet+i) ); // valor (com
ponteiro)
printf(" &vet[%d] = %X" ,i, &vet[i] ); // endereco
(com vetor)
printf(" (vet + %d) = %X" ,i, vet+i ); // endereco
(com ponteiro)
}
puts("\n\nObserve que os ENDERECOS sao ESPACADOS de 4 em 4
bytes...");
puts("\n\nPressione alguma tecla para continuar...");
getch();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6D6D-cpp
Proposito: Mostrar a manipulacao de strings.
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
#include <string.h> // biblioteca para manipulacao de strings
#include <conio.h>
void main(){
// ***************
// 1 Inicializacao
// ***************
char nome[80]; // vetor
char *frase = "Ola', "; // ponteiro
int i;
// *****************
// 2 Leitura do nome
// *****************
clrscr();
puts("Manipulacao de strings");
puts("Digite seu nome:");
i = 0;
do{
nome[i] = getche(); // leitura da tecla
if(nome[i] == '\r'){ // se pressionou [enter]...
nome[i] = '\0'; // troca por \0
}
}while(nome[i++] != '\0');
// ************************
// 3 Impressao centralizada
// ************************
strcat(frase,nome); // concatena (justapoe) duas
strings
gotoxy(40-strlen(frase)/2,12); // imprime centralizado
// |-> funcao da biblioteca string.h: calcula comprimento da
string
printf("%s",frase);
getch();
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6D6E-cpp
Proposito: Mostrar a alocacao dinamica de memoria.
999999999999999999999999999999999999999999999999999999999999999/
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
#include <alloc.h> // biblioteca das funcoes de gerenciamento de
memoria
// ********************
// 1 Programa principal
// ********************
void main(){
int i; // contador
int n; // tamanho do vetor
float *val; // declaracao de ponteiro
float media(float[],int); // declaracao de funcao
// **********************
// 1.1 Leitura de valores
// **********************
clrscr();
puts("Calculo da Media de um Conjunto de Valores");
do{
puts("\nDigite o numero (n > 1) de valores: ");
scanf("%d",&n);
}while(n < 1);
// ***********************
// 1.2 Alocacao de memoria
// ***********************
val = (float *)malloc(n*sizeof(float)); // Alocacao Dinamica de
Memoria!
if(val == NULL){
puts("Desculpe, NAO ha' memoria disponivel!");
getch();
exit(1);
}
// *****************************************
// 1.3 Leitura de valores e calculo da media
// *****************************************
puts("\n Digite os valores:");
for(i = 0; i <= n-1; i++){
printf("\n%d valor: ",i+1);
scanf("%f",&val[i]); // leitura dos elementos do vetor
}
printf("\nMedia: %.2f",media(val,n)); // impressao do resultado
// ********************************************
// 1.4 Liberacao de memoria e saida do programa
// ********************************************
free(val); // liberacao do espaco de memoria
puts("\n\nPressione qualquer tecla para continuar...");
getch();
}
// ****************
// 2 Rotina media()
// ****************
float media(float vet[],int q){ // declaracao da funcao
int i;
float soma = 0.0;
for(i = 0; i <= q-1; i++){
soma += vet[i]; // adiciona elemento do vetor
}
return(soma/q);
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6D26-cpp
Proposito: Mostrar o uso de ponteiro para funcao
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
#include <conio.h>
#include <math.h>
// ***********
// 1 Principal
// ***********
void main(){
// ***************
// 1.1 Declaracoes
// ***************
int round(float); // prototipo da funcao
float r; // numero para ser arredondado
int i; // numero arredondado
int (*p)(float); // declaracao de ponteiro para funcao
p = &round; // ponteiro recebe o endereco da funcao
// ********************
// 1.2 Entrada de dados
// ********************
clrscr();
puts("Arredondamento de numeros.");
puts("\nDigite um numero real para ser arredondado: ");
scanf("%f",&r);
// ******************
// 1.3 Arredondamento
// ******************
i = (*p)(r); // uso do ponteiro para funcao: esta instrucao e'
// totalmente equivalente a instrucao: i = round(r);
// ***************************
// 1.4 Impressao de resultados
// ***************************
printf("\nnumero arredondado: %d",i);
printf("\n\nPausa: pressione alguma tecla para continuar...");
getch();
}
// ****************
// 2 Rotina round()
// ****************
int round(float q){ // definicao da funcao: nada de novo !
return((int)floor(q+0.5));
}
/999999999999999999999999999999999999999999999999999999999999999
Gro&rama8 e6D22-cpp
Proposito: Mostrar passagem de funcoes para funcoes.
999999999999999999999999999999999999999999999999999999999999999/
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <dos.h>
// ***********
// 1 Principal
// ***********
void main(){
// ***************
// 1.1 Declaracoes
// ***************
float a = 0.0,b = 5.0; // limites do intervalo de busca
float z; // raiz da funcao f(z)=0
float f(float); // prototipos da funcao algebrica
transcedente
float acha_raiz(float,float,float(*)(float)); // prototipo da
funcao que recebe funcao
// ********************
// 1.2 Entrada de dados
// ********************
clrscr();
puts("Calculo do zero de uma funcao transcendente: Metodo da
Bisseccao\n");
puts("Qual e' o valor de x que satisfaz: x - exp(-x) = 0 ?");
puts("Vamos procurar uma solucao no seguinte intervalo:");
printf("x [ %.1f , %.1f ]",a,b);
puts("\n\nPressione uma tecla...");
getch();
// *************************************
// 1.3 Calculo e impressao de resultados
// *************************************
z = acha_raiz(a,b,f); // chamada de acha_raiz: a funcao 'f' e'
argumento!
printf("\nx: %f (verifique!)\n",z); // resultado!
getch();
}
// ********************
// 2 rotina acha_raiz()
// ********************
float acha_raiz(float a,float b,float (*pt)(float)){ // declaracao da
funcao... |-> ponteiro para funcao
// ***************
// 2.1 Declaracoes
// ***************
float tol = 1.0e-6; // tolerancia do resultado
float r; // estimativa de raiz
float fa,fb,fr; // valores funcionais f(a), f(b) e f(r)
// **********************
// 2.2 Teste de intervalo
// **********************
fa = (*pt)(a); // fa = f(a)
fb = (*pt)(b); // fb = f(b)
if( fa * fb > 0.0){ // se raiz esta' FORA do intervalo...
puts("Erro: Funcao nao troca de sinal nos extremos do
intervalo!");
return(0.0);
}
// *******************
// 2.3 Calculo ra raiz
// *******************
do{
r = 0.5 * (a+b); // bissecciona intervalo
fr = (*pt)(r); // fr = f(r)
if( fa * fr < 0.0){ // se raiz esta' no intervalo da
esquerda...
b = r; // puxa limite superior
fb = fr;
}else{
a = r; // empurra limite inferior
fa = fr;
}
}while(b-a > tol); // enquanto intervalo e' grande
return(r); // retorna raiz
}
// ************
// 3 rotina f()
// ************
float f(float x){
return(exp(-x) - x);
}