Lógica e Programação Aplicada: Prof. Marcos Fischborn Me iane ira - V .2

Lgica e Programao
Prof.
Me
l icad
Marcos
iane
ira
Fischborn
V
.2

CAPITULO 1 - SISTEMAS DE NUMERAO.......................................................................................................7

1.1 Sistemas analgicos e digitais ............................................................................................................7
1.2 Necessidade de representao de nmeros em outras bases: ............................................................8
1.2.1 Numerao posicional e numerao no posicional.................................................................................. 9
1.3 Principais tipos de bases numricas.................................................................................................12

1.3.1 Sistema Decimal .....................................................................................................................................12
1.3.2 Sistema Binrio ......................................................................................................................................12
1.3.3 Sistema Octal..........................................................................................................................................13
1.3.4 Sistema Hexadecimal..............................................................................................................................13
1.4 Tabela de equivalncia entre bases..................................................................................................14

1.5 Converses de Base..........................................................................................................................14
1.5.1 Decimal inteiro para base r .....................................................................................................................14
1.5.2 Converso de frao decimal para base r.................................................................................................15
1.5.3 Converso entre um nmero decimal com parte inteira e parte fracionria para um nmero na base r......15
1.5.4 Converso de base r para base decimal....................................................................................................16
1.5.5 Converso da base binria para a base 2 K ................................................................................................16
1.5.6 Converso da base 2 K para a base binria................................................................................................17
1.5.7 Mapa de converso .................................................................................................................................17
1.6 Unidades de Medida.........................................................................................................................18

1.7 Exerccios:........................................................................................................................................18
CAPTULO 2 - LGEBRA DE BOOLE. .............................................................................................................19
2.1 Introduo ........................................................................................................................................19
2.2 Operao E.......................................................................................................................................19
2.3 Operao OU ...................................................................................................................................20
2.4 Operao NO .................................................................................................................................20
2.5 Postulados ........................................................................................................................................20
2.6 Elementos de relaes lgicas..........................................................................................................21
2.7 Teoremas e relaes lgicas.............................................................................................................22
2.8 Funes Booleanas...........................................................................................................................24
2.9 Tabelas verdade................................................................................................................................24
2.10 Minitermos......................................................................................................................................25
2.11 Tabelas verdade aplicadas algoritmos ........................................................................................26
2.12 Exerccios resolvidos......................................................................................................................28
2.13 Exerccios propostos ......................................................................................................................29
CAPTULO 3 PROGRAMAO ESTRUTURADA EM C. ................................................................................31
3.1 Conceitos de Programao Estruturada ..........................................................................................31
3.1.1 Definies ..............................................................................................................................................31
3.1.2 Objetivos ................................................................................................................................................31
3.1.3 Propriedades ...........................................................................................................................................31
3.1.4 Estruturas Bsicas de Controle................................................................................................................32
3.1.5 Formato Padronizado do Mdulo............................................................................................................32
3.1.6 Estrutura de Controle do Programa .........................................................................................................33
3.1.7 Documentao ........................................................................................................................................33
3.2 Ambientes de programao. .............................................................................................................34

3.3 Estrutura de um programa em "C. .................................................................................................35
3.3.1 Regras Gerais .........................................................................................................................................35
3.3.2 Palavras reservadas (keywords): .............................................................................................................36
3.3.3 O comando #define.................................................................................................................................36
3.3.4 O comando #include ...............................................................................................................................36
3.4 Tipos de dados..................................................................................................................................37

3.4.1 Tipo Inteiro.............................................................................................................................................38
3.4.2 Tipo Real................................................................................................................................................38
3.4.3 Tipo caractere e tipo fila de caractere (string)..........................................................................................38
3.4.4 Tipo Lgico ............................................................................................................................................39
3.5 Variveis...........................................................................................................................................40
3.6 Representao dos tipos de dados na linguagem de programao C ..............................................40
3.7 Onde as variveis so declaradas:...................................................................................................41
3.7.1 Observaes sobre os nomes das variveis..............................................................................................42
3.8 Inicializao de variveis.................................................................................................................43
3.9 Constantes ........................................................................................................................................43

3.10 Modificadores de tipo.....................................................................................................................43
3.11 Expresses ......................................................................................................................................44
3.11.1 Operaes primitivas ............................................................................................................................44
3.11.2 Expresses aritmticas ..........................................................................................................................45
3.11.3 Algumas funes matemticas da biblioteca C ...................................................................................45
3.12 Operadores.....................................................................................................................................46
3.12.1 Operador de atribuio..........................................................................................................................46
3.12.2 Operadores aritmticos .........................................................................................................................46
3.12.3 Precedncia (Hierarquia) nas operaes ................................................................................................46
3.12.4 Operadores de incremento e decremento ...............................................................................................47
3.12.5 Operadores relacionais..........................................................................................................................47
3.12.6 Operadores lgicos ...............................................................................................................................47
3.12.7 Precedncia (Hierarquia) dos operadores relacionais e lgicos. .............................................................48
3.13 Exerccios:......................................................................................................................................49
CAPTULO 4 - ALGORITMOS, LGICA DE PROGRAMAO E FLUXOGRAMAS. ................................................51
4.1 Introduo ........................................................................................................................................51
4.2 Conceito de algoritmo ......................................................................................................................51
4.3 Representao dos algoritmos..........................................................................................................52
4.3.1 Linguagem natural ..................................................................................................................................53
4.3.2 Fluxogramas ...........................................................................................................................................53
4.3.3 Pseudo-linguagens ..................................................................................................................................53
4.4 Diretrizes para construo de um algoritmo....................................................................................53

4.5 Representao grfica: fluxograma ou diagrama de blocos............................................................54
4.6 Formas padres para utilizao de fluxogramas .............................................................................55
4.7 Exemplos ..........................................................................................................................................57
CAPTULO 5 - FUNES BSICAS (FUNES DE ENTRADA E SADA). ............................................................58
5.1 Funo de sada : printf().................................................................................................................58
5.1.1 Especificadores de formato .....................................................................................................................59
5.1.2 Seqncias de Escape .............................................................................................................................60
5.2 Funo de Entrada/Leitura : scanf()................................................................................................60

5.2.1 Usando scanf com strings .......................................................................................................................62
5.3 Funes para entrada e sada de strings: gets e puts.......................................................................64

5.4 Funo de Entrada : getch() ............................................................................................................64
5.4 Exerccios:........................................................................................................................................65
CAPTULO 6 - ESTRUTURAS DE CONTROLE E DE REPETIO. ........................................................................71
6.1 - Tipos de Comandos ........................................................................................................................71
6.1.1 Seqncia ...............................................................................................................................................71
6.1.2 Seleo ...................................................................................................................................................71
6.1.3 Repetio................................................................................................................................................71
6.1.4 Atribuio...............................................................................................................................................72
6.2 - Comando if ( ) ................................................................................................................................72

6.2.1 If s aninhados ........................................................................................................................................73
6.3 - O comando switch () ......................................................................................................................74

6.4 - Comando while ()...........................................................................................................................77
6.5 - O loop for (;;).................................................................................................................................78
6.6 - O loop do { } while.........................................................................................................................80
6.7 - Interrupo de loops ......................................................................................................................80
6.7.1 O comando break....................................................................................................................................80
6.7.2 O comando continue ...............................................................................................................................81
6.8 - O Comando exit()...........................................................................................................................82

CAPTULO 7 - FUNES DEFINIDAS PELO USURIO.......................................................................................83
7.1 Valores de Retorno ...........................................................................................................................84
7.2 Chamada por Valor..........................................................................................................................86
7.3 Chamada por Referncia..................................................................................................................87
7.4 Argumentos "argc" e "argv" do "main( )"........................................................................................87
CAPTULO 8 MATRIZES, VETORES E STRINGS............................................................................................90
8.1 Vetores (Matrizes de uma Dimenso)...............................................................................................90
8.2 Strings...............................................................................................................................................91
8.2.1 Atribuio de valores a strings ................................................................................................................91
8.3 Matrizes (Multidimensional) ............................................................................................................92

8.4 Matrizes de Strings ...........................................................................................................................93
8.5 Inicializao de Matrizes..................................................................................................................93

8.5.1 Inicializao de Matrizes de Caracteres...................................................................................................93
8.5.2 Inicializao de Matrizes Multidimensionais...........................................................................................94
8.5.3 Inicializao de Matrizes sem Tamanho ..................................................................................................94
CAPTULO 9 INTRODUO A PONTEIROS. ..................................................................................................97

9.1 Exibindo endereos de memria.......................................................................................................97
9.2 Declarando variveis ponteiros .......................................................................................................98
9.3 Alterando o valor que o ponteiro referencia ....................................................................................99
9.4 Usando ponteiros com funes.......................................................................................................100
ANEXO .......................................................................................................................................................103
BIBLIOGRAFIA ............................................................................................................................................104

EXEMPLO: EXPRESSO LGICA.........................................................................................................................22
EXEMPLO: MINIMIZAO .................................................................................................................................23
EXEMPLO: MINIMIZAO .................................................................................................................................24
EXEMPLO: FUNO BOOLEANA ........................................................................................................................24
EXEMPLO: TABELA VERDADE ...........................................................................................................................25
PROGRAMA EXEMPLO: FUNO MAIN()............................................................................................................35
EXEMPLO: #DEFINE ...........................................................................................................................................36
EXEMPLO: #INCLUDE ........................................................................................................................................37
PROGRAMA EXEMPLO: INCLUSO DE BIBLIOTECAS ..........................................................................................37
EXEMPLO: FILA DE CARACTERES - STRINGS ......................................................................................................39
EXEMPLO: DECLARAO DE VARIVEIS ...........................................................................................................42
EXEMPLO: INICIALIZAO DE VARIVEIS .........................................................................................................43
EXEMPLO: #DEFINE E CONST PARA CONSTANTES ..............................................................................................43
EXEMPLO: ATRIBUIO DE VALORES ................................................................................................................46
EXEMPLO: INCREMENTO E DECREMENTO ..........................................................................................................47
EXEMPLO: EXPRESSO BOOLEANA EM 'C' .........................................................................................................48
EXEMPLO: EXPRESSO BOOLEANA EM 'C' .........................................................................................................48
EXEMPLO: TABELAS VERDADE COM EXPRESSES EM 'C'...................................................................................48
PROGRAMA EXEMPLO: PRINTF SADA DE DADOS ............................................................................................58
PROGRAMA EXEMPLO: PRINTF SADA FORMATADA ........................................................................................59
PROGRAMA EXEMPLO: PRINTF SADA COM SEQNCIAS DE ESCAPE ..............................................................60
PROGRAMA EXEMPLO: SCANF ENTRADA FORMATADA SIMPLES .....................................................................61
PROGRAMA EXEMPLO: PRINTF SCANF ............................................................................................................62
PROGRAMA EXEMPLO: STRINGS COM ESPAOS E SCANF ...................................................................................62
PROGRAMA EXEMPLO: SCANF COM DELIMITADORES %[]..................................................................................63
PROGRAMA EXEMPLO: SCANF COM DELIMITADORES ........................................................................................63
PROGRAMA EXEMPLO: PUTS & GETS ................................................................................................................64
PROGRAMA EXEMPLO: GETCH ..........................................................................................................................64
EXEMPLO: COMANDOS EM SEQNCIA .............................................................................................................71
EXEMPLO: UTILIZAO DE SELEO .................................................................................................................71
PROGRAMA EXEMPLO: REPETIO ....................................................................................................................71
PROGRAMA EXEMPLO: IF-ELSE .........................................................................................................................73
PROGRAMA EXEMPLO: IF ANINHADO ................................................................................................................73
EXEMPLO: MAIS IFS ANINHADOS ......................................................................................................................74
PROGRAMA EXEMPLO: SWITCH-CASE ................................................................................................................75
PROGRAMA EXEMPLO: WHILE ...........................................................................................................................78
PROGRAMA EXEMPLO: FOR ...............................................................................................................................79
PROGRAMA EXEMPLO: FOR ...............................................................................................................................79

PROGRAMA EXEMPLO: DO-WHILE .....................................................................................................................80
PROGRAMA EXEMPLO: BREAK ..........................................................................................................................80
PROGRAMA EXEMPLO: CONTINUE .....................................................................................................................81
PROGRAMA EXEMPLO: FUNO DEFINIDA PELO USURIO .................................................................................83
PROGRAMA EXEMPLO: SEM VALORES DE RETORNO ..........................................................................................84
PROGRAMA EXEMPLO: VALORES DE RETORNO ..................................................................................................84
PROGRAMA EXEMPLO: VALORES DE RETORNO ..................................................................................................85
PROGRAMA EXEMPLO: CHAMADA POR VALOR ..................................................................................................86
PROGRAMA EXEMPLO: ARGUMENTOS PARA MAIN .............................................................................................87
PROGRAMA EXEMPLO: ARGUMENTOS PARA MAIN .............................................................................................88
EXEMPLO: DECLARAO DE UM VETOR ............................................................................................................90
PROGRAMA EXEMPLO: UTILIZAO DE VETORES NUMRICOS ..........................................................................90
PROGRAMA EXEMPLO: UTILIZAO DE MATRIZES ............................................................................................92
EXEMPLO: MATRIZ DE STRINGS .........................................................................................................................93
EXEMPLO: INICIALIZAO DE MATRIZ ..............................................................................................................93
PROGRAMA EXEMPLO: INICIALIZAO DE MATRIZES DE CARACTERES .............................................................93
EXEMPLO: INICIALIZAO DE MATRIZES MULTIDIMENSIONAIS .........................................................................94
EXEMPLO: INICIALIZAO DE MATRIZES SEM TAMANHO ..................................................................................94
PROGRAMA EXEMPLO: MATRIZES DE CARACTERES E VETORES .........................................................................94
PROGRAMA EXEMPLO: SOMA DE MATRIZES NUMRICAS ...................................................................................95
PROGRAMA EXEMPLO: USANDO OPERADOR & ..................................................................................................97
PROGRAMA EXEMPLO: USANDO OS OPERADORES & E * ....................................................................................98
PROGRAMA EXEMPLO: USANDO O PONTEIRO DE INDIREO .............................................................................99
PROGRAMA EXEMPLO: PASSAGEM DE ARGUMENTOS POR REFERNCIA ...........................................................100
PROGRAMA EXEMPLO: ENDEREOS NA PASSAGEM POR REFERNCIA ..............................................................101
PROGRAMA EXEMPLO: TROCA DE VARIVEIS ATRAVS DE REFERNCIAS .......................................................101
!"
#%$'&)(+*,(-$/.1032)465%(,78.:9'$/;=<>5%(,(@?'<@$6&BA/C1(D58.EC/F)08A=G/(+5).+?H9I<%0J9K(/L3()M/;%<ONPB./LDL@2)A6&%<
L8(=&8.H96A6(8C,4'</78<,.'LQ9K.)CR(8M/;%<TST7@.H9'$R;1<U(B46&8.H96A6<J9:VW.XL:21AR&1<@$Y.'Z8./L@?=C/<8$Y<3[/&@A'5)<8$U4'(
\84'&8.H964/.1&ON,]B0^9I()5%.1M1<_()`82%Aa(b&1<=5)<8$_.)$R&).8$c(@26&%<J9K.3$dV-`821.e58.ef)<J9gL)(hA14/53AH9K.=&1(
()i32/51(^9I(1Lj46<k&).RZ)&)<ONYl).+&BAm7@.)$%$/.-G1<=L)<Q<3[/&).:9U(n9K.=f).J9po)41G)AR(q?6(^9I(k&)<=5)<8$r.1C1.8$sV
.8$'&)(J96A6(1LU46(Y[8A/[%C)A6<)0:9K(1fBA6(tN]HC103214)$u.)$/&=;)<ON
] A%46&8.%41M/;%<h58.)$R&1(v(3?/<8$R&8A1C/(w*v$)A'L@?1C1.3$mL@.%46&8.x$/.J9y2'L)(vG=<84)$12RC/&)( 9Iz@?1AR51(vS3$
`@2R.8$6&%{).8$ [=z8$)A/G=(8$ 5%( 2/&8A=C)A1|/(%M1;1< 5%. f)C82KZ8<10^9I(/L8(3$ . 58. ?@9I<)0:9K(/L3()M1;1< 46(
C8A=4/082R(108.6Lx}~1NT=;1<Qf1<BA-<3[/i8./&BAm78<.)$1G@9'.678.:92mLjC)A'7s9K<OV?6<@A=$Q.RZ@A)$6&%./LC3Am7s9p<8$
L: 2=A/&1< [1<84%$4'<hL@.@9'G/(%51< . 26L%(`82'(@46&8AR51()5%.v53..6ZB.6L:?RC1<8$L@2)A'&1<v0^9I(@4653. 4'<
.%$)?6(3M/<HsN2'LL)()&%.H9RA6(3Cb58A/5=z1&@A/G=<5).b(@?'<8A/<bS@$_(32/C1(8$_53.b~1<1LB?)26&%()M1;1<5%<
G8289R$6<a5%._#=4/0%.841R(J9RA6(j5%(amPs=%c='1:1B./5@A'(@4/.3AB9K(ON]G1<84%$121C/&=(a(1<8$jC%Am79I<B$
G1<34)$6&%(84/&).3$4'(T[3A/[1C8A'<)0J9p(1f@A6(Y*u()[8$6<3C)2/&=(1L8.346&8.Y4/.)G=.)$)$6z^9'A/(N
]s$q(82/C1(3$&1(1L3[)*6Ly$R;1<j(8G/<=L@?/(34)6(15%(8$58.a2KLyG/<@4'i82)46&%<a5).&^9I(@41$%?6(s9po84/G3A6(@$`82=.
L:2'5)(OVA)4/.R7@A/&=(178.%C6L8.84'&8.V(TG=(15)(Y$1.6LB.)$/&:9'.N
$xG/<B4/G).%A/&1<B$v5%. ?@9I<10s9g(1L)(3M/;)< (1`B21Av.3$6&@2'5)(15%<8$ $/;1< $1A'L@?1C1.3$v.x5).3$6&@A=4/(15%<8$
S)`321.1C%.)$k`321.q4';)<k&3.6LcGR<@41=.1G8AmLB.)4/&=<?H9p*/7@A6<58.?H9I<%0J9K(/L3()M1;=<tN]^$1$)AmLV$/.r7)<3G1o
i)zY*Y2mLE?@9I<)0:9K(/L3(151<s9@V.3$6&)(X(8?/<3$6&@A/C=(Tp *T?6(^9I(u7)<8G1oN
&8.6Z3&1<(3[/<s9g5)(O
l8A1$R&)./L%(@$5).T4%2mL@.@9I(8M/;%<O
53.T6<%<)C).
~)<8C/034=.1G1[J.8A'9g(
)
&
8
<
$58.Y?B9K<=0J9K(/L3()M1;=<T.3$6&s9'2'&@2B9p(15)(O
^
P
1
A
R
?
8
<
$
8
5
u
.
51()51<B$d
'
#
@
Z
@
?
K
9
8
.
=
$
/
$
)
{
3
.
$.)$=GH9RA'&1(@$X46(YC8A14R082/(10%./L}~t1
/
?
:
.
I
9
)
(
=
5
s
<
K
9
3
.
$51(YC8A=460@26(%0)./L}~1
)
C
'
2
)
Z
)
<
:
0
K
9
/
(
3
L
8
(
$
1
2
R
4
1
5
1
(
3
L
8
.
6
4
%
&
8
<
$
5%(TC%A14/082R(108.'Lq}~O)
1
2
=
4
/
M
8
{
%
.
$
[/z3$)A/G=(8$
o
%
#
6
$
^
&
'
9
/
2
3
&
B
2
K
9
8
(
$uG/<B465@A/G%A/<84R(8A)$d
o
%
#
6
$
^
&
'
9
/
2
3
&
B
2
K
9
8
(
$5).E9'.)?R.1&8A=M/;)<O
o
/
.
%
&
J
<
'
9
%
.
d
$
o
8(1&^9'A1|=.)$
o
%214=M/{8.%$51<21$%26zs9'A'<t
o
R<84R&).8A89I<@$dN
o
1;=<y$6;)<j.)$R&82/5=()51(8$&%*)G)41A=G/(@$53.c?@9I<)0:9K(/L)(3M/;)<j(R78(84/M=(151(j&%(/L:?6<B2/G/<j()C=01<s9mA6&1L)<B$
.8$=?1.1G36f@A/G=<8$VkA6&3.)4)$L:21AR&1<41.1G%.)$)$6z^9'A/<3$?'(s9I(_`@2/.RL53.)$1.Ri)(bG/<@46&BA14)2'(s9j41.)$R&1(
zs9p.1(ON
&8.'Z8&1<j*_9K.8?RC)./&%<5%.j./Z8.6LH?/C1<3$n9m.)$/<%C/7@AR51<@$r&)(84R&1<58.f)C)2'Z)<)0:9I(1L)(B$G/<1L%<53.
?H9g<)0J9p(/L8(8$VGR<@46&3.)465)<A14%mL@.H9p<8$u.6Z@.H9mG)1G%A/<8$V9K.3$6<8C'7@A/51<B$.Y?B9p<8?/<8$'&)<8$N
Capitulo 1 - Sistemas de numerao.
=KpOIBKKgmIp8JpKI
B^jHH)HBJ:Hc8@8t6J3e8H@HH3^qBaB^BH8BJH8B^q:8^)H:HBJB8J
8J O6^8H:/ :8tR HH3J3J @O8^8tmHHH3 /8 B^HB@BJH8B
:@H3H^H):rjHH)J3JqB):8t6:H3c@E38HqO6:8H:/qqBJB
8HH BB m:@:HBBB^ ^ 3H@:H 63s:B8:8JH H 8J HBJ'^H8HH
JO/BHud:HHH):H@BcBB@H=@3^3t/3J:QHj@:H)O/:Y^@j8HHB
H^H)Ht/ ^@:8@@HH@@ 8HB JB^8O/B:/ m:H@B sHB:H@H8H
J:H8Bb8tH6@8J :)t/: t/@@BHHH38J@ t6:8HHH@ 8HH3 @O
t/BHHH: 3/3J: H H=HB8H^ J@ : :H@% H^H3Ht/@@3
8^8:HH@3::8Jv)vHB^)83HHH@@BJH%sBv:H@BhH:@3xHBJBH
HH8HBJ:@:BBHB^qBe8@8t6:BHBt/@@@HBBJH8^t^:)J3e8J@Bc@O
t/BHHH:Bt6)s:-@Q)J)sOR1t/:r:8H3H^@8^8:8@8J:H8:@@:H8B^-8t
8^)JO=8OR:j :1^@HB:x:8HB @d/ 8:8O6JBH3t/Hx@:8HHB^wB
HH8HBJ:D:8^)H:H
B8J38H@BH^D@O/:1JO=BBOX:B^BHH)J3J:+8B@
H8HBJ:q:8J)J:HE8BcHH8:3J:q^8c6:8:H@8eBH@@H@BH/8H^8
JB^) B@: 8O/@8:O=B8^B8: @:HH8@ @Bw:3^8 H 8^1sO=BB
JB^)k:)/-@8:B@HHH@)J:,-B^8:3^@B+H+B^B@HH@3
H8HBJ:@@H8H:H8:Xm^@:BBBQ@H@:B>JOR@:)J@k8-J3J)k^88HHB
JOx^@:B8^BOwsBBt/@ HH8O6 H 8J H:3J 8^8^BB@ H J:H@3
8tH6:8JJB:8O/B^s//:B8BkD^3t/@,t/@@HB@:
B B:B:@B H HB)JBJ @8HB@^H8 sHBHH8JB6 H 8^8:@6
8^@@@HH3 8^88HH@3s:HH:HB HH1JBJ HBHBBJ8 H )^8JH6
/:6:@:): sHB:B@HHB B s:@H@Bj 8^HB8B B )J8J:6
sHB:H@HB@rB>s:H3@B-HBQ%8H:8-kH8HkBDsOR@/B-8Q8:-H@8J
8^8:HH@ H sH8O/: sHB:H@H@B B @)HHH3JH 8JH sOR8O
8^8:HH@3::8J H @O6 @8 ) s 8^BH@8 B %^8J:6 )JH
^HH8OY:BHB^8XsH%tH)^@B:8O/> ,
3)
d8tm BJ3^8B H BH8J8H :8HBH^B) J6 HHBO6 H J= /8
H:H8 @@O6H@8 :B^8O/3:/ B B^@8:8J mJ:@ ^=@:8H: 8
HB^/ H )J 8H@H@ B JO= =) B H:@@/ J/H 8H
/:6:@:)::@B+-B^)HH>:@HD:>^8:3^@BHB:UsORBB):8:HH8BJ:8@
)^H)JBk@H8JH,s:)JBH:Bk8rH8kHBH)J8J:-B8^8J8H :8t/8J:)H-
^H@3n/HBkr/H3HJH@@8HBJ88Jk@@HB@:H8u8OmJ:8Bk%^@:@B:@3kH
HH8HBJ:>:8^3H:H/B:@UHH@OR@BrHk3HHB8^H):)J-H8:)sO6@B
:8t6+^>HH8H3J:
jsO/@3s@Bx'^@H)^@HH3:@n:HBH@:_@)+Byt/8@HeJH)t=@y8bH@
t=8HB@@HB@:H@:-HO6H3::8J-HB:-@B-::)t/BH:+r@:8H:>:@
H3s3@H^B)Ht/H3::@O6HB:3^8O6HHHB:+8)rBH8HBJ
8O/w@^ROn68s:8BvH:b::HHH8:h:3:8J:B^8:8Bv:@BBH^h8B
:8t6HH:Dr@@8H:8@HB@:H@@ t/@+BJ@@@B3s3k@OXBH:H)JHH:

H^)Ô6J 6^H@3 /HH B: :)t6HH: @@H3H:H@: BO/
Bt6H-:)J8JH

6^B:H@'Û^@O//->H@36J:@3-:8:8HH
t
H^)Ô6Jk:j@@@B:c:1^8J:8aBjBJBJc@/e:@@BwRBB,B
H@+Bt6H:@B3H^H@
7

HHH@b3^nBJ)^8H+H8Jn8^1sO=@)b/HH:)HHHy8B^HH8BJH)H^
8^H8:H@3J 8HH ):)sO/)t/@ :8HBHJH)d8@8:8J@H H H8^8HH^

:@H3H^H)J '1 H:@@8H:B3 B 3HB @ ^8H :BH8:H8^1H
HH8HHHH3
B^ H@8HBJ: :8J)J:H_^ HH8:B t/3JBB^ @B 8^@):8^H@3^ 8t
@B 8:HH8HrH3HO=H8:1J:@:B@:B3QH:1J:-@B@@HHB@kB:8Jr8
:H8:@BJ3wHH@R@)BhwB@BHHHwBB@O=88t6J8w@HH8x@8^B
^H8:-8:@H)s@BH>H8^3HB^ H)^3JB
/ U+-H8^)HB
3 t
B^ ^B6^)@^H8HBBt/: @B 8^@@@HBB: @: 8:@@@ @:8:
:HR8HtR3^ :B8:8t/3B^ ::@HBB^ :@ 8^8BB ^ 3J:8B^ ^8
8^@@@HBBJ B :@8^@3HB :H=)J RH8t6: 8H6^ ^@/HBO/:
JBJ3JB^B3^3:I
H8JO6@3J:)JB8t/BH@8Hk^x8@:B8JBBt/:h8
/:8:H@:88a:H1^@BJ)eBH8=Bê8/:BH)^@+qHBO/
' 8t
BJB:@B8c6H/BJHH)t6Bc8H^@8JBBO-@H)^HBcH3@HB^8J8B
@HH+J:@Bkr)Jr@B 8HHH@H8J=H@+:@r8tH6HH8^8BX38JO=8BJH)J
HBt/
K tU8H:)Hb8^88@HHBb8HBb8B:H8JB3t@O/a:B8^H8Ok^
HH@@HB8JB@:H1^@:8=8J b@B 8HHH@@yH
1 =b
3 3n:@
HH/:8:@@:@D-H:1H^HBBB

BJ:8HU

Bk:H@BrH8J@3uH>^8:8^83HH:-@Bt/BJ3H:-:H=8HH-8HH8H3J
H:H)JH 8^1t6JH)J 8O BH8 8^H8:8O6@^ ^ @H8HBJ: H
H8J/:@3r-3O6J-3r8J1sOmHOHBBJ@8O/+HH@
!6Kp mIK:K"$#%" gIII'&)(KHmJ+*Kt+" p@g',I-" g/.pII)0
1@B^B8t6: HB8HO=@8^ 8: B^8t/3 :8 : =3H:/@ /B^H8: B
8^8HBJB @8J3HB :3HHH:v3 @@8Ht/88 2m/3k3^BHs@8^)^8^)^
H^8O/Bk@@-:k8:3Ht/@-8^1t6JH%sBk@:H6:@@H8:-H@:88rHJ8J:>H
@HO6:ks 8J3JO_: :H)H@H @:)HO8@@OR3s )J @BO/ 8O/
@HHr85
4d@:3Brc/:@@H)nmBHt=83s QB@8Ht+/B^63sBr@^8H-H
@HO6 3J @O6 BHH :H)H@ ^@ 8:HB3J 3^/:B83 @H/@
HHBH3sBj:H3H:H7 6@jH3BJ:@8Be@H/@h6:@HH)_)3d@:8H:8:BB
BJ 3d@B:H@@ H@H@ /BHH8 :8J @ 6J=@ t=)HB H @HH3t/
@H:B@Bc6BkB3^8
8:9<;$8>=?;@=ACB^@rB8JH@@H8r8HO6@
)JHr@O6@@OH8t/@B8Q3^-1^H8^>JH)^k8BkHB:BH@@H@@+H)^@B-H
^@:)^@HB@8:H@ 6:)t=@3 3 8@JB =)^3^)H_HH JBB: ^@
8^HB@HO6 ^@ 8^H@ B@B:/ 8 H B@:H38J3JH8J H:H
H:@@)JJ%s@H^@jB@B^/q@8J:8H8H8J:8@B^3:@/@B@8^
Bt/@ @=8:H8B 3 J@:8:@HHB 8BB 3HHB =):8^): O/
/B:H@BHH8J H8^38^)sw8BH 3^ @H8JHHa )^8HBHB @O/
8HJ3vO/)Q3^B:H)@^rJ@/ HQh@6:aB)ht=H)hH
t/: : :8Btm J/ HBB:x 8HJ3 :@H@ 38^@H@3J:)J ^@ @%d@
^H8B^>: HBH:+@:H)+t/B8
H:8:H H:B@ =)J@/ )^BB B :@:)^@@BH @m^H H3JO6:8B
:HR8J B H8@ B @ B:8JO J /B^H1t6^ :8 @8J: 6B
H8^)J:@B@B^ @HH8 @BO/:8H JH :@ :8J: @ @/:@Bh/B
:@:B@:HB8OH/8HO:c/@s/:@:)J3^38J-:8@HH@BBHHrBO/r 8Jm^
^H8B t6:@@:x3H@ H8J/@@B :B=8J OR H88J 8H JOR@: B
JHH@/:n^_:8HB:@q^8O6_^/ H3H^@)^HHBB@:8@:H@__J=@:8B
BH@hJO=@8@Bqm^)^H8@vJ3x^wH:HvH)^8J^Bxx6^=@
:HR8J HBk@r@@H@OmHkDJ:@-H+:@+a/8^B8t6-Hr> 8JO6J>J@H@
H8J=@B>a/3:H8t6+H-)^H
dh=)J@mxHH):BJ:H:B=)JwH)HO=H8b^@w@8^HB@@Bx@3^
B^B^BHB8^+^+B^+H8JO'8ûH6J@B^+8tuJJBH-H
D1HkE
d
HH8HBJ:b@)@BJB:8:8::+B^)^yBt/HB@BB8^)J8^yB:b 8JO6Jb
8u8Hu8HBkB^-BHHB+a/@/@@H8J:83QB:>^)O6^-3HH@@@Bk
8HJB:B@:G
F%=HBHB@:B FB)JB )JO' DIHO/)@JHbO6:
@:HuHB@8BB8 @:1J:+D^83t6BH
H:8:H3^hB8^)J8^+s@8hw@B:@hB /:6@@:8J^ 3JO6^b8H
HBt6:@@HBk@HB:-8BH^-):/:@8k+t/B3HHrHB8J3:-H:>t=)HB
BBH8HBHj6@J:8+^@B+^-> 8JO6J-J
DOX)J
D/u8BJ
D/@3HB@3
/:6:@:):HBê@8H:aHBOR:K
M
L M
N P
OQ

+S
Rq/:H)@8^)^BJ:)H
T@:@BHB^yBhRHHBHB8^/3^H8BJ:):8^@@HyBBhBB)JBHH8J=)
^cB^HBH8,a:@BO6:H8jJ@Ha8HH3sHaj^@jnH@8JBHhmHJ:8nBHB
H 8HJ 3^ )JOm^ F%=B@HH@@H F 8J8:@H%J HB^@3 :8HO/HH8
H:8H:y@O6x6:/H8:8JOHj^8t6:y 8JmÛ
)O3JB^B3D 8HO6
HH
O/ /@/:@H)JHB 8H3 @@@B ^@HB@:)H: H@8^ @B H:H
HH8 @:8H>J:):HHEJ:@+8 J:H+3
BHJ:B@ ^8 B:8J: 3H)JBH: B^H%JB ^ )HOm^ @@BJBB:
3=BHHH8HH
ar)HH^BB_J3^@3-:@3JH@@@H@@b@8t/e^b@H8J3J:
H8J=8hhB:HHB8hwHH):BJ/BB mHJ:)-d=)J@'^H@1sB
8HH@8^8H3^_=@BHH@:3_B:@HB:nB^H=sHH@)J:_y8b@B@B>^@
B^BQ:)^8:8H^V
@BJ8B^H@%sBx)BHx@:)hBxBB8JB::HB6:
^@ /@/:8:8H3^B ^ )J6: 8 HBH8 BH HB3 @:)J @3
^HHB@:8BJ :8-B^tW
4dBB-/HH:8Br:)t6-BH: X
1d@B:8J3::8J @3 @ t/BJ H 8J 8^HBH@H@BH@ B8H B BH:
8^@@@HO68 8Jm^y8HHd=BHHB@:HE^B^8:B8ybHBBByH@O6By^
H@BHHB^@H8^wBx 8BO6^h8BJH:8:)J: ' @)^H@B@wHwHBx@O6h^
H8J=8^>kBHHHH8@r+ 8B^3@B^Hr@HH8r@O/DÔ6BH:amHJH)^@
@O/:H8jBHH@BD3H@: 8BO6^qO/8j@j8:@:8@HB^q3jH:8OH/:8H@
H 8:@:8^d/:@B B R8H:6 JBJHB@ B @HBH@H B 8BJB
=8:8^)H ^,HHB:>H:EJB:
1.2.1 Numerao posicional e numerao no posicional
e6^8HBHy3^_ 8J6ê@/@H8^H3@y:@:):nB /:s/:@:)J^33^

^@H3^@OBB8JBHb8Omd'@+@B83s:@)6^8@BJ_H3^)yBH@q8
HH8HBJJQ^8t6D38t/8H:8B8BjcH@@@)JH3^8JH8BjB8HJ8HH
B^>^=)HHBkj/H@:8HO@B8H@B^-@@B+sHDJ:B-8H:@H3@: 8HH3
=8H:/3::8JwJ)s ^@ @8:@B^8O B:@:8B:HH8 H@ JB^ 3HB
JB^BH@ B 8^%JBJB H=HBH8 YHHH@@ B^8@@B H3JHH8: H@H
H:HB@:8HH 6J8HkBH8 k:8:3
BH@+JB^3H@rH6^Bk83HpJ:8HkHr)Q@@ORH@H8J3H:8H-B6^@HB8
H)^8J3HBW
4s@:@3kO/+^'8JHBk%^8JOT 8HOm^>^H)@-t/@@H@
8HJ3 8^8:8H3^ 8B^@B8H H:HHH8 8 8J%^@:@) @H/: H8
@B^8:8qH^8H^@H8Bj@H@H@3J%sJHHq@H6:T8JB:@3sHB@
8J @B/ H3 83^H8B HJ8H ^/%s3dBB HJH: 8 @HOR@ B
=8H:6v3^8JZ
4d8:@3v 83^H@BxH@3J%svw@Hq8@B:@3J^B@w8H
@HO6H)-JO6@:6+H^8H-@a6B^6)sB-BJH:>:k8BO/@B@BJB@B
H^8Hq:HB)c3tD:8:8H,%H@3JBJ3H:8JQH:@@HH3BB:@@8
^@+J3sH@Ds=@8R8^8:/sH8HH-8R@:8H
RJH@8@6^B@B)t
JJBH B @HH@B )
y HH)t=8H:8H B^ :8/H@H)JHB @BB:
HHH8:@:+8^@:)HBr3J) H
)t JJ3H
3 @HH8B L )
H B6J @ [B@:8 H3JO6:8B
8^HBH8^8@ B @@@ 1 H@HB B^@H3H:8J B8J BB8JB: B^
:)d8BJH3 @ 36:@ 8 BOR8 B \ D)
@HBJBJ%HB^H3 /@@
9
RH^@3JH
T@:
RJHH8
d ]H)_ Ô=B8^ )t HB8 H38JBJ :88^
8 ^H8:H@38H@HH)JBHrH@B:8O/:@H8u8^H+Hm^H-8[H8H@HJ/
H %`s@H@3J H8:8:@HHB %`s:H8BJa`s 'H HHb )
I:@O6:@
O/:8F)@@)JO+@O6:)JO@HH8sHB8HJHH@/:@BH:3HFt
HH8 H8^B@@H@ 8B^H@)Je)th3JB^@3aBHHBHJ /
8JOm t
B^B@Bk% `s@H@3JE8H@ 8HOmJHHHBsHB:Qa6:@H3:8J H8B
=8J@6 / 8HO6 H @/@8J v @3JH@B BH@HH ^B @8J
:8^8O/H+Bd=8J:s6+JO'@:6 H8^@6Hk3@B:B@Brr:@H8r8t
:@:)J^86Hj 8HO6c
+JBHqHHsHHHkJ=8:mXJ8sBHQHH
sHH@ce@3^H@3,j:@sBBaHHJBH:e=8HH6P
=O6J:)HE@j
=8H:6 JHH O/: )J s@ ^@ 8B 8 ^8tm )J6 ^B
:8J@@HH @3^H8Bx^HHwO=H)J J=8:6vsHBxt6BH:3H^x
^@OmH sHB O/: @@ s%H^ )O6J:)H / d fe1 eC1@ eC/HB
8O=8:@^3B^B-k@8JO6@@B-kH@8H^H3HHr8:HHB8^8Hr8tmJ@k3rJH)H
8J68x8:8 n:BH8H_sO=3^_^H3t/:B:@:8B:@Bh@h8^H@8B

^@ :HB@ ^) @B^8O3/e)tBH3^@Bc@ H8JOm@@B 6HH:8
^@HcH8^%JBg

J_ NNNhb6:s/:@:)Jqe> 8JO6:BBt6:8:8B^qqt=B8J
et/:j
ie:H@mJe^@nBJ3^c^k
Nmlpj^HHB):@HB:@8J_BHye:n
7lp
sHH3c@)^/Q8o 6)HH:8Jk:@Q^@Hq^8O/H@3@@3Hb6HH:3H
@8H3:8JB%t:HR8Hb:3J:yHy8y^8O6B_::8trJHBtdrBH
HH8O/:3k:3t6k+^@@)^@H3H-^8j/H/@@@8J U

rHH8OR:-8kr@:
sHBO _ D=Hd38HHp 6 8 3t :HR8H H:)^B H 8 B8^8J3 ^@
/:6:@:):8rs@BOEJ:8O,:8^BHXHH8HJQ@:rJH3t,sBBO>B
^8tmeq HB@ ed8> e^8 ed8: eda ed: e^@
B8JO6@@Be3^BHH)^8HH8^@8:H8^8HjO6:@H3HJ:B@3e)_6^B@H8
Hr8H:H88^)^Hd/-q/:6:@:8H:BB-B+J@@:B@8H-3-:@@8
@:8O B )d@H@)J s:8J)J3 H HB^@3 8 BH8JBH B H3JO/@@B
8^HBH8^8@U@8Jc)J/:Qt/H8H/:BH)J:HBBa3Or@OmJj3:BBsR8^
:6:@:H @B 8O HH^1H^ J:BHH3: JH )t /H3:@ 8::8:H)d
/H:)^8^)J8^BeBH8JB@eO/b8mJ:8B3^nO/:3:j^HHBBJ:):
d =B)JB^ @6:@@H @B 8H:@3 /@)^H@H8O :@ ) HH3HBJ
H)s@8JH3@H8:H:6^B:H8+JHH8tX^@-rHH)J3J-:mJ8:J
r1^-)J
t/:8Hk:3HH8:-:8O/-::@%^HH8H:rB6^@8H ^@-B:6H)sB-^@r)H
xH8v3v@@:)-xHB8HBJ)^HH@8:@H@BwH)^H8:B@3^h3Jt/B@H
s:8HBJB^qHBBO=H8:@IJO6H^Bcs6BsBjBHBBtR8BBBt6:8H
HH8HBJB:@@H O/@8: ^@ BHH@@:@B 8 H88JBJ ^8 1^HHHB@:3H3s
@H:B@B^q/:@@3^-)HJ:)H8B-B3@r@:8Bk+H:HBJ
D@HO'-^8+
HH8HBJ J:@ H:BH@:)H /%sHB:@:JB : ^)^@B: B 8:/:
@:@@X8UBHBJ@BX8:)^HH)BQBH8 @k3^@@@B:@B+H38JBJj6H@:8
8H BB s8HBt
Lu_8:@ B8t
NNhe8^B :B8: ^)^@8:b8Ow@/3
t/H@HH8:B:H_/:HH%^/B H)^:@Bx BHJH8:@3 3 BH8J3J H3Bd
O/:BH8
d )JO6Jx@B /:/@@:)::@B Hx:B:8^8BHH '^R@3J:)J :3H
)t6H:8Hv
L
D@BeBJH)sHB:8J@daH8J6:Ha@Ba:n
%8HJ: qB^
8J6^ )t BJ3^8B ) B^B HH O/HB =):@6 B:m

JBJBH BJev@ HB@O=H)B: @3 ^ B8^8H3^J8 /8/:@H8JBx^
8J6^c

)tb3JB:@3a e O 6HH@@H8OR:HB8:@
Otw

Jg
RR
@6HH:8^8B^
8O=8:@BBJ^@h:wHBH=H83^v@BvBt6HH3^v)t_8Jh3H^8:HH@%H
8 B^B ^ H:H B8^8J%: ^8 8 /:83JB
^@BH6BH: :)H:
H8^)JB^xB H3J=H)H HG
xy{z|{}~c
)tb3JB^88j HBHORH8H Dv
Bt6HHB 8y8 ) :8H8HH8^@:)Hx %B vBt6HB8 8On^@3t6
:8^)H^
BcHH)J8JHB8JOR@@BH:B3JHB@B^8O6HHH8@BBqBJ3@H^
:8^)H^>:@-8t6HB+^r3BJOR@8H^
tW
HJ
DOu

\
bp68
HH8HBJ+@rH)HO/:@%a6@H:@@Br@8J

L
N
OW

-
R
10
BBH8J3HkHrB8J/@@BkH@38JH+^@-H@BH@k8H:rB3:O=H)H^-8B
/:6:@:):HB^ @HB 8B:8^HBBB B: :8:8B^

HHB ^ 8JOm^ @B
H@:BH8H:+^yHBHORH8@^b)JH3@Oj8B^8:8B^b8tq:8@8H:b:8^)H:
H:@ HO3 HH1JBJB H):O/:8B 8@HHH8H@H R:6:8:8H:@B )t
HBJ=H8BJ @:)J@8J /8^B@ 3:H @@B :3^)H 3 H8JORH)H
/:6:@:):r8HD^@:1^@H@B
BH@n:B8^BH8By:8O6n:H@:HO6Hâ_8:8tm::8Jn@R^@_@n3^8J
8^@@H@Br8Q@3^@BkB:-@:88kH8HO=@8:X1^H>^>J@8H:+:8^)H^>HB
sHBOH):O=H)-:@Hd/:8:+B@:@:>H@H/@8J@
dH@ms:88:HBBBH^b^@hwHH8J3JvHwH8HO6:@BB@H)JBhJBvHH
:8^)H^_:8BO/:)H:U
)t)HH:H8B8J8BH^n@BHO^8nBH8J3JyH
H8J/:@3b8:HHH%^@HeH_@88j
EJ8n
_@)^8Hê8@HO/83J:>)^Hc
HBJ=H8Bn^8v/:6@@:8Hn_8:@e_@B^/nBO6HHBb@B%@8^8Bn^@
/:6:@:):eb=8J@6b 8Jdm /@aJ@Hjy:8^)BnJO=@38tBasH@8
'J B)J :)^)H HO=@H)t B sHB8 J) 8H t=):3 B:8J@)J
8JH3^H@ 8 BH8BtR@ B JBJBHB^@8 %^)t/ t':8H @)s@H8B
/B:H@ B BO6 @ 8 B=HHB@H B: HH@HB H:@8)JJ3^8JH)H^
@O=B@:H^Q:8^1JHB^B8:@@:8BjHB6c8B3d@HB8J@qBQsOR8^
^8tm^ HH8H3J: H B)JO/8@B @B3 H:8^ HB :8^3B: ^@@3H
HH8HBJ@H@:
RJ: 8t6:@ 8 :1^HH@)^ H8HO/:@3 8@HHH8@@H @ 8:@ HH
X
8J6a3^:@8H:H8BaO'H8tR=@BJ@8HE@3a %^@HjBB:8HE8JH@B

@^@H3:@OjRHBBJ:HH3@TJBJ3JB^B8BJ:):c@BH:8B@/e 3HO6
HH@OX@HJH3r8HHD/ )JOmr@:@
H H) )J 6H@B :HHB)sB8B^/B ^ @
3 HH@ BB8JB: :@
8^@@@H 8HO6J B3^H@3^ H HH B HHB8 )HH > 8JO6:JBB@@
HBHHHBcBHB:B@HHH)^H8HOR8^YtR3H^qb6BJ:3^QHB8J/HBB
^-BHH8HHB:>B)HH>HB
HHB:vHH83t=H8:v)^B^8tmBv^@ /HH3J@8JhhJ:8OR@hH@t=B8^
H@:)J:@@b3JO=H):@:b3^@@@33s8hBH8JBHbH8J)JBJ3B:@HHB8
8J6 H BHB:H:wJB^

4d@@@ 1: HHB@ 8:B:@H%J3 H@8HBJ
H:H)JH^8O6^w
1a y8^B@@H%s3j:qaHB8HBJ^B@@O=)wm@:@HH@)J
^HH)JBJ+:HH8O/8d)H@H8BHe6@:@+^H@@BH :8t6:k
/ j8^B:@H%JB
bHH8J3JnHHB=8/B@@eBJH8__)HJ:8H_)a w8^8:8H3HBnbHH8HBJ
d8J@H8JBj/@@8DdH1JH rHH)J8JDJ=@=8j/@:8DO/:8
B8t6BJ:)@e:B:8OB BH8HBH H@H8JH @b 8:@:@@BB )^ @@:
B^@@Hq:@:@q^8e3H)sO'@HB:@8JU8^HB1sHcBOR@:8kH8H:@HBH@
H-:8tm^-HB3JBJ:>HrB8JOm:@B8@8k:8O=) k@@-+:)dB:8BkB
dH8H ^@3t6 8t/: R3^B 3@B:8J H BJH 3t6:@ 8t/
:)d8:@Hv% @:H8:)Jh:HH83^wh^b^HH3H^hBx@@H@@3Jv@3^H@8:7 6
8HJ:B@b:bB@:BHB8^%sByH@H@@:H@8bBHH8H8Jb:)JB:H)JH /8:8
BJHB
J:@vB^Hw8H H=8:H8HHHr 8HHw^@h^x88H^vH3B^v

8J6:
8JHHHB/HHOm:HH8j8cH38JBJHjH1JO/:)B^@:)J@8J@:@B3
)BJ:rHdJO6H@kd=8^8:1s+H3sB@6-BHH8u8tYBJ3J@B )HJ
^@ B^B1sH:B 8HH%6 1JBu B HH )@@@ JB^ t :@
3d@B:HH8)s H) B HB):BJ :BH@=8 H :B3^@ B)JH:Bx^
B^H1sHH@3J: :@H 3J@ @B /@H@:8:%sBJ@)JHB)s: /8
J:H8_a ^H)J RB^3bJ@@8kH3^8BhB@8h3wHB8H3J@:H8HB
RJ: HHH) :B^@3 HH8HB: H:H)JH 8JO6 @8H:@@HB@ H ^8tm^
HH8HBJ:U8O/8H@:B^B%sHH@8JBj 8Jmj:)J:8:J@BO/^
dH8Bq:8BO/HBHH8J:@BmdH8H:v:@hH:)t/vwB@H:8:HH8hB
HH8HBJD^8J:@)JH B)tm^)J@:u8:H)k^1H@EsO6HH@+8HkBOmJ
:@H8OR_^@3O6y)3sb6BJB3H8^)
%_B^@e:@O:BBO
8BJ^ @/ H8BH HH8B 6BJ3sH3H:8J 8txJ%3@ H:B@HB
11
@B^B@BbHB@3yHn@:nH38J8JnH)JO=@)o6En^@aH:8O/anH@@:@:BB@
BBH8J3:+^83JO=@d=8a6@:8D^@BO6:
" m#KK)#mIBK.pK IB',mC'"II
B 8JH8 ^B@B ^H@8 B^ HH HBB^ : =8BHH@@H @@@@
H8J=H@@8^8@@HHH8-@8
H:H)JHr>H@BBr8+:@+:86
THH@=@-:8JHw8BJ@H@H8HBxH@BB:Bx3H8JB@:H3^8t6HBh
HH8HBJ:>8H^B)J:H8@@:H
1.3.1 Sistema Decimal
bHH8J3HjJ:Hj8:H8:HBB 2 3cJB^3Bae@:Hc@8:/Hj_HH8H3J
H:H)JHW

H^8:38@O6@8JOm:J3^@Bk8^H8@H@B:k)BHQ@3^8H:r+:@
@B
t
H
Dtt\b
BH@HB@k@/j/H/:8@8JOT8JrH@BO'J:@3kB8kBO6J%H8:H@:8@B
8HHe8:BHH8J8H 3^@BJ8a 1d@Bc8^6je3HH3me1^HHH)^@@/ X@
-8:HHH8@@Hr86^8kr)^HH)BQ3@O6@8J/-H@8HJH@8^8tm
Y:@B@
d @O/:1JO/H J@H :1^@O/B @B J@H 8^)O6 Y:B@@ ^@ ^
@O/@8JO6H :@H
@/:8B 1t 8JB^83 8 8J' f _H
@O/@8JO6-H>J:8O8:8O6 Y:B@@r>H)^8HrrDQ@)^8H
HkJ3-JH)t
8^8O6 Y:B@@
daHH8BBJ::@B8H^H)^j6:8@H@B_BBBt6H@8J:j8:@@@HH@3anH@8HBJ
H:H)JH+)JjJHc^@aJ8HaHH8J3J:n8Bb=@H3:n@:@H8BBeHJ3^c^
@:H>HH3::8H:+83H8J8Hr83^/H+@r)^)JBHB
HBb@)HJ@8B8^BBH8^@8eB^H8Hy:H@B_b)HJ:@%8H:H)H^@Bn:@
:)JH3sje8HJ3Bt=@jHe88J@HH8:cHc@:@jB_B),Be8:8nHe8@@
H:H)JH+-@:8+r8
)tYBJB:BB r
8Jd6 DIHf @ 8JBr@OD/:/H@:)JBB@-B6J
654,321)10 = 6x102 + 5x101 + 4x100 + 3x10-1 + 2x10-2 + 1x10-3
(forma polinomial)
B HJ:B@b^8:H)@wBw8:Omx@Bt6H8^HBB8^@HB^@@:H@BBh
@:@ B ^@ 8J6 B^ /:6:@:8HBBBt'JBBJ@8Jb^@H@B @
t/BH-H+@:@>8 H@HB@H3OH@H@8HH@OH^8:8B
1.3.2 Sistema Binrio
H H)JBJv@H8O=)q68s%JHBJ:)JQvH:Hw3^8O6H:8HvB:8^BwB
HH8HBJhH@H)JHH:8@vH@)HBJQw@@@w %d b^h@O6:)JO6:
8^@@@HH3Jj8b/8/:@B8J:8Bc8BqaqUB8H:8O/@8:O/@y/:8@@Bc
H:8B^H@@BBkBP
T1-^@-B8^B8:H@
H@O+ `k:)Î !
)tBJ3^8Bj /
8J6 )^^8 6:6:8:8J8B 8 BtmB 8^BH@8:@H
B^H1sHH>
101,01)2 = 1x22 + 0x21 + 1x20 + 0x2-1 + 1x2-2
101,01)2 = 4 + 0 + 1 + 0 + 0,25 = 5,25)10
12
b3t6J8JBH8H^)Ht/:@8BtmJ^8HB^Br8J6jB^8BB:@rB:@B
8 8JOmk@8:@-3:H8:B
Bx 8HOmxHB@OR8hH3^hBOj:@3x@O6@8JO/bw@O6@8JOR-x:8J)H
J:H :3:@O6H @B^6 J: H H8JB@:H@%^)J ' R T RH:8
8^B@:H88^)s T{1 H:H
:/@8: @3:/ J@8^
H8^B@:H88^)J_ O T+Z
O8@@8 8^H@@HBB^1sP
T1
d H=H38H^ :3:8J:B )^8:@H8 HH8H3J HH8/8 8tm:@
8H^8O/H3J8@^:BHBB^B)^ /:/B@:8H3xHRBH8H:y::H@8^8H@
/HH@@H:88 ^@6:8H: 3B^H8: =8HJ)^H@:H:B /:3@HBJH8J 8H
J:8O-/@3J:H83krs/:H@8B
pt
8J6vH:)^8B:h@ /@/:@@3J:@3w8^HBB)^@@ / 3HO6
Hr8O/:):O/:U^@-8@O/H8Br)+dH)tR
>k:@B 6H:8Bh^HBteB /:/@@:3J@@Bx8:HHB8^@Bv3
sHBO-/B@-B+3s:83a/8:H8O6HB
1.3.3 Sistema Octal
_BH8JBHH8JHH8^:):)H^QU OJHDtQqcH@:B@
Hr8:@+a% d\
B^8B)J@:@B+r83J:@8r8:BHH8^8H8H:H)H^8@
)t BJB:8B t/@H8BtmH:@8
B 8JOm ^8HH D)f > 8 BO6J
8J:B8H^8@-D:8J:H)Bk8-B:B)sHH@8:-B:B8JB
56,32)8 = 5x81 + 6x80 + 3x8-1 + 2x8-2
56,32)8 = 40 + 6 + 3x 1/8 + 2x 1/64 = 46,40625)10
1.3.4 Sistema Hexadecimal
bBH8J3Jc@BHH@:H8HBe)^@:8B^:8^8@^qE tHDtE
\
bn
T

hx r :@H
T

hx r 8tH6:B8^BH3
/:H8:8^1^BJ:)Hk8XBX X OXa H DH@H:8:8:H8H@BkHr8:@
8JH3@H@B3^>^DH@HB@:% ddH^q+ d^q N^$ d
B8J
BH8H8J
8:):@HH3
B
^B6^m^@:BBHBt6:
^Hm^8^)6JHB3t/:D@O/,J:8BBJ:8BrHDJ3HtR@
)tBH8^@B@:B@
8Hm
D' tp3@ ,ByBtmJ)JHHH1^@H8/_
@:>B^H1^HH:)Hr@DBt6:8H@H8H^8H@/+-36J+B:B8JB
5A3,E1)H = 5x162 + Ax161 + 3x160 + Ex16-1 + 1x16-2
5A3,E1)H = 5x162 + 10x161 + 3x160 + 14x16-1 + 1x16-2
5A3,E1)H = 1280 + 160 + 3 + 0,8750 + 0,0625 = 1443,8789)10
13
g$.pKH'H%$,p Kp'JII-".Kp K
x|{
8
H

{H
D

'p %")KIBm'p
B8J@:88k+B:8^H)HH

|
HHB
HH:
H^)
H^B
^8B
^8:
^H)
^HB
8HB
8H:
8^)
8^B
H8B
H8:
HH)
HHB
~}
/

D
8
H

{H
D

H
D
\
b
8:1sO=@3r:8O/+:>:1Ô=@@+8:@@2m3
1.5.1 Decimal inteiro para base r
)^)sR@Be3^8:@Bc8JBB:Be8^H):H@Bc8BHc:)dH1J:HH@@HH)::
R +-+8^)J=@B+-HH)J8B^H@3r:+@3^HB8J@/BO6:
@hHH3^@h@)dB@3vBw ):O6w@:H8HBw@HB@:@ + /:8Bv
^8^B@:8Hr@O/H8H-H3s3@OT8JB:@HBJjR:B@:)^1sBHH8Jr)^ 8HO6
H:H)JH+-8^,r@:)j
/:BBH^B@ @)dH838)d@@H@B J8^H8@8J @O=H)H :8:OR8t
8Bs3J:8H-@HB@:@
):1dH@3H)sq@>H:8JBHq^8
@BJ)H^8^8@:8J:H)^8tRBB
@ HDJ:)BD^@->@:B
B8J3k 8JOKQ8^=sO6^83QD^8^8Bk@HH:83Q+H:8^6-:BHk:3:8H
J:HvH8^H):H@3:)J ^8@H@:8H
vwJ:)JxH8:B@HH8B^)Jxv
=8H:6
>ft
)JB:@B 8^)J=@B+Bk@@H8HBr{ HHD) @6-@H@
Dt
1445 |_5
0
289 |_5
4
57 |_5
2
11 |_5
1
2
Assim: 1445)10 = 21240)5
14
1.5.2 Converso de frao decimal para base r
H :8H 8:8 O/@8B B:B)JH H3J 8 ^@)^H@:3@HH 8HH 8:@

H:@HHHB /:B@BJB3 8HO/:)H^ @O6J H)H:/ JJBHBH^
^@B:H@:BBO8BHr@8@-+@OmH-O/@H3^@=8/:8HH8J
^8B^H8HH@:83kB8JO@mH^B8H+^8:BBr@DHB
kU^8tBR:HH8+H8O6J>O/@B8^@OR@-H8H 6
U^8J@@@B-Br8
8JmkB@@ HH3rH+:)^)H^7 6
+D@O6HO/@B8^@R@jR@@B:)^)s
_=8J:'j:8^83j:8^@8c@^8B^H@HB@:@3a::HH):H@:B@B^=J
@3^8H:8^)Bk+DJ:3:-B)^H@:B@8^)H

)JB:@B-O/:HB3t6Jx 8H6h DIHvHw@8@hH:88JH8O/hhB@@
^8JBr8Bk
D,@)^8H:>:8J>E^6^@B
0,254
0,032
0,256
0,048
0,384
x
x
x
x
x
8
8
8
8
8
=
=
=
=
=
2,032
0,256
2,048
0,384
3,072
=
=
=
=
=
2
0
2
0
3
+
+
+
+
+
0,032
0,256
0,048
0,384
0,072
Assim: 0,254)10 0,20203)8
)JB:@B 8^)J6JOu3HO6DfD1
0,375 x 2 = 0,750 =
0,750 x 2 = 1,500 =
0,500 x 2 = 1,000 =
@O/>HH8O/8
0 + 0,750
1 + 0,500
1 + 0,000
PARAR, FICOU ZERO
Assim: 0,375)10 = 0,011)2
)JB:@B 8^)J6JOu3HO6D$\H:)k@O6HH8O=)
0,800
0,600
0,200
0,400
0,800
0,600
0,200
x
x
x
x
x
x
x
2
2
2
2
2
2
2
=
=
=
=
=
=
=
1,600
1,200
0,400
0,800
1,600
1,200
0,400
=
=
=
=
=
=
=
1
1
0
0
1
1
0
+
+
+
+
+
+
+
0,600
0,200
0,400
0,800
0,600
0,200
0,400
PARAR, DZIMA
Assim: 0,8)10 0,1100110..)2
1.5.3 Converso entre um nmero decimal com parte inteira e parte fracionria para
um nmero na base r
@:BBOYDJBHH3kHH>:1^H8J:+@H@@HB)J:-8/->@6JH8:@/
k
c@@H8OjJ3HJ3vB:y^8B^HB:B@:)J@hHB@@HH%s:8/hw@mJ
O/:B8^@/@
15
)JB:@B 8^)J6JOukHHB8JBDfEBO/+@@@@H@OR8
57 |_2
1
28 |_2
0
14 |_2
0
7 |_2
1
3 |_2
1
1
Assim: 57)10 = 111001)2
0,300
0,600
0,200
0,400
0,800
0,600
0,200
x
x
x
x
x
x
x
2
2
2
2
2
2
2
=
=
=
=
=
=
=
0,600
1,200
0,400
0,800
1,600
1,200
0,400
=
=
=
=
=
=
=
0
1
0
0
1
1
0
+
+
+
+
+
+
+
0,600
0,200
0,400
0,800
0,600
0,200
0,400
PARAR, DZIMA
0,3)10 0,0100110..)2
Assim: 57,3)10 111001,0100110..)2
1.5.4 Converso de base r para base decimal.
q/BH:@B@Bk3O/3s:,H3t6H8J:B8@^@B
1.5.5 Converso da base binria para a base 2K
jBO6J@@3H@@O=8-H%sr@Y:)dB:8H-3kO=B8^>H]-H3:a':@B]>
8 8JOKcH)H:'J:3O+3q^883tmJH3^q@d6^,Hrd':@H
@O/aa:8:@O/Bnc@^6^BBnBO/c:R:8J+1yBB^H8Bj^8JBB^^
B^H1sHH@3J: mH:H8B:H @BHHH:H%J:H@ B^ tRH8: Bt'JHB:
H@BHBH^>H8H+H-B6J:B3kBDt=H)â rfs
)JB:@B8^)^6JOX )J6rHH@=8r8^H8p8^H+@ORr-8:@Dd8HH-
HBJBH:H):H
8 = 23
16 = 24
10
110,
k = 3
k = 4
101
010
2
110,
6 ,
101
5
Assim: 10110,1011)2 = 26,54)8
0110,
1011
0001
1
1
Assim: 10110,1011)2 = 16,B)16
16
0110,
6 ,
6 ,
1011
11
B
100
4
1.5.6 Converso da base 2K para a base binria
8^1sO=88 H @:8 { 8O/ BH@=3 8JB @O H@8: 8H 8

/ :H)^HHB3 H8@@HO
JHHx@8^8@ ^8BH 'Jx@BHHB:H3JBHxH3s 8O
B^@@@:@3 ) @: B^B1sHH88J HB8O=8 8@ t/: H3: '^8H@H
^@BO6B3^j68BJHH8H8J@B
)JB:@B 8^)J6JOu 3HO6D^8JH tHD8O/@H@OR)
8
= 23
k = 3
123,47
1
001
2
010
3,
4
011, 100
7
111
Assim: 123,47)8 = 1010011,100111)8
)JB:@B 8^)J6JOu3HO6@BJHB:@8JB
Ê@RrHB8OR8
16 = 24
C13
k = 4
C
12
1100
1
1
0001
3
3
0011
Assim: C13)H = 110000010011)2
1.5.7 Mapa de converso

DECIMAL
INTEIRO
DS
BASE r
FP
DECIMAL
INTEIRO
DECIMAL
FRACIONRIO
BASE r
MS
BASE r
FP
DECIMAL
FRACIONRIO
BASE r
EX 4 Bits
HEX (16)
FG 3 Bits
BIN (2)
FG 4 Bits
HEX (16)
OCTAL (8)
EX 3 Bits
BIN (2)
OCTAL (8)
r38piRJ@B-HS
H^)sd=@8-:8t6@:8:
17
O8BJ@@H
D
i ^@3JH@:B8:8J:DHHB@HH1J:76
+
i :)^@8J:DHH@:3H)sH6
r +
i Btm:r8H@H8H^)Hp6
Ng+
i B^8HH@B+Bo6
rIir1tm::@B+H+t'H8
'pKIpKBKJImp
:8B @/ :@:8J8:H@x JBHtR@ =HBBH@H B B^HH)BJ:8B )HH
@O/B@:H@@:@@H@@HB_HbO6:HH:@%J:8Hk@BH8H3^nBB^H8B:
Hr_ `JJ:8HB
]H88 K:@UH:H3HHH
RJ3: K:@:@Br>@@H8HBH
d): 6B@:@Br>@@H8HBH
R KO=@:@%DB:H)HHH
H8 d -^D
a `JJ d
\rH):Q
d d D1+8H:HH@@)J:6 8Jm^@
]H d d) H-a `JJ@f ]H@3â `JJB@
Z
R^ d d) HZ]Ha `JH@
d H\' DB+_ `JJ:% RJBH:_ `JJ8@

d d / d) HRâ `JH@
Q
d t$ aH^) \ H_ `J::' ^8J8a `JJ:B
> $" )II)0
r):@+:+3^)sR8J:,:@:3B)BZH8:B:>:)^>D^6^@B
11101110,0111)2 = X)10
7638,115)10 = X)16
6355,731)8 = X)2
1573,891)16 = X)8
1356,11)8 = X)10
3F67,5)16 = X)10
18
Captulo 2 - lgebra de Boole.
I I-" p',%&)(K
jsO/@3s@B_8H^@B_8HHy:a:H8^yH)J@6:_x/H@HxmHH:H)^@8^B@
Bt/%s:yHH3H:6_t/@:BH)^@BUes=@%s@HyBHHH@:r)t/B-8t
:HH)^/3 @@:8: B^H JHBt/@ HOm 8 :3 HB^3J@
@O/@8JOR@8^H8@r:8HO/@)J:@rH8J:6-t/3:HH8@@HH@)@8J:H
:/@@:8H6H^nâ^8O/@Bt6:n3H^H8Jb6^R8^yHb8Jb@H)^@BJ8H
6HO/BJ@BB B@ @@@B@:@8 3 B3Ht=)HB^ HBH^ )^ @3JO
/3JBJ:):k8r:/@8:@HBBkB-HB::6r@O/+B^B,sH3t/H
ik-HBJ@/
BBH8J3:rHB8O=8
d 8^B@:8HH @:HH)^ H@)H HBJH/ BO6B :6:@@3HHB^ @BH
=8H:/ sB B / \D_H 8O sBtmH T8BJ@xJBJ3HB^H3 :8B^3J3
H8JB: ) ba\
JB:@B 8I ^dHJ 8:H)^ :8:H)^ JBt/@
HBJ@/ B@H:H8 H HB)JB :: HHBH JHB8^ )O=@@B: ^8 ^
sHBO/:nh@bHB:8H3s3
)^H@@)H^)@Hh@8JBBbH:B:8JB3
sO/BHH:'k+BH:8
H3J:6HP
T)HJHEJBO/:D@O/:)J=H)^B@:+@@@H@:w
2 J
:3
/:,^@R:8J@XJIWJc$ eJ-r)HJ@H3J@8Hc p 6
B^H+@O6H8JO6@ +r
qsO=83s:Ba8B_H@:H8HB:j@@H:jHB/:jBnHHB:BBH
T

,
-BH
^8O6:3J:3H^B@@ J I ^ @3:/ /:H@8HB H/HH@:6x^
HH:) /vJJx^@@8B 3J@:@HB:Qs^@/H8H: s _ ^ @B
H^8O/HH@+r83^H
I %#K+" %&)(I
d@O6:@Bk>:)O/-@8:,^=@%J:H3^H)-BH:H8j/8HHBH@8J
0
0
1
1
A
(F)
(F)
(V)
(V)
0
1
0
1
B
(F)
(V)
(F)
(V)
A
0
0
0
1
E B
(F)
(F)
(F)
(V)
8O/ JO/HBB:6 /@ @ @JH: :xÔ=@3J@H Bt/BxsO/BHH:/@

/@
19
I q#p'"'&)(pq
d@O6:@B,s-@)t/+@@:EJO=8%s:H>B^B8-3H^H)a/8BHHB:8H
0
0
1
1
A
(F)
(F)
(V)
(V)
0
1
0
1
A OU B
0 (F)
1 (V)
1 (V)
1 (V)
B
(F)
(V)
(F)
(V)
8O/+@H:8'Jr)+H:B:>@,sOR@)s:B>Bt6B-@H:@@KJ
I %#K+" %&)(I!)I
d@O6:@BHBr)^/>8J,JO=8%sH-3^H)-BB^H8j/8HHBH@8J
NO A
1 (V)
0 (F)
A
0 (F)
1 (V)
k^@O/H)J:_Iqy$es@Bq8JBBa8O>)^@:@@@@H@)@j8Q^BO/:)H:
6J@8H-H:B8BkHDHB:@/Et/H:BH3^@B
bBBJ@Rj3K
T)BJHQJB^83c3^HHBqBB^HHq8:)^@HB3^BBt/BH:^@
:8J@@HH@BBJ:@@BBH:8H:BhHBJB/DdB^m:H8J@k^@/:3H:
8^8:@HH3J JBO/3J: )J@B @O HHB^ s=@HH8HB: BO/3s8 H
BJB:@B^DH-B3Ht=83H^++B6Ht6B::+@+:B8^88JB

oB
I II ,pI6I
Bb8y8:/:H3B_HnH:pJ:3J@a:@_@By:8@8H^n8ByB@@:BH@HBBnH
HBH:H8t6H@Bk
T)@JHwBH:@BHHB:HHw8J8^8HBB^:8x@Bhv@:@hH
H@+HBJ@/
HHH@c
>sOR83s:B:8:H8:8Ov
N
e
T@O6::B@:)J@Bq8^/ :B8H
8JH3H^>@H:HBY^D@B^@B8J@+8^8:@@HB:
7f>H8@H@B^1^@H@H+B@>^@/H8J@->Es
(X + Y) + Z = X + (Y + Z)
(X . Y) . Z = X . (Y . Z)
_
HH^8BB^)^@BHHB:U^@O/@8::-,DJ
X + Y = Y + X
X.Y = Y.X
f>7f>HHBB:8HrBH8:OR8@O/+>^@/@@BDs
BaHHBH@8HajHH8BO=8^@@BBaHHH)J^@O/B@B-/HB@H8^8:@BJB@
8H+^8tmrHH3H:8H
N UR@H@3Hr8r'^R8-HBBJ@3HQ
N
kD-HH8J@8BHB)JO=3r8O/++:BO/:83+s
X + 0 = X
20
uf8HBJ:1HBH)JO/8r8/-D^BO/@@3
BaHHBH@8HajHH8BO=8^@@BBaHHH)J^@O/B@B-/HB@H8^8:@BJB@
8H+^8tmrHH3H:8H
N UR@H@3Hr8r'^R8-HBBJ@3HQ
N
u++-BHBJ@)HH88JOR)8/-D^8O/@@3
X.1 = X
fBH8t=3H8^)^8HH@+H+8^/,s
X . (Y + Z) = X . Y + X . Z
ap%@@8t=H38^)^8HHHBEJr8^/D^8O6:@Bk
X + (Y . Z) = (X + Y) . (X + Z)
@X=^H8J8HH@+Br3-HB3J:8Hr3H^8H3J:)H
4d@H3^@O^@8HNB^@)J)8H:@@BJ@8BkBNkJHD:@
XX = 0
X + X =1
dk)^8^8BHB^+Hk+kDU:B-B^H1sHH@)J:@rH)J:6+t/3:HH8J@Hs@
^-)^8^8@HB^D
E@BB^8@HH)J:+H+H3J:/+@
T8BHH
/BO/:8/ R
23
>b@B_sH:@8:@H3H:6@
T8HHH
^@O6:@Bk,J3r=8=@H@Br):/-DJ@O6:8BDs
7 <{ F B@H8^)^HmB^ B8J 3:/:@83
3H^H@
H8^)JBH^@O/8@BQs8HBjH8:8HBjHQ^@6:@BcnR^H@^/sO=3H
HHH)^8^B6H^,Q:):8H-)EjR+d3@^1^=@H:8HB-:3JO/3H^-)J
8Bs B^m:H@B c:3^@B JO6HBH:RaH@8H^B8HH H/ O@ BJ/:B8B
t=8:H@Hq F
)H
eSNdQN 8:8:@HBB

U
s$ e^Z
I
y
NdQN 8:8:@HBB
H
)H NeS
eZdNen) UeJ
s$ e^Z
I
Nw
_W
dNxU) v5
J
I KOgmg@p"K$&+IIBImg
y/HH:)::qBH^3@:8J@3e)O/:/H8:8JBH@qBt/)J:qHq8a@B^8:8
H=BH8H )H^H) )H B@%s: @B:OR@ YB^3HH H@%s:
/:6:@:):B @ sO6@3s:3 @:3H :O/HH3:/ : BH:@
/:6:@:):HH8O8J Y8:@HBY^8/:8:@BO6KsO6BHB:6Jq^@
J:8HO/+H@BJBBcRH3:8J
dwHBBJ:83^wH RHH:)H:w3B^H@:h@B3:@:@BBB^v8O/h:)^@:8On
dHH8H:@BH@BbHy3:8^@H3BêeJBO/BJ:DJ:eJB)Hy:8:B@:@3@3
J:H HH:HBBH 3 :H)^8BJ@8H^ @H3tRH8^ )H HB^)J:
HJ:8:H@@3J: 8H3 :B8^@%JB H 6H/BH:8B B 1^8t6HHH8O/:
6HO/BJ%^:H
21
LO=83s:B
)B 3^H :8HH8:
/ H83s H:B@BH d^ B@)J
:@6J-dHJ
H@jBH:QH:8::
@+-BH@H@-8:-H8%s:
:@B
O{YB:@HH>@O/+HH@H@8H:8B
R Y3^@HHD:@:3
O_dd Y3^8HH
:@3JHHP
O_dJJ
d@O6:@Bk >D^@Om:@BBH^H8r,:)t/
:>:@:sO=@1s:H
d@O6:@B,s k^8O/:B3j3H:H@kdQ@86
:>:@:sO=@1s:H
^=BH8H
BH^B8
^@%s:
e
L
= A.B
A
= A+B
B=HH1Hk:8H8J+@3^BH8:
BtmJ
Lgica de
chaves
V
+
-
HHH+r88^HH)H-B^s/:HB3k3B^H@ @^8HDB=B@8H-3H:H8r8H
H@3J: / YB^@BB-r)BJO/8
)^6:H@3rBH:B@
D
Exemplo: Expresso lgica
L = AB + CD + D
C
A
D
B
L
I fpI+" gtIH"K$&$pIBImg
A=A
A + A + A + ... = A

A A A = A
A + 1 =1
_'>'I
_'>'I
_'>'I
_'>'I
A
A
A
A
1
22

_'>'I
_'>'I

_'>'I
A0= 0
A 1 = A
0
AA = 0

A + A =1
_'>'I
0
A
A+0=A

_'>'I

_'>'I

_'>'I

A ( A + B) =
A
A + AB=A + B

AA + AB=
_'>'I
_'>'I
A + AB= A
_'>'I
A + AB=A
A
B
A ( A + B) = A A + A B = 0 + A B = A B
A=A
Bt6BJ:DH-BRHt6B:
+8B^8^)@8OY:@:D@O'H:
F/)H^@B3J:8@kH8J
p)HJ H-HH3::8H:1^@H-3 6J:3Ho B^
@:H+8H:BHBJ@)H^fF
(A + B + C + D + ....) = A B C D....
F/b8H^8HBJ@)HnHe8 p mJ@8Hp>BaHHBJ@8B^ce8^8H
@:H+8H:BHBJ@)H^fF
(A B C D ....) = A + B + C + D....
Exemplo: Minimizao
R^HH)^@H>-B:/:H@%8J8:@B@@B)^3^@BH3^>+H8t/BH@
F = ( A B + C) (A C B)
F = ( A B + C) + ( A C B)
F = ( A + B + C) + A + C + B
F = A.B.C + A + C + B = A(BC + 1) + C + B = A + C + B
23
p8HJ,B^
Exemplo: Minimizao
R^HH)^@H>-B:/:H@%8J8:@B@@B)^3^@BH3^>+H8t/BH@
F = XY + X+ Y
F = ( X Y ) X + Y = (X + Y ) X + Y
F = XX + YX + Y
F = Y + Y X = Y (1 + X)
F=Y
I ,'+&$Ip'IpKIpK
8^H8:)HvBh@HH8Bw8H:HB:@JH)HvHH3J:/_t/H:BH8J8H
HH):@HBJ8O-B:6:H@3a@3J:=B@8JH@O-8:HH8H/BHc8@Hc8J
:HH8B)@JHH@8
Exemplo: Funo Booleana
HHH+-@@H@B :H@E+^BBtXHrdKIH
F(A, B, C) = A B + A B + C + B
:8J3
F(0,1,0) = 0 1 + 0 1 + 0 + 1 = 1
8O/8J>:HH838H,^=@%J:H HHHH+H8BJHH@@)J@-)^HH)::H
H+-rD-HB38t3 B-8JB^8B_dCt 8HH+r8H6rB
8H^BH@:):: dU\
I $.'gga'"Kp'
4d@H3^@OQ:8y@Hy_BH/:B8B8HJ@H@@)J@^3@e^8Hq)JnJ:8HH
8^H8:H@Bj8BHjB:@HB^/HBH^8Hj@:/:8:)JBHH3^k^sHBO/:
^@ x:HHB3 8BH :8H8^_^@@@B HhsOR83s:B :HB)HB HJHH:
8H^BH@:)::)^BH1s:@QHo IQ pa@8HO>HJ:8@HsO/HBHqB:
^@O6H: OB8_ ^@B BJB@8^ 6/

\ B/ \b{\HJ:H 8:B@:B@8 8HH O8_ ^H
JOHmJ HH=)BtB8^3BB8H:8^8
F'@H8r)
)HHB@Q
RJO63d@:3: Ft
d-8:H8:@O6+r'@:@8-HEJ:@HB-@B+:-8B^B@8J:
t=@@@B-@:-)H:H@:,H,JO=8%s:H
=@BHj8Bc)H:H@@O68@HsOR83sH^8BjJHHB)^H@@H@BH)s
)JB^@8HH@H @8^@6H q@BH@BQJBg
-sO=8%s:@Y 3J6
H HHH8: H 8H^8H@:8B 8n
@:)J 8H@H@ ^@ )JB^8BH^ ^
F/sORHHH)J
Ft
t=@@@B-@:-)H:H@:DH8:6JB@@O=@@
H:8H: 8:@H@:w@B )HB^@BB: )HJ:q6JH)H^v 3H:@BBJ@8H^w:@
H:H8:8J3 :@H@B@ 8 6:H@8JHB :HBH 8BO6 H 8::B@:
H:@@@H+@r8B:@HB^)HHH>H+@HH@B-H+3^@=@@@H@+B+:@B:H@
24
/H@HHH)::8H+H:-1J:HB@-B)JO6JB:BO=8:
@:B@:@3rB^D8^8^)HHBJ>DHBt/BH:@+3^6:H88kH>@BH8J:H3
d8J@H@BB+JBBt3-:@B@B@O/@@H8B^HB@:88
HH)^8^B@@B @H:B8B 3: 6:H@B@HB^ 8O=H8:B @H)^3t/:@3
B^6:H@3r:H8B
Exemplo: Tabela verdade
H^HB@HO6-@BH@Brdg $ T)
JWRH^8H-H@DH:@BHEÔ/HBB+-@H8^8/
^6:H@3:HB^
!
%
"
%
%
%
%
%
&
&
&
&
%
&
%
&
&
F(A, B, C) = A B + A B C
A.B
&
&
%
&
&
&
%
&
&
%
&
A.B
&
&
&
&
A.B.C
&
&
&
&
&
&
%
&
%
%
&
%
&
%
%
%
&
%
%
&
$
&
&
&
%
&
&
!
%
"
%
%
%
%
%
&
&
&
&
&
%
&
%
&
&
&
&
&
&
AC
A.C
&
%
&
&
AB
%
&
&
F(A, B) = A B + A C
%
%
&
%
&
&
&
%
&
&
&
&
&
%
&
&
&
I ('sK%"tI
4d@:8B @ @BH8JH T8BHHH:B@ 3t/3 :6@@:8H@H:cd8BJ :@ @H@
8JH3@TH8B^HH1J-8O6J
F(A, B, C) = A B C + A B C + A C
^@H nT
83 H sR@3sHH B @BH@BRJ:_JB@OmJ:@B ^
JO6B^ A B C A B C Bh3^@H@B)HH^B8w)HJ^@b:BH^3^H
6J@8H^:)HJ3J:8BH:H:q@Qt/@QÔ=83J:HqB:HH83B8JH3^H
JO6B^ 8B :@ B@BJ3B^ ^HH8HO6H:x88JBb^BH)J'H^ @B
6J@8HHBJ@=H8^@8:8H3HJB@@kÔ=83J:H8@:@Bj@H/
He@BH@@BUHc8Jj:BHBB aJO68 A C @Bae8j^HB3J6H_):H
@Br8^8H8kEJO=@3HH
T
25
J:8@H: s/HBH )HHB JB:@B @ 3^/@B@: BO/%s: B 8J

8HJ3Ht=8H@:3q:HH8:6H:_B^/:B@3j:@bR:/@8:)JqJ:8HH
sO/BHHqB8BJHB3O6Jq@@6BYj8J:%J)^8HBj8B8@JBHOR@
H+:HH8H6H^@:H)BH^DrB8BJ^8BH+BO6J@B/B-@H{ :H)^)s
BO6J @H/ :H1^)s :B3^8t6HH @H)^B@:8B @BH /HH@BHHB
sO/BHH:' 6@ 8O6 HHH@3 @: :HB8J6B B^H1JHH:3J
^HH)JO6BynBO6JH3bBHH8^1:HH@8_Bb@HHe@BBJ:1Hb8HjsH3tryH
:HH8hH8H:HH8:BBw@::8HH@HHB@bsR@3sH@OHRBHQhB/
@HH+HH3::8H8H+HHBtYBDJ:@BHEJO=83sB-H8:8H@
HH)X8/k+H:@@HDJO/HB3kr@B^Hd@8kBO6H8HO63k:H :H)^1s
!
%
%
%
&
&
&
%
&
%
&
&
$
%
&
&
%
&
8J:B8J:
H@HB:
%
%
4d@:8B
"
%
&
)*,+-*/.0132546
&
A BC
A BC
A BC
A BC
A BC
&
&
&
&
&
&
F = A BC + A BC + A BC + A BC + A BC
:J:8BH:vsO/@BH @3 8:@:@HBH@ B H 3Ht=3BHê@B :

8:BHHB: B ^H38JO6B^ ^B @B J:B OmB@:)JB:@8J
I f '.pIK_+" pKpJ$#KIIpK7HKg'"I
4d@:8Bv8^)^HB@H@BhH8w8^{:H8BhHw8BH:@B^yHw)vH3Ht=%HH
H:@@@HbH8Hes=8:HB:8BbH:yH8t/HB:yBtR8:H@8:b8HB@H@OR8
HHH3dB@aJ=@:B8:8J:_%H^H8HnH:8H:_:)t6HH@_+By@8t/38H
3sH@@:@3 8J8B @ HHHBH: :)s=@: @8J: @@H/@8:: 8)J
t/:8H:8 )6JBBJ@8H H:3H @@@HH3 @ 3:@O=B:HH8 B
6HO/BJB8t H:-8B+JH8HHsO/HBH-8HH+ @@HTB+:H)H^+@:8H
BH8H:@:88dB@ 8^)J:@@@8J3J88J : JOR@3^:B8JB8 )Ox@^8JBB:
J:@BH: ^/HBH @B8J:)H :@@HO6:@BBO/: H^8O/@8B Bt6H:
B^H1sHH@3J:Bk:8H:B@-B^q/:H8BJH)^Y1kH3^HH+@:8:u-:H8:@@
H+JO=@%J:H-BO6^)H8a/@1J:8@Bk/:H38Q3ÔB6^+3HJB:@B:B
:8t6HH: H BBBâH3^@@B 8O/ HB@O=8 J:B8BJ:@ /@HH@:
HH:)t/HBH-@3:H@BD8J{ :H)BkH8::H+BH)tH/3:BJ:)HH@3t6JH)^
w@B^HQ@BnH:)t/H8:aB^@aBJ3^@BJnBjJH:@B@@ByHa:)t/HB:eH
HHB: BJB:8B^ :3J: ^@ BB /:BB@O=BB H 8J :8H:H8 8t
J:@BH: s/HBH @/ 8/8 8:@H8H:8JH%^ H@ 8O HB8 H:)H
:H8H:H@3J-@6+H:)t/OR3ksH:@BH@-B+:@B:H8
26
BnHBHO=8HBnBn3^Ha8HOm^caH3JjJO=@:B@O@j^B:Ha8J6:
@B8^H3:)J^k^q@3HB^)H: )c3t)^H)^%Jq^)O6c8BJBH)J
e@:@HjaHH@8
RH:)JajB:@HHJ/HH@aBO/c@HBn%JjH:a@:8B:
sH:8H:
LO=83s:B
d8^H+ 8JOm:_ LsO=>+_ Ld
,Ô=@%J:H>3H^H@Bu L+ L
1@:8O=H8HH
)JH8@T8^B)^)JÊ^+8BJ3J)J^
:@:@:8B:
r%jRBHH-):H8:%J^@+
r R3^H@3HB^)H:@
L B'_ L=- 8JJ H8JB q La dd 8:BB La dJo
6 _ L= Bt
J:8OY^8HOmr L,Ds6HHB@6e6@
L B'_ L 8JJ H8JB q L dd 8:BB L dJo
6 _ L Bt
J:8OY^8HOmr L Ds6HHB@6e6@
G/()51<
%%[ & %[& 9 %& & %% 9 l3A6$ 0@94=A/&;:f8$6;%A=<
L)(BA6<s9p.8$ `B2/.X|).H9p<
f
s
(
9
.
&& %& %% %& f (s9 & < .ff (J(J99 9=9 :<
$ 9 $6;%<L8.346<s9p.8$ `B2/.X|).H9p<
d Hr):-BOmJ+J8H8:@:BB8J
f (^9 &
f (^9
&&
%9
f (s 9 &;&;>->-??%%
f (s 9 9 >-@59 ?% %
%%
%%
f (s9 &;@5%
f (^9
f (^9 &;@5%
f (s9 9 9 >-@5?% %
%
&
f (^9
f (^9 9
8H:H@3k@O6++J8@HHUsO6BHH@/D^8HB:@OY8k3:+@:)^
Ht=8^B@
r3Q
de A-BDC/ L@3F
E A-BDCOR L B
^
r3Q
deR_ :R_ LR5 8JJBr6I ^'I LO 8HJ@
r d LG
E- L
^
r deR_ Ld=5 8JHH
Ej'I LO 8HJ
BQBBHtR)HHJBQ%J8B:@:)k:8O/H@-H-BHB^+8H-:H8HH-H-H8O/:
B H: HHB@B ^ ^B HHHBB HH) @ :3t6HH H H3B^ H%s 8
/:@3^ :8J@@8H HH@O68 8B :8^8HO Nm 'J: BHH88J ^ o
'^H HHH88J RH^8H-+J:@B3+sO6HH@+^@+B^R8Hkr8:)JHHH8HHB-H
BJ:BH@BBkB@8
LO=83s:B
H8t/+@8^8HBHr@8BBB@OR3u O)BO/
,Ô=@%J:H>3H^H@Bu O3+ O
1@:8O=H8HH
cH@8qBHHH8JB33BJBJ@8H@kHBO6q3t,@@H6:8J-H
Nm
-:8HO/@3J-Bj
o H
QHH8k>H8JB6H^H3B8++@Bt/+BOg
Nm ^j
p B
BJ-@:@B
r38^8^8H@++BHHH8JOX-H@8
r3: dd@:@3
r)Q
dH
OB@6 O8BO6r8^3H-

Nm:8J3r OB
d@@8B O3S
dkp 6
O @6 O8BO6r8^3H-

o :8J3r O du@@8B O dkp 6
27
8^H@@H8HB
HBV o@3VNm@u8@8^HH)
o
:H BHB@B@O/
Nm H:
BHB@B@O/
HH HBk@8^)J@@ HB/-E^
^H HBH@BD^,JH HH3@H
B:/:BBBkB8^8@HHHBBHHD:H@
r3QdeA-BDC/OB)HFE;A-BDCj6O H
AB
d@HB>JBt63J-HDHRBt6H@
r3QdIA-BDC/OBJCK+
O A+B
d :H@BH>8J-%t6J,J:B>B^@@H@8J
r3Qde/
O)8t/+@@HO/88JB
N E O8BO/+:8HO6H8J+Bj
o
OB O
r3
I " )gg" p p mI
@R:HH8:8H->B^/8H@B-8^8@@H:@3r8^3^8HH3^>DJB6BH:
F = B C D + A C ( D)
F = BC D A CD
F = BC D A CD
F = A BCD

R:HH8:8H->B^/8H@B-8^8@@H:@3r8^3^8HH3^>DJB6BH:
F = AB+ C+ AC
F = A B + C A C
F = (A B + C) (A + C)
F = A BA + A BC + A C + C
F = A B + A BC + A C + C
F = A B (1 + C) + C (1 + A)
F = AB+ C
)R:HH8:8H->B^/8H@B-8^8@@H:@3r8^3^8HH3^>DJB6BH:
F = A CBA + A B A C A D
F = A C ( B + A) + A B + A C + A D
F = A CB + A C + A B + A C + A D
F = A C ( B + 1 + 1) + A B + A D
F = AB+ AC + AD
28
HJR:HH8:8H->B^/8H@B-8^8@@H:@3r8^3^8HH3^>DJB6BH:
F = A B (C D) + ( A + B) B A + C D
F = A B C D + ( A + B) + B + A + C D
F = A BC D + A B + B + A + C D
F = C D ( A B + 1) + A ( A B + 1) + B
F = CD + A + B
D)R:HH8:8H->B^/8H@B-8^8@@H:@3r8^3^8HH3^>DJB6BH:
F = (A C) ( A B) + (C D B) + A
F = (A + C) (A + B) + C D B A
F = A + A B + A C + B C + (C + D + B) A
F = A (1 + B + C) + B C + A C + A D + A B
F = A + BC + AC + A D + A B
F = A (1 + C + D + B) + B C
F = A + BC
I '"$ I#'" $#pKI

@RB^8J>:>H@@HH:sORBHHDH:3^/:B8H:>:@@3H
H F(A, B) = A + B
@ F(A, B) = A + B
@ F(A, B) = A B
H F(A, B) = A + B
H F(A, B) = A B
H F(A, B, C) = A (B + C)
J F(A, B) = A B + A B
@ F(A, B) = A B + A B
@ F(A, B,C) = A + A B + AC
H
F(A, B, C) = A B + C

R:HH8:BH-@>B^m:H8:@@8:8Hr8J@:8H@@Br8:3^@HB3^>DJBt/)J:
F = A C + A D ( A + B C) ( B C D)
Re sp F = A C D
F = A B C D A ( B + C) C D
Re sp F = A B C D
29
F = A D ( D + B) + A + D + C ( A + A D)
Re sp F = A + D
H
H
F = ( A C + A D) B D
Re sp F = A + B + C + D
F = AB+ CB
Re sp F = B C
F = A BC + A B
F = A B C + A ( B + C)
Re sp F = B ( A + C)
Re sp F = A + B C
F = (A + B) ( A + C)
Re sp F = A + B + C
30
Captulo 3 Programao estruturada em C.

m I6pKII IBK+" p'"It$&$(p " ,K,'"IK
3.1.1 Definies
H BaB^B)Jc8:jHH8HHH@%_B@)sOR@HBH@8J:@:3Hc@O/6HO/BJB@B
:8tR8^6@Hp6s 3:8t/R8a3^H8:B s=@: :B8HH: 3 @:B@BJB8H
^@+r8:@@:8:8B
B @@8^@8xJ: H /:8OR8HQ 8:H@:83 H mHt/3::@3 :8tR8^'HH
:@h/:B@:8B
BO6JaB_6Bt/BHncB_6^@:@)nHa8J:B:H@@@3

8 8^{ HH8H B 3^)s@B8J: J@ mH/BHH3t 8JH @3^H 8O/
6J@@:h )J:8@ :)O=8^6HBj /BO6: B )H:@:@):@B 3^)JB
:8^)J:8HH 3^/ H) H: :8tR3^/@ 8:HH8@ B 8J8t6HB
:8tR8^6H-Hr8HJ)^HH83kHB:@HOk3^H3J@8J@@3

BBQ@3JkB:8^83
rmHt/3::@B+:8t=1^/@B-@8B^@D^@3^BH8H:,@^HH):
@8B @8 H J R3:8^H8:@8 8H^@B3J : @O6H@H B
L 8 H6HJO@@/BBJ
B+J^ 6
:@@8: O/H :8tR8^6@ B:HH@8 B )J8t6JB
L @ B6H O8:/BHJH@88Bu @@8BH: @B+
r8H/:83o 6
1
r
t
>
:)=8:/HBo 6
LL @:B@:@3 H 8^/s:H8H@ B )J:@:3@:@B @8O=8^s/H@ )J
:H8:@BJ3-H-6Ht63J:@3r:B8:H@:B@
) ) @:)^@B J:B B^8Ba 6H/BJ@@B @)t=)^/H@ H=8:@H
J:8BQB:>JBB:B^Hr6Ht6%J:@B8@B 3t6J-36HO68J
8^8:B@
@B^B_8JJ3HJ3J3H^8v:8=8^RHHv8/tmJHH@BOcxm HB@xv
8^@B:8J@BBk3r6H/BJ dUH^HH)^+:1JH3d8B^>HH@@8B
@H:@H 6
L 1@ H6H:OB@/BBJJ@@8)HB/H:@B/8HH ^B8j/B:H8B::8Hp 6
LL :)s@HB+:H3O/:@3p 6
L 6HO/BJ@8B-@:J8B_ ^3HHBBdBH
3.1.2 Objetivos
=HHBH@B ^{HB:)H B 6Ht6BJ:83 :8tR)^/H8 6J:@@ )

6HO/BJ B BBJ @@H:8BH@ 8:)H BH)H 6^8O/B8^8:@B )J
:HHBH@:BB-H>6HtmBJ:B38/r8:HBB^Bd
RJH:3t/OXr8:8:@:H3:@HBB-3k6HO/3Jp6
L
8JH8JOX-H3:HH@H8HHHDBr6Ht/3J 6
LL
R^HH3^@HYr)B^@HBH@HHB+B-6Ht6BHp
6
p
6
LL
8JH8JOXrmH:8^)J@HHB+B-6Ht6BHHBO 6
B8JH@HH@8O)H+JB8JBJ3B^@>:HHHB@@H@BH+H-mBt/BH@@8
L
3.1.3 Propriedades
b@O6:8JO6H8^H):nJ:@b8BJ3J:HyH)6H/BJ:)OR8^/HBh8B
H@_B6JyH8/O6JB@HHH_a)^/ :H3H 6H:8:BBbHy@@@n:8O=8^6:
31
@:HB@: B )^86HH dBB H:H3: @B^@3 @B 8^HH8HORBH:

6^=@HB@H: 8^@3BJ:8B )^8t6::8H: :)t=8:/ @ 3^8tmJH
@HOm^H@B@H ^ /3^H@H8B^ H 68t/BJ@8B @ 8J)J:H8J@ H
:8^8B 3B^Hd 8 /@B8H H: m:=@BHBH: H 8 6H6BJ
:8tR8^6@B
MONI~QPON:|/xaxSRvawmBt/BH:)d8@@Bh38h8^{:H)HBbHJ:3B^
:HH)^8H:B8JqHB/O6:H8Q^@HH:B@H@@y/BH@8JHq3H:H@:H
JB^)kH>BJ:BB@B
MO/:NI~Q8OPON:=|/H8xHJaxB@ 8 h :8J@@:38JB H8H: @H:BJ:k@HH8:BH 8HH h:B8:@::@@BH O^@O/8 h^H8JHHb
8B
8^8O6JH H3J @w8:H@@B BO/ BJH@B B @H H@B8 3:8H H

:8t6HHj):_8xHH:8B Hw@:
BHH8 )^)HH@@8Hv RBHtR@O
@B^/-3HJ@8B-:8+kB@BB:
MONI~QPON:|/xaxUTr>r8JH)t=B@%QB-HH:BBkr@HOp^H@H3HkB-:8/38H
:/BO/:_t/B@HH)^8:HbBeHJ:@BO=BB:@B-bHy:8tR8:/@@:HB@@
Hr)^8tm:Hr83k:8@8JH@@>@B @@H@@8HH@@B8J6:8B--H:=d8
MONI~QPON:|/xax V /B^8=BH B^H)J:8JB@B /HH3:)s B 8J:)H
B^8H @d/ B:H/%sO :HB@B 3 mHt/3: 8H8 8 HJB
H:H/3sE8/q@HHQHJ@@3UH@:HB@3UB@@8O=8J/Bj8HB^Q
H@/HH@BB)B-^86^DBJ:83^Br6HO/3J
3.1.4 Estruturas Bsicas de Controle
tR: :8=8^6@ @HBH@@ H )^)t6:H @/ 8:H8O=H@3 H

6HO/BJ@+:8OR8^/3B^
W XQYZ/|/ H8BH @O/ 8^8O6JHv BJ:HBBB B s6Ht/3Jn:
8HJ@@B^n8By3J:H)HHB^n@jH:8JctRHB_Bn:@n@@O/@)Bb8b8J@8H
B^8H
:3tR8^/@ H @HHH8B 8:O/:)B H@)^8 83 H@BH: 8O/
HBJ/OvH@8HhHBH:H@@3vBw6HO6BJhBH@O/BBw@B @:H8@H
8t6HH
W /[\~,B8HHrBO/+H:8BOE)Jr8:@:HB3Q :8H33:@:@@:@3kH
@O J:3J s/HHB@6 ^ HB:8 ) 8^ BHH 8:/ :H%H^
HBJ=@B:%J^>BrHH1t=H3H:>+BJ:B8:HB
/}]NI[\~beH@HBe@O/cB:@H8J)y3^/
:38HnHeHH)O=H8H:cB_8
8J6_H8J@6nHsHH@naB8Hn,@ORa8^H8RH8eHH8vRBHJ@

Hn:H8:@BHB
I
B^@)JBe/@n3t6JH_8@HHB:e8O/na:8O=8^6nH
8JO6:@B_
^`baced
fgih/^`baced>k
jgDl
3.1.5 Formato Padronizado do Mdulo
B 'HO/BH :8tR)^/B3 3 mHO/B: BJ@@H )ORB 3 8

6HO/BJ+:8t/)^/B3k-HH:88u@HB-H@3:H@c6Bt6H-@:BH@@H
HJ:8HO=8@:@BYJ3eB@3t6HJ:BH8^)JBHy3^8^BB@3jH/BO/:
HBtmJ8Hb=8Htp^@:q@O68^B8O=H8BH)j3J:@B:1t=8^/H8j
8 :8tm J:) H B8^@:)@H@O @8t=)J/ 8 m@O/BH )B:
@O6:8JB+^@+6@t6BJBBOT8^H@H8t6rH@+BJ:H)B))J)J @3Qr8B
@-3t6J>BmHt/BB
32
/BO6: @6 8^H1t=@@3 H 8 BJ@@B :)tR8^s/HB B3 :

@B^BH8J@
HH:@BhHBx8@HB8x)^)HvBh:8t6HHhw)HHB)x8^8BvH
L B@h
:@B
HJH8Bnn8Hn@8O=8^6n3H^@BBJ_BJ:88Je8Jc
H@B@cJO'HH
L BBe
H^B@r8r6@t/3J+-+:8:3HHBr@HBr8:-3^8B-H-@8ORHB-r8:
8^8BkH>@:@@
3J3dB@
L @B 8::H8tH8=):D/8HH H:B@38xHH'@H:B ^)^BB 8Bs8B^@)jt6BJHHH :B8BJB@:@:HE 8J6:R8:O@=BBj
jH:)^8
@O/D):8HrBr@@8H-3HH@@B
3.1.6 Estrutura de Controle do Programa
)^H)Jx8H /HH@8BHwB@BHHBv:8O/hB^BBJ:8B: Tq3 8

6HO/BJ @8tR8^/@By@ HJH@B /3^HHB)J HHH@B T 8O/
BJ:B8JOYH@+@HH@3
B 8^8B 3 ^H8H H :)=8^6 B )^8tKJH B 6@O/BJxB)H
H8^B@:H8+^B+-HH:@3,H)BJ-+HJH@3
TW
4d8:8B--HHH@B,H8BH
xHJH@3 Tk 8^%t6JHhBmHt/8Hxx@@H@BBBb 8O/vt
Tq
8J:)HQ3
Tr+:8H8B::B8J3BQ+^@@8BQB8Jk%H^@H3H3@kBH:H@8B
@:H8+r3^8tmHH-HJJ8H-3+HJ:8BE
jBJ:@Brv'BJH@BB@BHHB6qH:8B^H8H3c@Hq%H::@3
Ty'HJ@@B
H@BHHBJ>++BJ:@BP
T>H:)B^H@H3r:@@8-B+HHH@BU
=HBHB@:B mBt/: @/ B:8H H 8:8t'JB @ 3 6HtR3J
:8tR8^6@B83
)^H)Jr)-r%HJ:8H8+@J:83a/@@ 8)r6HO6BJ@8O=8:/H3
LL
BH:HH83kB-6HO6BJ+@3s>8HJ:8OT8@++HJ:83a/H8
8^8tmHHaBe6BO/BJaB%sc@O@:8@HBe@O6e)aHJ@@%y3b8:
L b
8^8BkHD:8tRBH-DH3s+@:YB-BJ@@Br3r@:+)^8HH@@@H
8^86JHw/3@t=@n8BJ/cBnBJ:@BbB@BHH3t,^8@@BanHJ:8B
L
H@BHHBr)H^@@3J-DBJ:B@@B
H :H8^3BJB I
@J:8B @@:8 3JB B8BJOx HJ@8B 8: ^
:H@Bu)HJ@8B)HHr@8BJYrH,::8B
3.1.7 Documentao
B^H8HH8J@@B 8J @d6J :HB@HH@B H 8 6BO/BJ 83d

:8tR8^6@B 8B :R8^8H O/@ B)s@H H 3H:/B:H@3 B
6HO/BJ
sB^BH
LL
6JHH@H@8Bk3r6H/BJ
HH8=H@3-Br6Ht/)J
L
JHHH)J@HH@:3H)JjBR@:88Jd@@BH:HqH3:H:@BBBe6HtR3J
bHJB:n^yt/BH)J@H@3h@@@:H8=8^bBO/H8)B^/H:H83h
J:H)J:H88
33
m6C.mgpp8m#f" p'"It$&)(m
8O/ @ :3/3sd ) mHt68J @:@@@@O=) @@H8O BH^B@ B

6^8HBJh@wH:8BHO/BHx@Omx8Jv@H8^8BHBv:@h8BJH8JBBtnBH
@:@B B :8J:)HO 8H :H8^8BJ8 H%s JO ) ):/ :H3H H
HH8O=H8HH @B Y:)^H@ HH8HBJ '^R@@ ^@ 8^3HHH@H8J3
6J@H@BHr)r6H/BJ>BJ@B8J3sB
)^H)JB @H8J: :@)^@BH@H H 6Bt/8J@@B ) J=@H3 B^@@BJ:)H
:8J /@H@B :B8J3J3 )JH3 @ B8JH@@bH^BHJbB@B^B> `
T= a
TJm@

e/e

:BO=8@

H:HH@

@^)JHH@BHuB@HH@%H
r1t6:
r1O6O/H
s@)J
OBHHW
RHJ@@H^
RHHH@H^ O ^@O6^t d{ H:8^%s:
8:H8H 3O6 'JBB 8^8H :BHBJB:@^mOv ^H8H:

^H8H:>:3t/:'J:B>H D1+:H8^8B::H8
HJ:8Hj3t6:jB^38JB^H)@^j8H^3@HHBO6::@H)^H)J@HE8j^@B8H
8 BO/ @HH 8J @: :H)J@BJ@H B8:HH@
)/ :38^@BHB n)
pl
:8J3 @BH8^B%s:H H@=H888J:a ^BtR@@@H3O/: 8H 8BJB@HH3t/@
B^H8:8J@ H 6H6BJ:83 :H)H B:H@@@8J:
8^=B@c sa j^8:
oB^)H `JJ:)H:%^
BJ 8J @O'J B^ 6HO6B:: :6:@:)HHB^ 8 JBBH B^ J:8HHH
8^@@@H:88rk sa I1/@:a 68HJH@BH3t> U3 H)^B^H8:8H-H
6HO/BJ@BB 1/8: :HH8@@)s:B @ H8H=@BH

{Lu@^
/8H:H@HB8t s8>
ee 8H 3^H8:8J Lh@^8 JB^8B :BH)^H%s:H @
H8J=@B
d 3JB^@3^ @B8^86HB^ ) HBHH @ )^H@:1t/B B 'Ht/3J:
H8^8H:8^8:@B:8Bj:@HH)J@qH:H@@HB@:qB:H8:8BHB )
H8H
:@H@@vB6:@:B@3J:)H H):8^@HH8xw@3Bv:8t=):6:HvHBB^
8H^BH+H=):H>8JB: ^dO/>8HJORHB:H
8O/_HH/%JOq8mBt/BJ_/:HH8BB^y@@HB@3J:8:_Bb)bH:8BtqH
JBHB@BbBOmJBJ@388B:H@HH3td-8 caqprdfsa,tgDl_8u
fdvw-xxDdOl
Bt6HHBJ@3J+^@%H8HyJBbB^B8^@BhB8J
H3H@H8H6H:8H@BHHB
d^H8:8J>H-B@@:)JB3d8:@8HP
H8JBO/@BcI 8^)
HHxH:8BtyBwHBHH )JBB@^v:B/%sy8xJhH:HO6^B)J^:@
H@BHBH^ ''^B)J: r/:8J O 8HJH@BH3t 3JB^BB 8H:8H
sO=8:H@ B:H8H:@H@ H OHm^ 8:)sO63 H6: BH: 8O6B
H^8O/HB: @8J H:)HH :H8:H@HB@ JB ^8 @ H 3^HH1sB
@H:)^@:BBO>8tH=1^:B6^@8J8JBB:
8H^3@HHBO JO6 Om^H1:^ H):O6JB:8O=)^ H@%JHBJ 6^@1J^
^/ H3H^ 8 @d/ @BH '^H)H B^)J 3HB^H8BB cayprdfsa,tgDl
8H^BH@n^jJ=8^_m^H)JHj^/ HBB8Hb:yBB@:8HB:@:nm^=8:_B
8H^B@HH3=@++O6JB)J+BJ:H)J)sH
fdvw-xxidzl ) :@@H@3^1: 8H ^@H 8:HB)sB BJ:H)JO
6HO/BJ /:8B R@BB @@H) @@H3 xJ=@:B@x@H8:8t/On^
OH6:>^8>^,Bt6J:3-8@HBJ3-:/@8:+r6^8:H)rH=8:@3
34
{| }~; y-e ;
{| }~; y-e ,
{| }~; y-e
{| }~; y
{| }~; y q
{| }~; y
{| }~; y {
r38Jtg-Z dm^@:B8-H=8@@B-Hr)k6BO/BJ
4d@:8Bn_O6^@1J_BJHB8J3s3nn=@H3b_8O6^QBeJH8Bâ6^H1J:
B^8HBH@:BB@B /:HR8^ t/H@H8^ 8HB J@@H H33J:H:)J:

O6^B)J^vs/:HH88@Ojt6J8H@HH8^w8h^8vv3H^8J@)JwH8BJH3H
1)
sH/J,m^H):_:@nt6H@H@HeH:B:n:8H:x6:H=8:)Hy^H)J:
H8H^H8@:@3a^)O6^H3J3:@:8J)^8J@dr@@BJB3aB
QrdjOaced
HBkHHH8JBB@U@H8:H@d=8Ô6^8)J^>:@r8^@@)^/)rkB^H@H)J
Hr6Ht68J:@3--Op^H)::-)BH@3t'J:)J@>HB^)/O=8@
m u " ,K,q"Hm,' #%" p'"ItHK
d 6BO/BH: :H=)H^ 8 :H8:@8J3

JO/@H 8^Hq6:H8^)H:
n)
l @3J@B 83^8J@ 6Bt6:
3.3.1 Regras Gerais
a=8H:R:HH88@O,R3HHQH8mHO/BJkB)
oXH)JQ@O,
:HB@B+H:HO'
@HH@3-H:BORr3B/:BH8-@OYH:@B/HB

@BH8H8H/BO/
O/ W /Q~Q/}N_+@HH8H@H1JB8OB@@HORBH:
J:BOR :H@@B@:H@ja@BH@Be8t-:8Hje6HORBJc8HJ@8ae@O
BJ@H8JB3
)
)
oBHHH@Q:B^/8H8J:Q@3t'BJHH83HB:HB8::8Hq^
@Br@Of Y3JBtmJ
RJ:)H :@@@B @3 8^)J @OI Y3JBtm: H%s:B@ :BH ^@ @B
B^B8JB@Of YB:BO6^@B^8@H:HH@3
8O/qHH)cHB^3@@HH%/
/:8OmsBB
;~|{xt
BJ+:HB8Bk+@B^/+HB:)^3HHH8tT)@YHB@3s@F

O8BO/:vH:
HBHBH:x^B HHBBH: 8B t6BJBHH 8BB @6:8J/@
:@BO/:)H:
Q3t6J3BkB>JBHB--@)t/
sJ3^>:+8HHH@B^+8B+J6JB@HB:-8O
P{~/}>~UJyONIzQ/
~x@UsOR@)s:B>H3JBrBH@@HO6BH:
Programa Exemplo: funo main()

Descrio: observe a estrutura da funo main(). Neste exemplo a funo
no envia nenhum parmetro (a palavra void entre parntesis) e no
retorna nenhum valor (a palavra void antes de main). Logo em seguida
35
aberta uma chave "{", escrevem-se as variveis, operadores e funes e a

chave , ento, fechada "}".
#include <stdio.h>
void main(void)
{
//variaveis............
//operadores e funes.........
printf("Eu no fao nada.");
}
3.3.2 Palavras reservadas (keywords):
@:)Hk@3JB-BB^8J8HH+@BB3/:+@@3J:>BOBB3^@BH3)
oBHHBH8J
sO=83sH,^@BH@B+B@B@OR)8JB-8^8:8HOY:)::-8BH%/@-@
Bt6Hr8B@kBO6BkH3:HHBB:
8HH%/:/:@psHH:,-HBH8H@H:+@H@@8BJ:8:+BB83^/+HH:H8@H:
8H-HBt6H>^B HHH@3:
break
do
if
switch
case
double
int
typedef
char
else
return
union
const
enum
signed
unsigned
continue
float
sizeof
void
default
for
struct
while
:Jtg-Td3^8JH+@HB3t/:/:8OmsBB:BUOBH8@@BJ3)
B
3.3.3 O comando #define
_)HJ@@8JHH:H)j8^8@@HB8e8O6HH@@H>8@H:8H@:B@BBt>8J
8t=B8 8H^H)HHBy/@HH8:8^He @B@8^@@B@HBy@HB 8t/B8
@HHEsH,^@Dr@H:1^@:@8HBOYBtY:@8^)t6HBr8O6^B1J^8B:8J
#define identificador string
Exemplo: #define
#define
#define
#define
#define
#define
#define
#define
#define
DOWN
ENTER
ESC
FALSE
LEFT
RIGHT
TRUE
UP
80
13
27
0
75
77
1
72
3.3.4 O comando #include
HH8O=H3H:H@BH3t_8O/:@vHHhHH@H8v8v:8t6d6^H)Hd88:8J
:H8B8BrB^8BH-Op^H):+^8+:8J+@:@BO6:@3--8HJ@8B BH@:@8
36
#include <arquivo "header" (cabealho) .h>
d @O6H8JO6@ 8 8B )J8:@HH3^ 8t'HHBJ@)J @O6 BH@:8 :

O6^B)J^DHrBB@:8HB:@-8HO63kB
dk8O/:8BO/: D@B8J@:)HHB:k8tpJHB:@8Jr@O6rHH@8HU6^H=J^
Hr8:@:8@:8r=@HB@-@@3BB@O=8
8HHr8Bs@H6JH@B:@3kB1H^8H, ER:)HJ@@H:B8@)Q8^B:@H
BHJ@H@B
3 E)Ôp^H)::B@:@@@@:8
#include "arquivo
Zde
"header" .h"
Exemplo: #include
#include <stdio.h>
#include definicoes.h
/* header padro da linguagem C */

/* header definido pelo programador */
sJH@ : :HB8JH @:BB@@ BtR@:@@B: 8BB^ H@/H@:)J: H

8H^B@HH3/:3 OBH3:@BJ3 )
o:8JB8^8J8H:vB HB@@8HH:@:w:@
@B BH@HH8H: 1^ mBt/BH@ BO/3s@vB )BJ:@3 o@tkH@)
^@:8B_:HB8B
ryB@HByHH@B8HJ:)y8tH/HB8:@B:8JyB3J
@OTHH@@@@H
Programa Exemplo: Incluso de bibliotecas

#include <stdio.h>
#include <conio.h>
//para o printf
//para o getch
void main(void)
{
int dia, mes, ano;
dia = 26;
mes = 05;
ano = 2000;
printf("Agora ninguem me segura!!\n");
printf("Meu primeiro programa!!\n");
printf("Hoje, no dia: %d/%d/%d\n", dia, mes, ano);
getch();
}
m #mIBKJpIKm
H:8H )^8B s3H^ 8@J@@O t/:8H:@ 1H ^@ @ H@3J @

H@BO6JB:@@ B 1 H @H3^B 8^H8 :B:8^8@@ @8t/8H^ B
8^8HBH8H:B8J@bH@8tmJ@8J@-yJ:)t=8bH@8J:B83t6H:8J:eJ3
Bt6HBHr@8JORB8>8J@38@H@H@@:B@BH:
HHHj3J8^@BH)Bc3jH=@B8e)^8JH3@^q@H8^)O/O+88Hj
8HO6
HHH@3@BBHHOR8J@UJ^@-H:8/ Hk3B^/
u-/
Ld:@r@3J
@3^HHH) @B@8^H3 8J8^8 % H/:{ H@ H@8tma8J HO/@/ H
@O/@H@x:@x@ 8BJ@@
O
O- R@8J BO/:{ B :@@RH@:Hv@H 6:88 /3H w^Bd8HBB B:H3B8O/ @/ H: G
8BJ
HO/@/ H: 8:8O/3 - ^B8BHt/3JH
L@@8 /:) H^@ @:@@
_
HHB @6
% )i%uy:G
% )i%u:X
RJ:x8@Hx BBb
:H@3k+8^KJr83Ht/@B'HD^@@@:H J^8-@B:@+B3J:@3HH
37
v@BH3/8wB@8t=8Bx8tB6:H8^8H3h:H8^HwHH)^8^@@:H8B:
8HH-)t=B8+H8J@6q/H3ne8H^H)
4d@:B3y@_=@e8y6Ht6BH
H3s3b8OH@H3:^^H8:eBe@HB^jH@B^@B3^ce@HHtR:@HHBj^8
@bH:8 H /@6:@@8HOj8s6Ht/3Jk@888^8ORO=)8HHBH@O/@@
HB^BH d'HHBH:)@^ 8HHB:O6:H @:8H@8J H8B:@ B%s:H / g;dzlj]cg^
8tkBJ3^@BHHBn:HB8Ua^H8nBnBHBv/HBHBJaJ@@8^@HBBaH
JBHO=@DJ@DJ@-@O8^B@@HBBr@O6>^@/BOX-HH8H
HB B^ ^B)^ B HH3@ /@HH:H3@B^ 8@H: :B8^8BJ:H B
6HO/BJ@BB 8:H3 @@O/@@ : ^H)^ B HH3^ HB@HH@8^ BHB
HH@=8WJ:>@8J->8r@HHB)H-^8-@Br8O/Dt68JHB@@8JDJBH8
LBH:-8:+HBHBH/r3:>:B8^BHH3^+R8^)J)J^
3.4.1 Tipo Inteiro
>HHHkD^@H3^8OHBBO6J:8%H8HO=@8-^@@OmJ@H@-Br3^/
:B8Hk3^
8J6^ B8H:'^ )JH:8B @ @BHB^)H H3B ^ 8^H3^)J

BJB:@BvJ8HH8^8x8BJhHO/8/H:H8Hh^8On@@HOnJ@:8:@HH3vH
HO/@/H:@v8J:Bv8H:/HB@wx88JO'H8JB6+dHH@HhHH8J8B
8H^/ % D BO6:/ HB 8 HO=@@B JH8H J:8: f D HOH6HH: H
/HOR8JO6H8J
3.4.2 Tipo Real
BHBBt6H@8J:_B6J:H):8J@_38^/:@8BbB:8Jm^w/H:B+n^
sHBO/:v8BHB @_@BH3^)J@H@3^^h8^B8:)J^QBvBJ3^@Bx@B
sHBO/: 3 JH8 1@BH 6:8 B 6J@)H $\) 8:8 H:
HO/@/ H:y' H1H4d8H8^@Dt6:@HBHq:@/@HB@H8HOm^:8^q
d6:@HBO/:)HO=@H>8k 8Jma/HB
H H:H8B H 6HO/B:: H8HB 8 8^3B H:H3JB B H)J: H
d6:@HBO/6:/:):8JT88JOmc/HB
3.4.3 Tipo caractere e tipo fila de caractere (string)
Bc@O6:3JO/c@B@HHB8HHH@BO6@HH:83J:8BjHH)Bt6J@@Bj@
J:8O=@B:hHH)J8J:k:h8HQh R@/:8@8J:@)t/@@H@hH)J
HBt6/ 8JOm^H3:8JB:BB:H@BBjB@H:@3BeJB@HBH8J@8H
/:6:@:):HH8tr_ `JH:H@B::B@I
W hq dzlDap tpfzl,f gfdjgDl
8tp
jgz8l;Q)t:ag/ p:H) @ptdzHlr,`BOp-6xi:d)8Jj
vHJH ^8H8^8OwH)Bt6J8@B 8H^8H8J
m:rHBH:@)JO=H1âRXuB@ H) bHk: H^
@O/@8JO6H:B8:H@:3j

nBHI
B^/:B:@:@8j)jJH8c8O/@8JO/qBOj6HBO/@HHBH3a33s^B8c@8O
nZlR:H8H-H):@H:@>@ORH8@H@^83)HB:@B
W
%
5
5
Caractere W
Smbolo de porcentagem
Caractere 5
Isto no um caractere, o nmero inteiro 5, pois no tem
aspas simples
38
sO=1^ ]N_/}]NI/ @B 8H3^@H3: |/ R) BJB:BB

@ HH%/ /]N_@ J3H: 8 sB@txB @/:)HO/: ^ 3J :@H H
@O/@8JO6HyB3J H8H B @/:8J6: 8^B@:B@@ 8@B Iaq
:@HhBw8O/@8J/Hb^8=B8vB3sbê@B:/h:)O/h@HB::H3H:
a )kBH8RH8hb@@HO/B)JH)@O/:%JO/_H:8H)h
8JOmH
a `JJ@ 8BH 8 H38JBJ
4d):@B 8J 8t=38 H:8HO6@B H%s 8O
H@:B@HBa_ 8H6nHe@O6:)JO6:^@aHHe8HHe8^)HOZ
|n)y: `HJ
@O/D8/:8H/rB8B
4d@:8B
Exemplo: Fila de caracteres - strings

szFila[12] = "Linguagem C"
0
L
1
i
2
n
/N;[\a~
3
g
5
a
6
g
RHBHt=8,dHB@BH
7
e
a`JJ@
8
m
10
C
Ip/H@6-+@@HO/B8J+BF1F/8=B8J
byte
string
char
4
u
0
a
a
1
\0
------
F)F^HHB _`HJ:-3+J3Bt=8
Ipl r8-H@OX+^H8@-@8:@@+-a`:J@DHBHO=@
HJHFa/} |{z
F +JOmJH@BH)tT8k@/:)J/H@8F F
]N
@3^HJBH:>HB^3H8HB^83^H3t=B8:
laranjas
Marga Rida
55.67
55.67
;
Um conjunto de caracteres em fila formando a string

laranjas.
Um conjunto de caracteres em fila formando a string
Marga Rida. O espao em branco TAMBM um
caractere.
Um conjunto de caracteres em fila formando uma
palavra no numrica 55,67. Isto no um nmero.
Isto no uma string. o nmero real 55,67.
3.4.4 Tipo Lgico
B-HJH:>:>t/@@@HH:,^@+:HH)JBQ8@:@HB^Br:)HHB^t sO6HHHB6
^ BH:8H8D^-83@%J+:-@B-@3J
j:H8BH^B)jQ^B8Bj8H^8BjHH)JBJ@QHq:8BBJ:8B@@)^@:BBB
O lg
68^8tpJHH8O/:
BH:H)dB6HORBJ3J@H@
^
J8O6^
^Hm^8^)6JHB3t/:w
)t_BHB^8Ba) @:B8bHH1s@HH8O=8tnH
8Jr@:)J-H+B^@,s:,JO8@:@:3^@-H8HHBû@@)JkB8Jk@@@@+^
@:8H8Bk:):kHB@@ Q:8-HrHR8kH8HB:H8OmB):8JBJH8Ds:
JO:8:B:yB:By:8:BB^+@@:H@mB^B3^Hn@)HyH=)bê
H@:B@O6-@B-3^H8^3>r@8-BrHR8
B 3J3^@3jH^@ )HH B3Ô^ @B B3s: BOR:/ 3:c

HBH @
sO=83s:B)JHBBB:H/@@:8:yB^@y:8HH3^yHHBy:BH8HB:@@@@
B^HsHBtm:xH3J=H)^ q RHO6Hw^ /8H /:H83JH@3 B 3^H
:8JBB^+BB Y:):H8^
r' O k:M
L 1@/J 11a/:B@:)J)sBH@8H
39
11
\0
t/H@BHH: B ^H8 BH:38 RHB:H)^@3^B@ Bt/%J: 3 :@OR:)J:

BH^B@:y8HH8hBBBJ@68^H8@H@H3tcx]dvDl=fdggcda:@
@O/j:):@HH@c)_s6H^83_8HH8^8BXdq^8O6HB/@c%H^H):a6^R8^
H
O3H8^88JB

ou@d/Br@8^8BHB^+8r:B@B+H:8H-@:B)^8B
m m+" K
BJDsO=8%sH-r8J-H8:@HHB+H:8:H@@Bk+:@O/BO8HB88t6J@@BH
H@BO6JB:@@ @8HB 8 :8HO6:) 8 J8HO=@ RBHHHBH B
8H^B8JH3J8jO6HHB:@8a8^8H @B
86jH:@@@8JO+6HO/BJB@B
8JH3H^cHO8_8BJac:8Jj:@@O/:) Bc_8^B@H8HeHJO=@3^H
HJHwsB J8 8wsHBB:3@ 8:@H@HBB @R@ B@@:B@=8 @:Bb
:@H/:8 :@H sHBtv BOv8^@:8H@B :8J/@ @8@Oh^@:)H:
a `JJ@@@BtmH:@BD^HHB=@
BJEsO=8)sH+8H:)^8J+8tut/:+@6J@
BHH 8HH :B BOR@HH8B^ B @@HO6H8 ^8 :@O6H
H@3t6J@8B %HJ 8O6H@BJ:)J %^@:BH3J 83 Y:)JH@ H

sOR@3sB8r3^8J3HBk3r68t/BHp 6
H)n3aHH3 Uj^H8eR3^8^1JaHJO=@%sBE8@eq^8HjHH
@O6 B3t6J@8:@H 8 6HO63Jn^BH8:@3 @H@@8 B JBHO=@

H:)^H@B3k+@Hp6
H@3t6J@8B >g
6sBBt: ^B+DJO=@%JH-mJHH@8
HHHheJO=@)JHb^H3@8HB@:8w8_JBHO/@-:8HO6@3hHbJ@)J
8JH@O:@:B8HBk%kH8:8J@>:H8:@8J:B>H6B/BJ@8B
Varivel
er e
End
r38t
Nome
,
o
I n 1@@f or
/:@:ma
1J:@B+
H-)JDJOR@3JH
m m$#%" IgIp+&)(IJp'1#'g@pJKpKIBpJpq,pKpIK#+" K$"It+&$(I
d>:H8^DH-BBB^-):HH3:B%sB8OT:BR8H:B-@B:BH)J+Bt6J
Sintaxe:
tipo lista_variveis;
d@H
}|P{~H%^r@O8-@H8rH+BBB+sB:BB
caytzlDay;daq )J+J,J@B,sOR@)s:B+@:8O/B8^-)Oudm^@H
HBj:HB3@H@3O6JBJB@X^ksHB/:B8J@mÛ8O-%JB^@3U8B
sB H i e b JH3t B@:H@8H B 6HORBJ:@% ^H3H @3
8^H8:H@3cH:@8@HqBc 8J'aBB8^qH@H3c@qHBb/@/:@@8J:3B
)tHH)D@O/c@BH^H8aBaHH3n3^H8:a3Jc@:8He8JHBtE8BH
H^8O/HB:@:)B
40
Tipo primitivo
inteiro
Tipo em C
int
int (16)
int (32)
float
double
char
char
int
void
real
caractere
lgico
Bits utilizados
16
32
32
64
8
8
Bytes
Faixa de valor
Dependente do sistema operacional

2
32768 a 32767
4
(21474836471) a 2147483647
4
3.4E-38 3.4E+38
8
1.7E-308 1.7E+308
1
128 to 127
1
128 to 127
Dependente do sistema operacional
0
Sem valor
@Jt 0 Y@8^>H+BHB:
bsb 5
n:H8cH8:@6aH:8:8H:3HjBeH38JBH^BO6:B8^8Hc86jj:8H
mHt/8H-)H^H@8HB
HQ@H8^83JB
n)
pl8@HH)sB@@H@O
F%@H@ F>3HH6^8H:)HQH8J
:HH8BT^ QsBH@c@@B:B@OR8e8:H8O
F3@HB FQ@cB@@@O6O+^8
F3@HB
FQcO6:8H:)HaBjHHB@By@BH%/J8e38^H8@HBj
F3@BH F
++^H8
f7KsH@3uB@3J
^B8 B3^H8 tRH:8:8B @/ ) ^H) /zN^x^H) |/} @
:H8:@BJ8 n)
lH8B Y@8JH@HsO=)3sHU8O/3U@@:BjJ@)J
8x8JBbJOj3^Hns@Bt6:-h^hI
G|azQ/z> {~/}ax~
XQ/5XQ/]N {~iN x|/]N_/} x /]NI~

XQ/ ax~U|/x~{Z{PzN_\~z|//
|{z| |//
]Nxx/|zNf~
double
double word
word
byte
bit
float
int (DOS)
char
1 char = 1 byte
1 word = 2 bytes
1 double word = 4 bytes
r38Jt%Dd3J:H)-BrH3^,B^,^H8:+H+BHB^
m8)(gJKpI'"I'gE0
m :'p'Hpa ' "
)JH3
@d BHHHH8H: H:86 BOR H: :HH8B: 4d@:BB @B
HH:BH@H@ Bt/ H HJHH : :HH8H:eHH8:BH@3 :BH@B J:HR
:8J@ s=@)s@H @B H@B@HB: H Dl]ay;dsa c gvbaq 8JBB 8O
H@HB:3^@B3^@O@O6:+B6Ht6B:
4d@:8Bx8BvBH:BHBH:H@8tmvBw8Jh8HH@BQHH:b@BwHBBJHH8H
Dliaq;dsaqgbayen3y)JH8y@OB@HH:eB@8t6yBB:@H3y@HH@3
8J sR@3s@ B^@B JB J:)H 8HJ B 8J J=@%sB JBJ8H
@B^8HH+HHH@3-Dsd=@3^B-3:@H+HBk6:8HH@HH8-8^6++HB^@H
HB H @d/B H@@BO/BHH 3 8t=8 3 Om^@)J '@B^8:B@ ^ H
:HH)J:T:ksO=)3s:Bj3HHB@O+H:BHO6HB:@HH8JHq@Of YBJBm^
Bt6H:H>@-:BB@B
41
3.7.1 Observaes sobre os nomes das variveis
R^H8H: sHB: 8B 8J@:8HHB@ BB^8J@ 6Bt/@ B 8HJHB@HB^/ B

sO=83s:Bx^8 H:B@@8J8 wJ:B8J:H3B x 6J=8 H@)^/ H8
6HO/BJrBB@B 6BtR:n@=8J3Ht/8:+J:n:@8J@yB:/@@:bHBH3
^@:)JBHy):@:@@:8H:_@/cJ:8HOQ^_8JB8H^nB:)J:cJ@H_H:8:B
H )^@:@3O J:8H H:8H 8H 6H:B^1d8HHB H 8:H
6HO/BJB8t/: 3H H:):: /Bt6@ :@ /HB@:)H B 8H: H:
sO=83s:BYjt/8@H:)j:@H8H^@BBH:8Jb/@@@:8BjB:y/@H:@BBB
8t /N:/ W |{~| 2)H3y8y@@_O6^8BG
Fzl=g-xl=5Sfdptajadzlbayp-x
gpdptOaqgpFtv^^H sB3^ 8^8:@HO 8J 8HH@@B 38^8:B:H@HB B
/HH@@B-8^-)BJ:%^-BB:8:8:H@H3tR:
sO=8%s:H B :B8 B8::m @3:/ )HJ:88 8@ 8 p
^H HHH83o 6
s=83sHH B ^H) BO/@8HO/ BB:/ 8H@:@B 8@ ) p
^H HHH83o 6
bJO=@)s:Bh8w^H8 /HH@B^6x8HH:@3 )H 8 7 ^ p
^H HHH83^ HB@:@B:8B B /:/:@:%JB ) IHB@Bo 6/:H@@3

H8:@H:8D^
gB^H8H E':B@@/@HH@3Hp 6
B 8 ^B8 3@^H8 @B@/ 8@J@@B 8H 8 p7
/8BJHH@)J+:@ HHB@3-H:)H-@:@38H@O^-)rH8p 6
_Ô=@%s:BB^H8v@@HH@O/:)JOw6)t=H):H3^Bw@B:/
8HH:@O8Hr3V
p8p f tRH3+JOm^H@BB-BG
O6H
LBBt/:D@B^Rr8BJ@@Br)H
I
n
p
lROH6: `sp
RJBO=@H@+@B:/r)HH:@3r8@ no
l6
)^)J:m:-@3J/8BJ:8Br3B
np l6
bsb 5
d 8BJ:x3^ @BH8^@@B@HBO6: IsO=@=s:Hxx:HB8H:@B3s3 @BJB

HB^)J:qRBt/@+@:H3@:8-@B8^@BHB)
pH
=8J@68/:8HO6-B3Jr3OBBt/E^-@B@:HH)HB
d @O6@8JO6: 8B^BH)J: H3sB @O BB/: 8BO6^ ^
HH8:HH8BB
d
=)J:m:
'HHH:83JBO/@8JO6@j8BaH8^H8@H@3^1JJb/8HH
@OXHJ@8:H@B8J
sJB:@UsORB3s:B>H3JBrBH@@HO6BH:
HB :BH)h 8BJ H )B JO=@%sB H3s @ B)^HB@H@B^1J 8

8^8HBHHy3yH3Ht=)BH>H3H3dB@n%d8J)HJ:n83H v
N M
>B^H
8^H+H8Br:@@BH@BJDrBB:8:8:H@:8BrBr6^)^H)@kHs=@%sH
Exemplo: Declarao de variveis
Variveis tipo caracter
Variveis tipo inteiro
Variveis tipo Real
Variveis tipo Lgico
char cLetra, cSimbolo;

int iBase;
int iAmplitude, iExpoente;
float fPeso;
float fSalario;
double dResultado;
double dAngulo;
char bAvanca, bCalcula;
int bPassou;
42
m uKp ' &)(pH'>'" E
)

o8^HB)JH-B=8:@Om3^>sBBtR@k@Omk+J@8tR@-BHDs=@%s@H
BkH:8B-JB:3B^@+:rB8@HO6BHû8J3:@:@38rHH@@-Hr8:@H-
8J8^H)::8JD:8Û8@H-BEsO=83^H
tipo nome_varivel = constante;
Exemplo: Inicializao de variveis

char cLetra = 'a'; /* um caracter, declarado com aspas simples*/
int iPrimeiro = 0; /*um nmero inteiro */
float fNum = 123.23; /*um nmero real (ponto flutuante)*/
int iHoras = 12, iDia = 13;
4d@:8B8>JBDJ:HsO=B%s:B>B-H:3H+^B8r@:8u8HB^3@8JBJ8^
H:+@+HH8J+@HH@@:B/:83d8:+8X^m^@B:
m u6Ip
IIK
-)^H8HH8J:D@B+HHBtR@@)H^>:@>rmHt6BJ+@Br)JB-BBJO/
-)^H8HH8J:D8JHB@OHD:@HB^8O^B8r@@HH)
bsb 5
b8^B8J:8@:b@B)t6:H3J@8JbBH:H@@B:yBO/3J:_Hb3^Hb3HJ:8B:
H-@H8^88JB

oH

x|//+
~/}
Exemplo: #define e const para constantes
#define PI 3.1415
const float PI = 3.1415
dH@ms_^@
x|/@Bw%:@:@B8HH8@H):@H@3J:8H)J
H:@BO/:88 3 ^B8 B J/@3JH :)^@H8B :@ 8:8@@H:BB B
:H@@H@:BBHBt
~{}kB^)J-+H:@@O/@@3Q3-^H)kHEsO=B%sH-+H8
BBH@H>Hr):@H
('
m dIK I6'"IBKH#K
vHJ:8:B@BBtaB:H8hw )J@:@BHBw@/hH3HO/OxB8:HB:H@H3hB
^H8 @:8HH:)H:@B^1 s=@: :8:H@:%J: B ^H) @:8
1t
BJB:@B@BkBJH8Hk:)8Hr 8HO683JBJ)Hu@B^B8B^+@BJBJ)J:>^
@:8 @3J3^)J O)H8 8@H:B@ HJ8@:H@ :H8 @@8 B @)
@B^B@BÊ^-8@8@d/+J8r83k:@@8:BDsBBt6:+BBJB:1J:
b^@HH@:H8BBt
|{z/xH@@@8e^@nB8yJ:H_38^H@BH@3^1JH@:B8
8 HH@H @B 8 H@Ba sOR@3^H J3 HB@H_ ^@H:8:HBBBt
|az/xjH8:B@^BcB8B:HH8^@8:H@3^1JjH@@B@q8BHB@B
8BH@HJ=@3s3--) )JO6r@8BH8H
^@H:8HH@BBt {~DN_} :H8:B@:H8 ) H8H:6 B B H3^
^@H@@:H8@Btt
{~{z :B8:H@HB@ 8 H8J:6 H B8^G
)J@B @O
/:8H:@3JH@+@HH=/:
|{z{x-^G
|az/x
43
Modificador
signed
unsigned
short
long
Modificao
c/sinal
s/sinal
int de 16 bits
int de 32 bits
s:tfDSRHH:8:H@B3t/:DHD^B8
Tipo
char
unsigned
signed
short
unsigned
long
unsigned
char
char
int
short int
int
long int
bits
8
8
8
16
16
32
32
Faixa de Valor
-128 127
0 255
-128 127
32768 a 32767
0 a 65535
(2147483647 1) a 2147483647
4294967295
:JtH-1:B^@3^>HDBJ:3:H@BBt/@
Bytes
1
1
1
2
2
4
4
m #%" g)KI
@ HB3/vB^/8H@B BB^6Btm^@HJBJB:3^H88J@8H @:8J8B

8^@@@HH3kBk8t6^8B:k8O6@H:HBB^BkOmHkDHJ:)J-B+JB@JBO=8
RJ: H 8J Bt6H J:B HO/H B^6@H8J@ @B 3H:HH8:8J@ H
sO=83s:B>%^H8J@)J:j^86HBtR:^@^8@@Bn%sB:@B@@hR:H8BHB
8sHBtd Bc8^H)O=H@@@q@6^H^8O6:8HHjR8:8:1s:U8BH
HH8O/:@3 ^@)^H@:3@:@3 :%dH@3 B:6:H)JH 8JBB 8
O=8BJB^BB:hBH:B@: :)JO6:Hx)^d/:H8B: O=8BJ8:H@@ 8B :
B^6:H8HH :BJBJ%^H@: 83 /@H@B:HB H)J=H8p 6 : B^/:H)J:
BH^B@: 8B @ B:/:H3H: :)^@H@ 8 @:H):@B 8^' HBH:/ H
T8HJBp
6 : B:/@H)J: H8JO6:H 8B 3:/:B)J: ^B H)JJ%sB
J:HBH@H@BB H 8O=B8^ 3)J: @B^)H: /@BH@B B ) )^/ :@8B
HH:B@HB-Hk@@H8J@H-:H)@@BJBV
)
BX8H3Q:@HH)J:,J@cRHH@@BB
8^H8-3H^@6:@B+Hr3O=H):
3.11.1 Operaes primitivas
Hr)H^H)::@B :>@@O/H)J:D=8^)^%s:,HB-:+BB^HB)J@6Bt/:6
:B@B BB8t/H8B :B J:)J /@/@8:8J:3B BH8^8/HH 8
JBHBJB:B@c$e)
R^@3^H@@B@:@3 8O/3s8HOD8:HH)sBq8J@:H)Bc)HB3t/Q
+:@B^B8:H@@BBkB@:B@BH+8tT8U
R:8:=HH)H
:)^H@B 2 /:/@@@8J@Br)BH \
HB :HH3^ R:H@3HHB^wH:h^@O/88J:=8^):)s:xB:@@@HB 3^
^H8:H>HHB:,^@OmHB^
/:B@BJB8eHe8Jj^@d/:@8n8@c^cB^H^8/:@8:aH)J:6^c
8rH8JH6
/HH@BHBBHb8H_^8O/@@88H8y^@O6:8B /B@b)b^3tm
/BH+^>H8H:6-r3j/HB
B^6:H8HH =8HJ%^H@: 8:@:@H8 J8tm^ ^8O/H%tR: :HH)J:
B^H)^@H@D^@>@O/B+:8J8HH3:BHBrr8B:Hd
44
3.11.2 Expresses aritmticas

^H8H )B^8 :88^8tmO6H^ 3^/:B8H: 8B H @:HB: B
B^8:@:HBB:@BHB@:H H 6H:BH@:83 O6:8J:h3 3: B^@B
@B^BH8J>B^6@H@B/B^6HHDB^@)6^>B-@HHBB
x = x 0 + v0 t +
a t2
2
^@H= 1 tH@BEs=@%s:HD >8J3^H)J@8J

8O/ :)J 3^6:H8B BO):@:8HHHB 8 6H/BHjBB @3s 8O
/H:B=8HB-@HH@ HH:@@B+r@B:H@8J+3t6H
x = x 0 + v 0 * t + (a * pow ( t,2)) / 2
dH@ms+:@-:-H@HH8:H:sO=@%s:@-@B-Bt/3HHBH=3B^ 8:)H
I t/H:3H8^@@3J:)J ):@:8H@B BO/ 8@:H@ ^@B^3@:H@H@B B^
HHH)^8^BBBQBBBQ88JO=BB8e @rH1dH@38^8@@B^+kBH/c's-+
^@H/HB BwJOR@3^H x3^ @HH):8^H@% @HBx:HBBB 8_ ^ RQ^@
HHe@OmJaHeHH@@8BJ:8e@@HH8nBa:H8^8BHBnJ@8He@a:@@H@
/:@a^8HO6HBx/8tmRHncjsHBOQ:H8J@)H R:BRHJB^@Bb8Bb@
H@B8J:3@BJH>^-H@3J@k@8rB:/:H%J:@@:8:k8/:8HH@: q3HB
r@3^H:H8H/-H%^8JH>:BB8J:+@HHH8:>HHBB:8HH@@ n)
plH
3.11.3 Algumas funes matemticas da biblioteca C
bH:@HBjc8BJH+:H)J/HBJ8J:q:HB8H:qJ3:BJB^3@:q:H8:8/BH:
@rBH@:)@J:@ n)
olH
8O/+8^8@@H^8B:+H%sHB@:B
8JH3^p5
Funo
abs()
fabs()
asin()
Prottipo
int abs (int x);
float fabs (float x);
double asin (double x);
acos()
double acos (double x);
atan()
double atan (double x);
atan2()
double atan2 (double x, double y);
tan()
cos()
double tan (double x);

double cos (double x);
x em radianos
x em radianos
sin()
double sin (double x);
x em radianos
exp()
pow()
sqrt()
double exp (double x);

double pow ( double x, double y );
double sqrt (double x);'
45
Descrio
Valor Absoluto Inteiro
Valor Absoluto Real
Arco Seno
Faixa: -pi/2 a pi/2
/* resposta em radianos */
Arco Cosseno
Faixa: 0 a pi
/* resposta em radianos */
Arco Tangente
Faixa: -pi/2 a pi/2
Arco Tangente
Faixa: -pi a pi
Tangente
Cosseno
Faixa: -1 a 1
Seno
Faixa: -1 a 1
Expoente - e
Potncia
Raiz Quadrada
log()
log10()
double log (double x);

double log10
J (double
fDir x);
s: O
Logartmo Natural
Logartmo na Base 10
3BH8H:,J3JB:3^B@:>H-BH8^@%JB
m #p'"Im'" I
^ @O6BBt 8 H)J8JB 3^@:@3HB @d/ BH@H8J HBJOmJH@BH:

^@O6:8J@J)JBJB:B@:D)H^8ORB^)s@:c3H^B8:
HHj^q^@/H8O/:
8JHH)JH HHHHH8BOv H%JO/Oh^ sHB/: H: sORB%s:H 3J
J:8B )^@@@BO ^ R:H8BJB3^ 6Bs@B@:)JH H :HB8H: B 88s@
^@O6:8J@
3.12.1 Operador de atribuio
^@/HBOaHwBRHHHB8BBH@HhHw8^8H FI dCFOU4^8:8B @wH8

:8J^H3jB^BO/H3OD /:3@BJH3 j@3:/:BBB @/H)JBjHB@H
Hr)^@H>-BORHHH@% JO=8%sH H8^8O6H+H:BBrHB8H
Exemplo: atribuio de valores

iIdade = 30;
fPeso = 72,00;
3.12.2 Operadores aritmticos

Operador
Ao
+
*
/
%
-++
subtrao
adio
multiplicao
diviso
resto da diviso
decremento
incremento
s:Jp-d8O/BBtR@OR)HHB^@8^
3.12.3 Precedncia (Hierarquia) nas operaes
Hierarquia
Operao
1
2
Parnteses
Funes matemticas
(sen, cos, abs...)
- (menos unrio)
++ ou -* ou / ou %
+ ou -
3
4
5
6
@Jt++:8O/6^B@+H>:8O/:)J:
8H^/B8N;JH[3\a~BH4^@@H:8@J3D
c8J)JO+@@@qJQJ@BQ^BO/@8J@qHQJ@8HO6HBq
H 4s^> 181@/+ 1J /@
46
3.12.4 Operadores de incremento e decremento
@:HH):@ ,B:@O6@@B
H @H8t6@-%-^B/:83
-88^HH)H:>^)O/:3H:+8BkB:H%sHB:)J:
ee

x++;
x--;
x = x + 1;
x = x - 1;
y/^@N;O/B[B\at~Q 8:Bn@O8J%^@@B_:)J:cêH@)^HeBe:@6:8B4d@@8B
/:8HH 8: ^8O/:3B :H8J@BJ3 )

o HHB@@ :@O6:@B H
HH6BJ:)@r^+H:63J:8Bk:)::-@kH3O+JHBOU3-^@Om:@BW4dB@@B
x^@/HBtJB B:8:HwBw^BO/:@3)
H@hwJHBOnBxJ@O/@@B
:8J@H+HH63J:8J@8B:B@/BJ@8:^83
Exemplo: incremento e decremento
/=)J:mr BtyRBser
HH-101keQx`kser
+B:118^H+@H6BH:8H+H
x = 10;
y = x++;
' J> ed@xser

R8J11
@6ewy Hser
@6BJ11@8JhBBH:@3ddHb:8J8hBt=HBB
s HBOS`^
x = 10;
y'`
= d ++x;>d
3.12.5 Operadores relacionais

Operador
Ao
>
>=
<
<=
==
!=
maior que
maior ou igual a
menor que
menor ou igual a
igual a
diferente de
s:J$\rd8O/BBtR@/BB:B8^B:H
3.12.6 Operadores lgicos
B8J@^@6HB/@k)tH/@B8^@B8 J@HH@>^H)H^-)@@H8:B3k^8-t6BJ
H HBJ@/ H T8HHB sJH: : HHH8H@ 3HJHH8@: dH)J:
:8J=8tm::8J>8JHB@Ot/3HHH:+8J@:8H@@B-:)::>:8O6HBO/:
Operador
Ao (Boole)
&&
||
!
AND (E : (.))
OR (OU : (+))
NOT (NO : NEGAO (-))
:vt$bUd8/HB6:3B^H)J
r3^/:B)J:>^@r@@B-^@mHBt/@c/B@:H8:8:HkBB:H8:/B@t=@6B
8O/ @H:) @OR s/BHH:6 a H:@HBH JO/BBB BO/ :
^@O6:8J@ BHJB@: t s _ ^ @B 8 J:1J: J@ B/B
47
H:@@)JJ%s@H:)c@:B8J@Bc)^/BJH/HT8BJH_:):H@:8Bc3^
^@O6HBt6H 1) IsB R_Hs B 3^/HB8J@ BH:H@H
@BJB:@:): ,B^@:1J:)HJBB:@:H:)^8HHB:
3.12.7 Precedncia (Hierarquia) dos operadores relacionais e lgicos.
H H:8J Bt6J ^8 ^ :@O/H3t/H JBJ3J3^H)^ : ^@/HB/:

BH^B8^QJ@HB:@3c8JHB/Om^B@@jH@3J:BH8BQn/:1HJ:@B3s@
8^@@@H:88kHqTr)O/B:H8@8JOYH:)^/+H+8^/@B8H:>BH^H3:
Hierarquia
Operao
1
2
3
4
5
>
!
>= < <=
== !=
&&
||
:Jtg)P s/:@BH@HB@HE^@O6HBt6HBB:H8^
/:B@Btm: 3:@:@8 8HJB@@ B8J %^/:@8B 3H:H@B @H8^@8HB
)
oH
Exemplo: expresso booleana em 'C'
F= A + AB+ AB
F =! A ||! A & &! B ||! (! A & &! B)
/:B@Btm: B@@:@8 8HJB@@ B8J %^/:@8B 3H:H@B :B8^@8HB

)
oH
Exemplo: expresso booleana em 'C'
F = (A + B + C B) B
F = (A || B ||! (C & &B)) & &B
RH^8H-D::@HBEsO/3HHBr83^HH8HB^/@H@3k3@^H@
Exemplo: tabelas verdade com expresses em 'C'
F =! A ||! B
B ^6@H@3 F =! A ||! B h3^H1sHB:3J B^d/:H8B F = A + B k^@8O

H@ sHy@H3 J%t/BJ H H RHt6J@ B^8)sHH88J BJ/:B@3
F = AB
B8J3
A
0
0
1
1
B
0
1
0
1
!A
1
1
0
0
A
0
0
1
1
B
0
1
0
1
(A && B)
0
0
0
1
48
!B
1
0
1
0
!A || !B
1
1
1
0
!(A && B)
1
1
1
0
m q")K)0
@ ^@ H8JB@:H8 B@HO J8 3J sO=8)sH B ^H) @8J:6X

)JB:@:@H)^@

^8 H)^HB:B@ B@HO :@ 8J sO=8%sH 3 ^B) /BHX
)JB:@:@H)^@
) ^@ B)^H@BH@ H@BO ^8 )J JOR@3JH B :H3 BH^B8X
)JB:@:@H)^@
HJ J@ B8^H@@H8 :@Hx^8 8H JO=@3^H B ^H1 @/:8:OX
)JB:@:@H)^@
D) 8O/x@HHt/:@8HHx@H/)J^H) @:@H8 /:/:@@)J:@BB
)
o +k 8JOm-Hr `JJ:DH@B3^

Exemplo: 1,567
real float 4 bytes
3.1415
100
101,345
69123
11.98 e+125
"b"
"agosto"
'x'
"beleza"
"1.234"
'7'
-25932
124
-255
75.500
1000000,1
"Eu odeio Logica de Programacao"
"Imagine, entao, linguagem C"

@-BHBÊ^-83^HH)H:,^BBt6@U/@H3^@B+:,^@@3HJ:
int iA, iB, iC, iD, bE, bF;
iA = 10; iB = 20; iC = 30; iD = 40;
bE = 1; bF = 0;

0 (FALSO), iA menor que iB

Exemplo: iA >= iB
iB < iA
iC == iA
(iA + iB)*(iC - iA)
(iA + iB) >= iC
(iA + iC) / bE
(bF && bE)
(bF || bE)
(!bF)
(!bE)
!(bF && bE)
!!(bF && bE)
!(bF || bE)
(!bF || !bE)
!(iA + iB)
!(iA <= iB)
(iA || iB) && (iA || iC)
(!!iA || !!iB)
iA != iB

49

iA == iB
!iA == !iB
!bF != iE
(!!iA && bE) && (!!!iB || bF)
84^@H+rR8J:6+^B/:83kBJ@H3JHB@@B:/:H)H:>:8:8HX

iA + iB iC
iA * iB / (iC)
(iA + iB) * iC
(iA / iB) * iB
iA + iB * (iC iD)
iA * iB * iC * iD
-iB * (iC)
++iB * iA
\H

H8:8J@
/@@@BJB3 ^H8 8 @HB 8J H@ @3^HH%J:
B^6:H8HH
H Q
eHUi
@ eJH
@ JHr
H JH
H b
beUH
H Q
He
J UHe
@ Q
HS
e
@ Q
He
H DQ8
e
8 DtS
e
bHjHHH8c@8^/:38J:q:@@3HU:Hs/3s^)@j@Bt6Hc8B:H8H:H8^3H
8^@@@H:88-Û^@O6BBt/H>HD:H8^8B:B n)
plH

H-3^/@@@BrB8JORB@ a = ! # x + 2y. 3 $ " 6
3
%'
@-3^/@@@BrB8JORB@ b = e.{11, 6 ab + ( 2a + 2c ) + d &( } 6

@-3^/@@@BrB8JORB@ c = 10, 3a + 12, 5b 2ab 6
H-3^/@@@B-3H^H8 d = (a E b) OU (c E d) OU (a E d) 6
x
1
2
1
2
50
Captulo 4 - Algoritmos, lgica de programao e fluxogramas.

m I-" p',%&)(K
8O/j/:)H3sO8Q6:@H3Jr18H:H8:BBtU@:8:B@OR8
2D:3^8@ B
=8H:/3::8Jk:H8:)t/HB3JJH@:/HH:B/%sa:)J6^@8BJ
H)Jk3O6Jr@BO/-r/:HB)J+@:8@H@O/)Q:B8:8t6O%Jk@8@@HB@
H @@H)^x:@ )O6^)J^8x m:@H8J @B /@3J3d83 HxJH@@/
:8HBJB^BBrj/H@B:8^1sW3BQ:B8HH3s:3@-HH:BBE)@HrJ-H@3^
^@@O/3k6:8:H@H%^-B/B+O6JHB:BHB:+8r8H:@8JH3O
)t6H:8Hc 8H:H8B @ ) 6:@H3J )t)H^H)J@Bt_ @@@HH@ B
B^Ha8:)H^,c@3 8:H@@jHc@:H8:eaB6Ja8@BeJj@HB^c@/B
O6JBH:@B8^_88@:H8JH%t-B8Hy@B @BHH@_B):H8:_yB@BJBHyH
HBHO=8HB uBrBJB:8BB8:@BH-r6^3:H8 Hr8BH8s6^@H8Jr)JH
@O/:8H)d@3e@88jBt=B@@BB^8HcBB 8:BH@Bj@:H):Q^@H^86B
r8H:H@3 )Jj/8@:8:H8@H@O=8
8^@BnHc@BHt=)HBne@:8O/He@O6c@JHce8H^B3J:83=@@@B
H BBHO=)HH^ @O/ /:8@3JO ^ d6^@H%J: 8J B: J:8O6:
:@:BH@HB@H:B:hHBHB@:8H@Bx6B/BH:@3v3x)H^H)JBB/:
88H
8t6:@w8Bv3^H)J8w8^ :B8HhH /3O/:-:h@ B8hHBBt=88H
^@ 8: 86^)J =@ B3@t=)HH^

J:3 H)B 8^H8 )^HH%sH
:HH8B B =@BB @ @3Ht=)HH^ H@8:@OR@@O=@ BB^6HBJH)J
B^H)JB:3H@:H:)t/@wv@)t=8^/@v@@HH@@x@6^nB:^8:H
8JH3H^ks=@O@BHO=8BH:B:rr8J:BBB8H:@BBJk3:@:8@rB-t/H8H
@O6H B =@B8t B BBBt=)HH sRHBH:8H B:H8J3 H)sOR8^
HBHO=8HBJr@6a/@)J3sY+J:8H':@HBJX@H38@3JB@B-8:)H
HD^H8J>B8@-R8HBt
B @: :1t6 2p 3 ),wpf5dptc cx]gDl]at`Q BJ 3:8HH ]BH)^
:/@@:8H 8H sR@B 8O/ t=)J3 B:8H @HH%t/ )H B=@
HO=1sHHqB8HJH8HBBJ8JBH3JB^H%e8=@qH@B:H3-Hk
s@+ *'HO
RJBHHeBBk
R-,H YjH^: ]H8a ^Yd=H8h \ D)^@O/H@@:BBa:1JO/B3J:8::@O
:@H ): H s@+ *RB RJ%BJ :@@3 H RH^H8H B ]H8_ ^YO/8B
]H8a ^YO=@3h)
HB@HHHyB
]HH)J@3hHH8B B^8BJH@3)J
:8HO :H/%s: 8 @)' H@BHHB .satv c /zvDl ^10 c/hw32vce
I 1@BO/:HG
18:8H:/:83vG
18H:B@BJ+v^8^)BvBh@)6h@:bt=3HB
JB^8B @HH%t/4
%J:R
HH)h@8J @:B)^@B H @HBH8 B :8^@3 8: BBHt'8HH^n^^H
@O/3y8/:@B8JHB:HB:8H:qHH:H@H8H:a):/jHBBtR8H@^,BH:H8aH
6HO/BJ@BBk>8J-3rHB@6@/:@@8::8H:,t6H:BB: :>H:)HHt/)J:
m 6ImII:KJIm$" O
BhHBBtR8H@8JbB:H=88Bw@:B8@:88hH8m:@HH8B)J
@B 8:HH8-@OmH-HDBJ:@B@B
BnHBHO=8HBa:@O/e8^/e)_8^/ @H8HnHa:)t/BB:cHjHJBnjJ/O
8JB:@H^8 @ Ht
8H@8ORw H@@O=)B BBBt=)H@xHB HBH8
@O/@8JOR@8^H8@-8^1t6JH)J:
51
5>||{}{x
BkBBHtR3HH-B3sr)B^RDJm^H@OYH8^+)8J'k:BB8BkBr@:88^
[\ s H 8 BBHtR)H@ H3s @ 6:HHB3J:8H BB:HHBBa

:8J@H%^B8 HH8HH@@@R)Ht6^8B::8H+r8B-8^H8B@BHH@
6/}]IN xs
BvHBBtR8BHvH%sbJOjH6^b::HH)t/HB@H)Bvb^@:)^@@BH:
|| ~
JHH @:B8
^@@B-H@r83kBt'@:HBB:>@8J:>BrH3HO=8BHr@HHH8
y{x
B nHBHO=8HBnB3sjJO8Ha:j::Hc@:BH:,H3Bn^@:8J@HHH@^8
JBr8JRHH:83k:H):H@HB@)Hk:>H8t6HB:
6}/|5|{xax
B BBHO=)HH B3s @O 3BB^): @8H @8^H@8H@ :@ BJH: :

^@O6:8J@H3^3@EH8@HH@88JBJH8J@:HH):rH+HH3k^8r8^@@B8O
B RHBH@H8 3J:B8HHHH 8B /:HBBB B ) HBJ8 @BH8B 88
H8J@8BB:@B@:@HD-@@HH
HB-:HB3 :>HBH=8H@:-)HHB8O@B:BH@@H@B8^3
B@t=8H3^-83^H8::B8^8:B
B@t=8H3^-@%dB8@^B8J@H)^@BH
)JB:@B^DH-B3Ht=83H^8Br)H^H8H:@8^8:B
HH)t=H)H:-8/r)^8:@B:8BHr8:8J@+@:@8O=8: 6

1@BO/:+8O/BH:H8B-Br)^3:8H-Hj6@@Hp
6
t
6:@H:)H:8H: @O6 8H@H@3 8H @:@/:8:@ :H)HBJ@3J:HH
O=)HJB:B@p 6
H
HH)t=H)H:-8/+HBO=HB@B-8rHB)sORB@HH@
6
Dt
BJ/:8@8J@@:H8OR@p 6
6:@:H)-H+@:=B@@@BrB8:+H:=H@DHjRBO=8Jd/:8HH
)JB:@B^DH-B3Ht=83H^)H^B)J:H8:@HH

JH@H@B+Hr)@J:HB@+H)J+HH8HHH:83a/HB@H:BB@H> ^3HJRH@Hp 6

JH@H@B+Hr86JDJ6^B@++HH8HHH:83kH>O):@:HB3^@B3o
6
t
:8H:HH):@BJ@3HkBD^HB@B:3H:7 6
H
:8H:HH):@BJ@3HkB8J@@@+6JB:B@8JH@@7 6
Dt
:8H:HH):@BJ@3HkBH@%s3JH 6

JH@H@B+Hjm:HBJ@8B^7 6
JH@H@B:>:8:@8HJ@HBH8:7
6
\
6:@HBH@>JR:H>HDJ3J3J8:H@p
6
b
6:@HBH@-@R-8H:H8B-@HRHH8B:H@3t=H):7
6
8 )JBO=@B@@B-@rH=BH8B^>@BBtf :HH8: 6
H
JH@H@B H BJ8H: B H:3J:8J@8B :8J:BH)^@3J@8H H
8H:8^@@)J:
m R#'" K
I K'&)(pHKp@gIq" tI
d HBBt=8H8^ 8JH3 @O /@/:@@8J@B: Bt/%J: B :@8^@3JB
@B^/Hk3t/)s@HH:)HBO/3J:^yBt/3::HB@:@B:8:H)^@B:@H
@HH8J+8HrB@:,H:8J8H:H,-:8:8::8H:
52
4.3.1 Linguagem natural
d BBHt=1HH^ @B B^/@B8: :/3JB::)J H)H @H8^83:B BB^6B

8HHcB8:m:@:8BB:8Jq@@3YjBBHtR3HH8JO688a3BHt/@)HH
8^6:HH88r8JH@r8^8@@:H):@HH@v =tEHB)k:H1^@BH8Q@8^/B-
8^@@@HHB-8tmHHBJ:1JrB/)HJ:8HO-H3HtR8HB^+8OmJ:>HHH
4.3.2 Fluxogramas
H:8H 8:8 J HBBt/8HB^ @B :H=8@: B8J @H)^@B:3 O/H:@@

B^@@@HB^8@ H)^)JB: JB8J3t=B8^ 8O6 R:/@8:8J @ H)sOR@:
:8J@rr8O/B-BHJ@H@-@O//:8J%sOQ':@HBHr6:8:8@
JBH-:B8
H ^@6:@B m:/:):8J@3 8t 8 H)^8:B 8@HO6@8J
BHH
s:8HBJB @3J ^88 H 6@/:@@8H:@8 @O6:)J :1H^@:B@B:@8H
dHH8HkB-H:)HkBkHB@O=8H3Y38t/B@:8H )^@:8B:@B-HB8^8:3^
8JH_:HHH':@O8OmJ:b36Ht6BJH8@:@H8@BH)H:@H3^@HH8bB
8J:)H%QH@8@Ht6BJr)JH/:/@@:3HO^38H@B-HO/HBHDd@8J:>H
Bt6HxJ:m
8d/ /@/:@@)J:@8 HJO/H@@v^Bmj8HH^3@x^3HO
8tT8JDJ8t/DBt6JDH6:6@@:8J@@8
4.3.3 Pseudo-linguagens
B8J Bt6B H /:':@:8H@@3 8^@@@H %J :@8:@3JB 38JO6HH:B=@

:8t6 @B8^8BJ3 @3:/H :B8:@8JB H 6@t63J@@B 38J
:8t6HBJ3 ^H8J6 @ H@H8:@BHH: H @H)^@8J3 8B^/B 8H
/:BH@BH:H8@@BJ3a@pHt/BH:@8x/:s/:@:3H:@B8:BO6J
H H@:@3d38::8B 8^BHHB@@3J B 6HtmBJH3O :B3t/:8B B:
HBJB:@:DHrBB8JBJDH@H8:8BJB-H-mHO/BH:@3
t/:8H:8B:8:)HJ%d@8@@8JB=8h)^@@@BO/b /@6:@@8J:@)H
HBHO=8HBJBO63s:,H-@@8HBO/BJ:
-7m " g-" I#K'"spK-"-,q&)(pJK,K"Km'"O
)^H)t/H@BHHB@O=8HB^k:B^B8HjBjHBBH/@8BJ@@Om^
H8j8^/ :38HH6Bt/@3JH^3@q=@O+8B^B8:8JH1^H8^1Jj8H
:@H @ H 8^BB)sH 8^B1t=HdyJ@H H:H83J:8Hh8 HBBt/8BH
B^)J:>@:H@@q/Btm:-B3
@H@8^@@B@:@3B6^BHBH+BBJO'^H8Oy:@y@n^@_6:8J)s
^,^@HE^/ H3J)J-@OY3^@)^@B

@H@8^@@B@:@3k@:U
):)t6HH@+H+HHB^ tuB8Bt6:@8J:>BtR8:H@@:
r8O6^YH:E^@:B+@+H@@H1JJ3JO/BD^-BB:H@3:
t
@H@8^@@B@:@3H: 38:@B:wHwHHB^
t:vB@BtmH:8J@w@/3
JO6HH:D8HH/:H8BHHB
H
@H@8^@@B@:@3rH:q6Bt6:@8^8H:8J@>jR@8t=B)J:>8m^@HBH
Dt
HBHO6^B8:@B 8 ^@ H3J @ H@8B @O/ t/@H8BO'JO :
):)t/HB@
3 )8:@H@ tyB@8J 8:8B H%s 8Ow@BJ6@H@HH
@B @:HB8-H>:8J@,^@+B3^ )J:H83kB-6^8BBJ

H^B8t=B8B B BHO=)HH 8^@@@H:8B 8J H: 3O6J: H
/:/:@@)J:@3rH+H3HtR8BHJ
:)JH)H:H@3x_BJ:BH83hH_HJH:b@:8J@3hH3@t=8BH
@B:HH@3 B:8B :8J@BHH@H8B @6 s=8:HBO @ BH @8J
53
/HBBJ:)H HO/:83 : 6:H@3JHB^

8^BH)s@BOB'^3rH@+B:@=H@3
m '#q"KII'&)(pJ'"
:3@O/H)^
BBJ:3J
08 ,$ pq"KOJ,sKm'"IOHm.KKgI
B QBBHt=)BHka/@R:@@8HHB+t/H@H@B:@8J-Bt63J:rB)-H:8@Ht/3H
H@8HHtmBJ H^)t6 H ) BJB H:B @HO6 @3@@HH@ B
^@O6:8J@/8H:@HBB:a8O6a3H:H8:Or8JjHBH6^H8HBjJRBH3^BH
B^H8^):B^H@3B^@HB:1t/:@3a@j3:8HH/BJ:83jB:8t/@B^@
:8^/ H H@B:@H:)B B :8HO/B^d/ 8^HB8BJBH 8JH3 @O
:H8:8t/B8^ ^8O6^ H8@8JB: J: ^ 8JB^83^ B@@BO/@B^ B@8J
t/:8H:8-8^@@8HBk>H8J)JBB:@-:8:3H
d@/:8J8rd6^@:B)^>H8>HJB+J/B
H8HOms:3@Bk)HH8=8r)m^@:B8u1H
HH8O=8+:8^8@DsH3O/:+8O/+8J+:8O/BHH
HH3^
H:BH@B
i
HHH@O/:83e/B8:HB8^BHHB@@@H@H+H
H:1d8^,H+^3O/:8H@6^B@H8^+8r6H/3JH
H:BH@B8Ha':@B^B8BUiEmHt/3J8
6:H@B^)-H:%^HB@3^B@HH)J-8:@@H@8
Incio
Fim
Om^H@H8@HHHirH8@H@DrH@BH8-B-H@8H@t6BJ
Om^H@H8@HHHirH8@H@D-:3-B-H:)HBt/8J
:6:@B+BkHB8HkB+HBB:>J>Br6:@@H@8J@8H
H^8:8Htm:HB8t6-B+H:)J-8B^H8
H^8:8Htm::%t/r83^H8:
HHH:8JO'8^>H-8HH@
:8H%^HHY@+HBH
:8Hu1^=8HB:B8J@8B
54
6:H)J+H-H8B^
1@:8B^H@%
3^)JB:-8O6-@:)BHt/3J:
sJB: @8J: H8^8@B^ H3 B^H)JBH:8:@ B @HH8H@ /HHBHHH8H@
@HH@ :H8:BBJ:B B mHt6BJ:@) H:8B Bt6H J@:@3 Bt
:H@@H@:BBHB ^8 8 8:H8H:)H H=s BO ^8O/@H3 8 Bt6H H
O6^B)JB:H3JBHBH8J@c/8H8^H83sHBk@H3QOmHHH:8BH:3BQB:rHBB^
Bk6^H1:^
HHHeR)J:'a3JB:@3n3h6@H:H)^@BH@8Hj:RBBa:8tmaH)^8J8B^@
BvH:)HBt6BJhh@H)^@8J3vH6HO6BJ:@%QB:8t/@3v:@:)Bv
8HJ@@B-@r8BH:8JO'8
r1t6H+JRH-3r8HJ88JO/)
ZB8Hr@-88HJ:%JO=)F
a
r3)HZi
dH8:8:B^Zan)JHB8:3JOEsR@::HH8@3J3t6Bj:/)d8HH
H-BHHOY8HJ@)JO=8@B:@@8:-8H:HB@++r88^HH)H
@8H-@-88HJ:%JO=)-H+8J-@HB@
]
m q "tI#Kpq"-Ip{#pq",p $ &)(mH' ,'K+" IOK
B^)J:+3^H8ORH8J:D@B-8H:BH-@RHH@@B:@3kBH:)BHO/BH:d
:8^/:>-@B:B@8H8tR3k@)J:-)^@8tRH)J:,^8-@O63-B^8Bt/@B:
8^,^H8BJBH3^@B^,H:3H+H3HH 8kBH@
HH)t=H)H:-88
@:BH8:7 6
H8^8H 6
O8:)kH/:@3JH@Br)^8O6HH@3o
6
O8:)kH/:@3JH@Br)^@@HB8J8Hp
6
RJ:B@BJ3--@3t/HB+H+HBBJ
:;=<?>A@CB?DFEGH<I<JGFKL=G;?MNO9NF<
Instrues a
serem
processadas
PA>A<@XO=>FOFNW;=GH<?;C>A>@CTHB?<YDFEWGHO=< >GCWH<FZFG?>9KN?L=M=QT;F<\MR[]N?OP^< VCO<C@XSR>T N_@a>9ÙFGbVRN?GMF;COH>-< @O`FO_GCW<

`@XGG <=B?`RdFOF>FÒ_T;C< `Ta<C`FSORT `FT9<h@cGFÒGYdHN?<CeFO9OFUC`R`ROOi< [ N;=fgW9G3@cO< THVFG3@cODFEGR<
Instrues a
serem
processadas
55
j G=dGFD=SFTkM=T;?`HNFMNJT;COd
Condio
Instrues a serem
processadas quando a
condio falsa.
Instrues a serem
processadas quando a
condio verdadeira.
P ;?TA@mWOd<FW9GFGdR;JGF>DFGS=T MFOA@cM?OT9MF;>`9GN?@MHNFNCeJT9O;C`FORO d VCT-l @

GxA?BCWs9G3OnNR@c`F<C>OV=`RGG3WtG@o_N_BF@c<CT;CT=>WO4GGu;CdJ>HyCpGOodN=`9<M?TzBOiO9q qr<uV?j O@XNg@XGHW{O<FV?G}OTH<?>FK|?OSFBCOHT+<wd v[
~MFOFO?W3`RO{NF;BT WO`=O<`HG @cG<FVJTV<?>F@XTO_MF<GH<F>F<?T=OJWW9O{G;C>RBWT
W`9V3ONC@HTRNRoAG3<@@XOJGR}W;?>OAGD=SF@qIGRT ;C>TRG\dF [>F~iO_ ;C|?q ÒuTdGON<J;>Fo9<?O BCGÔFoHHGCBWTA;C>F@WHO-`HOG@
MFMFTT?WH;RO<C>;?`=@gT9B?><N=ORczGR;F_M?T_;CG>@HO\?V?mOR@AcMJ?T?FW_-[T_<
O8:8-HR:@B:B@B1^8t'HHH3
Inicializao;
Condio;
Incremento
Instrues a
serem
processadas.
O8:8-HR:@B:B@B1^@:@B8^8B
Repita
Instrues a serem
processadas.
H:)J
:H8
B
/:8B:B@B
HHBH@H@8H:@3 HB Ô=@3H:H H
8^)t6JB:R3JO=)^k@q8/HHQ
HvBH/8H:8Hx@3wH:B^hB8:HH@3^
8rHHHB)kBH:8
H :H)^8BJB n)
ol 8HJH8B ^@
/HB:@H H8J /@BB^H83
HH)t=H83}
C-
B8H
JB8
H
R:@3^B8B
@
@ O6:8JR@H )HH s=@:H):8B 3^
=)JO=): H @O/3H 8 :BBH B
H:) @@8J BO6J 6B@B^H8B
:8:8J:8+B+::8^+)JEsB
H :H)^8BJB n)
ol 8HJH8B ^@
/HB:@H :8J 6:@3^H8B @B :
HH)t=H)H:
i?_
Condio
RJ:H8BJB-:)O/HHDH-@BB^
Informe os Dados
Entrada dos dados
B8H BO6J 8:H8O=)^)J 8 /:8BJ

^H)J: J@H: )J JH ^8
@:8:H@O68 :)^@O B @H8O=) 3
6Bt/BJ 8J H:HBBHB B@3t6JH@3
^@ mHt/3H :B@O/ ^@ HH
:8:8J-8BH18:H3JH
56
m : KC#p'
i
1@@8J:B8B
@8 @@HB@H 1 8H B8JO6:B@HH B%^@:@3 8B
8 J:BH8JB8^Qc8H@8O=8B:@j8HO6:^Q:@:HQH3:B@O8@JBB^
sB3t :B8^3t6HB B=s 8O B^HH)B @ HHH 8H@8t6
H:8BHt/3:-H@)JrpHt/8H
Incio
Soma=Valor1
+Valor2
Informe o
primeiro valor
A soma :,
Soma
Valor1
Fim
Informe o segundo
valor
Valor2
i1@:8H:B@B@3
B:HH)H%kt6:@H:3HBtB3s-:6@@:8HB@B6B
8 /BH3H=8 Bwd@3J8 )B :@H8:@HBH B JH8HHBOm^ 8tbBH
@O=)tH=88^ 1 @H t/BBH H t/:@@@8 3 H3HtR8HH B
t/:8H:@B8t+HHqH@BO6:^k^H@BJB6:cm@t/BHt6@H@B6JB
JBtm^>:H8 Y@HH@>@O=3OH=8B

inicio
f Distancia*=1000.;
Este programa transforma km em m!\n
A distancia em metros eh = ,fDistancia

Informe a distncia em km:
Fim
f Distancia
57
Captulo 5 - Funes bsicas (funes de entrada e sada).
HHHadB8Hy8b8@H8^B3tD8yHBHO=8BHyn8@^8:)Hb@@HH8BJ:)HnH
sO=83s:B ^8/HB6: :HB8J@ B: @:B)^@B: /:8H@:)J:
:8^8HBH:+:UJO=@3H:H+DÛ^@O/BB/:r)H3JB^88^>@>:HB8J:
B H3Ht=88H 6:BH@ H 8 HBJOm^H8H3 8@O6 H :HH)J:
/HBH:HBBH:@O/:BHH8:BO8tH/3HBJ@8Jj@j3t6HjH8emH/3J
)tBJB^)Bu@8QB:@:B8O=@8r:HB8J:D^@r8:HBHH@@)JBk-:8/HH+H
HHB: B@BO6JBBJ 8HB BHBOR8 HBH8J: ^@ 8:=)J3 @ JBB
:HH)J:@@8:@@B-^BHB^+@O6kr8^/@H8/:BB8J:,JBHBJB^8@:
+^B8J:E^8t6@
:H3^8BJ3 )
o )^HH@ B 8J6^ 6:H=)^ ^@ @ t/B:@H3 B
:HH)J: ^@ )JH3 @ B8@H: B@8tm 3 6Ht68J

HBH :BH8B
BJ:B8J)H-HO/H@-:H8:B@:3@WdB^8:@rH@8J@:HH)H:-BBQ=H8HR
/8^=8^R BB:@K RHd/ JB^3OR m@O/ mBO/BH BH
H:8:/H
=
m ,K%&$(IJpJ $ '0 #%" K
:H@@B B @:@B =H)HR 8:B:@ 8 HHH B 8H:H8J@3t

@ O/@8JO6Hc8=H8^c8HOm^ @8J:m^3JOm^ /B:HxwHJH:x@
^8t6: H@3tmJ:)JH ^@ :)HB ^@O/BBH: @ :3Ht=8 3t/3s@ H@
sO=83s:Bh@HH@3b=H8J'aH^8O/n:eH@8O6J:1J:n@jJHBeH_8
HJB @3 O8=8JH3 RBmJBHH3J ^ @B d@3 s@ B:@@@HO B^
@O/@8JO6HHDBt6J%J:@8r8:8:@HH3^
BO6JD::H+8:HH@DH@HH83k
=H)Jc_ )8-H3HH-@@HBJ8OT)H@/H8J/@>H-36JBH@@3 ) 6
Programa Exemplo: printf sada de dados
Descrio: Este programa demonstra a sada de dados com printf().
#include <stdio.h>
void main (void)
{
printf("Saida de dados com prinf();\n");
printf("Funcao de impressao com saida formatada!");
printf("Utiliza uma string de controle na forma mais basica.\n");
}
: HH88 =H)J' J3:@B 8JB HO J8O6^ O6:3J:)H: 8HB 8J

t5liaqp-x fd 5gpt5l=gced 8:3J:@3 :B8:H@@HBH3t/@ H 8t6J3H
:H@@H@:BBHBt6@H>8H^R8J@)Hk+H-6:BH@3
BO6JD::H+)H^@H%J-@+:BB@B=@8JRDJ3k+@B^BB8HrBH8JB@
=H)Jc_ F5t5liaqp/xfd gpt,lgcdFO:H)JH+6^)J:)@^@p 6
58
t5liaqp-xfdIgpt5l/gcd -3t6J3B8HB8:/ :@8BQB@6:8Jd/:-8JB^3HB

: 8t6h:B@@ttB)J8^:B8HhHw@6:8JOm:h8J8h8^3HOjJ8BH
^@_@O6cH^86HBy@aJ3HjJ:HcâHH@:B8:H@B3t/:eHa3t6JBBn^@
HH:B@By_HH38HH@/BeH^)t/HBHa^_HHB@Ed_:H):H@:B@H8O/:
H BtmHBH 3BJ:@3 8H HH8H @O=8@8^BH BO=@:BB 8
8^8O6JH+8^HB8HO/3HHr3:/Dr@:8HBO6HBJBH+@-:BB@3
sayt fd lxwOdptg 3BJ H/3 sO6@3sB/H@ J@ BO/R3J
8^6:H@R@ )-H:B8Ht
5.1.1 Especificadores de formato
HjJ:8Hn3t6Jj^8e8JqsO/83sHeH)J:/e@3_8JHj^8/HO-jsBBt
H_8Js=@3^Bw/HHa^n)_B8^8J3b@O/@)JO/>nR:BH)@@BtmHO
@O/hw:H@8B/B8J'^@^B8xHhHBBBHbs:h8:=)^ h
:HH8BBBBOqH@BmJHHD^@b:@d/:@R@_JBBy8bH^)JyH
HHB:j@3e3:HH8c8@8^@8
1O/HH8cB@H8JB::H8:B@@B@HB/:QH
Bt6HBH
J@@HHq/:H)BkHD:H@HB@:B8HBt/@+H+BO6J3H-r83^BH8H
RF`?R 3N;C?> :;C>HGN3@Ta`G=MNgWHOdIMJTFW4<FN;COHCdARF

NB
NN;C;C>> ::;C;C>H>HGGN3N3@@TaTa``G=G=MMNgNgWHWHOOdIdkMJ<JTFG?W4W4<F<FNN;C;COHOHdd
Hd?TO=> ÒG?Rd=OTABF@hd?>aM=T?W4`Ga<NF;JO`dU?o`=NOI>TR<TAO9@WVCOp_<cOJF9`F`FU_`R@cìoBF[`=dJÒz`F[ `R`F`kM=T?W4V3@XGFMHNF<?S=T

oG
HHd?d?TTO=O=>> OOd=d=TATA@h@hM=M=T?T?W4W4<<NFNF;J;JOOddk`=;OIOIRRTATA@@WWOOYcJT9FìB[`RY`F`F`ROH\<FG?ROR9`FTF?`R;J`FO` V@GFMNR<CST
M
MH;JOFCOÒ @ `?WTM=OAM?OO@XOd?@T-OHM=>M?@r>GA`=G9@ O@ `FT lkNgW_V3@XGH<F<?T
< @b<J>Ai@JNF;JHo @BH?WOa/:9BN?8d=:OI@H`RGIBM=+OA@XO:MJH>8G3:@gHG@<@@lY@NCHW_BV3@X/G:<R<CO B+Bt'HBH
Programa Exemplo: printf sada formatada

Descrio: este programa utiliza especificadores de formato para formatar
os dados de sada. Imprime nmeros inteiros, reais, smbolo, caractere e
string.
#include <stdio.h> /*para o printf*/
#include <conio.h> /*para o getch*/
void main (void)
{
printf("d imprime um numero decimal inteiro %d\n", 2);
printf("i tambem imprime um decimal inteiro %i\n", 11);
printf("f imprime um valor real %f\n", 13.12);
printf("e imprime um real com notacao cientifica %e\n", 8.1e+2);
printf("use dois sinais percentuais para mostrar um simples %%\n");
printf("c imprime um caractere %c\n", '#');
printf("s imprime a palavra %s\n", "modelo");
getch();
}
59
5.1.2 Seqncias de Escape
j8H^8n@@O/:8/BnHBBâB8JjJBHaB_8H:H8JB3t@aBt6HnBe8J
J:@BHjB8B 8^B@B^@8B BO/3s@ H: @B8:HHB H :H@@@aBJ
@B 8:HH8 H :H8:@ 1J @O=@ H BO6:8J6: H@HBJ 3O/
J:HBH@HT+HBH-E-JH8HH3
?HF O J ? =GFGV
FF F=
O==G?>O9;?@THD=TIMFG`R<=Gk<?T VJZFo9NF;JOmFT@WHGGJ`
;@ ;J@gT?G?>TAOY@Cd;CTaN;=`?OGaM?gOR;C@F>H@cTG3@=W@XO9GF>NF<IB9@;FRN=;F3G?H?GF|gAG?`RX
> >R>ROOk_JTAG3@J@X>HNJeFNFTM?OH;J>Fd Od
A O_O_<F<FV?V?OO<<a`9<B=NXWVFd?V?O_dRG< <
=OAG3@X@T @ON;X9G3@c>N?`FO
9 ::H;C>8G3@R@ To= OBD?SR8T :HHB@+@H@@B
Programa Exemplo: printf sada com seqncias de escape

Descrio: este exemplo demonstra seqncias de escape de nova linha,
tabulao e acionamento do alto-falante do micro.
#include <stdio.h>
#include <conio.h>
void main (void)
{
printf("A\nB\nC");
getch();
printf("\nA\tB\tC");
getch();
printf("\nAB\b\bC");
getch();
printf("\nBeep\a");
getch();
}
O
I,%" 0 gc
m ,'+&)(KJp I-"IK
:BH@BH-@)t/HH>H@H8RDH+J3H@-:+@O6:8H/:>3+J:8HHB
3t6J@DJ:B+@:H3@:+B-@BH@Br@8
scanf ("%s", uma_string); /*l uma palavra do teclado*/
scanf ("%d", &um_inteiro); /*l um nmero inteiro do teclado*/
scanf ("%f", &um_real_tipo_float); /*l um nmero real do teclado*/
scanf ("%lf", &um_real_tipo_double); /*l um nmero real do
teclado*/
60
: BH@B H@:8R HB^@8 HH H8 B^ :H@:B8:H8H3t/H H Bt6HBH

8^@@@HH3J 8O RB8J'c HH3JBJ H H@:8R 8H 8tRH8 H
8^8O6JH>
H@:8ca F,t5liayp/x fd=gpt5l/gcdFOUcaytFfdJDlyx]wQdptgBp6
t5liaqp-xfd gpt5Ol/ gc
d {}]-N:|3atz
6J3B8HB8:/ :@8BQB@6:8Jd/:k)JB^3HB
:8t6y@H8:
\~ P{~xc>~/}]N/z/~Qc]N}N_/
P/|/|Ma~|P///n~/P/||/>x~]N_nx~iNI/}~Vx||{x~
/}N:|{~iNI//}Edy:H8HH@:B)HBt/@bHbBtpJBH3HH:@38HHH8H
@O=8:8^8@c d
sayt fdHlx]wdptg UB3Jj@/@sd=@3sB/H@q^8e)O/'3Jj:@@/@
@HB+J:8@HB
Linguagem 'C'
Hh:H)JHh6:8J@8HJ@3Jw@e@:B8HBhh@@HO6@8v3vOm^8JB8H
^@r@O/+:@BuBk@:8kBFt5liayp/x] :@:@88J8t=B)Q3@O6:8:/:
@:H8HB@68Jb@HH@Br@ /HB@@HHB@:B8HBb:BHO/:)B
=8H:6 @/:3J/ H )tRH8 Hcaa5tdpt;d\ g pg5d fd w5Q
Dliaq;dcit5liayp-x w{gpt;da;l=gBH8q@H@:B8:H@ah^@/HBOnB
:@H/:8j@O/:1JBc)H3t=H)jb/HBH@H@)JYH:8:3JBYJ@@@B
k:BH@3H@@BR-3tEB8HH@O/--H@8^/-H8Jr)t=H1k-^@/@Bt
H-@@HO6H8e s-H3Hr@XH:)^@B
J@@HH>:@:)Ba/:38J>:@B@:H@@HBHBO/@B-36JBB-BrB@:@m
=` ?R
N
MB
dJ
<
3NR;C>?
NR;C>
MHHNRd?;CC>OTO=@ >
`RTBF=dG
<J>A@JN=;?o
__CA??>>RllWbWbFBBWIWIOHOHd?d?TT@@NFNF;C;C>H>HGGN3N3@m@mTITI`H`HGFGFMMNgNgWHWHOOdd`GFMHNgWORdiqTMF>FOHdI<=GT
HV9O@XdFGTM=GF@r``_NJ`FNCo9TINC>R`HOFG `Ta s9F TA@V3@cGMFG=`N?`FTa`G T_BIJG?sOR`GMNWOdY<FG
__??>>llWbWbBBWbWM?NFO-;J>@OGMJN>@XTG3@ `HGFMNXWOdY<FGCW4<FNR;COd
__??>>llWbWbBBWIWIOHOHd?d?TT@@`GCW4G`VCT9B;VJ>dFTaTVCT9dBC;C>_>RTBCOH;J>dGiB?>[ BJO;?>RGi[
_`ROF?>`THlWb<laBWOG;?MR<J>AG3@J@N=@mO;?o`FOa`HKGIB?OHMJO;?`F@OHTM?>BCWG3@gGM?OA<h@cWOO9MF><GOk@XGGR`;?>AGa@cOFG`<OaVCOH`D?TYG GCW
@O9;JMFTYlIG;=M?T9;>@OF`RTi[
BH8:H@:8@HBtm:H>BtmJ3H-BrHB:@R
b@HH@BcH3:@R@)J:@@:3@:8^qBam:H8cH):j:)t6HBB6JBHBH
8HHr@:8/HBO6:H>@BJ)^+8+J:)J:BH8
Programa Exemplo: scanf entrada formatada simples
Descrio: este programa mostra a utilizao da funo scanf. Observe
os caracteres '&' antes das variveis inteiras.
#include <stdio.h> /*para o printf e scanf*/
void main (void)
{
int iValor, iVal1, iVal2;
printf("digite valor inteiro: ");
scanf ("%d", &iValor);
printf("digite dois valores (separados por espacos): ");
61
scanf ("%d %d", &iVal1, &iVal2);

printf("%d + %d = %d\n", iVal1, iVal2, iVal1+iVal2);
getch();
}
Programa Exemplo: printf scanf

Descrio: este programa mostra a utilizao das funes printf e scanf.
Observe que scanf primeiro permite a entrada de uma string com no mximo
127 caracteres de comprimento. A posio 128 deve ser reservada para um
nulo. A string no precisa do caracter '&'. Quando o valor inteiro iIdade
recebido, o caracter '&' obrigatrio.
#include <stdio.h> /*para o printf*/
void main (void)
{
int iIdade;
char szNome[128];
printf("Qual seu Nome: ");
scanf("%s",szNome);
/* nome o endereo da string "nome" */
printf("Qual a sua Idade: ");
scanf("%d",&iIdade);
printf("Seu nome eh %s e sua idade eh %d\n", szNome, iIdade);
printf("Formatando o drive C:");
getch();
}
5.2.1 Usando scanf com strings
: BH@B H@:8 8:8:@H /8J:m @d/:8Jd/ B /@@8 H8^8HHB

8HH 8^)H :H@BV
BH BH3B :8:8JO6BJ 8t=H)^ )H :H@@8^
:8t6n8n8BH36Hc8J@3H^@H8:8t/OrH//@@:D8BBy%HB^@H@:H8BB
@HBr6B/BJDr@3:H
Programa exemplo: strings com espaos e scanf
Descrio: Este programa recebe uma string atravs de scanf e imprime a

mesma com puts. A string pode ter 127 caracteres, desde que no possua
espaos...
#include <stdio.h>
#include <conio.h>
void main (void)
{
char szString[128];
printf("Digite uma string e tecle enter: ");
scanf("%s", szString);
printf(szString);
getch();
}
62
R^H8B^kmHt/8H:k):@:@BBk6H^@@@B^k8/-:)t/BH-@r8tRH8:
6H^B@ H@:8 3^@:8BHH @O6 :8/BH H @8H:m: HBHB:

@ O/@8JO6H )t=B8: 8/ :)^@:8 @8O/HB H )O=H)^ 3B
:HH8B H8:8 :H)^@8HB n)
pl BtR@:@ ^ @H@@H8:@@H3t/: H
Bt6HBH<2%3J 23
:H@:BB:H8HBO H 8O6J3H ?2%3 HB 8B J@ H@8@ 8JB@:@
@O/@8JO6HB@8t6H8Jq8O/H8j3J^8HB:38^8t'c1e@/H8HO/
^@@B-@Hr86J-%8J{ :H)Bk:H8:@@:B@BB-H:)6k3:+8J@H@BJB
6HORBJ 8BJH @:B)/ 8:@:BH@@B B :B@:B8@H@H8t H
Bt6HBH
2%3 6@t/BHr@Op^8J-k:)O/H@r@r@O/@)JO/8J: HHH3B^
-B-:H8H8k3r/:38
Programa exemplo: scanf com delimitadores %[]
Descrio: este programa recebe uma string atravs de scanf e imprime a
mesma com puts. A string pode ter 127 caracteres, desde que os caracteres
estejam dentro do conjunto delimitado pelos [] (caracteres maisculos e o
(branco)).
#include <stdio.h>
#include <conio.h>
void main (void)
{
char szString[128];
printf("Digite uma string e tecle enter:");
scanf("%[ ABCDEFGHIJKLMNOPQRSTUVWXYZ]", szString);
puts(szString);
getch();
: H8:H@:3@HBtaHvB6JBH 23wBHv8@H@:3RwH@Bv@O6:8J6:
H8Jr8tRB8Q)J^3-HB@O'8B8t6HH@Hr)QB@k@O6@8JR:-8HB8H
:H@@H@:BBHB-@8t/>8J:@8BJ@
Programa exemplo: scanf com delimitadores

Descrio: este programa recebe uma string atravs de scanf e imprime a
mesma com puts. A string pode ter 127 caracteres. A entrada da string
ser interrompida quando o usurio digitar uma tabulao ou ENTER.
#include <stdio.h>
#include <conio.h>
void main (void)
{
char szString[128];
printf("Digite uma string e tecle enter:");
scanf("%[^\t\n]", szString);
puts(szString);
getch();
}
63
O
m ,mq&)pK#K$"sgp"ImHJ'KHpJ-"'p)0 pgB#+,p
j:BH@B+JB^R^%JB8H1t=H8kH@O/H)JO/@BBH@/8r@m^
B J@@HH) )J ) @O/@3JO/ H@B B @8 @ 8tRH)k :H@@3
/:HB@O/DHJBJ>^-@/:)J/@>^@-:@/:@Br@+JBH-BJ+B^@HH@H8
8%O> 1WBH8QH8@O=8r8J3kH:)JOTr:3O/HH+HkBBB^+8Hk:HB@8^
J8^8B 8H TR
] 6
d HH8OR8 3Bt/:8@H@ :@8:8
/:@msH3x@O/vw8t=B)QH3ÔRx)^6:)Jh^ysH3t6:h@:BHt=8
H8Hw)JBH@BOwmHt/B@bHH:@r8tc8H8h8O=H)@:8t6BH
H3s @b6:@Bx H3:HH8@)Jj
r3H@)J: )H J8Ô'xJ@)JB nHo l
@O/+:H)J8t/Xk:3@HBr)O=H8
:HH8BwH8:ORB:H@8:8t=B8vBw8O/:)HO/:8H@8v@O6H8J
^H8:/O@/:3J/@ 8H ^)tm^ :H8^ H BH3^Q @@H@B JB:@B
B^H8 8 8O6:8:O6xHh^@H8H@Hw:HH8 ) HH@HwB @HB8t/H)
^@:8Bk@@8^8O6+)O/:3HO/>H@B-H>J@8H
Programa Exemplo: puts & gets
Descrio: o programa a seguir pede para que o usurio digite uma string
e usa a funo gets() para recuper-la. O programa usa a funo puts para
mostrar a string na tela. Voc pode usar a tecla Backspace e espaos em
branco para editar sua entrada.
#include <conio.h> /*para o getch */
#include <stdio.h> /*para o puts e gets */
void main (void)
{
char szStr[128];
puts("digite uma string e pressione ENTER ");
gets(szStr);
puts(szStr);
getch();
}

mX
m ,'+&)('BmI"I'0Ig
j:B@H:8BHH-@r:@H8B-JB:3ORHj/:B@@OE1@/@8J/-@-:8O/HB-B
J:@BHB /BHt'@^88 B 'Ht/3Jn :HH83 8B B^B@ H3t/
:H8:H@HBBDJHBtXH-H)t/BBr@DJ@H
Bt6H+J@@-@@BH@ JB^@Rp6
Programa Exemplo: getch
Descrio: o programa pede que o usurio digite um letra. O teclado
verificado com getch() e em seguida a letra impressa com printf. O
segundo getch() apenas segura o programa para a visualizao da tela.
#include <conio.h> /*para o getch */
#include <stdio.h> /*para o printf */
void main (void)
64
{
char cLetra;
printf("digite uma letra: ");
cLetra = getch();
printf("\nVoce digitou a letra %c\n", cLetra);
getch();
}
m '" )II)0
r):@ 8 B:8@HO/BH ^@B 8 8HH BO/x BH8O=8 :8:8:O8:H

8J6^yH)H:6^__B@8^Hn8H:H@Byy8^=3^@_eJ@@@eB^_B:H

sHBO/:BH6%s+-6HO6BJDBk:@8:@BHB_
t
Expresses
Mdia: M = (A+B)/2
Variveis
Os nmeros: iA, iB
A mdia: fC
Restries
Os dois nmeros so valores inteiros
Descrio
o programa calcula a mdia de dois nmeros
incio
Digite o primeiro nmero
iA
Digite o segundo nmero
iB
fC=(iA+iB)/2.0
A mdia fC
fim
65
#include <stdio.h>
#include <conio.h>
void main (void)
{
int iA, iB;
float fC;
printf("Digite o primeiro numero: ");
scanf("%d", &iA);
printf("Digite o segundo numero: ");
scanf("%d", &iB);
fC = (float)(iA + iB)/2.;
printf ("A media eh: %f", fC);
getch();
}
r):@_8_@:8HBt6BJa^8eH:BeB:Hn8J6ên8^68JcJaB:Hn@
t/H3 8H8t/OR8 H 8:8^6vBH/%J KHt/BH 3 :@8^@3J3
_
t
Variveis
Os dois nmeros: iA, iB
Media: fMedia
Restries:
Os dois nmeros so valores inteiros
Descrio:
Este programa pede que usurio digite dois nmeros e depois os
imprime na ordem contrria leitura.
Incio
Primeiro nmero?:
iA
Segundo nmero?:
iB
iB
iA
FIm
66
#include <stdio.h>
#include <conio.h>
void main (void)
{
int iA, iB;
scanf("%d", &iA);
scanf("%d", &iB);
printf ("Segundo: %d\n", iB);
printf ("Primeiro: %d\n", iA);
getch();
}
t r):@
8 H:)HHO/8J :@ BH@ t/: 8:O6: 8^=)J JB:@

:8t6+Êt/:uBHR3sDrmBt/BJ3k@H)^8BJB_
t
Expresses
Mdia: M = (A + B + C)/3
Variveis
Trs nmeros: iA, iB, iC
Media: fMedia
Restries:
Os trs nmeros so valores inteiros
A mdia um nmero real
Descrio:
Neste algoritmo o usurio deve digitar 3 nmeros e a mdia
calculada e impressa.
67
Incio
Primeiro nmero? :
iA
Segundo nmero? :
iB
Terceiro nmero? :
iC
fMedia=(iA+iB+iC)/3
fMedia
Fim
#include <stdio.h>
#include <conio.h>
void main (void)
{
int iA, iB, iC;
float fMedia;
scanf("%d", &iA);
scanf("%d", &iB);
printf("Digite o terceiro numero: ");
scanf("%d", &iC);
fMedia = (float)(iA + iB + iC)/3.f;
printf ("A media eh: %f", fMedia);
getch();
}
H r):@
8 @:8HBO/BH 8O6 @B:H@Hd O/B H
/BY@8^@8XBB/3s,mBt/3H-Br:B8^8BHB_

Expresses:
rea do tringulo: A=bxh/2
Variveis:
68
t//Y:8:8B
A base do tringulo: fB
A altura do tringulo: fH
A rea do tringulo: fA
Restries:
A base, altura e rea podem ser valores reais.
Descrio:
Este algoritmo calcula a rea de um tringulo retngulo
depois que o usurio informa a base e a altura.
Incio
Base e altura?
fB, fH
fA=fB*fH/2
A rea fA
Fim
#include <conio.h>
#include <stdio.h>
void main (void)
{
float fBase, fAltura, fArea;
printf("Digite a base e a altura do triangulo, b h: ");
scanf("%f %f", &fBase, &fAltura);
fArea = fBase*fAltura/2;
printf("A area eh: %f\n", fArea);
getch();
}
Dt r):@
) H:8BBt/BH ^@ B:8 6:8 8 8J HRBH8H/:HB@

@ H:B@H-@R8JBmkk/BQ8^s=8J+^rB:H>sBBO/:BHR%s
mHt/8H-B+:H8^3BJB_
O
Expresses:
rea da circunferncia: A = PI * r * r
Permetro da circunferncia: P = 2 * PI * r
Variveis:
O raio do crculo: fRaio
O permetro do crculo: fPerim
A rea do do crculo: fArea
Restries:
O raio, o permetro e a rea podem ser valores reais.
O valor da constante PI ser um define
Descrio:
69
Este algoritmo calcula a rea e o permetro de uma circunferncia

depois que o usurio informa o valor do raio.
Incio
Raio?
fRaio
fPerim = 2*PI*fRaio
fArea = PI*fRaio*fRaio;
Permetro
rea
Fim
#include <conio.h>
#include <stdio.h>
#define PI 3.141592654
void main (void)
{
float fRaio, fPerim, fArea;
printf("Qual o raio?: ");
scanf("%f", &fRaio);
fPerim = 2.f*PI*fRaio;
fArea = PI*fRaio*fRaio;
printf("O perimetro eh: %f\n", fPerim);
printf("A area eh: %f\n", fArea);
getch();
}
70
Captulo 6 - Estruturas de controle e de repetio.
m g#Km)6/IOpKpI
6.1.1 Seqncia
B b8HH:@3^c:@n8yH:1HnH_8^8O6JBnBy'Ht63J_@3_BJHH8JB3^
@:H8:@B-BH@HH@B@OR+6H^8H-HH)tRH@3
Exemplo: comandos em seqncia

clrscr();
printf("Letra: ");
letra = getch();
printf("Valor = ");
scanf("%f",&Valor);
resp = valor * 1.25
/*
/*
/*
/*
/*
/*
Limpa a tela */
Imprime */
Atribuio */
Imprime */
Entrada de um valor */
Atribuio comando de seqncia */
6.1.2 Seleo
B 8HH:8B^ ^) ) B@8H H 8:8t6H@ 3 s6Ht/)J @O6^)JB

@HH@@B-H8t/D:@:U^>:@H+BH8t=B8::
Exemplo: utilizao de seleo

if (numero % 2 == 0)
{
printf("NUMERO PAR\n");
}
else
{
printf("NUMERO IMPAR\n");
}
6.1.3 Repetio
B 8HH:8B^ ^) ) B@8H H 8:8t6H@ 3 s6Ht/)J @O6^)JB

/:@3^H@3rH)-ÛJ:H>HH)O=H8J@
Programa exemplo: repetio

Descrio: este programa pede que o usurio pressione qualquer tecla.
medida que as teclas vo sendo pressionadas os cdigos das mesmas vo
sendo impressos na tela: o caractere e o decimal equivalente da tabela
ASCII. O programa interrompido quando a tecla ENTER pressionada.
#include <stdio.h>
71
#include <conio.h>
#define TRUE 1
#define FALSE 0
void main(void)
{
char cTecla, cContinua;
clrscr();
printf("Mostra as teclas pressionadas.\n");
printf("Pressione qualquer tecla: ");
cContinua = TRUE;
while (cContinua)
{
cTecla = getch();
if (cTecla == 13)
/* (13) cdigo da tecla ENTER */
cContinua = FALSE;
printf("Tecla: %d | %c\n",cTecla, cTecla);
}
getch();
}
6.1.4 Atribuio
LH8J3kDtfDrKd@OmHBtH^t=HHBHBBJ
m
m $'pOImKJ
b8HJ:8B_@e@O6:8HaHBHO6Oke@B@:HH8nBaBJ:BB@BaBnH:)HnB
6HO/BJ+8Hr8:@r)-3^B:@@8BkH3J8:@@H@B
Sintaxe:
if (condio)
{
declarao 1;
}
else
{
declarao 2:
}
)HJ:83 BH@ :HH8:)H 3:@:H8B 3t )sH:8HH B

sO/BHH:' K^@H3:@O sBBt :@@O6:8H H J 8@H@@B 8O/
BJ:B8JH3 E8@8 8J)t/OR8R8^@@H@3jHB:BusHBO8J8Bj8O6J
8HJ@@B @O'rBJBH8JH3
3HJ:@8QD^r3BJ:@3 )HHBr@OH8J8H:
^ 8H:8:8H:JH/:)BJ:@3^B@+H3@rH83J:dTJ:8H-J@@@B
8BJ:@3rBtH8^@3:
if (condio)
{
declarao 1; /*comando composto */
declarao 2; /*mais de uma linha de instruo */
}
else
72
{
declarao 3; /*comando simples*/
}
Programa exemplo: if-else

Descrio: este programa verifica se o nmero digitado pelo usurio par
ou mpar.
#include <stdio.h>
#include <conio.h>
void main(void)
{
int iNumero;
//clrscr();
printf("Verifica se o numero digitado eh par ou impar.\n");
printf("Entre com um numero inteiro: ");
scanf("%d",&iNumero);
if ((iNumero % 2) == 0) //se o resto da diviso for igual a zero
{
printf("NUMERO PAR\n");
}
else
{
printf("NUMERO IMPAR\n");
}
getch();
}
6.2.1 If s aninhados
BB@HHH@8B8q8HHH@BQ@HH@OR@Bq@8^Q8q8HHH@3q@
8)HJ:88kH@8
^H
Programa exemplo: if aninhado

Descrio: este programa pede que o usurio digite um valor inteiro
qualquer positivo, negativo ou zero e depois imprime na tela o resultado:
maior, menor ou igual a zero.
#include <stdio.h>
#include <conio.h>
void main(void)
{
int iNumero;
printf("Verifica se o numero eh >, < ou == a zero.\n");
printf("Entre com um numero inteiro: ");
scanf("%d",&iNumero);
if (iNumero == 0)
{
printf("ZERO\n");
73
}
else
{
printf("voce digitou %d\n", iNumero);
if (iNumero > 0)
{
printf("o numero eh maior que zero\n");
}
else
{
printf("o numero eh menor que zero\n");
}
}
getch();
}
Exemplo: mais ifs aninhados

if (x)
{
if (y)
{
printf("1");
}
else
{
printf("2");
}
}
^8Haj 3HJ:@3dc d+@/HH/X )gI

UUdced,:8J :)JHB-B
aj J:BqmH^8H^B:B@H@BQ^)s>88HH:@3qH:8HB8^H@BB
HH8^8:@H@8BnHeH@%s@a8nBJ3^@Bn:B8Je@BnH@)Ja)d8H:c
:8J 6:H@:%HUbB@3^:y3:8^H8BbB^B) H@B@HbH38JO=/BH:8B
B 6Ht63JHBt B @:83t B:8:B@:@B 3s:):@:H :H8:H@:%J:
H@H@@ HB@:
smA
m )dIItIpKJ
B8J 3HH:@B HH 6Ht6%J ::)JO): J=@3J@ B3@:HH%sBH:)J

8 ^8O/b8J_@B8JyHy8HH8J@)J:_H8::/:a:y@/:)JO6H+H:8:H_H
:H8:8t/ 8H 8^BHB@H:B@@w 8H^B8JH)t BJ :B3J 8HJ:8B ^
@B^)^ H 8@J@@B: ^@ @3JH3 @H8JB@HB: :@HH 3:H8J:)Jh
8HJ@@Bj@HH@@Bj3J:H3HHB@@Ba8^1s@:HB3J8^H3H@H:BH@X
8HJ@@Br/HÛrH@3BB/D:=8JTr8:8H+Br3HJ:83r ^)^H
Sintaxe:
switch (varivel)
{
case constante_1 :
{
declarao;
}
break;
case constante_2 :
74
{
declarao;
}
break;
default:
{
declarao;
}
}
Programa exemplo: switch-case

Descrio: Este programa pede que o usurio digite um nmero entre 0 e 2
e depois avalia o nmero com um switch-case, escrevendo o nmero
literalmente.
#include <stdio.h>
#include <conio.h>
void main(void)
{
int iDigito;
clrscr();
printf("Entre com um numero [0 .. 2]: ");
scanf("%d",&iDigito);
switch (iDigito)
{
case 0:
{
printf("Zero\n");
}
break;
case 1:
{
printf("Um\n");
}
break;
case 2:
{
printf("Dois\n");
}
break;
default:
{
printf("ERRO: de 0 a 2\n");
}
}
getch();
}
75
Descrio: Este programa pede que o usurio digite um nmero entre 0 e 3

e depois avalia o nmero com um switch-case, tal como no exemplo
anterior, entretanto faz a leitura atravs de um caractere ao invs de
utilizar um inteiro. Depois escreve o nmero literalmente.
#include <stdio.h>
#include <conio.h>
void main(void)
{
char cDigito;
clrscr();
printf("Entre com um digito [0 .. 3]: ");
scanf("%c",&cDigito);
switch (cDigito)
{
case '0':
{
printf("Zero\n");
}
break;
case '1':
{
printf("Um\n");
}
break;
case '2':
{
printf("Dois\n");
}
break;
case '3':
{
printf("Tres\n");
}
break;
default:
{
printf("ERRO: Numero fora dos limites! \n");
}
}
getch();
}

Descrio: Este programa monta uma pequena entrada de dados utilizando
switch-case. A captura da opo do usurio feita com um caractere. Cada
opo leva a um direcionamento onde um conjunto de procedimentos pode ser
realizado.
#include <stdio.h>
#include <conio.h>
76
void main(void)
{
char cOpcao;
clrscr();
printf("[I]nclusao\n");
printf("[A]lteracao\n");
printf("[T]ermino\n");
printf("Qual a opcao: ");
scanf("%c",&cOpcao);
switch (cOpcao)
{
case 'i':
case 'I':
{
printf("Faz uma chamada a um procedimento de inclusao.\n");
}
break;
case 'a':
case 'A':
{
printf("Faz uma chamada a um procedimento de alteracao.\n");
}
break;
case 't':
case 'T':
{
printf("Faz
encerramento.\n");
}
break;
uma
chamada
um
procedimento
de
default:
{
printf("ERRO: Opcao Invalida\n");
}
}
getch();
}
63
m $'pOImK
B8J_8BJ:8B6HH:8B_8
F)8H: FRH:3Hc^@_@v/@@3^my@8^@@8Hy
8^@@H@B-BtXÔ/HBB:/W4d8H@Bkk8H@:H@%QBtYHH@@+k8^8O6JB-B
6HO/BJc@:BBa@O/ja:H8@^@a@BH@j
F=BH^ FG
F%3B^ FP^B@Ba
8^@@@HH3 B B8^@H)J:^@B s=@:H8:@3 H )^@:@8B B3s @O
sO=8:H@B@8HB@H8B
F)8B: Ft q8:8:HBBj%t+@H:8Y
)BB^
@B--BHHH8JB3@B@-=8H@/DJH
W |/}
while (condio)
{
comando 1;
77
comando 2;
}
H^@@H@Bq^@H%^@Oy3^/@H8Bx^H:@BH/3
'r O /E^>H
6:H8BHH3 8H1@^^
HHJ@@B8:H
@ ) )HJH@3 sB:8H8:BH: ^ 8H@8^8H _s:H

8HJ@@B^>@O/3j/:@%^@BJ>BHD^@+-8^8:B@B+HO/@^B8+BH:8
Programa exemplo: while

Descrio: faz a contagem de 1 at 10 com o loop while. A comparao
realizada NO INCIO do loop. Se for falso no executa o loop.
#include <stdio.h>
#include <conio.h>
void main (void)
{
int iCont = 1;
while (iCont <= 10)
{
printf ("%d\n",iCont);
iCont++;
}
getch();
}
A A X
m )dI$# + "
8BJ:@3rBtXHH:B8r8>^H)-H-B:3kB+BH:HH88
)^HBHqO/:@H3J:)H:a)eBBjHH:H3H@BHBHHBH@@H:838^@HH8Ba
HH6BJ:)@ HBH@@H@@B:@3 ) )BJ:@8 H Bt=@BBH@3 J@
8H^B@HH3rB8c)O/q:8J@@BB:BO+s=83s@B8:8t'HH3a8:8
8^@@H@B 3H 3^6:H8B B /BH:8B ^@ H:8J s=@3^B H
8^8O6JHqBH:88J)t/HB:3JH3t@RjB3JO6:B@O,^8:8BcB:8
JO6:H@O6 HH6BJ:)B BH@H@ J:B:/ 8H@ sOR@3sB H
8^8O6JH+BQ8:8Q3O/-H3JOmHHr@HH,sH+:@-r8H:H)JH)tr/H@B:Y
H:8
W |/}
for (inicializao; condio; incremento)
{
declarao 1;
declarao 2;
}
pbaaycaHg8 8HH@@B '^ s=3^ 8:@O6@B^ 8tbd6:@HH H

Bt=BHHH88r^B8@^H8HBBtTH@r@O/rHHB@@H:8BOU/@EsO=@%sHO6H@
Hr)^8tm:H-3-BH^t
gpfagHg 8: 8:/:B8B /HH:@8^8H ^8 J@8J sO=@%sH H
8^8O6JHqBBH^8J)t/HB:3JH3t@RjB3JO6:B@O,^8:8Bc3H^
JO6:H@O6
78
@OpOO/+
l=d5HBdHptg/HDHD
HH:8@eaJ:@:s6_8HHys=@3^BeH_8^8'JHeByBB^
:8ÛkB@:-8-/:8BJ@B
UkBH^qRBt6@O6/:B3^@3-:8^8:3H-8:@:H88kBOuJO/BHH:'
Tq8^@@@@Br8O/DH:8J@Br)r8HJ@8rB-3H:
4d@H%^@O 8H H B@: B@8J: z aypbaacaAHg6 ,gpfagRg76
aypOOl=d5dptg@r)HHr@dY^BBB^8B^/HH@3DsH@@H>BZ

Programa exemplo: for

Descrio: faz a contagem de 1 at 10 com o loop for.
#include <stdio.h>
#include <conio.h>
void main(void)
{
int iCont;
for (iCont = 1;iCont <= 10;iCont++)
{
printf("%d\n",iCont);
}
getch();
}
Programa exemplo: for

Descrio: faz a contagem para cima e para baixo em duas variveis. O
loop encerrado quando os valores das variveis se igualam (em 5).
#include <stdio.h>
#include <conio.h>
void main(void)
{
int iCont, iContB;
for (iCont = 0,iContB = 10;iCont != iContB; iCont++, iContB--)
{
printf("|%d|%d|\n", iCont, iContB);
}
getch();
}
QBB^3:u66+-B@H)s@B:8H+B8BJHH)J8BJ:88Q^B8H
inicializao;
while (condio)
{
comando;
incremento;
}
79
Agwp
m $dI$#sp
8BJ:@3rB>M^H)H+:3^@3j/HH@@@r)J+H@8-@j/@8B:H@3
B:8 B::B8JBB :):@:)@ )^@:BBB BsO/8HH@6hJ:
8^@@H@B--JB8JHH8k:B@HHHB:@88H+^@DQBH:-@> HkBH:H3HHB
@HB+J:)J-8HEsH
|/}
`RT4 M=T?WOH;?`FT+
FN=dFGXM?T_;C`NFDJST
Programa exemplo: do-while

Descrio: faz a contagem de 1 at 10 com o loop do-while. A verificao
realizada no final, logo o loop do-while sempre executado pelo menos
uma vez.
#include <stdio.h>
#include <conio.h>
void main(void)
{
int iCont = 1;
do
{
iCont++;
} while (iCont <= 10);
getch();
}
m $K+""-,'#+&$(K:KHK#K
6.7.1 O comando break
4d@:8Bhw8H:H8HH8tcHH)^8O6x8HJ8@BxmH^HB8t6hBw8wB@:
HH 8JB:8BJBHH8J :H@O3/ BH^ 8^)6JH

6^B@B^8-8r=8J:s63BJ:83kH:)^@3-BH:
6H6BJ
Programa exemplo: break

Descrio: este programa tem um loop for que faria a contagem de 0 at
99. Mas a existncia do comando break interrompe a contagem quando iCont
for igual a 10.
#include <stdio.h>
#include <conio.h>
void main(void)
80
{
int iCont;
for (iCont = 0; iCont < 100; iCont++)
{
if (iCont == 10)
{
printf("saindo..\n");
break;
}
}
getch();
}
6.7.2 O comando continue
8 HJ@8B 8J)^HH8 B s@ H %t=@O HH@OB/3J:1H BR@

6H:8J3JO/@8BkB+BHJ>B@H+r3J:)H+^8-@3^)sT)-H:8
Programa exemplo: continue

Descrio: este programa imprime somente os nmeros pares. Quando o
nmero for mpar o if ser verdadeiro e o programa vai pular a execuo
das linhas abaixo e continuar na prxima iterao. O resultado a
impresso s de nmeros pares, pois o if dar zero como resultado.
#include <stdio.h>
#include <conio.h>
void main(void)
{
int iCont;
//clrscr();
for (iCont = 0; iCont < 100; iCont++)
{
if (iCont % 2)
/* 0 par, 1 impar */
{
continue;
}
printf("%d ",iCont);
}
getch();
}
B^nB@^Hk^H8Hy_B>^BBHy88@J@@B)^3^HB@_HBb8B_^@n
8^8O6JH B mHt/8H s :6BJBJ@)J 8O/ J@8H )^@:H@8^8H
H:8:H-)J8^HB8+k%H^
B @:8 ) BH^ B:u 66I 3H^H1JHBt =8J@6 BJ:@8J
HH6BJ:)@ B BH^ 3@8^H J:8H 8^8HHH8:8H @8J: H
:H@BBJ:):_HHHQb3H^y8:)^HH@Z
B8H)t'^8_@H/3J:8H3HH
HH:BHh 8^)^HB@H@B J @/HH B 3H^c
H :@ xsO=8%sH H
8^8O6JHbBH@8J)^@HHB8:@Hb@8J6B^B@3J:)Jb@B^6b:8JH@bB
HH6BJ:)@
81
A

8BJ:@3rB^)-:8tpJ+-6BO/BJ+B^8H3^@B3^@:83
m )'gOKKps)
82
Captulo 7 - Funes definidas pelo usurio.
O<@mK9BFNV3@mT9T<oA@cO?RWTO9;?< >RG< G?sROFMW9BNR@X;C>FOT_`F<THqt< VJTOFB?>HM?l T ORM=oFT?TW@mVJO dN?M?<JORSF`FT T9< @XGG d?O=MF>9T?NgW O=WBCG>;JN=>dG NCÒ=<F`NCG W9V=dFdRGNCW9<NJq >FOF`MJOT?W [
;V3RfX;@mW9T>oAG3@XG=@c@c>FO?T WO9O;C>R`RTiG VJq4TF`M?M?GT?T9W;OH<?;?TAG`F@m@T_W<G^[ KTBFG=JAOOA@B@cORWO `FGT ;C>=<=TNCG?W9W V=`RdO N?M?THMJN=dFTFM?GW9ODJV?@ EdRGGC< sO N`d=OF>FTF`HO-oG^@XN=GFM?`FFO?THO W9< GR;C`H>V9G G @ToAV@c@c@XGO?TFd?Wo-OHO_@M<ÔFN?WTOHOH;JBCD?OFWS`GHTOH;C<q >O `BTWG
MFTJWO;J`FT9<q]MOFWOR`FO<9BF;=D?EG<w[
dGJo9V9N?@HTN?od@XNCO?`RWHOFOF``FGaT@uGb@XVCG?TO9`RVG @XT?M3_@CGNCN?O>F@O=WG<=;BC>FOTI< `RTkV9@p9MJpV`@JNCNJO_oFTz<u[ 9BF;=D?EGR<\q^TK_B?G VJGA@W3NC>G{WO9NCT@
Forma geral:
tipo nome (tipo parmetros)
{
corpo da funo;
}
-BN=<TIV?Ti`RvTkFM?<FT=VFWG=O9M;NC`_T N?MF O T >H NbVCT`ROHTd?T@c O d=TA[ @4KB?GOB;JDFSFT `RG?G`RG?TdJG3@4O=>@O?_l<`RT

JOO@@J?NCW_Z=G?>GNF@T_<<K9v BJGn @gGFBgMFWGO =GA@dRSRNFTI<?>FTO+<q O@m<?oGBCVJWOAGH@X;CO=>`THO <K_VCBCT-O9@ ;C`RTIU_O@co9BFBFdJ;=O9D?<Sq TaFMJT-TF@hW MTHOF< WOR`F;?OzTFWH[ G< ÒH<
4V3@TRoA@XO?WHOIO<?G=oBFN3@N?dHBF<?>A@cOBXWOI_BF;FDJSTa`GFNR;FN?`=OV?GRd?TB<FBJZA@JNCT[
Programa exemplo: funo definida pelo usurio

Descrio: o programa a seguir define uma funo criada pelo usurio
(MostraAlfabeto). O programa utiliza a funo para imprimir o alfabeto um
nmero de vezes determinado pelo usurio.
#include <stdio.h>
#include <conio.h>
void MostraAlfabeto (void);
void main (void)
{
int iI, iNum;
printf("Imprime Alfabeto\n");
printf("Quantas Vezes? :");
scanf("%d",&iNum);
for(iI=0;iI<iNum;iI++)
{
MostraAlfabeto();
}
getch();
}
void MostraAlfabeto (void)
{
int iI;
for(iI='A'; iI<='Z'; iI++) putchar(iI);
83
putchar('\n');
}
;6g'"K3'6g $" m
9 T=R`FO < qÒ9G<T9dJB=;FG?D?WEHGBC<\WqYGCOs9dJMFTAGJ@A>T[ OFK_@gB?G?GF>d=TO@J<;CTK9BJ`G Tb<CSRORT dFTA`@YGM=ldFOAG@c<OFV?`GROM<N?HM?NFTFM?WRORT `FT <?GV=;G`d?T T`FM?T T=W>O9N;C`RVTT
[
R;JMFT;J>A@XO?WHT<a;?TA@mWOd?WHG;C>HG>A@gQ<>NVCT_<`RG_BF;FD?EHG<\v
Oky=BR;?DFEGH<KHBFGY;CSFTa`GCHTd?GJWIROdFTA@gG<\[ j SRTVFB9@OFWHG;?>GYV3@mTMFG=`B3@OHN<[
Programa exemplo: sem valores de retorno
Descrio: este programa utiliza duas funes definidas pelo usurio para
imprimir valores e strings. Ambas no retornam nenhum valor.
#include <stdio.h>
#include <conio.h>
void MostraSoma(float fV1, float fV2);
void MostraMensagem (char *sMsg);
void main(void)
{
float fV1, fV2;
printf("Soma valores.\n");
printf("Digite dois valores, separados por espaos: ");
scanf("%f %f", &fV1, &fV2);
MostraSoma(fV1, fV2);
MostraMensagem("Saindo...");
getch();
}
void MostraSoma(float fV1, float fV2)
{
printf("Soma dos valores %f + %f = %f\n", fV1, fV2, fV1+fV2);
}
void MostraMensagem (char *sMsg)
{
puts(sMsg);
}
MFTJW y=BRF;?ODF<=ERG G<;CK9O9B?< GTGFVFG3GJ@c>9OBCDFO=ERWG<TH[VFG33@cO< D?EGRO<ndJTGJ@XW GH< <=GB`<G O@@GJoH>BCTAW@CG;C;JT >FT9<;?SFGbT `<FGCHG Td?@HGRG?<CW >@BgNRW;CoGOW d?T-O @
BOR<=dFB?TAZA@g@CGNCTz< [ N;C>HGN3@T_<[ JTF`HGCW <FG3@ @gG?O9NF< T_B THB?>A@cT< >9NFVJT< `G?_NF;NC`RT< VFGFd=T
Programa exemplo: valores de retorno

Descrio: Este programa utiliza uma funo definida pelo usurio para
calcular a base elevada ao expoente.
#include <stdio.h>
#include <conio.h>
84
#include <math.h>
float pot (float x, int y);
void main(void)
{
float fBase,fResp;
int iExpoente;
clrscr();
printf("Calcula a base elevada ao expoente.\n");
printf("Base: ");
scanf("%f",&fBase);
printf("Expoente: ");
scanf("%d",&iExpoente);
fResp = pot(fBase,iExpoente);
printf("Potencia = %7.2f\n",fResp);
getch();
}
/* --- Funo definida pelo Usurio ---- */
float pot (float fX, int iY)
{
float fValor;
fValor = exp(log(fX)*iY);
return(fValor);
}
M<NXWV?dRy=GBR<C;?WDFGHE;CGH>< GYNFKH;JBF`G N?MFOaWTO;F<FNRBFVFMFBFGHdJ<FO?<?W TT9NFB;?FTIT-@W@XORODFM=EOG<< <CTa`G OWÒG?;RRNFTVdCBJ_dFGCOW D=SFTzB[ W ROd?T-@ KB=G
Programa exemplo: valores de retorno

Descrio: este programa utiliza uma funo definida pelo usurio para
calcular o determinante da equao do segundo grau (tambm conhecida como
equao de Bhaskara). Dependendo do resultado, a funo retorna um
inteiro: 0,1,-1, com o qual o resultado classificado pela funo
main().
#include <stdio.h>
#include <conio.h>
int VerificaDeterminante(float fA, float fB, float fC);
void main(void)
{
float fA,fB,fC;
int iValor;
//clrscr();
printf("Calcula o Determinante da Equacao de Bhaskara\n");
printf("a = ");
scanf("%f",&fA);
printf("b = ");
scanf("%f",&fB);
printf("c = ");
scanf("%f",&fC);
85
iValor = VerificaDeterminante(fA,fB,fC);
if (iValor == 0)
printf("Determinante ZERO\n");
else if (iValor > 0)
printf("Determinante POSITIVO\n");
else
printf("Determinante NEGATIVO\n");
getch();
}
int VerificaDeterminante(float fA, float fB, float fC)
{
float fDet;
fDet = fB * fB - 4.f * fA * fC;
if (fDet == 0) return(0);
else if (fDet > 0)
return(1);
else return(-1);
N=< ;?>G?GHsN_GC@XW3TV?<wdFqTH< @GJO N<qG VCT9;q >GN9O@d=T9l?<?W wqh`BCG >N=dGNF;C_e?O=NCWnO@XGJTnW M=T?V?WOO@;JF`FWT G=>A @X TH < 4`G VCOA@cKO B?O@d=GJK>BFTAG9@C@ ;CO>9@INFVJBXWT
ORdFTA@OTYM?TFWRO9;C`RTK9BJGIMHCOFWT_BO9BF;=D?ST[
|FV?T4T=>QGJs;=MGCW3N?OV?dF T VCO@XOq T4OuM?@TFTW>O_NR;C;CÒ T ` G M aO?W`9OFN?`=eYOz[ _BFV_;FD?@XT=SRoAT @XO??WHOi q4VOG@;CO>RSFTz@GJqY>TAO@C>;C@OANF@BRTYNTOHd?TO@d?T-`=O @
@GJ>TA@C;CO`FTV?T@ JF O-@N?Z?_GFd F [
|FMFT}OJWNFGC;Rs9CGT4WV?`d=GbT <CiO9qUC`ROT{V_M?@cT=TWV?O9TA;@g`MT NCT_;C O `FTn V=GFd?l}T_<BC>9M?N?TFdHWRN?O9eF;CO=`R`TT<Y`>-Gb@XQ<<?GdFGRGD?eFSGHT<[
qJ`ROAG@cV?OnGH;CM?ÒG`=;JOn`FT MFO`R<JTT
TnÒM=O_T?W;CZOdH;J`FNFT<FG4 VJOA @O4 YO`N=@TReY>N4;OkBF`H;=GD?SMT CO=W O`F O+ q K BF Gw qh VCTA@I <=B?OYnGRVCO-e\@q]OO>A@GJ@C>N?TAB@CNa;COTY@HTkOdFTOd?@T- @
O@JNCZ=Gd A [
WfJdFG>s9NRGCV?W9dFV=Td?< T ;JO MR;?SFO?T WOR`F@XO G=>FT`F@O ;JO 9BF;F;JGDF;RSFFT BCW G H>OO?dFW_TF@Al?q W GHBg;CWH>AO @GJ><CO>-;C@>RNT ;o G;J;O9NCO TA@VCWHO-O @ FWH`RGFG >A@cTBW<
V?V3TH@mT;?>MFG=GH`N_NC@XWT GH;CVJ>OATH@X< O `HM?G O@NgORW9MFV3>G@cG@X<G<C<S=[ T ;O <=G3@>HGFG dFO[K9B?G ~ T?WGT <?>FO_;C< SRT 9BF@c;=GFD?>FETAGR@C< ;COFW GCs9G=;?MGHBC;F>RO?BgWW HO_OV?GdFTA;?OH@< q
K99BB=O;Fd?D?K_SRTiB?GA[ @nV_@cTMGR<<CO=WG;C>=T GCs9GFMRB?>FOF`RT^;?O<W_G<gWOH<N?M=O@cG<C>-@N?>FTGJsGMBJDFSFT`RO
Cm IOKp#K'"36g$"
V?V?ROO<>@@ O??W_W_G?G?l >>@@OTT_<4=T;?S=@TAWHT4@OWH>OG3d`R@cGSFT`=MO?GJO?WHGOFNC`B>RO;JTnDFT9SF;?Ti;O`[<IGTÔJTA@gN?@cH>FZ?OO_dF;?GT>=N@Tz<4q `FBT >9N?OOdH< N?@o_eFBgOFOW`RdFGO>R;<4G3>@XTVCOO-DJ@l EOnGM=< MHTCVOFNHWOGZ_`FNC?T >RdFOO<VJ[hOA@|O ;CBWT_TO<
TM@gOFN?WoORNR`F;COOd\[ VCT-@ OHd?TA@ OHB;?D=SFTOMRG<<CO GOdF>RGA@OOHVFG;JO<BgWHO MFpVRNCO`RT Od=TA@
Programa exemplo: chamada por valor

Descrio: este programa demonstra a utilizao das chamadas por valor. O
valor recebido pela funo alterado atravs de um processamento, mas
quando a funo retorna o valor original permanece inalterado.
#include <stdio.h>
#include <conio.h>
void MudaValor(int iA);
86
void main(void)
{
int iQuantia = 10;
printf("Antes da chamada da funcao: %d\n", iQuantia);
MudaValor(iQuantia);
printf("Depois da chamada da funcao: %d\n", iQuantia);
getch();
}
void MudaValor(int iQuantia)
{
puts("Dentro da funcao!");
iQuantia = iQuantia * 5 + 10;
printf("Valor dentro da funcao: %d\n", iQuantia);
}
P<?OUJ`FOI`HG<?>RGkV9@TFo@mOFWOa>GCWYO<?GFoBRNF;?>RGRTA@WO+v
Antes da chamada da funcao: 10

Dentro da funcao!
Valor dentro da funcao: 60
Depois da chamada da funcao: 10
9;?TJRW9<FG3G@m`FG OK_B?OG@gNCZFO^G=Hd B;?GD=sSFNFT<J>9GBJ;C`F>HOJGx_OH;Cd?OnTA@H_B;?D=`SFGJT9NFW;=O9G^NF;BCWiO [XOAW_@C?NCTAZF@XOG=d^>GHdF;FTR?MFOJOW dTbM=TFW9W^GH<gTWT W_G;?T?<CW_WRTG

<?S=THOA@JNCZ=GN=<M=T?W9VFd=GF>FO=WG;C>HG`HNCG3@gG;?>RG<[
p KOKp#K+"3/m +"g'
jByJT<NOo9@W`F;FOONJV?NFÒAM?GO @cOkMKMROFBF?WGO?OFWH`RO9OAO<@rTHOOR;?dF`@>GTRG3>@cTNO;CDFGO+ER;?[G`<G@XHGGDJNCT >RO`R< TO-;JT@o9< BXW9VCGO-;C@ >RFT WHGFl>A@cTVCO_<<F<?OFO=H`G?T>FO-M=@T?SFWT T O VCO-@ FOAWH@CGFNCZF>A@T+GRd [
R<>G>Fp9VFN=M?T<FG3@cZIG?s_VFd?T-@O`FT;?TYV3@p=s9NCWRTkM=OVUC>_B?dFT[
m" +,KtIKI $" pe=+" e/K OKX
V?O@X OWHO@XNG;9MFXGR F GA@VJTT<a<<FVCBRON}@ F`FWT9G=N=>A<u@XT<OA@ò_OaBgWdGNF;;R>CTOa< ` GaO@M?oTFM W O_;C`G T[ OA@co? NR;C>A@JU=;F<FGFM=T<BF<JOF`FT_<
OO@m@mooF4MY ~T_T_;C;C>>lGRWkN3@TT;FVCOfCWH@mOGA@TaBWÒGWHOAOF>@XoH@gBgN?W9eG`H;J>FGkT9<aVT9;C;COY>HGdN3NF@T_;RC<IOaVÒAGI@XOYM=T?M?WOOH@mO;?`FM?T>HG3@G<
WOHNV_;3@XcT=\o[ @O=WOuOt<?G=oBN@ WRT9<C>-@OuOtBJ>NFdN=e?ODJST}`T< O@o_BgW9GR;?>FT_<VCO_<F<?O=`T<uVCO-@O
Programa exemplo: argumentos para main
Descrio: este programa recebe parmetros do Sistema Operacional (uma

string qualquer) e imprime a string ao contrrio.
#include <stdio.h>
#include <conio.h>
#include <string.h> /*Para o strlen*/
87
void main(int argc, char *argv[])

{
int iI,iN;
if (argc != 2)
{
printf("ERRO: Faltou o Nome para INVERTER\n");
}
else
{
iN = strlen(argv[1]) - 1;
for (iI = iN;iI >= 0;iI--)
{
printf("%c",argv[1][iI]);
}
}
getch();
?;<FRTJG9<W9>@ GG4NRV?V_;gO@m9@XTG3OnoA@m@c>9NFO?NC;W`ROuT GA@V_>HV_@XG3@XG@AGRMR[]MNN<C_<OB4O <J<?GAGY<?G9@^F@ T-M@NFOF;=GJWMFsORdG`FB=MRTU?B?`F>FOT OR`FT4VC;CO-T9On@< >9NVCO-@NC>@>9GR`FN_;FO <@d`FNR`RT4;FT ?M?OT?V3W3@m`HVFTGNFd?G?ORM?>R`FT=TiTWq @9O9q ;M?`TnTFTW9;?BMFT?WTJWHGW G;J>OTG
MOFWOR`FTI`HGPi@o_BgWG;>T<aV?OA@cOIT9@TRoA@XOJWO4@cTFo@mO?WP@o9BXW9G;J><F\[
P<?OUJ`FOVJOA@XOYG<J>GkV@XTFo-@OFWOV?T=`GA@NJO<JGA@3v
FRGR;><VC@ORT_`F<COz>Oi[Fv1v]PG?WRv T9|NRB=G;g GA@m>G GB?|=T?W9G
Programa exemplo: argumentos para main

Descrio: este programa recebe parmetros pelo Sistema Operacional (uma
string de caracteres) e ordena (coloca em ordem alfabtica), imprimindoos em ordem alfabtica.
#include <stdio.h>
#include <conio.h>
void main(int argc, char *argv[])
{
int iI;
int iNumCar;
char cTmp;
if (argc != 2)
{
printf("ERRO: Faltou o nome\n");
}
else
{
iI = 0;
iNumCar = 1;
while (argv[1][iI] != '\0')
{
iI++;
iNumCar++;
}
iNumCar--;
printf("Numero de caracteres: %d\n",iNumCar);
88
iI = 0;
do {
if (argv[1][iI] > argv[1][iI+1])
{
cTmp = argv[1][iI];
argv[1][iI] = argv[1][iI+1];
argv[1][iI+1] = cTmp;
iI = 0;
}
else
{
iI++;
}
} while (argv[1][iI] != '\0');
printf("Nome ordenado.......: ");
for (iI = 1 ; iI <= iNumCar ; iI++)
{
printf("%c",argv[1][iI]);
}
}
getch();
P<?OUJ`FOVJOA@XOYG<J>GkV@XTFo-@OFWOV?T=`GA@NJO<JGA@3v
R;>@OR`FOz[Fv1P v T-@`G;Oxy-R? 9|=M?oJB?OR
9ORMJT<FG3@`R@mTkGM?K_T=WkB?GOaT>FOHV9F@TFGFodFO@mOFPWOaj=~ T::\@`H[ G;?OO9<hWO9N=f<?MHB?dFO<G`GVCT_NF<O9<hW9N;Ff=<FMB=d?O9<q`G
Numero de caracteres: 16
Nome ordenado.......: EFMNRTUVabcfghju
89
Captulo 8 Matrizes, Vetores e Strings
?@WRGJO G3@gGWR;FOM>ANJ@COFN?è OH<Il V=GFd?BgTWHOW9G<WM?TTHdF;JGT?D?W9SRGwT qBC`H>_G N?dNJHeFOAO@;JN?`FZJT99FG<=NRG< `RGk`T BgW4UW;GH`9<gN?WMRT G\[ >NVCT KB=G <CSRT
?FWROHONCsT WO>M?T-@NF@Fe@G<RMJVCT9T9;F;<R`NFG}<?>GOFTGJWV_@JNgVCW_T9G<=N3NFD?@mT{EGH< GRdFM?G?T9WGH;>9;C>UCo_TBCq O9<G `T GWW_OGCNRW<p@JNCOHO+d?>[4Tu MFTAG@R;?`R@XGGA<=@XV?GRTD?;JT `G}WOOFNRT<
fFV?THdJ>9<NgN?WHD=T4SFT GdF GJWXGeF;CG>R@TiT[r|?GObT^dNfJ;CdFoH>B?NOFWoHT GCW G~<?>=ZTV_;CO^@NWVCGT_N<F@XNFT4D?SRGT d=G?|W GHw;Cq>TT<I;?``GG4| BgW4M=TAG=@>F@cGT<F@VJTGH;?<C`>GZnOF;JOT
MFTJWV_@CNgW9G;J>FTa`TG?>T@A[
?MFWO@XO9M=GJ>>GATA@X@uGH<[l BXWO WO>A@CN?e `G BXWO `9NgW_G;<CS=T G BCWO j >@JNF;Jo l BCW GF>FT-@`HG
m ;mp '"I_ JI-" KBp,KOA67 tIp)(IX
P`GFMRd?O@OHD?STa`GYBgWOWOR>A@JN?eYB;=NC`9NgW_G;<=N?T;JOd GF>=TA@>G?WYO<?GFoB=N;C>HGFT-@WOv
>9>OJN=WV?OTi;Rv C-TzNFv]VJTI|fCWH`RGGA@`RTaOF`F`TaGa`GGadFGJWM?OG`F;COY>RTG<d=`FGCW9OGWH;J>FOFTz>@g[ NFe OR>l>FOFWO_;F?T?i[
tipo nome_varivel [tamanho];
Exemplo: declarao de um vetor
9~ ORR<FG3G@mOFTOD?SRV9Ti@Tvo@XP O?WHOFd`FNRT;Co9@BWOFO_o;CGC>W G3@ ~ OYG<?;?>AS=@CT BC>9BGA@X@gOYN?M?N?T9M=;?OuMHNF<?T9O<u`dTN<W9N?`>O=GH`<}T<w[`FTu9GJ>TA@mFWOF>-@NFew[

int x[10];
/* 10 elementos: x[0] x[9] */
Programa exemplo: utilizao de vetores numricos

Descrio: o programa a seguir ilustra o uso de vetores numricos. Pedese que o usurio entre valores inteiros que so armazenados em um vetor.
Ao digitar -999, a seqncia de entrada terminada e os valores
digitados so mostrados na tela.
#include <stdio.h>
#include <conio.h>
void main (void)
{
int iNum[100]; /* Declara um vetor de inteiros de 100 posicoes */
int iCount=0;
int iTotalNums;
do {
printf ("\nEntre com um numero inteiro (-999 p/ terminar): ");
scanf ("%d",&iNum[iCount]);
iCount++;
} while (iNum[iCount-1]!=-999);
iTotalNums=iCount-1;
printf ("\n\n\n\t Os numeros que voce digitou foram:\n\n");
for (iCount=0;iCount<iTotalNums;iCount++)
{
90
printf (" %d",iNum[iCount]);

}
getch();
}
m Hp-"'g
GW<=VFGF MH~ NC 9qhN?M=BXOFWÒnTY<CM?>-T=@WNT ;Co4 l4iBXW[ GF>FT-@`GM=OA@OMJ>G3@gG<a>G3@mW9N;O`FT4GJWbe=GA@T+[
?WneFG@T4l
?WRO<J>A@JNF;JoVT`GY<?GA@`G=N;FNJ`FOVCT@3v
;FG=BO9MG;C`R<RT
`NJGT MFdJO@OO?MAWH@XTGH<<?MGRBgWH;C>O OA@mMJWT9T9;F< <C>RO;CT >HG <>@ NRq ;CoVCMFT9T?N=W< T T:<?>=T MFTJGHW VFN=d?BOW`FT->@ G<C>HGFOeq;SNFT<R<CTl
C
<
Z

@
O9B>T?WHOF>9N?M=O?W9GR;?>G[
P`GFMRd?O@OHD?STv
:MFO;=NF@XOMM=NJO>dGAN?@Xe=GaO |<?e ~ Tq`KGBFGM=T?>WGT@WBgNFW;JOOI>=TFGJ>`TAO<@bO9`<aG <C^>-@GNd=;CG?o_W<GH;CdR>FNCT9><G3[@cO N<[ BCO@X>FT^GRdFG?WHG;C>RT lT
jMFOG @XOHM=T>MGAQ@XGH< G<RV?GJGsM>NJ@OHN?< M=OA@ <?G@BgSW T >N?O?oWR;JO9TA;F@XJOFT `RT<\`HG[ |FGFT >FT-@M=pF`WNJGoF;CT T-@ O=KOBFNCG sRTzq O O <?>A@CNF<?GF;?ooHBq NF;JT_>G<
`G=Md?O-@OD?SRTN=;N?MHNCOdNJeFO<?e ~ TR`GaM?TFWTBCWRO_G?>TA@`G>@XQH<MJO@OHM?>G3@cG<[
#define STR Isto eh um teste
char szCode[ ] = "abc";
jMFTJOW9@XOGM=;J>>GGA@XG!T_< }G}>-@XQT{< M?O-V_@@JONXMJW>GG3N_@g@mG T9< `HG M=OA>H@XG3OR@MFW9>NRG;C@XOGDJ< ST}<C`SFOT <CO>>A@@CNRN?;CoB=U?<?`FGAT_@m< ST} `G<=<=e M?~OTR@`>RGiOF`[ TH<\ [
|FMFT=O>@XOG M=>KGAB=@XGG K_NB?<G >T WHOAM3@M?@CNCO O@m<=Z GBBgW9ONXW9\<C[n>@:HNR<C;C>Fo To;JSFG9T9@XOAC>R@cZGA@W3BgNFW;?OOF`RWHO G;F<JXOFBoWGCO W<?`H>G @N`9;CNCo O=o9;C<?p_G?<CW >9N?M=BWT
N;`9N?M=O;?`FTaTV3@THFdFG?WROz[
P<`GRMFdFOA@cODFERG<v
<?S=TNJ`Q;C>_N?MFOH<+v
char szCode[3] = "abcd";
char s[] = "abc", t[3] = "abc";
char s[] = {'a', 'b', 'c', '\0'},

t[3] = {'a', 'b', 'c' };
9|GRGJ><?TA>Gu@q M?TO_<<CTzGq d=G?W<FGGH;C>FOT9<<C>A@XGH@JN=<C>;?o}O;J>GTA<@ <FW9G3G@cSF;JTAT@ N;FKN=BFMG N?OTudHN?eF>FO=OF`FWRT9O9<;FCM?T TFW G<RV?G[ MRN?N=M?O`FTVCO-@OuT

PO>A@CN?BFN=D?STa`GOdJT@XGH<O<C>@gNF;?o<aV?T=`GY<?GA@GN>FOI`HG`=T9NF<hWTF`=T9<v
" a R m$ #
8.2.1 Atribuio de valores a strings
char szPalavra[6];
szPalavra [0] = 'H';

szPalavra [1] = 'e';
szPalavra [2] = 'l';
91
szPalavra [3] = 'l';

szPalavra [4] = 'o';
szPalavra [5] = '\0';
% RI
'&( A )+* -X ,+- X / .01#

R<>OaB;?D=SFTYMFTVRNCOITYM?T_;C>GfJ`FTa`Gk<J>A@JN=;?o32YV?OA@cO<>A@JNF;Jo/\[
strcpy (szPalavra, "Hello");
m uJ-" p,K6OIm g'I
POM9@`RGG<=MFMFd?GO-;C>R@OODJ;?S`=TT9F<=`RGG G;Bg>WH@XO GaMFWTOdR>M@JFN?GJe >G<l O<N?`T9QHBC;C>->9@N?O9M=<O `NC WHG;`<CGREHMFGdF<\Ov@XOD=SFT `G BgW _G?>TA@q
B>@TYG?sGJW9VFdJTzqOFoFT@mOVJOA@XOBgWOWOF>-@NFeaNJ`NCWGH;F<NT;?Odv
`W9|O=GRN><?@>G@GNJN=>FeO G;s9ON=GCW3;?`dRV?GJNdFsTi;COôqBJOFO_To<GJWUFMF;JT`dHNF~iBFMF;?GqOH< `FT O URd=;CGOA`9<J@XNJKoHMBFB3GbG3@OH@cW`F\O9O[ N=<nNFBJ;JO`G?;?`sR`=TON9@XGONCOJ<>=WOT9dH<NFH;OAV_C@J@OHNG=< OnG;?WMHOO_?dJNFG3>9< @nB_@c@XT_OOB VRNCd`GG9OJ@W9TG;CBW>H`ROOG
K9`G=BJGMd?O-T @OU`F;CT+`_qN?MWGGH;C T9<G<JBgKW BFG9@WÒ_Oi<[O^P3dlCdWNF;Jo`_B?NFOF<oH<CGCTW T< ~UF;?;?`HSFNFTMFGH<bHONOA@NJGO?@W NC_N?`MFG OA@e=GAN@T<C>RTÔFT VCO@OOd?T-T @
B<=B?ZA@CNCTz[4O9;>G3@T<aU;C`_N?MG<a;?OONsOVFG3@mW9N?>NJ`FOYl>FO-@XGF=OI`RTV_@mToA@cO?WOF`RTA@A[
tipo nome_varivel [tamanho_1][tamanho_2]...[tamanho_n];
tipo nome_varivel [altura][largura];
Programa exemplo: utilizao de matrizes

Descrio: o exemplo a seguir preenche uma matriz, seqencialmente por
linhas, com nmeros de 1 a 200.
#include <stdio.h>
#include <conio.h>
void main (void)
{
int mMtx [20][10];
int iI,iJ,iCount;
iCount=1;
for (iI=0;iI<20;iI++)
{
for (iJ=0;iJ<10;iJ++)
{
mMtx[iI][iJ]=iCount;
iCount++;
}
}
for (iI=0;iI<20;iI++)
{
for (iJ=0;iJ<10;iJ++)
{
printf("%d ",mMtx[iI][iJ]);
}
printf("\n");
}
92
getch();
}
m JI-" K3'@m-"'g
JON`9@XONgW_G;M9<F@JNJNCTOA;?@mORWdT9< `G4BgM=WOAO @XORMF>WGOF@X>-G@<NFq e
`H`GGT4<C>>-O?@WHNFO;J;o< T4``TG9U=GC;?WH`TN?< MRG4GBF<J<JKOABF@ G3@m`BT4WO `HG?>WHG3OF@mW9>N@N=;Oe

T
_
C
;
TMFTJW;FV_f@CWNgW9GAG@T;J>FT`HWG Z?s3<Ng>WTa@NR`;Co9Ga< M?OG`FOT<?>@>NO?;CWHo+O[ ;CT `RT UR;C`9NJMFG `N3@cGNC>FT GH<FVFGFMHNC9NJMFO T
Exemplo: matriz de strings

char nome[3][10];
+----------------------------------------+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
+--------------------------------------------|
| 0 |
|
|
|
|
|
|
|
|
| \0 |
|--------------------------------------------|
| 1 |
|
|
|
|
|
|
|
|
| \0 |
|--------------------------------------------|
| 2 |
|
|
|
|
|
|
|
|
| \0 |
+--------------------------------------------+
BCWROGCs_GC<JW>AVJ@JdFN=T4;?oMA@gVJN?OAOn@X>HBCNFWRMOB=d?WOO@b>@`NFGCeY_GC`WG6T< 5kG<?<R>AV?@CGNFM;?NJo<kNFMJM?OTF@W6O97V?GHM?;CO-O9@<OMJ>T G3@gURG;C<\`9[

N?MRCG OA@GHO4<?KOB=MRG3G@X<`=<TzOqI@WHT_TB<
<FGJOiq ;?T?W_G iq ;CT?W9G 2F[
m pgp '&)(pH'sg " I
dMFTJN=W<?>FVCOOR8H>UCOGHd=TANF<@GRG?<\WYv >dNFV?NTY<>OM?T=Wk`TaG >MFNTVTk;=<?>F?O_O_;C<?>GG`< OW<=GOV?>AOA@CN?@cOFei`[ OH< VJTA@ U_@coB?d=O< K9B?G <CS=T
tipo nome_matriz[tam_1]...[tam_n] = {lista_valores};
Exemplo: inicializao de matriz

int i[10] = {0,1,2,3,4,5,6,7,8,9};
P^<FG9@N=;N?MHGNCNJO>FdO N=e?ÒG}DJSFTnZ-`@GkN?OHW<}O>F@TNF@eFWHGRO<Y<\`[G4 M=OAV9@X@XORTFMFo->@GOF@XWGOu<qO T9B4<=G?<Fo9NXBFWNV?@ dRG<CNFWdGHBR;C<C>>G@O <C>O_@<}NR;Co9`<NCHqGAVC@TR<JÒG<

T@WO_<`GYN;=NFMNJOdNFeJOD?SRTi[
8.5.1 Inicializao de Matrizes de Caracteres
Programa exemplo: inicializao de matrizes de caracteres

Descrio: o programa a seguir ilustra a inicializao de strings.
#include <stdio.h>
#include <conio.h>
void main (void)
{
93
char szStr1[128]="Inicializa";
char szStr2[128]={"Outra inicializacao"};
static char szStr3[128]="Inicializa como static";
char s[] = {'a', 'b', 'c', '\0'}, t[3] = {'a', 'b', 'c' };
puts(szStr1);
puts(szStr2);
puts(szStr3);
puts(s);
puts(t);
printf("%c\n",szStr1[18]); //imprime nulo tem 10 caracteres
puts("fim");
getch();
}
8.5.2 Inicializao de Matrizes Multidimensionais
N;C>:9z;<2F>=bwq?q@2iq4zq?5q@7iqAiq?=
9z9z ?>
> ==
9i9i 2F2Fww F
== 75
9z9z<<FF?>
>== 2
9i9i5J5JwwF
== ?
Exemplo: inicializao de matrizes multidimensionais
WMFWÔ=TH>;?>@BgGN=WHe\@rOqn>FNRTRG;F`FNF;CT9>RMR<SFN?OTTd<aN=Te?NFO;M=D=NJT?SFMWTNCVFOHN=`dd?GNFOe?`=BCORTW`F@ ObT@cM3WG@O<INJ>OA@JV9@XN?@XZ eG<JqaGBXW;C<JO>HGG;C<ISFWTOR;J>AOI@JTN?`R@e GFMGRo-d?<@O-V?O9@GR;OM`DJN?GSTiN=T[ M?O`=<FTBJTNFMRNF>GO=;JW>OG;T V?OA`R@cOO
8.5.3 Inicializao de Matrizes sem Tamanho
Exemplo: inicializao de matrizes sem tamanho

char erro[] = "erro de leitura\n";
Programa exemplo: matrizes de caracteres e vetores

Descrio: este programa pede para o usurio digitar nomes e idades e os
guarda em dois vetores (uma matriz para os nomes e um vetor para as
idades). Ao final da entrada de dados os nomes e as idades so impressos
na tela. Observe que na entrada de dados o nome referenciado somente
pelo primeiro ndice. Admite-se no mximo 40 caracteres para cada nome.
#include <stdio.h>
#include <conio.h>
void main(void)
{
char szNome[10][40];
int iIdade[10];
94
int iI,iN;
char cCh;
iI = 0;
do {
clrscr();
printf("Nome: ");
scanf("%s",szNome[iI]);
flushall();
printf("Idade: ");
scanf("%d",&iIdade[iI]);
/* entrada de um nome */
/* limpa o buffer de entrada */
/* entrada de uma idade */
iI++;
printf("Continua [S/N]? ");
do {
cCh = getch();
puts("");
} while (cCh != 'S' && cCh != 's' && cCh != 'N' && cCh != 'n');
} while (cCh != 'n' && cCh != 'N');
iN = iI - 1;
/* numero de elementos */
clrscr();
for (iI=0; iI<=iN; iI++)
{
printf("| %s | %d | \n",szNome[iI],iIdade[iI]);
}
getch();
}
Programa exemplo: soma de matrizes numricas

Descrio: este programa pede para que o usurio informe as dimenses de
duas matrizes que sero somadas. As dimenses devem estar no range de 1 a
10. O usurio ento informa os valores contidos nas duas matrizes A e B.
O programa executa a soma das duas matrizes e mostra o resultado da soma
C=A+B.
#include <stdio.h>
#include <conio.h>
void main(void)
{
float a[10][10],b[10][10],c[10][10];
int
col,lin,m,n;
clrscr();
printf("Informe a ORDEM da MATRIZ: (mxn)\n");
do {
printf("Numero de linhas (m): ");
scanf("%d",&m);
} while (m < 1 || m > 10);
/* m de 1
10 */
do {
printf("Numero de colunas (n): ");
scanf("%d",&n);
} while (n < 1 || n > 10);
10 */
95
/* n de 1
for (lin = 0;lin < m;lin++)

{
for (col = 0;col < n;col++)
{
printf("A[%d,%d] = ",lin,col);
scanf("%f",&a[lin][col]);
printf("B[%d,%d] = ",lin,col);
scanf("%f",&b[lin][col]);
}
}
printf("\n");
for (lin = 0;lin < m;lin++)
{
for (col = 0;col < n;col++)
{
c[lin][col] = a[lin][col] + b[lin][col];
printf("C[%d,%d] = %f\n",lin,col,c[lin][col]);
}
}
getch();
}
96
Captulo 9 Introduo a Ponteiros.
B9MFOTJBW@X@JONCVFZ=;JBJ>>FOGG`FNFT-<wO @3[[>GCWs9BObGFGMHV=GB?DF;?OAS=`R@CTGNC;CZ?`R9`TG=G d`RTBlW >HBCWNV3VC@mT;CTTFoAW`@cGbGO?WO9O O<=<?@JOTNCdFZ=MHoNCB=OFG;`d <uTXORVJTFO`d?BgT-GWO@XG<F<G3VCT9@4<=<JNFBSFD?WT SROT OA@ ;?OAWO@JONeRW9ZFGGC;?WHGROFpAd `R@JTNMH<OCO`RG@9WT q
lNV?TH;>z<`N?qN?D=RSFGATId=@XTFGH`HO;CG>i>qG\WHG?[`RWTp-BFP3@FdRNCdRlCOzGFW [ `_ONF<K9<CBCT+O_qt;C>9NM=`FOFO`Ò G ÒAGb@CNCW9ZFGCHWGp-d @N?O^GH<C;J>GZ MFGHO<F<?<RZA<CT@CNCMONJOF`V?OOA@mO O OA@BgWRWOO eG;JfZ;FFN=dJM?OO
|JTHGR<?;?>>GGHN_@XM?TO9<VFUJO->@BFWdJORT{eG<?;JGO?@W^ZV?OHTV_<R@N?GDF<JEGGR;C<>FOR``FGbT{W9BGCWWRp@>9NJN=OiV?[rTPA`HdFG lJWOA`@CG NCZFBH<CGORd`FT9MH<COFM?WTJO=W`TOOVJT@N?;?Z?>_GHGN_N@XT<[q
V?VFTHG9;?@W9>GHNJ>N_G@XTWH<{O;>FN=OFVWHB?d=lCOAW @ RV?OTF@`HNJGCZ?W 9G<?NRG<@ GWkBF<?O=BR`;?TDF<tERGMF<T?[ WHTO@o_BgW9GR;?>FT_<u`G HBF;?DFERG<qT KB=G
m .mKK:IK6$" $&IpBKJOI'"
P R<>dGNF;JToVFB?G9OFoR@XOFG?`FW T-@ ~z@g G?>FVJT-T@<;?<FOBRN^TBGW ;C`HTG3V=@XG3G@XDJOFT`RTA`H@G MHBCWO?OWHOFÒATC@NJZ?T9VJGRG3d @XOF;J`ROTA@nWHGC`HWG^pA@CNCGHOz;C`[G3@cGD?GT;C`HG3@;D3GFD=\T [

`GWGJWp@NJOklOA@mWOeGR;?OF`RTkGCW4BCWROO-@N?ZJ9GFd`Ta>NVTVCT_;C>GRN3@T+[
Programa exemplo: usando operador &
Descrio: Este programa aloca na memria um valor inteiro, um valor real
e um caractere. Todos os valores so inicializados. Em seguida, usando a
funo printf os valores so exibidos na tela, junto com suas posies
iniciais de memria.
#include <conio.h>
#include <stdio.h>
void main (void)
{
int iCont = 1;
float fValor = 5.5;
char cLet = 'a';
printf ("valor inteiro = %d \t\tendereco int = %X\n",iCont, &iCont);
printf ("valor real = %f \t\tendereco float = %X\n",fValor,&fValor);
printf ("valor char = %c \t\t\tendereco char = %X\n",cLet, &cLet);
getch();
9WsHGWGpAMBJ@C>FNCOO9;C`RVJTTF`GYT <?GV_@ @mT`9oAN@cO?G3W@gOiGq;?>GBgWÒ O=KBF<JGFOd=U?O`FO WRT9<CVC>-T9@<FO<R`FUgO9G=;?d TY<F<FGG3B@CNCMFO TJWVFBJO >FO`Fd?TTM?@\OHdv NFeJOD?SRT `G
valor inteiro = 1
valor real = 5.500000
valor char = a
endereco int = 12FF74

endereco float = 12FF78
endereco char = 12FF7C
P<FGJo9`_BFNFN9<@3VCT_[<FNFHDJSF<?T4G@`9GRG <?>GHK_<aB?G ÒF`RTT< <H;COOdFTAW@gGJGW< p@gN?NRO;C>VCGRTRN_`@XGnT< <?G;@BXW @GV9M?@XT=GW9<JVGBC;C>R>FOFOR`F`FT-On@ V?GRM?d?T=O4W 9N<o9N=B_<?>@cOGJWOO

T9TMRVJGABVC@OHHO MN?T;J' O9du>G<È
G O 5VJ2 OA@X>HN?N_>@4<}`FTTHMBGV;JO?`F
W GA@cGD?IT G 9'>H2_GyF<\y [nJzPAq<RT<FNCW+qOHd?TA @@XOG=d?OT-d@ xNF;?O>Rd?GT-N_@k@cT THMBN V~ HO T;J>
`G 9RTY>GG<;J`GAO @XGRV?D?OT@X>N92H@kyRy`RJ T~ [ G;C`G@XGDJKT 2HyRy JLGTOHd?T@YMCO-@TMB=V?HO 9>RGO^VJOA@X>HN3@
97
int iCont=1;
&iCont
12FF74
float fValor=5.5;
&fValor
12FF78
char cLet=a;
&cLet
12FF7C
4 bytes
5.5
4 bytes
1 byte
ig. 8.1 Disposio de dados na memria.
m 7mK'"IpK/ '"Ep/#pKII "I
V?JOOT@X@J@ONCZ=BWk`GGOd\MF<JqdJ>OGAT @@gO-N>_@<?NFM=V?TTBgWO `RM=Ti[ OAOk@Cd?NCT-OZF@<JH>GFGAK9d @gB?NFG<FVJM?TGRTY;?d?>RO^laGN_M?M@cT_CTi;CO=q>WlCOW^``FGJTaG G`=GNV9<F@XG GJTM=GFV=GH`G3<FG3@XVFO=@G=`MTAT^NC@_;JN?`T?MFGaW9OAG@tN;C`R`_T ON_@GF;?OAD=TJSF@CW9NCTOG ZF-[ `RGROd
G?sGJW9VFd?TaO<FG?o_BFN_@`GCWHT;<C>-@OaOBC>_N?dNJeFOD=SFTI`RT<TVFG3@cOF`T@G<PDbGM\[
Programa exemplo: usando os operadores & e *
Descrio: este programa aloca na memria um inteiro e um ponteiro para
inteiro. Em seguida atribui ao ponteiro o endereo do inteiro. Utilizando
printf mostram-se o valor do inteiro, o endereo onde inicia a varivel
inteira, o valor da varivel ponteiro (que armazena o endereo do
inteiro) e o valor da indireo acusada pelo ponteiro (que aponta para o
valor contido no endereo que ele armazena).
#include <stdio.h>
#include <conio.h>
void main (void)
{
int iCont = 1;
int *pC;
pC = &iCont;
/*Declara a varivel ponteiro.*/

/*Atribui o endereo de iCont a pc.*/
printf ("valor inteiro = %d \t\tendereco int = %X\n",iCont, &iCont);

printf ("valor de pC = %X \t\tvalor de *pC = %d\n",pC,*pC);
getch();
9W?WRGWO{pA@C<?NCOHOU?`FVJOuTF`V?GYT<R<?<FGUg@ 9G=`9dNG3V?@gOG@X;?Ou>GG<C`>O=GKBFGFV3d=@XOT=oWR@T9O=<CW>-O@Ol `FOO{;?TY<?G=<FoGBBNF;JMF>TJG WVFBJm>FOO`Fd?TTH@M?\Ov dRNFe?OHD?ST `G
valor inteiro = 1
valor de pC = 12FF78
endereco int = 12FF78

valor de *pC = 1
98
P}N;>9GNN9o9@B_O @cOTMROBVC<FOGJo9^BFN9'@ 9>NJGRd<BF<JG^>A@GO<C>ROZ<ONC@>_WHBCOOeDJGRS;?T OF`ROoGA@mOÔ`FVCOO@mV?>9GRN_d?@4T`=T^V3@TRGoA;?@`ROFGAWR@XOiGF[ID=TKP 2Hy=OAyQ@CJGNCLZF[hGRPd

ÒG=M@Jd?NCZ=O-@OG`Fd OHV?THOA;?@>WRGHON_eF@XGHT ;COV?GOA;C@c`HO G3@GFNRDJ;CT9><GRN_@X`T GNF ;JM>V G~ N@T9R <[aGH<C?>>O NFdRNFl e?O_;CO `TTTA@mWTOV?G@M=OTF`=WTT @:DG=dFVCO O@mOl
TV?THJ>;?>G3GH@ N_@XTTi[SGC;JOA`@XG3O @G=TDF?T >HG3`R@T TNF;?OR>RdFGTAN_@@T+`q TT N;C>HHGON3dF@mTAT @ O`T VCO-@GH>9;CN_`@GA@c`GT D?T V?Tl ;J>GON>A@X@CTN?BFB=<?U?OH`FT <?G ORTT
T9VJGA@OR`FT@`GYN;C`_N_@XGDJST M\[
int iCont=1;
&iCont
12FF78
1
Varivel iCont
*pC
int *pC;
12FF78
Varivel pC
pC=&iCont;
Fig. 8.2 Disposio de dados na memria.
m m6+" g'psap'"f$,K:#KIIp " "m '"I'g
WT=`9VNC@X_TFN?o-MF@OAOF@WOtTO Od=<?TAG?@ro_BF`=N3O@HOAW@JT9NC<CZ=>@XGO dw[ T B=<?T`FT TVFG9@XOF`FT-@`GN=;?`N9@XGFDFS=T MR VCO@mO

Programa Exemplo: usando o ponteiro de indireo
Descrio: Este programa aloca na memria um inteiro e um ponteiro para
inteiro. Em seguida atribui ao ponteiro o endereo do inteiro. O valor do
inteiro modificado atravs do operador de indireo (*). Utilizando
printf mostra-se o valor do inteiro antes e depois do uso do operador.
#include <stdio.h>
#include <conio.h>
void main (void)
{
int iCont = 1;
int *pC;
pC = &iCont;
/*Declara a varivel ponteiro.*/

/*Atribui o endereo de iCont a pc.*/
printf ("Valor inicial de iCont = %d\n",iCont);

*pC = 30;
/*Um novo valor para iCont, indiretamente.*/
printf ("Valor final de iCont = %d\n",iCont);

getch();
}
99
R<>GYV_@XTFo-@OFWROIO_V_@XG<JG;C>ROIO<a<FGJoBNF;J>G<a<CO_UCÒ<wv
Valor inicial de iCont = 1
Valor final de iCont = 30
~ TJOROWdF@JTnTANCZ=@}V?GT=K9dY`B?G4G N ~ <FTHG9@;?@GR>i<T[1NC`HPG<JGAR@;COHT @OFNJ`Z?TiG9q;CGF`HdYMJG3TF@XV WGR~ TnD?T @V G~ V9N=@X;?MFG`T<JN=;JGM?>;COl?>R`FW4OT TnBgV?WHGRTAOI;?@ `=GTAV @X@~ GWqD?OaTÒH`RGd?Tn>OG3N MR@c~ OGTH<F;?<=<C>iTaGq T OHd?>OG3@O@cNJd?OZ?T-;?9@`=G=T4di`=[ OT
m ' pKm#'IKI " IBp ,m%&)KK
9OJT=B=@mò9;FGCD?BgWHW_SRTTG<u
V;?>FCTYBCT>9`RG?N?GW4dHN?<FeFWNwOOH[ @ ;NFVR_B?BFdF;FOAD?EH@ G< T KBFGOd=TA@@ G=MGFKHRB?GCG W OA@XGR@XMFoGFBRWG\G;Jq >FT9W<UO_< TWVXZ;CSRT Y\[^]_VCVTFX`Hq G >ROOd}RG?>KOABF@ G OT
9MR;B=>OF;FWD?@XSRORG=>FT`FO9T;C`>RVJGJTiO<qnG?<WRO<?T9oGF< GJ=WIO VCOO9`H@m<FGo9<J<FBgOAG?W_@ RGOA;?@T>FWHT_T<`G< ;JTÒRVG3dFXN@>G=GX'DFac@T Obad@`FXGeOTf3<giHh\OA[\O@J[ dJNCTZ=@XGHG<d `FVCOHO-<@O HOAO @JNCZ=BFG;=NRD?<^SFT+`R[ G;C:>-<J@>FT T `=Ol
4V3@TRoA@XO?WHOIO<?G=oBFN3@N?dHBF<?>A@cOIOYB?>N=dNFeJOD?SRTI`FOV?OH<F<?OFoHGCW4V?TA@a@G?RGA@XQH;?MNCO+[
BORORGRdFdF<FTATAM3@C@@N?`DF`RSFTGT+NFvBC;?W>RRG<C>HN_NRGn@c;CTi>V_[GRN3@cTF@oAT@XOJO=W>O4@O=>GJlWn<Bg`HWG O4HBgWB;?OM=SFMHTnCOFM3WR@CONC`FOO`FOVTV?@Gd?T@GJBG3<FBC@gZ-Q;F@N?MTYNOK_B?GGO@d=G=>MGAGF@mROGYTT
Programa exemplo: passagem de argumentos por referncia
#include <stdio.h>
#include <conio.h>
void main (void)
{
int iCont=5;
void MudaValor(int *pIn);
/*Ponteiro para inteiro.*/

/*Declara a funo.*/
printf("Valor inicial = %d\n",iCont);

MudaValor(&iCont);
/*Passa por referncia.*/
printf("Valor final = %d\n",iCont);
getch();
}
void MudaValor(int *pIn)
{
*pIn += 10;
/*Recebe o ponteiro.*/
/*Altera o valor do inteiro.*/
printf("Valor dentro da funcao = %d\n", *pIn);
P<?OUJ`FOI`HG<?>RGkV9@TFo@mOFWOaO9V_@gG<FGR;C>OaO<a<FG?o_BFN;C>HG<hWG;F<JOFoGR;<v
Valor inicial = 5
Valor dentro da funcao = 15
Valor final = 15
V?OdF`=T4OTRV?GF<?d=GO@OFBWR;JT9DF<YSFT KB=V9Ga@NFOY;J>FzO[r@gN?PZ?_GFMHdnCO?NWH~ OFT`;?O>4 lnHNRB;F;?NFD?MRSRN?TOd9N=BCe?`ROFO`Rx_OOHd?M=TTF@4W4lTHHOGdFNC>RTO @

=|V?OHGR<?<j><CqO_G4;CW`GJTTs<JRG?>A<?W_@G
k
9M B=VJ:;FD?;gQSR=lT 3 qBC`<COT=x9WT}OOHdFTG ;?@ `RGAO@@XTG=GRMD?GFT ROGdJ`RTO@T K_O-B?GG@;?NC`RZFGA@HG@XG<RGRduNCD?`T GN ~ `=T9;CO O;>id?q THO-M?;@OSN?dTZJNJeFGT Od D=SFTGiOdJqu`TG@^MFT?W_`=W GCOWpO @JO-NC@ON=N?;Z?O<C_>-dJGFT@diM?BF[OFD?`RSRPOT
V?O@XOOO@gN?Z?GRdN ~ T;J>iqKBFGGR<C>Z;?TG;J`GA@cGFDFT OVJT;?>FOR`FTV?GdJT VJT9;C>HGN3@mTz[Y
100
GV3;@m`ToAG3@g@cO?GFWDFT4O`=GCOs_GCWOVJ@gdFN?TZ?_O GFdn<?G=N o~ BTN;?>4@A[n;?S=|?T4TF>HlG OKd?BF>HG G3@XTHO=<`TiqrG;?MJ`RTFG3W@TGFD=TVJTF< `GORK<=BG3N @WT_G<C@>N?@mON=`FM?T_O<`=TV?GFVF`GFdJGJTW
<FG9@r`_NCG3@gG;?>RG<`FOFK9BJGdFGH<T=>N?`=T<I;JT<JGBM?TFW9VRBC>O=`FT@3[
Programa exemplo: endereos na passagem por referncia
Descrio: Este programa tem uma funo criada pelo usurio que recebe o
valor de um inteiro atravs de uma chamada por referncia e altera o
valor do inteiro. O programa tambm mostra o endereo da varivel na
memria, referenciado pelo ponteiro.
#include <stdio.h>
#include <conio.h>
void main (void)
{
int iCont=5;
void MudaValor(int *pIn);
/*Ponteiro para inteiro.*/

/*Declara a funo.*/
printf("Valor inicial = %d\nEndereco do valor = %X\n",iCont, &iCont);

MudaValor(&iCont);
/*Passa por referncia.*/
printf("Valor final = %d\n",iCont);
getch();
}
void MudaValor(int *pIn)
/*Recebe o ponteiro.*/
{
printf("Endereco do valor dentro da funcao: %X\n", pIn);
*pIn += 10;
/*Altera o valor do inteiro.*/
printf("Valor dentro da funcao = %d\n", *pIn);
P<?OUJ`FOI`HG<?>RGkV9@TFo@mOFWOaO9V_@gG<FGR;C>OaT<a<FG?o_BFN;C>HG<@XG<FB=d?>O=`T<wv
Valor inicial = 5
Endereco do valor = 12FF7C
Endereco do valor dentro da funcao: 12FF7C
Valor dentro da funcao = 15
Valor final = 15
OGJT=M=;``GGCG3<FWH<=@gTGFGDF<YTTTR;CO<?TdJGAT@KH@B?OAOK@dB?GbK_@B?G@G<RGNC<RT4`NCGb`GGY;CT4`H;CG3HTY@OG=d?GD?T-;?T4@`GO`@XM=GGGDJ<FTzN <J~ qOFT_Ò;CTndF>z>[V=GGF@dFO9O;T_`FV?_T9GABFC@;FT+ORD?[`FSRTT@9BCMF`ROx3V?ORGd?T@W@NC>HlYG4TKB=W_G G<CWR<JTG

O@JVNC@Z=ToAG@cNFO?<}WO `HGFOMdJO<?@GFORo`FBRO9N_<}@ `B?GH>H;CNF>d@mN=T e?O `G}V?THW;COH>NG;N9[@T9P< VOBR;?@D?O SRT}>-@T@MJTHOM?@ OJx_TORdFTA@XOHGHd?< T@ @GF`RMRG GFGu`9BCO_TH<<
V?TH;?>GHN_@XT<aV?O@XOa`BCO9<hO-@N?Z?_GN<[
Programa exemplo: troca de variveis atravs de referncias

Descrio: este programa tem uma funo criada pelo usurio que recebe os
endereos de dois inteiros e faz a troca dos valores atravs do acesso
aos valores residentes naqueles endereos.
#include <stdio.h>
#include <conio.h>
101
void main (void)

{
int iPrim=1, iSec=2;
void TrocaValores(int *pIn1, int *pSec);
printf("Antes da troca: primeiro=%d, segundo=%d\n", iPrim, iSec);
TrocaValores(&iPrim, &iSec);
/*Envia os enderecos*/
printf("Depois da troca: primeiro=%d, segundo=%d\n", iPrim, iSec);

getch();
}
void TrocaValores(int *pIn1, int *pIn2)
{
int iTemp;
/*Recebe os ponteiros.*/
iTemp = *pIn1;
*pIn1 = *pIn2;
*pIn2 = iTemp;
P<?OUJ`FOI`RTV@XTFo-@O?WOaOV9@XG<?GH;C>OO9<a<?GFoHBNF;J>G<hWG;=<COoGH;F<\v
Antes da troca: primeiro=1, segundo=2

Depois da troca: primeiro=2, segundo=1
~NTJ;W>TGN9@VCT TR``G G <?NcG39@G?W_V^TRl<?G3@mTJO>`=N?T `FT;?OT >@XG?O?s_GJlW9< VFdJ`RT T `THO VFG3@ORB`F;JTDF@SFT MR\\@qYTM?K9OCB?x_G OdJOTM@XGRGH<<<CqO T T OOd=dJTTA@@
@GR<NC`HG;?>GY;?TYG;J`G3@G=DFTa`FOHOA@JNZ?9GFd[
P<@mTM?OCx_OO@d?NJT-Z?@X9GGR<N< BC>N=NddNF@CeJNgOW ;JSFG TnTbN j GFOM d=TA@I<?SR`HT GN j O-GF@MN?Z?GHGNFNQ<_@NCWNR;C>G GN9<=@NgO9W<q[ MCP O=WO`FMO_CO=<WOO`FO <?GB=O<
G;`G3@gGFDFT<w[
102
Anexo
Tabela ASCII
Non-Printing Characters
Name
Ctrl
char
Dec
Hex
Printing Characters
Char
Dec
Hex
Char
Dec
Hex
Char
Dec
Hex
Char
null
ctrl-@
NUL
32
20
Space
64
40
96
60
start of heading
ctrl-A
SOH
33
21
65
41
97
61
start of text
ctrl-B
STX
34
22
"
66
42
98
62
end of text
ctrl-C
ETX
35
23
67
43
99
63
end of xmit
ctrl-D
EOT
36
24
68
44
100
64
d
e
enquiry
ctrl-E
ENQ
37
25
69
45
101
65
acknowledge
ctrl-F
ACK
38
26
&
70
46
102
66
bell
ctrl-G
BEL
39
27
'
71
47
103
67
backspace
ctrl-H
BS
40
28
72
48
104
68
horizontal tab
ctrl-I
HT
41
29
73
49
105
69
line feed
ctrl-J
10
0A
LF
42
2A
74
4A
106
6A
vertical tab
ctrl-K
11
0B
VT
43
2B
75
4B
107
6B
form feed
ctrl-L
12
0C
FF
44
2C
76
4C
108
6C
carriage feed
ctrl-M
13
0D
CR
45
2D
77
4D
109
6D
shift out
ctrl-N
14
0E
SO
46
2E
78
4E
110
6E
shift in
ctrl-O
15
0F
SI
47
2F
79
4F
111
6F
data line escape
ctrl-P
16
10
DLE
48
30
80
50
112
70
device control 1
ctrl-Q
17
11
DC1
49
31
81
51
113
71
device control 2
ctrl-R
18
12
DC2
50
32
82
52
114
72
device control 3
ctrl-S
19
13
DC3
51
33
83
53
115
73
device control 4
ctrl-T
20
14
DC4
52
34
84
54
116
74
neg acknowledge
ctrl-U
21
15
NAK
53
35
85
55
117
75
synchronous idel
ctrl-V
22
16
SYN
54
36
86
56
118
76
end of xmit block
ctrl-W
23
17
ETB
55
37
87
57
119
77
cancel
ctrl-X
24
18
CAN
56
38
88
58
120
78
end of medium
ctrl-Y
25
19
EM
57
39
89
59
121
79
substitute
ctrl-Z
26
1A
SUB
58
3A
90
5A
122
7A
escape
ctrl-[
27
1B
ESC
59
3B
91
5B
123
7B
file separator
ctrl-\
28
1C
FS
60
3C
<
92
5C
124
7C
group separator
ctrl-]
29
1D
GS
61
3D
93
5D
125
7D
30
1E
62
3E
>
94
5E
126
7E
95
5F
127
7F
DEL
record separator
ctrl-^
RS
m<n<noprq<q\s<sstuo<mwvyx{z|<xt_};~Gt<~};q;s<nx;y;qx<|{<;yq<x<|z<ztum{n<
unit separator
ctrl-_
31
1F
US
63
3F
103
9BjXJN=><7CVC_T_:2;FRUCP GRj=L~3dI[ G:XRWP v q_OoHV;F[G3M@[ -BB;?GHO?<FWV\OJ[ W3T@>FRT+Wq O9jBN@J<CNg=>H9GCW|?Oj<NF`<?>RG||BCWzBgW_[G3VC`@XORDFq SFT+OHMFqG2<F=<O`F2\TY[ G?Wzv

=2C5 >> FJ|z_B Rq4 j HOH|iN3@q>RTJdF;d[NT=>FdF>+G=>A[@3d=;RoN?MFGO:9@B9ONCo_JTFNC>TORd=diGFO[ ;JOkj STGaMO9N3BJ@cd?MT^BNC>Rv4T<O/`9Ga@T_M;I?O?CHT=TOGFO?=W_<wGq?;?>FGT+7Q7d[ 5wj [ ST
JOHR BFd?Tj : v_|y9Mw:i@mq O ~ JOA N?@Xddd
`F[ T 39 @@TRO_oA<FNF@XOJdwWq?:?G`H7dGJ;?J\>H[ N?N=G3@h|=O?WN=;Co ~ T;CHG;C>_NCT9;F< [ j ;NFVRV?GF>H<\v
R
G
\
<
?y>=jg>9hVPvFd?oQTA@CNC>F[mWR<=T9;<NFVRqV?G?G>9737Q<JI[TA@coiP3q ÀOH@CMFNCO9G;<=T <CTkTRGJW6OFK9B=5GNC WY`H`GGOF_oRTd<?NCH>=TIGN3`@OG~2 =@gBF\Le\[q
`?m>=G=>9NVRB=vFd|F9C?TaG?K_ `BFq GNBVJGi2^F[8;=BMF\L HG\[ [mJBr=@H+@[AH@8HHOF:`8@gHNCBO9U;CT=M?BRBO9tVC/T_8<C^>9)N?^d=UO?ORJd?HoTA@CNC>FWR T9<[C>FWzq1P3MRG<<CTYG?WSj
Bibliografia
/N-Z/|>I{x{~P{~P]Ny/|a~
|PF7R7/P-J R[ q y?G3@X`HN;CO_;C`FTz[1PABJ>FTFWOHD?STa:;C`_BF<?>@JNCOHdk:2da `9N?D=SFTz[ j SRT OHBFd?T v_@NFMJOzq
c P3=lFj P:R|\qq3 BR@CONF;\<\[[49~ N=M3VCOA@T9@XOY
dF>GHNCo~ Tv<a`NFMJx_OT<\dq BW<?GGFo\@G?[ `RTj S<TG>O9BJ@gd?BCK9T^B?GHv <F[ G9j@GSFJTGRdFGGJ 9zOBJqdFTiG7Qv47 jO[ _@T9;

<

T
F
jPF?~QT=mPATO d:H= <wgzBCq?q Gq 7Qg7 i2GAGA@c@m[ >TG3;@c>i~ [ T9~NXW93M?T=@cW9OIVF`dFG=G>Fq TYP9Gd?o>FTATR@C>FNC>FOWRdwT9[ < j SFR T y=BRCO;C`BFOJdJWTiGv;CH>RTO<9@mT9G;a_ C@ZT>TNJ?MF<\Oiq[ G7372[
R cF I ?= FRF
PPVVT9T9<C<C>_>_N?N?dFdFOOy=B3B;@c`FTO?W_~G;C>TH<;F`RNO4GA=@<RNRNC;Cò9O=BÒFoG GCW~ OF> ~pRd N?M=R OI~ `FGyR= G=d?TGF>FÒ_NJO<I;FGRN3G@O7Q73R\ [ H @XTF+[ O-@XMFTH<
P2yR=N=VT9<FM<C>_=?N?TdFO@; pR oH2NFFM?ROa `G9 @TRoA@XO?WHODFS=T R ~ y=X GF`NJO;FGRN_@XOH @XTF+[ OHBFd?TJTV=G< R
104

Idioma

Bem-vindo(a) ao Scribd!

Lógica e Programação Aplicada: Prof. Marcos Fischborn Me iane ira - V .2

Enviado por

Dados do documento

Descrição:

Data de envio

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Descrição:

Direitos autorais:

Formatos disponíveis

Lógica e Programação Aplicada: Prof. Marcos Fischborn Me iane ira - V .2

Título original:

Enviado por

Descrição:

Direitos autorais:

Formatos disponíveis

Títulos relacionados

Lgica e Programao

CAPITULO 1 - SISTEMAS DE NUMERAO.......................................................................................................7

1.3 Principais tipos de bases numricas.................................................................................................12

1.4 Tabela de equivalncia entre bases..................................................................................................14

1.6 Unidades de Medida.........................................................................................................................18

3.2 Ambientes de programao. .............................................................................................................34

3.4 Tipos de dados..................................................................................................................................37

3.8 Inicializao de variveis.................................................................................................................43

3.9 Constantes ........................................................................................................................................43

4.4 Diretrizes para construo de um algoritmo....................................................................................53

5.2 Funo de Entrada/Leitura : scanf()................................................................................................60

5.3 Funes para entrada e sada de strings: gets e puts.......................................................................64

6.2 - Comando if ( ) ................................................................................................................................72

6.3 - O comando switch () ......................................................................................................................74

6.8 - O Comando exit()...........................................................................................................................82

8.3 Matrizes (Multidimensional) ............................................................................................................92

8.5 Inicializao de Matrizes..................................................................................................................93

CAPTULO 9 INTRODUO A PONTEIROS. ..................................................................................................97

PROGRAMA EXEMPLO: FOR ...............................................................................................................................79

Capitulo 1 - Sistemas de numerao.

8^H8:H@3J 8HH ):)sO/)t/@ :8HBHJH)d8@8:8J@H H H8^8HH^

e6^8HBHy3^_ 8J6^e@/@H8^H3@y:@:):nB /:s/:@:)J^33^

J:@vB^Hw8H H=8:H8HHHr 8HHw^@h^x88H^vH3B^v

1.3.4 Sistema Hexadecimal

1.5.1 Decimal inteiro para base r

1.5.2 Converso de frao decimal para base r

H :8H 8:8 O/@8B B:B)JH H3J 8 ^@)^H@:3@HH 8HH 8:@

Assim: 0,254)10 0,20203)8

PARAR, FICOU ZERO

Assim: 0,375)10 = 0,011)2

Assim: 0,8)10 0,1100110..)2

1.5.4 Converso de base r para base decimal.

1.5.5 Converso da base binria para a base 2K

Assim: 10110,1011)2 = 26,54)8

Assim: 10110,1011)2 = 16,B)16

1.5.6 Converso da base 2K para a base binria

8^1sO=88 H @:8 { 8O/ BH@=3 8JB @O H@8: 8H 8

Assim: 123,47)8 = 1010011,100111)8

Assim: C13)H = 110000010011)2

1.5.7 Mapa de converso

d H\' DB+_ `JJ:% RJBH:_ `JJ8@

Captulo 2 - lgebra de Boole.

8O/ JO/HBB:6 /@ @ @JH: :x^O=@3J@H Bt/BxsO/BHH:/@

Exemplo: Expresso lgica

^@O6H: OB8_ ^@B BJB@8^ 6/

Exemplo: Tabela verdade

J:8@H: s/HBH )HHB JB:@B @ 3^/@B@: BO/%s: B 8J

:J:8BH:vsO/@BH @3 8:@:@HBH@ B H 3Ht=3BH^e@B :

Exemplo: Tabela verdade

I '"$ I#'" $#pKI

Captulo 3 Programao estruturada em C.

=HHBH@B ^{HB:)H B 6Ht6BJ:83 :8tR)^/H8 6J:@@ )

@:HB@: B )^86HH dBB H:H3: @B^@3 @B 8^HH8HORBH:

8^8O6JH H3J @w8:H@@B BO/ BJH@B B @H H@B8 3:8H H

tR: :8=8^6@ @HBH@@ H )^)t6:H @/ 8:H8O=H@3 H

e6^8HBHy3^_ 8J6^e@/@H8^H3@y:@:):nB /:s/:@:)J^33^

J:@vB^Hw8H H=8:H8HHHr 8HHw^@h^x88H^vH3B^v

d H\' DB+_ `JJ:% RJBH:_ `JJ8@

I '"$ I#'" $#pKI

=HHBH@B ^{HB:)H B 6Ht6BJ:83 :8tR)^/H8 6J:@@ )

8^8O6JH H3J @w8:H@@B BO/ BJH@B B @H H@B8 3:8H H

{| }~; y-e ,

{| }~; y-e

m u " ,K,q"Hm,' #%" p'"ItHK

sO=1^ ]N_/}]NI/ @B 8H3^@H3: |/ R) BJB:BB

H@3t6J@8B %HJ 8O6H@BJ:)J %^@:BH3J 83 Y:)JH@ H

m m$#%" IgIp+&)(IJp'1#'g@pJKpKIBpJpq,pKpIK#+" K$"It+&$(I

XQ/5XQ/]N {~iN x|/]N_/} x /]NI~

^H HHH83^ HB@:@B:8B B /:/:@:%JB ) IHB@Bo 6/:H@@3

d @O6@8JO6: 8B^BH)J: H3sB @O BB/: 8BO6^ ^

^@H= 1 tH@BEs=@%s:HD >8J3^H)J@8J

^@/HBOaHwBRHHHB8BBH@HhHw8^8H FI dCFOU4^8:8B @wH8

' J> ed@xser