Info1 PDF

Curso de Engenharia Eltrica
Informtica Aplicada Engenharia Eltrica I
Apostila de ANSI C
Prof. Fernando Passold
Observao: material ainda est em fase de edio!

Usando sistema MiKTeX/LATEX 2 de edio
Referncia: http://www.miktex.org/
Prof. Fernando Passold <fpassold@upf.br >
Engenharia Eltrica
Semestres: 2005.1, 2006.1
ltima atualizao: 13 de maro de 2006.
Sumrio
I Introduo Programao
vii
1 Introduo Lgica de Programao

1.1 Programas e processos . . . . . . . . . . . . . . . .
1.2 Desenvolvimento de software . . . . . . . . . . . .
1.3 Projeto de Software . . . . . . . . . . . . . . . . . .
1.4 Algoritmos . . . . . . . . . . . . . . . . . . . . . . .
1.5 Programao Estruturada e Fluxogramas . . . . .
1.6 Variveis . . . . . . . . . . . . . . . . . . . . . . . .
1.6.1 EXERCCIOS . . . . . . . . . . . . . . . . .
1.6.2 Tipos de Dados . . . . . . . . . . . . . . . .
1.6.3 Nomes de Variveis (ou Identificadores)
1.7 Comandos de Atribuio de Variveis . . . . . . .
1.7.1 Expresses Aritmticas . . . . . . . . . . .
1.7.2 Funes matemticas . . . . . . . . . . . . .
1.7.3 EXERCCIOS . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
2
3
6
8
11
12
12
14
15
16
17
18
2 Programao (ou Codificao)

2.1 Programar ou Codificar . . . . . . . . . . . . . . . . . .
2.2 Declarao de Variveis . . . . . . . . . . . . . . . . . .
2.3 Breve Histria sobre a Linguagem C . . . . . . . . . . .
2.4 Viso geral de um programa em C . . . . . . . . . . . .
2.5 Estrutura Padro de um programa em C . . . . . . . . .
2.6 Comandos Bsicos de Entrada e Sada de Dados . . . .
2.6.1 Comando para Sada de Dados funo: printf()
2.6.2 Comandos para Entrada de Dados . . . . . . . .
2.6.3 Comentrios dentro de um programa . . . . . .
2.6.4 EXERCCIOS . . . . . . . . . . . . . . . . . . . .
2.6.5 PROBLEMAS RESOLVIDOS . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
19
19
19
20
20
20
21
22
25
26
27
27
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
II Estruturas de Controle de Fluxo
31
3 Estruturas de Deciso
3.1 Comando if..else . . . . . . . . . . . . . . .
3.2 Usando operadores Lgicos . . . . . . . . .
3.3 Comandos if encadeados . . . . . . . . . . .
3.4 Operador Ternrio Operador ? . . . . . .
3.5 Comando switch case (Decises Mltiplas)
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
35
35
43
44
52
53
4 Estruturas de Repetio
4.1 Repetio com teste no incio: while . . . . .
4.2 Repetio com teste no final: do..while . . .
4.3 Uso de flags para controle de programas .
4.4 Algoritmos Interativos . . . . . . . . . . . .
4.5 Repetio Automtica: for . . . . . . . . . .
4.6 while for . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
57
57
63
67
68
71
77
SUMRIO
ii
4.7
4.8
Instrues break e continue

4.7.1 Instruo break . . .
4.7.2 Instruo continue .
Problemas Finais . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
III Matrizes & Strings

5 Vetores, Matrizes
5.1 Conceito de array . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Declarao de Arrays unidimensionais . . . . . . . . . . . . . . .
5.2.1 Inicializao de arrays . . . . . . . . . . . . . . . . . . . .
5.2.2 Problemas . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.3 Solues dos Problemas . . . . . . . . . . . . . . . . . . .
5.3 Arrays Bidimensionais . . . . . . . . . . . . . . . . . . . . . . . .
5.3.1 Inicializao alternativa de matrizes . . . . . . . . . . . .
5.3.2 Observaes . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.3 Problemas . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4 Strings um caso especial de array de char . . . . . . . . . . . .
5.4.1 Inicializao de strings . . . . . . . . . . . . . . . . . . . .
5.4.2 Inicializao de strings no-dimensionadas . . . . . . . .
5.4.3 Sadas de dados do tipo string . . . . . . . . . . . . . . .
5.4.4 Entradas de dados do tipo string . . . . . . . . . . . . . .
5.4.5 Operadores especiais com strings biblioteca <string.h>
5.4.6 Outros exemplos . . . . . . . . . . . . . . . . . . . . . . .
5.4.7 Matrizes de strings . . . . . . . . . . . . . . . . . . . . . .
5.5 Matrizes multidimensionais . . . . . . . . . . . . . . . . . . . . .
5.6 Problemas Finais . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
80
81
83
87
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
91
91
92
93
93
95
98
99
100
102
112
112
112
113
113
115
116
116
116
118
A Ferramentas de Eng. de Software
121
B Erros Comuns de Compilao
127
Tpicos Previstos
1. Introduo Lgica de Programao
6. Operadores
(a) Lgica
(a) Operadores Aritmticos
(b) Seqncia Lgica
(b) Operadores Relacionais
(c) Instrues
(c) Operadores Lgicos
(d) Algoritmo
(d) EXERCCIOS
(e) Programas
7. Operaes Lgicas
(f) EXERCCIOS
(a) EXERCCIOS
2. Desenvolvendo algoritmos
8. Estruturas de Deciso e Repetio
(a) Pseudocdigo
(a) Estruturas de Deciso
(b) Regras para construo do Algoritmo
i. SE ENTO / IF . THEN
ii. SE ENTO SENO / IF . THEN . ELSE
iii. Deciso Mltipla: CASO SELECIONE /
SELECT . CASE
iv. EXERCCIOS
(c) Fases
(d) Exemplo de Algoritmo
(e) Teste de Mesa
(f) EXERCCIOS
(b) Comandos de Repetio
3. Diagrama de Bloco (Fluxogramas)
i. Repetio com Teste no Incio: Enquanto x,

Processar (Do While . Loop)
ii. Repetio com Teste no Final: At que x,
Processar . (Do Until . Loop)
iii. Processar ., Enquanto x (Do . Loop While)
iv. Processar ., At que x (Do . Loop Until)
v. Repetio Automtica (for)
vi. EXERCCIOS
(a) O que um diagrama de bloco?

(b) Simbologia
(c) EXERCCIOS
4. Constantes, Variveis e Tipos de Dados
(a) Constantes
(b) Variveis
9. Arrays
(c) Tipos de Variveis

(d) Declarao de Variveis
(a) Vetor
(e) EXERCCIOS
(b) Matriz
(c) Array Multidimensional
5. Comandos Bsicos
10. Manipulao De Strings
(a) Atribuio
(b) Entrada
(a) O Tipo De Dado String
(c) Sada
(b) Comandos de Entrada e Sada com Strings
iii
iv
SUMRIO
Bibliografia Recomendada
Algoritmos:
1. ALGORITIMOS: teoria e prtica. Rio de Janeiro: Campus, 2002. 916 p. ISBN 8535209263.
2. MANZANO, Jos Augusto Navarro Garcia; OLIVEIRA, Jayr Figueiredo de. Algoritmos: lgica para desenvolvimento de programao. 9.ed. So Paulo: rica, 2000. 265 p. ISBN 857194329X.
3. MANZANO, Jos Augusto Navarro Garcia; OLIVEIRA, Jayr Figueiredo de. Estudo dirigido: algoritmos. 9.ed. So
Paulo: rica, 2004. 220 p. ISBN 857194413X.
4. SILVA, Jos Carlos G. da; ASSIS, Fidelis Sigmaringa G. de. Linguagens de programao: conceitos e avaliao :
FORTRAN, C, Pascal, Modula-2, Ada, CHILL. So Paulo: McGraw-Hill, 1988. 213 p.
5. VILLAS, Marcos Vianna; VILLASBOAS, Luiz Felipe P.. Programao: conceitos, tcnicas e linguagens. Rio de
Janeiro: Campus, 1988. 195 p. ISBN 8570014775.
6. ZIVIANI, Nivio. Projeto de algoritmos: com implementaes em Pascal e C. 3.ed. So Paulo: Pioneira, 1996. 267 p.
Linguagem C:
1. KERNIGHAN, Brian W.; RITCHIE, Dennis M.. C: a linguagem de programao. Rio de Janeiro: Campus, 1989. 208
p. ISBN 8570014104.
2. SCHILDT, Herbert; C Completo e Total, 3 ed., So Paulo: Pearson/Makron Books, 2004. 827 p.
3. SCHILDT, Herbert; GUNTLE, Greg. Borland C++ builder: the complete reference. Berkeley: Osborne McGraw Hill,
2001. 977 p. ISBN 0072127783.
4. SCHILDT, Herbert. C avanado: guia do usurio. 2.ed. So Paulo: McGraw-Hill, 1989. 335 p.
5. SCHILDT, Herbert. Programando em C e C++ com Windows 95. So Paulo: Makron Books, 1996. 537 p. ISBN
8534604797.
6. SCHILDT, Herbert. Turbo C avanado: guia do usurio. So Paulo: McGraw-Hill, 1990. 457 p.
7. SCHILDT, Herbert. Turbo C: guia de referncia bsica. So Paulo: McGraw-Hill, 1989. 242 p.
8. SCHILDT, Herbert. Turbo C: guia do usurio. 2.ed. So Paulo: McGraw Hill, 1989.
9. PUGH, Kenneth. Programando em linguagem C. So Paulo: McGraw-Hill, 1990. 251 p.
10. MANZANO, Jos Augusto Navarro Garcia. Estudo dirigido: linguagem C. 5.ed. So Paulo: rica, 2001. 180 p. ISBN
8571944199.
11. DORNELLES FILHO, ADALBERTO AYJARA; SENAI. Fundamentos da linguagem C. 2.ed. Caxias do Sul: SENAI,
1998. 111 p.
12. HERGERT, Douglas. O ABC do Turbo C. So Paulo: McGraw-Hill, 1991. 341 p.
13. MIZRAHI, Victorine Viviane. Treinamento em linguagem C++. So Paulo: Makron Books, 1995. 2v. ISBN
8534602905 (v.1)
14. WIENER, Richard S. Turbo C: passo a passo. Rio de Janeiro: Campus, 1991. 319 p. ISBN 8570016123.
15. TREVISAN, Ricardo; LEHMANN, Anselm H.. Turbo C: guia de referncia rpida para todas as funes. So Paulo:
rica, 1990. 141 p. ISBN 8571940525.
vi
SUMRIO
Parte I
Introduo Programao
vii

1a Parte da Apostila de ANSI C

Introduo Programao
Observao: Esta apostila est em constante fase de edio

Usando sistema de edio MiKTeX/LATEX 2 para a mesma:
Ver: http://www.miktex.org/
Prof. Fernando Passold Semestre 2005
Captulo
Introduo Lgica de Programao

Contents
1.1
1.2
1.3
1.4
1.5
1.6
1.7
Programas e processos . . . . . . . . . . . . . . .
Desenvolvimento de software . . . . . . . . . . .
Projeto de Software . . . . . . . . . . . . . . . . .
Algoritmos . . . . . . . . . . . . . . . . . . . . . .
Programao Estruturada e Fluxogramas . . . . .
Variveis . . . . . . . . . . . . . . . . . . . . . . .
1.6.1 EXERCCIOS . . . . . . . . . . . . . . . . .
1.6.2 Tipos de Dados . . . . . . . . . . . . . . .
Comandos de Atribuio de Variveis . . . . . .
1.7.1 Expresses Aritmticas . . . . . . . . . . .
1.7.2 Funes matemticas . . . . . . . . . . . .
1.7.3 EXERCCIOS . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
2
3
6
8
11
12
12
14
15
16
17
18
1.1 Programas e processos

Um computador nada mais faz do que executar programas. Um programa simplesmente uma seqncia de instrues definida por um programador. Assim, um programa pode ser comparado a uma receita indicando os passos elementares que devem ser seguidos para desempenhar
uma tarefa.
Cada instruo executada no computador por seu principal componente, o processador ou CPU (de unidade central de processamento).
Computador pensa? Claro que no. O que faz armazenar dados, dar forma a eles e informar o resultado.
Como a frma d forma aos ingredientes que formam o pudim. por isso que informao no passa de dados
que ganharam uma formatao. Mas ser que a mquina pensou a? Ainda no. S processou.
Quem costuma trabalhar em um terminal burro o posto avanado de um computador central conhece s
meia verdade. A verdade inteira que o computador na outra ponta tambm burro. E se eu pensar que o
computador pensa, perteno mesma famlia. A menos que aprenda que pensar enxergar alm de dados
informes. Ou alm da informao.
Quem se concentra demais nos dados e na informao s consegue enxergar o furo do pudim, onde no
h sabor nem sensao. Todavia, quem pensa saliva. Estimulado pelas glndulas da intuio, desperta a
imaginao que leva criao. J viu um micro com intuio?
Criar, programar, isto se faz com criatividade, a capacidade humana de enxergar nos dados informes aquilo
que o computador no v. Agostino DAntonio, de Florena, trabalhou um grande bloco de mrmore e no
chegou a lugar nenhum. Desistiu da rocha ruim. Outros tambm. Por quarenta anos o bloco permaneceu
em sua monoltica inanio at algum enxergar nele uma possibilidade de criao. Na rocha informe
1
1.2. Desenvolvimento de software
Michelngelo viu um Davi. E o esculpiu.

Por: Mario Persona, "Criando de cabo a rabo", janeiro - 2005, site: http://www.rhoempreendedor.com.br/.
Cada processador entende uma linguagem prpria, que reflete as instrues bsicas que ele pode executar.
O conjunto dessas instrues constitui a linguagem de mquina do processador. Cada instruo da linguagem
de mquina representada por uma seqncia de bits distinta (dgitos 0s e 1s), que deve ser decodificada
pela unidade de controle da CPU para determinar que aes devem ser desempenhadas para a execuo da
instruo.
Claramente, seria extremamente desconfortvel se programadores tivessem que desenvolver cada um de
seus programas diretamente em linguagem de mquina. Programadores no trabalham diretamente com a
representao binria das instrues de um processador. Existe uma descrio simblica para as instrues do
processador a linguagem assembly do processador que pode ser facilmente mapeada para sua linguagem
de mquina.
No entanto, mesmo assembly raramente utilizada pela maior parte dos programadores que trabalha com
linguagens de programao de alto nvel devido ao seu estilo mnemnico. A figura 1.1 mostra ttulo
de curiosidade as instrues assembly para programao de um microcontrolador PIC 16Fxx (note que so
pouco mais de 35 instrues).
A figura 1.2 mostra um exemplo de programa (TESTER.ASM) em Assembly para PIF16Cxx que acende e
apaga um LED. O LED est ligado ao bit 7 da porta B do microcontrolador. A tecla 1 usada para acender o
LED. A tecla 2 apaga o LED.
Em linguagens de alto nvel, as instrues so expressas usando palavras, ou termos, que se aproximam daquelas usadas na linguagem humana, de forma a facilitar para os programadores a expresso e
compreenso das tarefas que o programa deve executar. Vrias linguagens de alto nvel esto disponveis
para diversas mquinas distintas. Essa independncia de um processador especfico uma outra vantagem
no desenvolvimento de programas em linguagens de alto nvel em relao ao uso de assembly. Em geral,
cada linguagem de alto nvel teve uma motivao para ser desenvolvida. BASIC foi desenvolvida para
ensinar princpios de programao; Pascal, para o ensino de programao estruturada; FORTRAN, para
aplicaes em computao cientfica; Lisp e Prolog, para aplicaes em Inteligncia Artificial; Java, para o
desenvolvimento de software embarcado e distribudo; e a linguagem C, para a programao de sistemas.
O fato de uma linguagem ter sido desenvolvida com uma aplicao em mente no significa que ela no seja
adequada para outras aplicaes. A linguagem C, juntamente com sua sucessora C++, utilizada para um
universo muito amplo de aplicaes. Um dos atrativos da linguagem C sua flexibilidade: um programador
C tem sua disposio comandos que permitem desenvolver programas com caractersticas de alto nvel e
ao mesmo tempo trabalhar em um nvel muito prximo da arquitetura da mquina, de forma a explorar os
recursos disponveis de forma mais eficiente. Por este motivo, o nmero de aplicaes desenvolvidas em C e
C++ grande e continua a crescer.
1.2 Desenvolvimento de software

No h dvidas hoje em dia quanto importncia do software no desenvolvimento dos mais diversos
sistemas. Com esta evoluo do papel do software em sistemas computacionais, veio tambm uma maior
complexidade de programas e uma maior preocupao em desenvolver programas que pudessem ser
facilmente entendidos e modificados (se necessrio), no apenas pelo autor do programa mas tambm por
outros programadores. A disciplina que estuda o desenvolvimento de programas com qualidade conhecida
como Engenharia de Software.
A Engenharia de Software estabelece alguns princpios de desenvolvimento que independem da linguagem de programao adotada. Estes princpios so utilizados nas trs grandes fases da vida de um programa,
que so a especificao, o desenvolvimento e a manuteno de programas. A especificao inicia-se com o
levantamento de requisitos (ou seja, o que deve ser feito pelo programa) e inclui a anlise do sistema que deve
ser desenvolvido. Na fase de desenvolvimento realiza-se o projeto do sistema, com descries das principais
estruturas de dados e algoritmos, sua codificao, com a implementao do projeto em termos de uma
linguagem de programao, e testes dos programas desenvolvidos. Na fase de manuteno so realizadas
2
1.3. Projeto de Software
Figura 1.1: Conjunto de instrues Assembly da famlia PIC16Cxx de microcontroladores.

modificaes decorrentes da correo de erros e atualizaes do programa.
Uma vez estabelecida a funcionalidade do programa que se deseja implementar na fase de definio, a
fase de desenvolvimento propriamente dita pode ser iniciada. A fase de desenvolvimento costuma tomar a
maior parte do ciclo de vida de criao de um programa. Nesta fase so tomadas decises que podem afetar
sensivelmente o custo e a qualidade do software desenvolvido. Esta fase pode ser dividida em trs etapas
principais, que so projeto, codificao e teste.
Dentre as diversas tcnicas de engenharia de software presentes atualmente a que vm se destacando
fortemente por facilitar abstraes de objetos, a tcnica UML (Unified Modular Language) para especificar todo
um projeto de software, incluindo relacionamento lgico entre os dados do programa, interface com o usurio
e arquivo, fluxo de dados no tempo. Para os mais interessados, ver Apndice A.
1.3 Projeto de Software

O projeto de software pode ser subdividido em dois grandes passos, projeto preliminar e projeto detalhado. O projeto preliminar preocupa-se em transformar os requisitos especificados na fase de anlise
em arquiteturas de dados e de software. O projeto detalhado refina estas representaes de arquitetura em
3
Figura 1.2: Exemplo de cdigo Assembly para PIC16C84.

estruturas de dados detalhadas e em representaes algortmicas do programa.
Uma das estratgias de projeto mais utilizadas o desenvolvimento top-down. Neste tipo de desenvolvimento, trabalha-se com o conceito de refinamento de descries do programa em distintos nveis de abstrao.
O conceito de abstrao est relacionado com esconder informao sobre os detalhes. No nvel mais alto de
abstrao, praticamente nenhuma informao detalhada sobre como uma dada tarefa ser implementada
simplesmente descreve-se qual a tarefa. Em etapas sucessivas de refinamento, o projetista de software vai
elaborando sobre a descrio da etapa anterior, fornecendo cada vez mais detalhes sobre como realizar a tarefa.
O desenvolvimento top-down estabelece o processo de passagem de um problema a uma estrutura de
software para sua soluo (Fig. 1.3), resultando em uma estrutura que representa a organizao dos distintos
componentes (ou mdulos) do programa. Observe que a soluo obtida pode no ser nica: dependendo de
como o projeto desenvolvido e das decises tomadas, distintas estruturas podem resultar.
Outro aspecto to importante quanto a estrutura de software a estrutura de dados, que uma representao do relacionamento lgico entre os elementos de dados individuais.
Uma vez estabelecidas as estruturas de software e de dados do programa, o detalhamento do projeto
4
Figura 1.3: Exemplo de Metodologia top-down.

pode prosseguir com o projeto procedimental, onde so definidos os detalhes dos algoritmos que sero
utilizados para implementar o programa. Um algoritmo uma soluo passo-a-passo para a resoluo do
problema especificado que sempre atinge um ponto final. Em princpio, algoritmos poderiam ser descritos
usando linguagem natural (portugus, por exemplo). Entretanto, o uso da linguagem natural para descrever
algoritmos geralmente leva a ambigidades, de modo que se utilizam normalmente linguagens mais restritas
para a descrio dos passos de um algoritmo. Embora no haja uma representao nica ou universalmente
aceita para a representao de algoritmos, dois dos mecanismos de representao mais utilizados so o
fluxograma (ver Fig. 1.4 e a descrio em pseudo-linguagens (por exemplo: Portugol1 ).
Um fluxograma uma representao grfica do fluxo de controle de um algoritmo, denotado por setas
indicando a seqncia de tarefas (representadas por retngulos) e pontos de tomada de deciso (representados por losangos). A descrio em pseudo-linguagem combina descries em linguagem natural com as
construes de controle de execuo usualmente presentes em linguagens de programao.
1 "Portugol" derivado da aglutinao de Portugus + Al-gol. Algol o nome de uma linguagem de programao estruturada usada
no final da dcada de 50.
1.4. Algoritmos
a) Fluxogramas tpicos.
b) Exemplo de fluxograma.
Figura 1.4: Fluxogramas.
1.4 Algoritmos
Para resolver um problema no computador necessrio que seja primeiramente encontrada uma maneira
de descrever este problema de uma forma clara e precisa. preciso que encontremos uma seqncia de passos
que permitam que o problema possa ser resolvido de maneira automtica e repetitiva. Esta seqncia de
passos chamada de algoritmo. Um exemplo simples e prosaico de como um problema pode ser resolvido se
fornecermos uma seqncia de passos que mostrem a soluo uma receita de bolo.
Algoritmos so uma seqencia de instrues que se seguidas realizam determinada tarefa. Pode ser
tambm um conjunto finito de regras que fornece uma seqencia de operaes para resolver um problema
especfico. Nesta seo trataremos no apenas de algoritmos, mas tambm das estruturas de dados que eles
utilizam. Este um dos principais pontos quando lidamos com programao de computadores.
No seu livro Fundamental Algorithms, vol. 1, Donald Knuth apresenta uma verso para a origem
desta palavra. Ela seria derivada do nome de um famoso matemtico persa chamado Abu Jafar Maom
ibn Ms al-Khowrism (825) que traduzido literalmente quer dizer Pai de Jafar, Maom, filho de Moiss,
de Khowrizm. Khowrizm hoje a cidade de Khiva, na ex Unio Sovitica. Este autor escreveu um livro
chamado Kitab al jabr wal-muqabala (Regras de Restaurao e Reduo). O ttulo do livro deu origem
tambm a palavra lgebra.
Assim um algoritmo uma soluo passo-a-passo para a resoluo do problema especificado que sempre
atinge um ponto final.
Exemplos de algoritmos:
Instrues para Receitas de Bolo de Cenoura:
1.4. Algoritmos
Receita 1 (Soluo 1):

Ingredientes:
1) 2 xcaras (ch) de cenoura picada;
2) 2 ovos;
3) 1 xcara (ch) de leo de milho;
4) 1 e 1/2 xcara (ch) de acar;
5) 1 xcara (ch) de maizena;
Entrada(s)...
6) 1 xcara (ch) de farinha de trigo;
7) 1 colher (sopa) de fermento em p.
Cobertura:
1) 4 colheres (sopa) de leite morno;
2) 4 colheres (sopa) de chocolate em p;
3) 6 colheres (sopa) de acar.
Modo de Preparo:
1) Bata a cenoura com os ovos no liqidificador;
2) Passe para uma tigela e acrescente os demais ingredientes, misturando bem;
3) Leve ao forno mdio, numa assadeira
Processamento...
(mdia) untada e enfarinhada, cerca de 25 minutos;
4) Misture todos os ingredientes do glac;
5) Retire o bolo do forno e cubra com o glac;
6) Deixe esfriar e corte em quadrados.
Rendimento:
Sada...
1 bolo.
Receita 2 (Soluo 2):

Ingredientes:
1) 1 tablete de margarina;
2) 2 ovos;
3) 14 colheres rasas (sopa) de acar;
4) 14 colheres cheias (sopa) de farinha de trigo;
5) 2 copos de leite;
6) 1 lata de leite condensado;
7) 2 colheres (sopa) de fermento;
8) 3 colheres (sopa) de chocolate em p;
9) chocolate granulado;
10) 1 vidro de leite de coco;
11) coco ralado.
Modo de Fazer:
1) Bata no liquidificador: a margarina, os ovos, a farinha de trigo, o
acar, o chocolate em p, baunilha ou o leite de coco.
2) Numa tigela coloque a farinha de trigo.
3) Entorne aos poucos, o creme batido, 1 copo de leite e o fermento.
4) Leve ao forno, em assadeira grande untada e enfarinhada.
5) Depois de assado, ainda quente, perfure com um garfo e, coloque leite
condensado e, ou coco ralado, ou chocolate granulado.
Rendimento:
1 bolo.
Entrada(s)...
Processamento...
Sada...
Um algoritmo opera sobre um conjunto de entradas (no caso do bolo, farinha ovos, fermento, etc.) de
modo a gerar uma sada que seja til (ou agradvel) para o usurio (o bolo pronto).
Um algoritmo tem cinco caractersticas importantes:
Finitude:
Um algoritmo deve sempre terminar aps um nmero finito de passos.
Definio:
Cada passo de um algoritmo deve ser precisamente definido. As aes devem ser definidas
rigorosamente e sem ambiguidades.
Entradas:
Um algoritmo deve ter zero ou mais entradas, isto quantidades que so lhe so fornecidas
antes do algoritmo iniciar.
Sadas:
Um algoritmo deve ter uma ou mais sadas, isto quantidades que tem uma relao especfica
com as entradas.
7
1.5. Programao Estruturada e Fluxogramas
Efetividade: Um algoritmo deve ser efetivo. Isto significa que todas as operaes devem ser suficientemente
bsicas de modo que possam ser em princpio executadas com preciso em um tempo finito por
um humano usando papel e lpis.
claro que todos ns sabemos construir algoritmos. Se isto no fosse verdade, no conseguiramos sair de
casa pela manh, ir ao trabalho, decidir qual o melhor caminho para chegar a um lugar, voltar para casa, etc.
Para que tudo isto seja feito necessrio uma srie de entradas do tipo: a que hora acordar, que hora sair de
casa, qual o melhor meio de transporte, etc.
Um fator importante pode haver mais de um algoritmo para resolver um problema. Por exemplo, para
ir de casa at o trabalho, posso escolher diversos meios de transportes em funo do preo, conforto, rapidez,
etc. A escolha ser feita em funo do critrio que melhor se adequar as nossas necessidades (tempo de
processamento, armazenamento).
"Ao verificar que um dado programa est muito lento, uma pessoa
prtica pede uma mquina mais rpida ao seu chefe. Mas o ganho potencial que uma mquina mais rpida pode proporcionar tipicamente
limitado por um fator de 10, por razes tcnicas ou econmicas. Para
obter um ganho maior, preciso buscar melhores algoritmos. Um
bom algoritmo, mesmo rodando em uma mquina lenta, sempre acaba
derrotando (para instncias grandes do problema) um algoritmo pior
rodando em uma mquina rpida. Sempre."
S. S. Skiena, The Algorithm Design Manual
Por analogia, um pacote de Software pronto = pacote de bolo industrializado.
1.5 Programao Estruturada e Fluxogramas

A programao estruturada estabelece uma disciplina de desenvolvimento de algoritmos que facilita a
compreenso de programas atravs do nmero restrito de mecanismos de controle da execuo de programas.
Qualquer algoritmo, independentemente da rea de aplicao, de sua complexidade e da linguagem de
programao na qual ser codificado, pode ser descrito atravs destes mecanismos bsicos.
O princpio bsico de programao estruturada que um programa composto por blocos elementares de
cdigo que se interligam atravs de trs blocos bsicos, que so entrada de dados, processamento e sada de
dados ver figura 1.5.
Cada uma destas construes tem um ponto de incio (o topo do bloco) e um ponto de trmino (o fim do
bloco) de execuo ver figura 1.6.
A figura 1.7 mostra os fluxogramas que utilizaremos nesta disciplina.
O bloco processamento implementa os passos de processamento necessrios para descrever qualquer
programa. Por exemplo, um segmento de programa da forma faa primeiro a Tarefa_a e depois a Tarefa_b
8
Incio
Entrada de
Dados
Processamento
(Clculos)
Sada de Dados
Resultados
Fim
Figura 1.5: Principais blocos de uma programao estruturada.

Incio
Fim
Figura 1.6: Incio e fim de cada bloco.

Incio
Processamento
(Clculos)
Sada de Dados
Resultados
Entrada de
Dados
Fim
Para..Faa
FOR
Enquanto..Faa
WHILE
Se..Ento
IF
No
Sim
Figura 1.7: Fluxogramas utilizados neste curso.

seria representado por uma seqncia de dois retngulos (Fig. 1.8a). A mesma construo em pseudolinguagem seria denotada pela expresso das duas tarefas, uma aps a outra (Fig. 1.8b).
Como no caso do exemplo da figura 1.3 uma forma de documentar na forma de um fluxograma um
programa que soma dois nmeros poderia ficar como mostra a figura 1.9. Note pela figura 1.9 que aparecem
as variveis de programao: Num_1, Num_2 e Soma. No prximo item entraremos no item que se refere
ao que se chama de variveis.
Incio
void SEQUENCIA (void){

Tarefa_a();
Tarefa_b();
}
SEQUENCIA()
Tarefa_a
Tarefa_b
Tarefa_a
Tarefa_b
(b) Formato de pseudo-linguagem.
(c) Em ANSI C.
Fim
(a) Formato de Fluxograma
Figura 1.8: Exemplo de blocos de processamento
Incio
Numero 1 ?
Num_1
Etapa de Entrada
de Dados
Numero 2 ?
Num_2
Soma=Num_1+Num_2
Etapa de
Processamento
Soma
Etapa de Sada
de Dados
Fim
Figura 1.9: Exemplo de fluxograma para soma de 2 nmeros.
10
1.6. Variveis
Varivel de nome:
Num_1
Memria do
Computador
Figura 1.10: Analogia entre variveis e pastas de arquivo suspenso.
1.6 Variveis
Um computador necessita organizar os dados que manipula na forma de variveis. Como o prprio nome
indica, seu contedo varivel, isto , serve para armazenar valores que podem ser modificados durante a
execuo de um programa.
A figura 1.10 mostra uma analogia para o que seriam variveis comparando a forma como o computador
manipula dados e a forma como ns seres humanos podemos organizar informao escrita (documentos).
Note que a memria do computador poderia ser comparada um arquivo de ao. Uma pasta suspensa
dentro deste arquivo seria o equivalente ao que se chama de varivel. Assim como podemos etiquetar (colocar
um nome) na pasta suspensa, o usurio quem define o nome que prefere para suas variveis. Note que
cada varivel guarda um certo tipo de dado (ou informao). Quando dentro de um programa o usurio
faz referncia uma varivel, o computador automaticamente sabe onde est localizada esta varivel dentro
da sua memria (o que de certa forma explica porque um computador pode ser mais rpido para recuperar
dados que um ser humano buscando um certo documento dentro de um arquivo de ao).
Note que quanto maior o arquivo de ao, mais documentos podemos estocar dentro do mesmo. Da
forma, assim com o computador, quanto mais memria RAM, maior a quantidade de dados com a qual ele
pode lidar instantaneamente. No caso de no haver memria RAM suficiente para lidar com os dados em
questo (uma folha de pagamentos por exemplo), eles podem ser gravados numa memria secundria (disco
rgido, CD, DVD, etc), na forma do que chamamos de arquivos. Neste ltimo caso, o sistema operacional
(S.O.) que est sendo rodado pelo computador que vai definir a maior facilidade ou no para acessar estes arquivos e o S.O. que se responsabiliza por localizar os arquivos com os dados desejados pelo computador.
A cada varivel corresponde uma posio de memria, cujo contedo pode variar ao longo do tempo
durante a execuo do programa.
Note que assim com num arquivo de pastas suspensas, vrios tipos de informaes podem ser guardadas:
folhas simples, folhas vazias, fotografias, fitas cassetes, CDs, DVDs, etc. Da mesma forma o computador
pode lidar com diferentes tipos de dados ou variveis. Note que depende da capacidade de abstrao e
experincia do usurio, a definio das variveis que sero necessrias para executar um certo programa.
Note ainda que o programador que vai definir se existe ou no uma lgica de relacionamento entre
diferentes dados e como se d este relacionamento. No exemplo anterior (da Fig. 1.9), a varivel Soma
que vai receber o resultado da soma do contedo de outras duas variveis: Num_1 e Num_2:
Soma Num_1 + Num_2
Note tambm que quem atribui valor para as variveis Num_1 e Num_2 o usurio via entrada de
dados pelo teclado (indicado na figura 1.9 pelo bloco referente Entrada de Dados voltar a figura 1.7 se
for o caso).
11
1.6. Variveis
1.6.1 EXERCCIOS
1) Como seria um simples fluxograma para fazer aparecer na tela uma mensagem como "Al Mundo!"?
2) Esboce na forma de um fluxograma o algoritmo correspondente ao clculo da mdia de 3 valores informados pelo usurio.
3) Monte um fluxograma correspondente a um algoritmo capaz de calcular o valor final atingido por uma
mercadoria, dado que o usurio informa o valor inicial da mercadoria e a porcentagem de desconto dada
pela loja.
4) Desenhe como seria o fluxograma correspondente um programa capaz de calcular as razes para uma
equao do 2o grau: ax2 + bx + c = 0, onde o usurio entra com os coeficientes da equao: a, b e c.
Note: para todos os fluxogramas acima, cada aluno deve abstrair que variveis sero necessrias para que
o programa funcione, a seqencia (correta) de instrues (blocos de fluxograma) e quais seriam os blocos
necessrias para garantir a efetividade do algoritmo. Como um primeiro auxlio para esta etapa do processo, o
aluno pode montar uma tabela chamada IPO2 que o auxilie a estruturar a forma como deve ser o programa
ver figura 1.11.
Entrada
Processamento
Sada
Figura 1.11: Diagrama IPO (vazio).

A figura 1.12 mostra como ficaria este digrama para o item (1) dos EXERCCIOS.
Entrada
(Nenhuma)
Processamento
Imprima "Al Mundo"
Sada
Al Mundo
Figura 1.12: Diagrama IPO para o item (1) dos EXERCCIOS.
1.6.2 Tipos de Dados

Tipos de Dados Bsicos
Como podemos perceber pelo item anterior, o computador exige que o usurio defina uma varivel
relacionada cada dado ser manipulado. Ocorre que para o computador existem 4 tipos bsicos de dados: int
(inteiro), float (real), double (real de dupla preciso) e char (carcter) que so tratados pelo mesmo, de diferentes
formas. A tabela 1.1 mostra os diferentes tipos de dados bsicos disponveis no ANSI C.
Tipo de Dado
char
int
float
double
Bytes
Exigidos
1
2
4
8
Faixa de Variao
0 255
-32.768 32.767
3.4 1038 (7 dgitos)
1.7 10308 (15 dgitos)
Tabela 1.1: Tipos de dados bsicos do ANSI C.

O tipo de dados int serve para guardar nmeros inteiros, positivos e negativos.
Variveis inteiras podem ser qualificadas na sua declarao como short ou long e unsigned. Um tipo
unsigned int indica que a varivel apenas armazenar valores positivos. O padro que variveis inteiras
utilizem a representao em complemento de dois (binariamente falando), para valores positivos e negativos.
2 IPO
= Input Process Output diagrams = ou Diagrama Entrada Processamento Sada.
12
1.6. Variveis
Tipos de Dados Extendidos

Os tipos de dados bsicos foram extendidos atravs de modificadores de forma a extender e tornar mais
especficas certos tipos de dados bsicos ver tabela 1.2. Os modificadores short e long modificam o espao
reservado para o armazenamento da varivel. Um tipo short int indica que (caso seja possvel) o compilador
dever usar um nmero menor de bytes para representar o valor numrico usualmente, dois bytes so
alocados para este tipo. Uma varivel do tipo long int indica que a representao mais longa de um inteiro
deve ser utilizada, sendo que usualmente quatro bytes so reservados para variveis deste tipo.
Tipo de Dado
char
signed char
unsigned char
short
unsigned short
int
unsigned int
long
unsigned long
float
double
long double
Bytes
Exigidos
1
1
1
2
2
2
2
4
4
4
8
10
Faixa de Variao
0 255
-128 127
0 255
-32.768 32.767
0 65.535
-32.768 32.767
0 65.535
-2.147.483.648 2.147.483.647
0 4.294.967.295
3.4 1038 (7 dgitos)
1.7 10308 (15 dgitos)
1.2 104932 (19 dgitos)
Tabela 1.2: Tipos de dados extendidos do ANSI C.

O tipo de dados char serve para guardar um caracter, por exemplo a letra Z.
Reparem que no importa o tipo de dados, todos eles so codificados com seqencias de 0s e 1s para o
computador (seqencias de bits). Para representar um nmero inteiro sem sinal de valor igual 75 seriam
necessrios: 7 bits (26 = 64 e 27 = 128, 75(10) = 01001011(2) ).
J para representar um caracter so usadas tabelas padres de converso de um determinado caracter para
a correspondente seqencia binria por exemplo, a tradicional tabela ASCII (ver figura 1.13).
Figura 1.13: Tabela de cdigos ASCII

Assim por exemplo, o cdigo ASCII para a letra A 65 ou 65(10) = 01000001(2) . Note que cada carcter
gasta exatamente 1 byte (ou 8 bits). E mais, perceba que o caracter 7, binariamente no tm nenhuma relao
com o nmero em decimal 7:
O nmero 7
O caracter 7
0000 0111 (2)

0011 0111 (2) = 55 (10)
Os tipos de dados float e double so usados para guardar nmeros reais (nmero com ponto flutuante, ou
com casas decimais). A diferena entre eles a preciso. O float tem uma preciso de 6 casas decimais e o
double tem uma preciso de 10 casas decimais.
Valores com representao em ponto flutuante (nmeros reais) so representados em C atravs do uso do
ponto decimal, como em 1.5 para representar o valor um e meio. A notao exponencial tambm pode ser
usada, como em 1.2345e-6 (= 0, 0000012345) ou em 0.12E3 (= 120).
13
1.6. Variveis
Os nmeros reais (em ponto flutuante) tambm so codificados numa seqencia de 0s e 1s na memria
do computador s que de uma forma diferente da utilizada para nmeros inteiros. Para armazenar nmeros
reais o computador representa o nmero na forma de uma mantissa e um expoente, gastando uma quantidade diferente de bytes para os mesmos. Por exemplo, o nmero real 6, 574 pode estar armazenado na
memria do computador no formato: mantissa igual 6574 (2 bytes) e expoente igual 3 (1 byte), ou seja,
6, 574 = 6574 103 .
Assim, nos computadores os nmeros reais no so um conjunto contnuo e infinito como na Matemtica.
Isso s seria possvel se a memria dos computadores tambm fosse infinita (quantidade infinita de bytes
disponveis). Na prtica, isso pode no se transformar num problema maior porque grande parte dos
problemas podem resolver-se limitando os clculos preciso desejada. A diferena entre as variveis do
tipo float e double que as variveis do tipo double tm mais preciso, isto , so representadas internamente
no computador usando mais bits.
Estas dimenses de variveis denotam apenas uma situao usual definida por boa parte dos compiladores, sendo que no h nenhuma garantia quanto a isto. A nica coisa que se pode afirmar com relao
dimenso de inteiros em C que uma varivel do tipo short int no ter um nmero maior de bits em sua
representao do que uma varivel do tipo long int.
Algumas linguagens possuem ainda outras formas mais sofisticadas de representar dados, como no caso
de Programao Orientada Objetos (POO), onde um objeto nada mais do tipo especfico de abstrao de
dados, especialmente definida para a aplicao em vista. Por isto, programar orientado objetos exige uma
nova filosofia de programao no suportada nesta disciplina. Mas ttulo de curiosidade, para o MATLABr ,
qualquer tipo de dado sendo processado pelo mesmo na realidade um objeto e isto fica mais fcil de
compreender quando nos lembramos de que o MATLABr est preparado para lidar com nmeros complexos
que possui parte real e parte imaginria. Note ainda que nas linguagens orientadas objeto, no momento
da definio de um objeto, por exemplo, no momento da definio da classe complex por exemplo, tambm
podem ser codificados a forma como o sistema deve executar operaes de adio, soma, subtrao, diviso, exponenciao, etc desta forma que o MATLABr lida de modo transparente com nmeros complexos.
EXERCCIOS: Volte lista de EXERCCIOS da pgina 12 e identifique o tipo de varivel adequado para cada
um dos dados definidos em cada exerccio.

Toda varivel identificada por um nome ou identificador. Identificadores so nomes escolhidos para
representar dados. Ocorre porm que certas regras devem ser levadas em conta na escolha de um identificador
para uma varivel:
Comprimento limitado: A princpio, o nome adotado para uma varivel poderia ter qualquer comprimento,
mas na prtica, seu valor varia conforme a linguagem de programao sendo utilizada e seu compilador.
O ANSI C distingue apenas os primeiros 31 caracteres utilizados para identificar uma varivel.
Por exemplo, as variveis abaixo so idnticas para o ANSI C:
1234567890123456789012345678901 Quantidade de caracteres
Minha_Mae_disse_para_eu_escolher_este_nome_aqui = Minha_Mae_disse_para_eu_escolhe,
Testa_Sensor_Esquerda_Video_Cassete = Testa_Sensor_Esquerda_Video_Cas,
Exemplo seguir: no limite dos 31 caracteres:
TestaSensorEsquerdaVideoCassete.
Outros exemplos: Sensor1, NomeArquivo, Nome_Arquivo, NomArq, NA.
Note: Exagerar no comprimento do nome utilizado para identificar uma varivel pode tornar a codificao de um programa extremamente difcil: voc j
pensou em digitar vrias vezes durante o programa a referncia para a varivel TestaSensorEsquerdaVideoCassete ? Ao mesmo tempo, letras simples, ou
nomes muito curtos ou mnemnicos dificultam a compreenso do programa.
Assim, o melhor ser razovel, usar o bom senso e escolher nomes que agreguem um significado at intuitivo para cada varivel (isto , o prprio nome
escolhido para a varivel, j indica a sua funo).
14
1.7. Comandos de Atribuio de Variveis
Primeiro caracter: uma letra obrigatoriamente.

Exemplos Errados: 10, 10E, 102Elefante alm de no agregarem nenhum sentido varivel, no so
nomes vlidos para uma varivel.
Exemplos corretos: E10, Elefante102.
Aps a primeira letra: letras, dgitos ou sublinhado: Pode-se usar letra, nmeros ou o caracter sublinhado
(_).
Por exemplo: Sensor_1, Nome_Aluno.
Letras maisculas 6= letras minsculas: A maioria das linguagens de programao faz distino entre letras
minsculas e maisculas.
Por exemplo: No ANSI C:
Nome_Arq 6= Nome_arq Note que mudou apenas uma letra!
INDEX 6= index 6= InDeX.
Desta forma, o programador deve ser cuidadoso no sentido de sempre ter que
lembrar-se a sintaxe (grafia) correta usada para identificar suas variveis.
No podem haver identificadores repetidos: Isto , cada varivel deve possuir um nome diferente de todos
os outros.
No pode ser uma palavra reservada: da linguagem de programao em questo.
Por exemplo: C, possui 32 palavras reservadas; nomes que no podem ser adotados como identificadores
para variveis ver tabela 1.3 seguir. Note que so instrues da linguagem C e esto todas em letras
minsculas.
auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
Tabela 1.3: Tabela de palavras reservadas do ANSI C.
1.7 Comandos de Atribuio de Variveis

Atribuir valores uma varivel significa armazenar valores dentro da mesma. A tabela 1.4 seguir
demonstra como atribuir valores variveis.
a
i
delta
x
3
i+1
b2 4 a c
A
a
i
delta
char x
=
=
=
=
3;
i + 1;
b*b - 4*a*c;
A;
(b) Em ANSI C.
(a) Em PORTUGOL
Tabela 1.4: Comandos de atribuio de variveis.
15
1.7.1 Expresses Aritmticas

Expresses aritmticas so aquelas que apresentam como resultado um valor numrico que pode ser um
nmero inteiro ou real, dependendo dos operandos e operadores. Os operadores aritmticos disponveis so
mostrados na tabela 1.5 seguir.
Operador
Descrio
*
/
(
)
Soma
Subtrao
Multiplicao
Diviso
(
)
Hierarquia da
Operao
3a
3a
2a
2a
1a
1a
Tabela 1.5: Tabela de operadores aritmticos bsicos e precedncias dos mesmos.

A coluna Hierarquia da Operao, indica a ordem de precedncia de uma operao aritmtica (vlido
para qualquer linguagem de programao). Isto quer dizer que, numa expresso como a seguinte:
x = a (b + 2 c)
os seguintes termos sero avaliados nesta ordem:
1o ) (b + 2 c)
2o ) 2 c
3o ) b + Resultado de: 2 c)
4o ) a Resultado de: (b + 2 c))
isto , primeiro ser avaliada a expresso contida dentro dos parnteses ((b + 2 c)), depois ser resolvido
primeiro a multiplicao: 2 c; obtido o resultado da multiplicao realizada soma com o termo b e por fim
realizada a multiplicao deste resultado pelo termo a.
16
Exemplos:
Em linguagem natural:
Em ANSI C:
Resultado:
1)
a=3
a=3;
a=3
2)
i=a+3
i=a+3;
i=6
3)
i=i+1
i=i+1;
i=7
4)
b=a+i
b=a+i;
b=10
5)
b=i+a
b=i+a;
b=10
6)
a = 2b + i
a=2*b+i;
a=27
7)
a = 2(b + i)
a=2*(b+i);
a=34
8)
= b2 4ai
delta= b*b - 4*a*i;
delta=-852
9)
b=
b=a/i;
b=4.857
b=2+a/i;
b=6.8571
b=2+(a/i);
b=6.8571
c=a+b/2;
c=37.4286
c=(a+b)/2;
c=20.4286
10)
11)
12)
13)
a
i
a
i
a
b=2+
i
b
c=a+
2
a+b
c=
2
b=2+
14)
z=a
b
+
2
c+i
2

z=a*((b/2)+((c+i)/2));
ou
z=582.8571
z=a*(b/2+(c+i)/2);
Para o exemplo 14) , note formas descuidadas de se codificar esta equao:

ERRADO:
z=a*b/2+(c+i)/2;
z=130.2857
ERRADO:
z=a*(b/2+c+i/2);
z=930.1429
b c+i
+
2
2
b
i
Calculado: z = a
+c+
2
2
Calculado: z = a
1.7.2 Funes matemticas

A tabela 1.6 seguir relaciona as funes matemticas mais tpicas:
Funo
x
xy
ex
cos(x)
sin(x)
tan(x)
arccos(x)
arcsin(x)
arctan(x)
arctan(y/x)
Em ANSI C
sqrt(x)
pow(x,y)
exp(x)
cos(x)
sin(x)
tan(x)
acos(x)
asin(x)
theta=atan(x)
theta=atan2(y,x)
Exemplo
y=sqrt(x);
a=pow(x,y);
y=exp(x);
x=cos(theta);
y=sin(theta);
z=tan(x);
theta=acos(a);
theta=asin(b);
theta=atan(y/x);
theta=atan2(y,x);
Obs1 : funes trigonomtricas so realizadas no espao de radianos e no de graus.

Obs2 : estas funes trabalham e retornam variveis do tipo real SEMPRE!.
Obs3 : estas funes exigem o uso da biblioteca <math.h>.
Tabela 1.6: Funes matemticas mais comuns.
17
1.7.3 EXERCCIOS
Converta as equaes matemticas abaixo para o formato linear, isto , compatvel com uma linguagem de
programao como ANSI C:
1)
2)
3)
4)
5)
6)
a+b
c
b+c
x=a+
2
a
b
x= +
2
4
a
b
+
x= 2 3 4
b
y =a+
2+c
x=
z = a2 + 2ab + b2
(a + b)
2
7)
z=
8)
x = b0 +
a1
b1 +
a2
a3
b2 +
b3
18
Captulo
Programao (ou Codificao)

2.1 Programar ou Codificar
Uma linguagem consiste essencialmente de uma seqncia de strings ou smbolos com regras para definir
quais seqncias de smbolos so vlidas na linguagem, ou seja, qual a sintaxe da linguagem. A interpretao
do significado de uma seqncia vlida de smbolos corresponde semntica da linguagem.
Existem meios formais para definir a sintaxe de uma linguagem a definio semntica um problema
bem mais complexo. A sintaxe de linguagens expressa na forma de uma gramtica, que ser introduzida na
seqncia.
A etapa de codificao traduz a representao do projeto detalhado em termos de uma linguagem de
programao. Normalmente so utilizadas linguagens de alto nvel, que podem ento ser automaticamente
traduzidas para a linguagem de mquina pelo processo de compilao. Neste texto, a linguagem C ser
utilizada nos exemplos e atividades prticas desenvolvidas.
2.2 Declarao de Variveis

Para declarar uma varivel de nome i do tipo inteiro em um programa C, a seguinte expresso seria
utilizada:
int i;
Essa declarao reserva na memria um espao para a varivel i, suficiente para armazenar a representao binria em complemento de dois (com sinal) do valor associado varivel, que inicialmente indefinido.
possvel, ao mesmo tempo em que se declara uma varivel, proceder a sua inicializao, isto , se atribuir
um valor inicial definido para a varivel, neste caso, a declarao ficaria assim:
int i = 0;
Ateno nas Operaes misturando nmeros Reais e Inteiros
Ateno: Expresses aritmticas podem manipular operandos de dois tipos:
reais e inteiros. Se todos os operandos de uma expresso so do tipo inteiro
ento a expresso fornece como resultado um nmero inteiro. Caso pelo menos um dos operandos seja real o resultado ser real. Isto pode parecer estranho a princpio, mas este procedimento reflete a forma como as operaes so
executadas pelos processadores.
Por exemplo, o resultado da operao:
1/5 0, porque os dois operadores so inteiros.
Caso a expresso tivesse sido escrita como 1.0/5 ento o resultado 0.2 seria
o correto.
19
2.3. Breve Histria sobre a Linguagem C
2. Programao (ou Codificao)
2.3 Breve Histria sobre a Linguagem C

A linguagem C foi criada por Dennis Ritchie em 1972 no Centro de Pesquisas da Bell Laboratories. Sua
primeira utilizao importante foi a reescrita do Sistema Operacional UNIX que at ento era escrito em
Assembly.
Em meados de 1970 o UNIX saiu do laboratrio para ser liberado para as universidades. Foi o suficiente
para que o sucesso da linguagem atingisse propores tais que, por volta de 1980, j existiam vrias verses
de compiladores C oferecidas por vrias empresas, no sendo mais restritas apenas ao ambiente UNIX, porm
compatveis com vrios sistemas operacionais.
O C uma linguagem de propsito geral, sendo adequado programao estruturada. No entanto mais
utilizada para escrever compiladores, analisadores lxicos, bancos de dados, editores de textos, etc...
A linguagem C pertence a uma famlia de linguagens cujas caractersticas so: portabilidade1 , modularidade, compilao separada (linkagens), recursos de baixo nvel, gerao de cdigo eficiente, confiabilidade,
regularidade, simplicidade e facilidade de uso.
2.4 Viso geral de um programa em C

A gerao de um programa executvel (arquivo com extenso .exe) partir do programa fonte (no caso,
com extenso .c ou .cpp, dependendo do compilador) obedece a uma seqencia de operaes antes de
tornar-se executvel. Depois de escrever o mdulo fonte em qualquer editor de textos, o programador aciona
o compilador. Essa ao desencadeia uma seqencia de etapas, cada qual traduzindo a codificao do usurio
para a forma de linguagem de mquina, que termina com o executvel criado pelo linkador conforme
demonstra a figura 2.1 seguir.
Editor
(arquivo fonte em C)
Pr-processador
(arquivo fonte expandido)
Compilador
(arquivo objeto)
Linkador
(arquivo executvel)
Figura 2.1: Seqencia de compilao de um programa em C.
2.5 Estrutura Padro de um programa em C

Estaremos estudando aqui a forma de programar no ANSI-C standard. A linguagem C foi introduzida
pelos pesquisadores Kernigan e Ritchie atravs do livro The C Programming Language. Atualmente j
existe a segunda verso deste livro: The C Programming Language - Second Edition que trata da forma
clssica de programao em C.
Todos os programas em ANSI C possuem um bloco principal de programao, uma funo chamada de
main().
As funes so as entidades operacionais bsicas dos programas em C, que por sua vez so uma unio
de uma ou vrias funes executando cada qual o seu trabalho. H funes bsicas que esto definidas em
bibliotecas em C (arquivos .h). As funes printf() e scanf() por exemplo, permitem respectivamente
escrever informaes na tela e ler dados partir do teclado estas funes esto definidas na biblioteca de
nome <stdio.h>.
Todo programa em ANSI C inicia sua execuo chamando a funo main(), sendo obrigatria a sua
declarao dentro do programa. Um exemplo do programa mais simples possvel de ser realizado em C segue
abaixo:
1.
2.
3.
1 h
main()
{
}
controvrsias
20
2.6. Comandos Bsicos de Entrada e Sada de Dados
No existe forma mais simplificada de um programa em C. Infelizmente, este programa no faz nada! Mas
serve para nos dar uma pista sobre a estrutura clssica de um programa em C.
Note, a palavra main, muito importante e aparece sempre e uma nica vez em qualquer programa em
C. Note que depois da palavra main existe um par de parnteses que indicam para o compilador que se trata
de uma funo (function). Mais tarde (na continuidade desta disciplina) ser explicado exatamente o que
uma funo e para que servem estes parnteses. Por hora, considere simplesmente incluir SEMPRE este par
de parnteses em todos os seus programas.
Note nas linhas 2 e 3 as chaves (caracteres { e }) que definem incio e o fim do prprio programa.
Equivalente aos blocos de inicio e fim de um fluxograma, ou em PORTUGOL o que mostrado na figura
2.2 seguir.
Incio
Incio
Fim
b) Equivalente em C.
c) Equivalente em PORTUGOL.
Fim
a) Fluxogramas de incio e
fim de um programa.
Figura 2.2: Blocos de incio e fim de um programa.

Note que o programa em si, deve vir dentro deste bloco de incio e de fim. Note que no exemplo anterior
(nosso primeiro programa) no existe nenhuma declarao neste espao porque justamente este programa
no faz nada. Apesar deste programa poder ser compilado e aparentemente o usurio no poder enxergar o
cdigo rodando, trata-se de um cdigo perfeitamente vlido em C. Eventualmente no momento de compilar
este programa poder ser gerado uma advertncia (warning), ignore ou modifique o cdigo para:
1.
2.
3.
4.
int main()
{
return 0;
}
O cdigo acima deve poder ser compilado em qualquer compilador padro ANSI C. A nica diferena com
relao ao primeiro programa que agora existe uma declarao return entre as chaves. Como esta prpria
declarao indica, o programa retorna um valor inteiro para o Sistema Operacional (S0) utilizado para disparar
sua execuo. No caso, retorna o valor 0 (zero), indicando uma execuo bem sucedida. Cdigos diferentes
de zero podem ser tratados como cdigos de erros para o SO (como de fato ocorre em sistemas Unix). Isto
ocorre porque na definio original de K&R para a linguagem C, por padro (por default), todas as funes
retornam um valor inteiro, independente da vontade do programador. Quando explicitamente no queremos retornar um valor para o SO, podemos tentar escrever o programa como mostrado no primeiro exemplo.
Ou, caso o compilador no aceite compilar este cdigo, uma declaro extra void (nada em ingls) pode
ser utilizada para indicar que efetivamente no desejamos retornar nenhum valor para o SO. Ver exemplo
seguir:
1. void main()
2. {
3. }
Note que neste ltimo cdigo no aparece mais a declarao return, porque a funo main no vai retornar
nada para o SO. Compiladores modernos aceitam trabalhar com void ou esperam o retorno de um inteiro para
a funo principal do programa (como esperado para padro ANSI C).
2.6 Comandos Bsicos de Entrada e Sada de Dados

Esta seo descreve as funes de entrada (input) e de sada (output) mais importantes da linguagem
C. Todas esto declaradas na biblioteca <stdio.h>. Portanto, o seu programa deve ter uma linha contendo a
declarao:
#include <stdio.h>
21
para poder usar essas funes.

Para que um programa torne-se minimamente funcional preciso que ele receba dados do meio externo
(teclado, mouse, portas de comunicao, drives de disco, etc.) e emita o resultado de seu processamento de
volta para o meio externo (monitor, impressora,alto-falante, portas de comunicao, drives de disco, etc.).
De outro modo: um programa deve trocar informaes com o meio externo. Em C, existem muitas funes
pr-definidas que tratam desta troca de informaes. So as funes de entrada e sada do C. Nos exemplos
mostrados nos captulos anteriores foram vistas algumas funes de entrada (scanf(), getch()) e algumas
funes de sada (printf()). Neste captulo veremos, em detalhe, estas e outras funes de modo a permitir
escrever um programa completo em C.
Mostraremos, nas duas sees iniciais as mais importantes funes de entrada e sada de dados em C: as
funes printf() e scanf(). A partir do estudo destas funes possvel escrever um programa propriamente dito com entrada, processamento e sada de dados.
2.6.1 Comando para Sada de Dados funo: printf()

Biblioteca: <stdio.h>
Usos:
printf("Mensagem");
printf ("Mensagem %caracteres_controle", dados);
A funo printf() (print formated) pode imprimir mensagens simples na tela.

Ex1 :
Ex2 :
#include <stdio.h>
void main()
{
printf("Oi");
}
Sada do programa:
Oi
#include <stdio.h>
void main()
{
printf("Primeiro ");
printf("programa");
}
Sada do programa:
Primeiro programa
Note que o programa anterior (Ex2 ) imprimiu numa mesma linha as mensagens que estavam em linhas de
comando diferentes. Isto acontece porque no foram includos caracteres de controle, chamados de caracteres
de escape dentro da mensagem printf().
A tabela 2.1 lista algumas seqencias de caracteres de escape que podem ser utilizadas com o funo
printf().
Sequncia
de Escape
\a
\b
\n
\t
\
\"
Resultado
Caractere de Beep
Caractere de Backspace
Caractere de Mudana de Linha
Caractere de Tabulao Horizontal
Caractere de Aspas Simples
Caractere de Aspas Duplas
Tabela 2.1: Sequncias de escape para printf().

Desta forma, para corrigir o problema verificado no Ex2 deveramos digitar:
22

Ex3 :
#include <stdio.h>
void main()
{
printf("Primeiro\n");
printf("programa");
}
Sada do programa:
Primeiro
programa
Outro exemplo Ex4 :

#include <stdio.h>
void main()
{
printf("Linha1\nLinha 2\nLinha
3\n");
}
Sada do programa:
Linha 1
Linha 2
Linha 3
A funo printf() tambm pode imprimir dados numricos, caracteres e strings. Esta funo dita de
sada formatada pois os dados de sada podem ser formatados (alinhados, com nmero de dgitos variveis,
etc.) de acordo com os caracteres_controle utilizados,neste caso especfico, os especificadores de formato
conforme mostra a tabela 2.2 seguir.
Especificador
de Formato
%d
%i
%u
%o
%x ou %X
%f
%e ou %E
%c
%s
%%
Tipo de Valor
Valor inteiro
Valor inteiro
Valor inteiro sem sinal (unsigned)
Valor inteiro na base octal
Valor inteiro em Hexadecimal
Valor em ponto flutuante (float)
Ponto flutuante em notao exponencial
Caracter no formato ASCII
String de caracteres com terminador nulo
Exibe o caracter de sinal percentual
Tabela 2.2: Especificadores de formato de sada para funo printf().

A figura 2.3 mostra a sintaxe correta para trabalhar com especificadores de formato.
comando
sada
printf(%d + %5.2f = %6.4f, 3, 4.567, 3 + 4.567);

3 +
4.57 = 7.5670
5 caracteres
2 casas
decimais
6 caracteres
4 casas
decimais
Figura 2.3: Exemplo de sada formatada com printf().

Seguem programas exemplo mostrando o uso de especificadores de formato com a funo printf().
Programa 1:
1
2
3
4
5
6
7
prog1.c
#include <stdio.h>
void main()
{
int a=3;
int b=4;
printf("a + b = %d + %i = %d", a, b, a+b);
}
23
Sada do programa anterior:

a + b = 3 + 4 = 7
Programa 2:
1
2
3
4
5
6
7
8
prog2.c
#include <stdio.h>
#include <conio.h> /* biblioteca que contem a funo clrscr() */
void main() {
int a=3;
float b=4.5;
clrscr(); /* esta funcao limpa a tela (clear screen) */
printf("a + b = %d + %i = %d", a, b, a+b);
}
Sada do programa:
a + b = 3 + 0 = 0
Perceba que neste caso, foi mostrado um valor incorreto para a varivel b. Isto ocorreu porque o programador
usou %d para tentar exibir valores em ponto flutuante. Por conta disto a funo printf() mostrou um
resultado incorreto na tela. O correto seria codificar:
Programa 3:
1
2
3
4
5
6
7
8
prog3.c
#include <stdio.h>
#include <conio.h> /* contem a funcao clrscr() */
void main() {
int a=3;
float b=4.5;
clrscr(); /* esta funcao limpa a tela (clear screen) */
printf("a + b = %d + %f = %d", a, b, a+b);
}
Resultado da execuo do programa:

a + b = 3 + 4.500000 = 0
Note que agora o contedo da varivel b exibido de forma correta mas o resultado da operao de adio
no porque o especificador de de formato utilizado para demonstrar o resultado da adio continuou sendo
%d quando deveria ter sido usado %f (o resultado da adio de um int + float retorna um float).
O programa a seguir explora um pouco mais as opes para formatao de dados de sada de um programa
e as diferentes tipos de dados possveis de serem declarados em ANSI C.
Programa 4:
prog4.c
1 /* Program 4 - LOTTYPES.C */
2 #include <stdio.h>
3 void main() {
4
int a;
/* simple integer type
5
long int b;
/* long integer type
6
short int c;
/* short integer type
7
unsigned int d;
/* unsigned integer type
8
char e;
/* character type
9
float f;
/* floating point type
10
double g;
/* double precision floating point
11
12
a = 1023;
13
b = 2222;
14
c = 123;
15
d = 1234;
16
e = X;
17
f = 3.14159;
24
*/
*/
*/
*/
*/
*/
*/

18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49 }
g = 3.1415926535898;
printf("a
printf("a
printf("a
printf("b
printf("c
printf("d
printf("e
printf("f
printf("g
=
=
=
=
=
=
=
=
=
%d\n", a);
%o\n", a);
%x\n", a);
%ld\n", b);
%d\n", c);
%u\n", d);
%c\n", e);
%f\n", f);
%f\n", g);
/*
/*
/*
/*
/*
/*
/*
/*
/*
sada
sada
sada
sada
sada
sada
sada
sada
sada
inteira
em octal
em hexadecimal
inteira formato longo
inteira formato curto
inteiro sem sinal
para caracter
para ponto flutuante
para ponto flutuante dupla preciso
*/
*/
*/
*/
*/
*/
*/
*/
*/
printf("\n");
printf("a = %d\n", a);
printf("a = %7d\n", a);
printf("a = %-7d\n", a);
/* sada para inteiro simples

*/
/* sada com largura de 7 caracteres
*/
/* sada justificada esquerda, 7 caracteres */
c = 5;
d = 8;
printf("a = %5d\n", c, a);
printf("a = %8d\n", d, a);
/* use 5 caracteres de largura */

/* use 8 caracteres de largura */
printf("\n");
printf("f = %f\n", f);
printf("f = %12f\n", f);
printf("f = %12.3f\n", f);
printf("f = %12.5f\n", f);
printf("f = %-12.5f\n", f);
printf("f = %e\n", f);
printf("f = %5.2e\n", f);
/*
/*
/*
/*
/*
/*
/*
sada
sada
sada
use 5
sada
sada
sada
simples ponto flutuante

com 12 caracteres
com 3 casas decimais
casas decimais
alinhada esquerda
formato cientfico
formatada cientfica
*/
*/
*/
*/
*/
*/
*/
Sada deste programa:

a
a
a
b
c
d
e
f
g
=
=
=
=
=
=
=
=
=
1023
1777
3ff
2222
123
1234
X
3.141590
3.141593
a
a
a
a
a
= 1023
=
1023
= 1023
= 1023
=
1023
f
f
f
f
f
f
f
=
=
=
=
=
=
=
3.141590
3.141590
3.142
3.14159
3.14159
3.141590e+00
3.14e+00
2.6.2 Comandos para Entrada de Dados

Funo scanf()
A funo scanf() para entrada de dados partir do teclado, implementada em todos os compiladores
C (por padro). Ela seria o complemento para a funo printf(). Sua sintaxe similar printf():
25
Uso: scanf("expresso_de_controle", argumentos);

onde expresso_de_controle serve para indicar o tipo de dado ser lido, conforme mostra a tabela 2.3 seguir:
Expresso de
Controle
%d
%f
%c
%s
Tipo de dado ser lido

valor inteiro
valor com casas decimais (ponto flutuante)
apenas 1 caracter
string (conjunto de caracteres)
Tabela 2.3: Expresses de controle para funo scanf().

e argumentos contem o nome da varivel onde o dado lido atravs do teclado vai ser depositado. Em argumentos pode ser colocada uma lista de dados de entrada serem entrados, no entanto, no se recomenda
esta opo pois o sistema no avisa o usurio de que est esperando mais dados de entrada, e cada dado
de entrada deve vir separado por vrgula ou espao em branco. Detalhe extra: Antes do nome da varavel
em argumentos, deve aparecer o smbolo & (que na realidade serve para avisar o compilador o endereo na
memria onde deve guardar a informao lida do teclado).
Ex1 :
1
2
3
4
5
6
7
8
9
10
11
ent1.c
#include <stdio.h>
#include <conio.h>
void main() {
int a, b;
clrscr();
printf ("Entre com a: ? ");
scanf ("%d", &a);
printf ("Entre com b: ? ");
scanf ("%d", &b);
printf ("\na + b = %d + %d = %d", a, b, a+b);
}
Sada do programa:
Entre com a: ? 3 Entre com b: ? 4
a + b = 3 + 4 = 7
2.6.3 Comentrios dentro de um programa

Os pares de caracteres /* e */ delimitam blocos de comentrios em C, sendo que esses comentrios
podem se estender por diversas linhas. A outra forma de comentrio aceita pela linguagem a barra dupla,
//, que inicia um comentrio que termina com o final da linha.
O uso de comentrios deve ser usado como forma de documentao interna de um programa. O excesso
de comentrios no recomendado, pois pode at prejudicar a leitura de um programa. Entretanto, h
comentrios que devem estar presentes em qualquer programa, tais como:
Comentrios de prlogo (ou iniciais): que aparecem no incio de cada mdulo ou arquivo-fonte. Devem indicar a finalidade do mdulo, uma histria de desenvolvimento (autor e data de criao e modificaes),
e uma descrio das variveis globais (se houver);
Exemplo:
/* Programa: exemplo.c
Programa para converter de graus Farenheit para graus Celcius
Fernando Passold, em 16/03/2005
/
*
26
Comentrios de procedimento: que aparecem antes da definio de cada funo indicando seu propsito,
uma descrio dos argumentos e valores de retorno;
Comentrios descritivos: que descrevem blocos de cdigo. Comentrios devem ser facilmente diferenciveis
de cdigo, seja atravs do uso de linhas em branco, seja atravs de tabulaes. importante que comentrios sejam corretos e coerentes com o cdigo, uma vez que um comentrio errneo pode dificultar mais
ainda o entendimento de um programa do que se no houvesse comentrio nenhum.
2.6.4 EXERCCIOS
1) Escreva um programa para calcular a mdia de 3 valores informados pelo usurio.
2) Monte um programa capaz de calcular o valor final atingido por uma mercadoria, dado que o usurio
informa o valor inicial da mercadoria e a porcentagem de desconto dada pela loja.
3) Escreva um programa capaz de calcular as razes para uma equao do 2o grau: ax2 + bx + c = 0, onde
o usurio entra com os coeficientes da equao: a, b e c.
4) Monte um programa que converta uma temperatura em graus Farenheit fornecida pelo usurio para
graus Clcius, sabendo-se que:
5 (o F 32)
o
C=
9
2.6.5 PROBLEMAS RESOLVIDOS

Segue uma lista de pequenos programas realizveis em sala de aula.
Primeiro exemplo:
1
2
3
4
5
6
7
8
9
TESTE1.CPP
/* TESTE1.CPP
Simples programa para mostrar funo printf()
/
*
#include <stdio.h>
void main(){
clrscr();
printf("Mensagem");
printf("Mensagem2");
}
Sada do programa:
MensagemMensagem2
Note que apesar de terem sido usadas duas funes printf(), as mensagens no apareceram em linhas
separadas e sim, uma aps a outra. Para fazer com que as mensagens aparecessem cada uma na sua linha,
deveramos ter usado o caracter de escape \n na primeira funo printf(), como demonstra o programa
seguir: TESTE2.CPP.
1
2
3
4
5
6
7
8
9
TESTE2.CPP
/* TESTE2.CPP
Usando caracteres de escape com a funo printf()
*/
#include <stdio.h>
#include <conio.h> /* biblioteca com funo clrscr() */
void main()
{
clrscr(); /* esta funo limpa a tela (clear screen) */
printf("Mensagem\n");
27
10
printf("Mensagem2");
11 }
Sada do programa:
Mensagem Mensagem2
Note que agora, cada mensagem apareceu na sua linha.

Mensagens em linhas separadas no necessariamente devem usar vrios comandos printf() diferentes:
1
2
3
4
5
6
7
8
9
TESTE4.CPP
/* TESTE4.CPP
Brincando um pouco mais com \n e \t na funo printf()
*\
#include <stdio.h>
#include <conio.h>
void main(){
clrscr();
printf("\n\n\nMensagem\tMensagem2");
}
Que gera o resultado:
Mensagem
Mensagem2
Note que pulamos 2 linhas na tela antes da primeira mensagem.

Outro exemplo, mas agora usando tambm especificadores de formato para mostrar informaes numricas na tela:
1
2
3
4
5
6
7
TESTE6.CPP
/* TESTE6.CPP */
#include <stdio.h>
#include <conio.h>
void main(){
clrscr();
printf("\na + b = %d + %d = %d", 3, 4, 3+4);
}
gera a sada:
a + b = 3 + 4 = 7
Especificando agora diferentes formatos de sada de acordo com o tipo de certas variveis:
1
2
3
4
5
6
7
8
9
10
11
12
13
TESTE7.CPP
/* TESTE7.CPP */
#include <stdio.h>
#include <conio.h>
void main(){
int a;
float b;
int c;
a=3;
b=4.57656566855;
c=a+b;
clrscr();
printf("a + b = \%d + \%d = \%d", a, b, c);
}
28
Note que este programa gera a sada:

a + b = 3 + 0 = 16384
quando deveria gerar algo como:
a + b = 3 + 4.57656566855 = 7.57656566855
O programa anterior possui alguns erros de programao:
1) O primeiro erro (do programador) foi no ter percebido que a varivel b na linha 06 foi declarada como
float. Lembrando que: int + float float, a varivel c na linha 07 tambm deveria ter sido declarada
como float.
2) E na linha 12, os especificadores de formato usados para imprimir o contedo das variveis b e c esto
errados. Deveria ter sido usado %f (adequado para variveis do tipo float) no lugar de %d (apropriado
para variveis do tipo int).
3) Erro de execuo: Tentar imprimir o contedo de uma varivel do tipo float usando especificador para
varivel do tipo int, faz com que o compilador gere informao incorreta na tela: 0 para o contedo da
varivel b e 16384 para o contedo da varivel c.
O programa anterior corrigido fica:

1
2
3
4
5
6
7
8
9
10
11
12
TESTE8.CPP
/* TESTE8.CPP - correo do TESTE7.CPP */
#include <stdio.h>
#include <conio.h>
void main(){
int a;
float b, c;
a=3;
b=4.57656566855;
c=a+b;
clrscr();
printf(" a + b = %d + %f = %f", a, b, c);
}
Que, agora sim, gera a sada:

a + b = 3 + 4.576566 = 7.576566
Note porm que as variveis do tipo flutuante foram impressas com vrias casas aps a vrgula. Isto
pode ser consertado se nos espeficadores de formato adotados para as variveis do tipo float houvesse sido
indicado a quantidade total de caracteres e nmero de casas decimais desejadas, como demonstra o programa
seguir:
TESTE9.CPP
1 /* TESTE9.CPP - melhoria do TESTE8.CPP */ #include <stdio.h>
2 #include <conio.h> void main(){
3
int a;
4
float b, c;
5
a=3;
6
b=4.57656566855;
7
c=a+b;
8
clrscr();
9
printf(" a + b = %d + %4.2f = %4.2f", a, b, c);
10 }
Que gera a sada:

a + b = 3 + 4.58 = 7.58
Mas o que aconteceria se o contedo da varivel b do programa anterior fosse negativo?
29
1
2
3
4
5
6
7
8
9
10
11
12
TESTE10.CPP
/* TESTE10.CPP - variao do TESTE9.CPP */
#include <stdio.h>
#include <conio.h>
void main(){
int a;
float b, c;
a=3;
b= -4.57656566855; /* Unica diferenca para TESTE9.CPP */
c=a+b;
clrscr();
printf(" a + b = \%d + \%4.2f = \%4.2f", a, b, c);
}
Seria gerada a sada:

a + b = 3 + -4.58 = -1.58
Note, que no havia sido previsto no TESTE9.CPP, o caso de alguma das varveis ser negativo. Note ainda
que nos espcificadores de formato para o contedo destas variveis, temos que prever uma quantidade extra
de caracteres, para o caso de ser necessrio imprimir o prprio sinal negativo do nmero. Sendo assim, a linha
11 deveria ser corigida para:
11.
printf("a + b = %d + %5.2f = %5.2f", a, b, c);
30
Parte II
Estruturas de Controle de Fluxo
31


Estruturas de Controle de Fluxo
Observao: Material em fase de edio

Prof. Fernando Passold Semestre 2005/1
33
34
Captulo
Estruturas de Deciso
Contents
3.1
Comando if..else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
35
3.2
Usando operadores Lgicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
43
3.3
Comandos if encadeados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
44
3.4
Operador Ternrio Operador ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
52
3.5
Comando switch case (Decises Mltiplas) . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
53
Neste captulo voc aprender a usar as estruturas de deciso do C para alterar o fluxo de execuo de um
programa conforme o resultado de condies sendo testadas. Sero estudados os comandos:
if (condio) { bloco de comandos 1 } else { bloco de comandos 2 }
switch (varivel){ case (constante1): ..; break; ... default: ...;}
3.1 Comando if..else

Note que para resolver certos algoritmos faz falta realizar um teste na condio de certas variveis e tomar
uma deciso entre mais de uma opo de acordo com o resultado deste teste. A figura 3.1 mostra a sintaxe a
na forma de fluxograma o comando if..else.. da linguagem C.
if (condio){
/* Condio verdadeira */
bloco de comandos 1
}
else{
/* Condio falsa */
bloco de comandos 2
}
No/Falsa
condio
Sim/Verdadeira
% Caso Verdadeiro
Bloco de comandos 1
(a) Sintaxe
% Caso Falso
Bloco de comandos 2
(b) Fluxograma.
Figura 3.1: Comando if..else...

35
3.1. Comando if..else
3. Estruturas de Deciso
A condio ser testada pode ser qualquer expresso usando operadores chamados relacionais (porque
permitem testar uma relao). A tabela 3.1 mostra uma lista destes operadores disponveis na linguagem C.
Operador
Matemtico
>
<
=
6=
Operador na
Linguagem C
>
<
>=
<=
==
!=
Funo
Maior que
Menor que
Maior ou igual a
Menor ou igual a
Igual
Diferente
Exemplo em C
(a > b)
((a+b)<c)
a >= b
a <= 0
a == b
a != 0
Tabela 3.1: Tabela de Operadores Relacionais

Este comando funciona assim, caso a condio testada seja verdadeira (ou um valor 6= 0), o bloco de comandos
1 executado, seno (else) (ou valor do teste = 0), o bloco de comandos 2 executado.
Observaes:
1. Se o teste ser executado simples (1 nica linha de comandos), as chaves ({ e }) no so necessrias.
2. O else do comando if opcional.
Em PORTUGOL este comando ficaria:
SE (condio) ENTO
INICIO
bloco de comandos 1
FIM
SENO
INICIO
bloco de comandos 2
FIM
Exemplos
Exemplo1
1 void main(){
2
int value = 5;
3
4
if (value >= 0 )
5
printf ("Valor eh positivo\n");
6
7
printf("Valor eh %d", value);
8 }
Quando executado o comando:

4
if (value >= 0 )
o contedo da varivel value testada. Se value maior ou igual zero, o comando seguinte executado,
ou seja, a linha:
5
Se value menor que 0, o programa mostraria apenas o segundo comando printf, ou seja, executaria a
linha:
7
36
Note ainda que um ponto-e-vrgula no finaliza a linha contendo o comando if:

4
if (value >= 0 )
Um comando if realmente contm sempre no mnimo duas partes. A primeira especifica a condio e a
segunda contm o comando que ser executado se a condio for verdadeira. Como pode ser notado, o bloco
de comandos referente ao caso do teste ser verdadeiro, a parte do printf identado, linha 5, no inicia nem
termina com chaves, porque neste caso de uso do if, existe apenas 1 comando para ser executado lembre-se
da observao 1.
Tambm repare que o comando associado a if est identado. Embora o compilador C no obrigue a
identao, os programadores costumam identar comandos associados com uma instruo para auxiliar
visualmente o programador.
O exemplo anterior pode ser ampliado, encaixando os smbolos { e } para indicar o incio e o fim do bloco
de comandos referente ao caso da condio testada ser verdadeira:
1 void main(){
2
int value = 5;
3
4
if (value >= 0 ){
5
6
}
7
8 }
Exemplo2
2 void main(){
3
int value;
4
printf("\nEntre com um valor inteiro: ? ");
5
scanf("%i", &value);
6
if (value >= 0)
7
{
8
printf("O valor digitado eh positivo\n");
9
}
10
else
11
{
12
printf("O valor digitado eh negativo\n");
13
}
14
printf("Fim.");
15 }
Este programa pode gera a seguinte sada:

Entre com um valor inteiro: ? 3
O valor digitado eh positivo
Fim.
caso o usurio tenha entrado com um valor 0. Ou gerar uma sada como a mostrada abaixo em caso contrrio:
Entre com um valor inteiro: ? -5
O valor digitado eh negativo
Fim.
37
O programa anterior poderia ser escrito de uma maneira mais resumida:

2 void main(){
3
int value;
4
printf("\nEntre com um valor inteiro: ? ");
5
scanf("%i", &value);
6
if (value >= 0)
7
printf("O valor digitado eh positivo\n");
8
else
9
printf("O valor digitado eh negativo\n");
10
printf("Fim.");
11 }
e os mesmos resultados seriam gerados (comprove na prtica).

O Fluxograma equivalente ao programa acima aparece na figura 3.2.
Incio
Entre com um valor inteiro: ?
value
value 0
No
Sim
O valor digitado negativo
O valor digitado positivo
Fim
Fim
Figura 3.2: Fluxograma do Exemplo2 .
Problema:
E o que aconteceria se o usurio digitasse 0 (zero)??? Como este problema poderia ser resolvido?
38
Detalhes:
A linguagem C SEMPRE avalia qualquer valor diferente de zero como verdadeiro.
Por exemplo:
if (0)
Sempre resultar como um teste FALSO;
if (53) Sempre resultar como um teste VERDADEIRO;
Por exemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Sada:
#include <stdio.h>
#include <conio.h>
void main(){
int i;
clrscr();
Falso
Verdadeiro
if (0)
printf("Verdadeiro\n");
else
printf("Falso\n");
if (53)
printf("Verdadeiro\n");
else
printf("Falso\n");
}
Exemplo3
Por exemplo, um simples programa escrito em ANSI C para calcular as razes de uma equao do 2o grau
s funciona para os casos em que suas razes sejam reais (xi <), mas d erro no caso de razes complexas,
por exemplo:
Programa Calcula razes equao 2o grau:
Formato: a*x^2 + b*x + c = 0
Entre com a: ? 2 Entre com b: ? 2 Entre com c: ? 2
Delta = -12.000000 sqrt: DOMAIN error sqrt: DOMAIN error
x1 = +NAN x2 = +NAN
Note que o programa consegue determinar o valor de 4 = b2 4ac, mas a funo sqrt() no est preparada para extrair a raiz quadrada de nmeros negativos, o que resula nas mensagens de erro:
sqrt: DOMAIN error sqrt: DOMAIN error
e
x1 = +NAN x2 = +NAN
referentes s linhas 23 25 do programa abaixo:
1
2
3
4
5
6
/* Programa equacao do 2o grau - 1a verso

*/
#include <stdio.h>
#include <conio.h> /* contem clrscr() */
#include <math.h> /* contem sqrt()
*/
39
7 void main(){
8
/* Declaraco de variveis */
9
float a,b,c,delta,x1,x2;
10
clrscr();
11
/* Etapa de entrada de dados */
12
printf("Programa Calcula razes equao 2o grau:\n\n");
13
printf("Formato: a*x^2 + b*x + c = 0\n\n");
14
printf("Entre com a: ? ");
15
scanf("%f", &a);
16
printf("Entre com b: ? ");
17
scanf("%f", &b);
18
printf("Entre com c: ? ");
19
scanf("%f", &c);
20
/* Etapa de processamento */
21
delta=b*b-4*a*c;
22
printf("\nDelta = %f\n", delta);
23
x1=(-b+sqrt(delta))/(2*a);
24
x2=(-b-sqrt(delta))/(2*a);
25
printf("\nx1 = %f\nx2 = %f\n", x1,x2);
26
getch(); /* "congela" tela ate usurio apertar uma tecla */
27 }
Seria muito interessante se houvesse uma forma do programa avisar o usurio de que as razes do seu
sistema so complexas e parar o clculo das razes ou tentar realizar este clculo com alguma modificao no
programa mostrado anteriormente.
Isto pode ser feito se houver uma forma de testar o valor de 4 e ento direcionar o programa para
continuar realizando o clculo ou no. Para tanto, necessitamos de um comando que possibilite esta tomada
de deciso. Este comando o IF..THEN.. (ou SE..ENTO.. em PORTUGOL), ou if em linguagem C.
Soluo1 : em PORTUGOL:
1 INICIO
2
LER a,b,c
3
delta = b*b-4*a*c
4
IF delta < 0 ENTO
5
INCIO
6
IMPRIMIR "No h razes reais."
7
FIM
8
SENO
9
INCIO
10
x1 = (-b + sqrt(delta))/(2*a)
11
x2 = (-b + sqrt(delta))/(2*a)
12
IMPRIMIR x1, x2
13
FIM
14 FIM
40
Soluo em C:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/* Programa equao do 2o grau - 2a verso

*/ #include <stdio.h> #include <conio.h> /* contem clrscr() */
*/ void main(){
clrscr();
scanf("%f", &a);
scanf("%f", &b);
scanf("%f", &c);
delta=b*b-4*a*c;
/* Etapa de Sada de Dados */

if (delta < 0)
printf("No h razes reais\n");
else {
printf("\nx1 = %f\n", x1);
printf("x2 = %f\n",
x2);
}
getch(); /* "congela" tela ate usurio pressionar uma tecla */
Sada do programa:
Delta = -12.000000 No h razes reais
Soluo2 :
O tipo de soluo anterior pode no satisfazer o usurio. Entretanto o ANSI C no permite trabalhar com
variveis complexas. A soluo ento improvisar. Note que no caso do delta ser negativo, as razes se
decompem na sua parte Real e na sua parte Imaginria, da seguinte forma:
b
j
x1 =
2a
2a
e
x2 =
+ j
2a
2a
|{z} | {z }
Real
Imaginaria
Note que j que a funo sqrt() do ANSI C no extrai a raiz quadrada de nmeros negativos (resulta num
nmero complexo), multiplicamos
o encontrado anteriormente por 1, tornado assim este nmero positivo.
S temos que nos lembrar que: 1 = j. Dai os 2 termos encontrados para a raz x1 e x2 . Como cada uma
das razes possui ento dois componentes, a parte real e a parte imaginria, declaramos 2 variveis para cada
uma das razes, por exemplo: x1_Real, x1_Imag, x2_Real, e x2_Imag e o problema estaria resolvido. Veja
o cdigo abaixo:
41
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/* Programa equao do 2o grau - 3a verso

*/
#include <stdio.h>
#include <conio.h> /* contem clrscr() */
*/
void main(){
float x1_Real,x1_Imag,x2_Real,x2_Imag;
clrscr();
scanf("%f", &a);
scanf("%f", &b);
scanf("%f", &c);
delta=b*b-4*a*c;
/* Etapa de Sada de Dados */

if (delta < 0){
x1_Real=-b/(2*a);
x1_Imag=sqrt(-delta)/(2*a);
x2_Real=-b/(2*a);
x2_Imag= -sqrt(-delta)/(2*a);
printf("\nx1 = %f + j%f\n", x1_Real,x1_Imag);
printf("x2 = %f -j%f\n", x2_Real,x2_Imag);
}
else {
printf("\nx1 = %f\n", x1);
printf("x2 = %f\n",
x2);
}
getch(); /* "congela" tela ate usurio apertar uma tecla */
42
3.2. Usando operadores Lgicos
Sada do programa:
Delta = -12.000000
x1 = -0.500000 + j0.866025 x2 = -0.500000 -j-0.866025
O nico problema continua sendo a forma de apresentar os resultados na tela, especialmente para o caso
da parte complexa ser negativa. Voc saberia como melhorar a sada anterior?
Problemas
Problema1 : Monte um programa onde o usurio entra com 2 nmeros quaisquer e o programa indica depois
qual foi o maior valor entrado.
Problema2 : Melhore a sada da 3a verso do programa para calcular as razes de uma equao do 2o grau, no
caso de razes complexas, de forma a evitar que o mesmo gere uma sada como:
x1 = -0.500000 + j0.866025 x2 = -0.500000 -j-0.866025
3.2 Usando operadores Lgicos

Existem 3 operadores lgicos em C que permitem ampliar a condio testada: AND (&&), OR (||) e NOT
(!), conforme demonstram a tabela 3.2 seguir.
Operador em
Linguagem Natural
E
Ou
Negao
Operador na
Linguagem C
&&
||
!
Funo
Exemplo
Lgico AND
Lgico OR
Lgico NOT
if (letter >= a && letter <= z)

if (letter == y || letter == Y)
if (!((letter == y) || (letter == Y)))
Tabela 3.2: Operadores lgicos em C.
Exemplos
Exemplo1 : O programa abaixo indica se um aluno est em EXAME depois que o mesmo entrou com sua
mdia semestral.
EXAME.CPP
2 #include <conio.h>
3 void main(){
4
float media;
5
6
clrscr();
7
printf("Entre com a media semestral: ? ");
8
scanf("%f", &media);
9
10
printf("Este aluno ");
11
if ((media>=3)&&(media<7))
12
printf("ESTA EM EXAME\n");
13
else
43
3.3. Comandos if encadeados

14
15
16
17 }
printf("nao esta em exame\n");

getch();
Rode este programa e verifique as sadas geradas.
3.3 Comandos if encadeados

Comandos if podem ser encadeados um dentro do
outro. Por exemplo:
1 if y == 1
2
Tarefa_a();
3 else
4
if y == 2
5
Tarefa_b();
6
else
7
if y == 0
8
Tarefa_c();
9
else
10
Tarefa_d();
O segmento anterior de programa poderia tambm ter

sido escrito na forma:
1 if y == 1
2
Tarefa_a();
3
else if y == 2
4
Tarefa_b();
5
else if y == 0
6
Tarefa_c();
7
else
8
Tarefa_d();
Na forma de fluxograma, o segmento de programa

acima ficaria como o mostrado na figura ao lado.
44
Figura: Exemplo de IFs encadeados.

Incio
media
media 7
Sim
Aprovado
No
media 3
Sim
Em Exame
No
Reprovado
Fim
Figura 3.3: Fluxograma relativo soluo 1 do Ex.1 .
Exemplo
Monte um programa para indicar se um aluno foi Aprovado, est em Exame ou foi Reprovado numa
disciplina, baseado na mdia semestral informada pelo usurio.
Soluo1 : Comparando a nota obtida pelo aluno do valor mais baixo para o mais alto:
10
REPROVADO
EM EXAME
APROVADO
O fluxograma representando esta soluo mostrado na figura 3.3.

O cdigo referente ao fluxograma da figura 3.3 mostrado abaixo:
MEDIA1.CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <conio.h>
void main(){
float media;
clrscr();
if (media >= 7)
printf("O aluno foi APROVADO\n");
else{
if (media >= 3)
printf("O aluno est em EXAME\n");
else
printf("O aluno foi REPROVADO\n");
}
getch();
}
45
Soluo2 : Outra soluo:

MEDIA2.CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <conio.h>
void main(){
float media;
clrscr();
if (media >= 7)
printf("O aluno foi APROVADO\n");
else{
if (media < 3)
printf("O aluno foi REPROVADO\n");
else
printf("O aluno esta em EXAME\n");
}
getch();
}
Soluo3 : E se o problema anterior tivesse sido resolvido da forma abaixo. Onde est o erro?
MEDIA3.CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <conio.h>
void main(){
float media;
clrscr();
printf("Este aluno est");
if (media >= 3)
printf("em EXAME\n");
else
if (media >= 7)
printf("APROVADO\n");
else
printf("REPROVADO\n");
getch();
}
Exemplo de sada gerada:

Entre com a media semestral: ? 8
Este aluno est em EXAME
Note que o erro est na lgica de programao envolvendo os IFs das linhas 11 e 14. Note
que o primeiro IF, da linha 11, separa media em valores maiores ou iguais 3 o primeiro erro
(conforme demonstra o exemplo de sada mostrado acima), caso contrrio, o programa segue para
o segundo IF (encadeado), da linha 14, mas quando alcana este IF, s sobraram os casos de media <
3 e assim a condio (media >= 7) nunca vai ocorrer o segundo erro de lgica de programao.
46
Soluo4 : E se este problema tivesse sido resolvido desta forma:

MEDIA4.CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <conio.h>
void main(){
float media;
clrscr();
printf("Este aluno est ");
if ((media >= 3)&&(media<7))
printf("em EXAME\n");
else
if (media >= 7)
printf("APROVADO\n");
else
printf("REPROVADO\n");
getch();
}
Resposta: a lgica deste programa est correta apesar de terem sido utilizados operadores lgicos.
Soluo5 : E o que est errado na verso abaixo?
MEDIA5.CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <conio.h>
void main(){
float media;
clrscr();
printf("Este aluno esta ");
if (media>=7)
printf("APROVADO");
if (media<3)
printf("REPROVADO");
else
printf("em EXAME");
getch();
}
que capaz de gerar uma sada como:

Entre com a media semestral: ? 8 Este aluno esta APROVADOem EXAME
Desta vez, repare que os 2 IFs no esto encadeados entre si, isto , o IF da linha 13 sempre ser
executado tal qual o IF da linha 11. Isto que gera o erro como o mostrado no exemplo de sada
demonstrado para este programa (acima).
47
Problemas
Problema1 : Monte um programa que classifique a faixa etria das pessoas conforme a idade que foi informada para elas, segundo a tabela abaixo:
Beb
menos que 2 anos de vida
Criana
maior que 2 e at 12 anos
Adolescente maior que 12 mas menor que 23
Adulto
maior que 23 mas menor que 70
Idoso
maior que 70
Possvel Soluo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
IDADES.CPP
/* Programa: idades.cpp */
/* Problema 1: classificacao de faixas etarias */
#include <stdio.h>
#include <conio.h>
void main(){
float idade;
clrscr();
printf("Entre com a idade da pessoa: ? ");
scanf("%f", &idade);
if (idade <= 2)
printf(" um beb\n");
else
// if ((idade > 2)&&(idade <= 12)) <- AND redundante!
if (idade <= 12)
printf(" uma criana\n");
else
if (idade <= 23)
printf(" um adolescente\n");
else
if (idade <= 70)
printf(" um adulto\n");
else
printf(" um idoso\n");
getch();
}
Note que o programa anterior pode tambm ser codificado da seguinte forma (usando os marcadores de incio e fim para cada if e else: { e }):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
IDADES.CPP
/* Programa: idades.cpp */
/* Problema 1: classificacao de faixas etarias */
#include <stdio.h>
#include <conio.h>
void main(){
float idade;
clrscr();
printf("Entre com a idade da pessoa: ? ");
scanf("%f", &idade);
if (idade <= 2) {
printf(" um beb\n"); }
else {
// if ((idade > 2)&&(idade <= 12)) <- AND redundante!
if (idade <= 12) {
printf(" uma criana\n"); }
else {
if (idade <= 23) {
printf(" um adolescente\n"); }
else {
if (idade <= 70) {
printf(" um adulto\n"); }
48
23
else {
24
printf(" um idoso\n");
25
}
26
}
27
}
28
}
29
getch();
30 }
Problema2 : Monte um programa capaz de identificar o tipo de tringulo baseado nas dimenses dos 3 lados
passados pelo usurio. Sendo que o caso de um tringulo possuir 3 lados iguais, o qualifica
como tringulo equiltero; no caso de possuir 2 lados iguais, um tringulo issceles, seno
o caso de um tringulo qualquer. E no caso do usurio informar algum dos lados maior
que a soma dos outros 2 lados configura uma figura geomtrica que no caracteriza um tringulo.
Possvel Soluo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
TRIANG.CPP
/* Programa: triang.c
Problema 2: classificao de tringulos */
#include <stdio.h>
#include <conio.h>
void main(){
float a, b, c;
clrscr();
printf("Entre com as dimenses dos lados de um tringulo:\n\n");
printf("Lado a: ? ");
scanf("%f", &a);
printf("Lado b: ? ");
scanf("%f", &b);
printf("Lado c: ? ");
scanf("%f", &c);
if ( (a < (b+c)) && (b < (a+c)) && (c < (a+b)) ) {
// um tringulo de fato...
if ((a == b) && (b == c)) {
printf("O tringulo equiltero");
}
else {
if ( (a == b) || (a == c) || (c == b) ) {
printf("O tringulo isosceles");
}
else {
printf(" um tringulo qualquer");
}
}
}
else {
printf("No um tringulo");
}
getch();
}
49
Problema3 : Monte um programa onde o usurio entra agora com 3 nmeros e que depois mostre o maior
nmero entrado. Teste as 3 possibilidades possveis, por exemplo:
a
5
b
4
c
3
a
4
b
5
c
3
a
4
b
3
c
5
Soluo1 :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
IFPROB3.CPP
/* Programa: IFPROB3.CPP
Problema 3: classificao de nmeros */
#include <stdio.h>
#include <conio.h>
void main(){
float a, b, c;
clrscr();
printf("Entre com 3 numeros:\n\n");
printf("a: ? ");
scanf("%f", &a);
printf("b: ? ");
scanf("%f", &b);
printf("c: ? ");
scanf("%f", &c);
if ( (a>=b) && (a>=c) ) {
printf("Maior numero => a=%f\n", a);
}
else {
/ * a < b e a < c */
if ( b>=c ) {
printf("Maior numero => b=%f\n", b);
}
else {
printf("Maior numero => c=%f\n", c);
}
}
getch();
}
O cdigo acima suficiente para descobrir qual o maior nmero, mas incapaz de identificar
o caso dos 3 nmeros serem iguais ou os 2 maiores serem iguais. Para prever estes casos
necessrio se refinar esta primeira soluo.
50
Soluo2 :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
IFPROB3B.CPP
/* Programa: IFPROB3B.CPP - verso melhorada
Problema 3: classificao de 3 nmeros
*/
#include <stdio.h>
#include <conio.h>
void main(){
float a, b, c;
clrscr();
printf("Entre com 3 nmeros:\n\n");
printf("a: ? ");
scanf("%f", &a);
printf("b: ? ");
scanf("%f", &b);
printf("c: ? ");
scanf("%f", &c);
if ( (a==b) && (b==c) ){ /* No necessito testar se a==c ! */
printf("Os 3 nmeros informados sao iguais\n");
}
else {
if ( (a>=b) && (a>=c) ){
/* mas a=b? ou a=c? */
if (a==b){
printf("Maiores nmeros => a e b que sao iguais (%f)\n", a);
}
else{
if (a==c){
printf("Maiores nmeros => a e c que sao iguais (%f)\n",a);
}
else{
printf("Maior numero => a = %f\n", a);
}
}
}
else { /* a<b, a<c */
if (b==c){
printf("Maiores nmeros => b e c, que sao iguais (%f)\n", b);
}
else {
if (b>c){
printf("Maior numero => b = %f\n", b);
}
else {
printf("Maior numero => c = %f\n", c);
}
}
}
}
getch();
}
Note que agora esta soluo capaz de prever casos como:

Entre com 3 nmeros:
a ? 5
b ? 2
c ? 5
Maiores nmeros => a e c que sao iguais (5.0000)
Observaes:
51
3.4. Operador Ternrio Operador ?
O cdigo da soluo2 demonstra ainda como importante comear

a identar (tabular) corretamente o programa at para melhor compreenso do mesmo ou no mnimo para o programador ter a certeza
de onde iniciam e comeam cada bloco de if { .. } e else { .. } .
Uma boa prtica para evitar esquecimentos em relao }s principalmente (resulta em mensagens de erro do compilador como:
Missplaced else ou else perdido), , durante a codificao do programa, o programador j ir se habituando a abrir ({) e
fechar (}) cada bloco no momento em que est digitando cada if ou
cada else.
Por exemplo:
if ( condio_testada ) {
...
}
else {
...
}
Problema4 : Complemente o problema anterior, mas agora, depois do usurio entrar com os 3 nmeros, o
programa deve mostrar os 3 nmeros em ordem decrescente. Quantas possibilidades existem?
Existe uma forma de montar um algoritmo bastante curto para executar esta tarefa?
3.4
Operador Ternrio Operador ?
C permite realizar testes IF simples usando o operador dito ternrio: ?. usado no lugar de declaraes
IF do tipo:
if (condio) {
varivel = expresso_1; }
else {
varivel = expresso_2;
}
Sintaxe:
varivel = condio ? expresso_1 : expresso_2;
Se a condio testada for verdadeira, o valor da expresso_1 atribudo varivel; caso contrrio, varivel
assume o valor de expresso_2.
Exemplo:
x = (y < 10) ? 20 : 40;
atribui a x, o valor 20 se y for menor que 10 ou atribui a x, o valor 40 caso y seja maior ou igual 10.
52
3.5. Comando switch case (Decises Mltiplas)
3.5 Comando switch case (Decises Mltiplas)

Adicionalmente ao comando IF..ELSE, programas em C podem usar o comando switch case para processamento de condies.
Sintaxe:
switch (varivel) {
case (constante1): { bloco de comandos 1 } break;
case (constante2): { bloco de comandos 2 } break;
..
.
default: { bloco de comandos nenhum dos casos anteriores }
}
Este comando avalia o estado de uma varivel e ento tenta localizar uma coincidncia dentro de uma
lista de possibilidades digitadas pelo programador. Se a lista contm uma coincidncia, este comando executa
os comandos associados ao valor coincidente. Se o swicth case no encontra uma coincidncia, a execuo
continua no bloco chamado default ou no primeiro comando seguinte ao switch.
Entretanto, C nos reserva uma pequena armadilha associada com o comando switch case. Durante o teste
das coincidncias dentro da lista passada pelo programador, se o programa encontrar um valor coincidente, ele
executa os comandos associados ao valor e, a menos que esses comandos sejam seguidos da instruo break,
o programa continua sua execuo na instruo associada aos outros valores restantes da lista por exemplo:
veja o programa seguir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
CASE1.CPP
/* Programa: case1.c
Usando swicth case de maneira incorreta */
#include <stdio.h>
#include <conio.h>
void main(){
char letra;
printf("Entre com apenas uma letra: ? ");
scanf("%c", &letra);
switch
case
case
case
case
case
}
(letra){
A: printf("Vogal
E: printf("Vogal
I: printf("Vogal
O: printf("Vogal
U: printf("Vogal
A\n");
E\n");
I\n");
O\n");
U\n");
getch();
}

Entre
Vogal
Vogal
Vogal
Vogal
com apenas uma letra: ? E

E
I
O
U
Note que apesar da coincidncia com a letra E o programa continuou a executar os outros cases (linhas 13
em diante) at encontrar o fim do switch (linha 17), ou continuaria assim at encontrar um comando break
(que faltou). Isto , uma vez que o programa tenha encontrado um valor que coincida com algum case, ele
continua a executar os prximos cases, no importando mais se ocorrem coincidncias ou no.
A maneira correta de codificar o programa acima mostrado seguir (no esquecer de usar break associado ao final de cada case):
CASE2.CPP
1 /* Programa: case2.c
2
Usando swicth case de maneira correta */
53

3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <conio.h>
void main(){
char letra;
switch
case
case
case
case
case
}
(letra){
A: printf("Vogal
E: printf("Vogal
I: printf("Vogal
O: printf("Vogal
U: printf("Vogal
A\n");
E\n");
I\n");
O\n");
U\n");
break;
break;
break;
break;
break;
getch();
}
Desta vez, gerada uma sada como:

Entre com apenas uma letra: ? E
Vogal E
Note que nos exemplos anteriores no fizemos uso da condio default utilizada para executar um bloco
no caso de nenhuma coincidncia ter sido encontrada dentro da lista programada.
No caso do programa anterior, poderamos contemplar o caso do usurio entrar com uma letra que no
corresponde nenhuma das vogais verificadas, neste caso, a letra seria uma consoante. O programa ficaria
ento:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
CASE3.CPP
Usando swicth case com condio especial "default" */
#include <stdio.h>
#include <conio.h>
void main(){
char letra;
switch (letra){
case A: printf("Vogal A\n");
case E: printf("Vogal E\n");
case I: printf("Vogal I\n");
case O: printf("Vogal O\n");
case U: printf("Vogal U\n");
default: printf("Foi digitada
}
break;
break;
break;
break;
break;
uma consoante\n");
getch();
}

Entre com apenas uma letra: ? d
Foi digitada uma consoante
54
Observao importante:
Note que o comando switch..case s trabalha com variveis do tipo int ou char!
Nos casos anteriores, o que aconteceria se o usurio tivesse entrado com uma vogal minscula ao invs de
uma das maisculas programas para testar as vogais??? Como resolver este problema???
Note que o comando swicth..case bastante flexvel e permite testar faixas de valores ou combinaes de
condies. Neste caso, devemos usar a vrgula (,) para separar as coincidncias que correspondem um
mesmo case.
A soluo para o caso do usurio entrar com uma vogal minscula ficaria ento como mostrado abaixo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
CASE4.CPP
Usando swicth case de forma mais flexivel */
#include <stdio.h>
#include <conio.h>
void main(){
char letra;
switch (letra){
case A, a: printf("Vogal A\n"); break;
case E, e: printf("Vogal E\n"); break;
case I, i: printf("Vogal I\n"); break;
case O, o: printf("Vogal O\n"); break;
case U, u: printf("Vogal U\n"); break;
default: printf("Foi digitada uma consoante\n");
}
getch();
}
Que gera uma sada do tipo mostrada abaixo:

Entre com apenas uma letra: ? i
Vogal I
55
56
Captulo
Estruturas de Repetio
Neste captulo sero estudados os comandos:
while (condio){bloco de comandos}
do {bloco de comandos} while (codio);
for (inicializao; condio; incremento) {bloco de comandos}
Contents
4.1
Repetio com teste no incio: while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
4.2
Repetio com teste no final: do..while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
63
4.3
Uso de flags para controle de programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
4.4
Algoritmos Interativos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
68
4.5
Repetio Automtica: for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
71
4.6
while for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
77
4.7
Instrues break e continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
4.7.1
Instruo break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
4.7.2
Instruo continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
81
Problemas Finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
83
4.8
4.1 Repetio com teste no incio: while

Esta estrutura permite repetir um bloco de programao enquanto a condio testada for verdadeira. Caso
contrrio, o programa sai deste bloco de repetio e continua sua execuo pelas linhas seguintes de cdigo.
57
4.1. Repetio com teste no incio: while
4. Estruturas de Repetio
Fluxograma:
Sintaxe:
while ( condio ) {
/* bloco de comandos ser repetido
enquanto a condio for vlida */
}
condio?
bloco
Exemplo1 : Suponha que queremos montar um programa que continue repetindo um teste (como o do
programa CASE4.CPP, pg 55), se ao final o usurio digitar S (Sim).
WHILE1.CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/* Programa: while1.cpp
Usando while */
#include <stdio.h>
#include <conio.h>
void main(){
char letra;
char continua=S;
while (continua==S||continua==s) {
/*************************************************************/
clrscr();
fflush(stdin); /* limpa buffer de teclado */
switch (letra){
case A:
case a: printf("Vogal A\n"); break;
case E:
case e: printf("Vogal E\n"); break;
case I:
case i: printf("Vogal I\n"); break;
case O:
case o: printf("Vogal O\n"); break;
case U:
case u: printf("Vogal U\n"); break;
default: printf("No foi informada nenhuma vogal.\n");
}
/*************************************************************/
printf("\nDigite S para continuar no programa: ");
continua = getchar();
// scanf("%c", &continua);
// printf("continua = %c\n", continua);
} /* fecha o while */
printf("Programa abortado\n");
getch();
}
Note que na linha 9 estabelecemos 2 condies para que o programa execute o teste que queremos repetir
(linhas 11 27) at que o usurio aperte a tecla S ou s. Note que como a condio j testada no incio
58
do bloco while, se faz necessrio forar uma condio inicial para que este teste seja validado ao menos
uma nica vez e assim o teste seja executado ao menos uma vez. Por isto, declaramos a varivel continua e a
inicializamos j diretamente com S linha 7.
Note ainda que aprimoramos um pouco o programa CASE4.CPP da pgina 55, de forma que o mesmo
identifique os casos em que o usurio digitou uma vogal minscula ou maiscula. Para tanto, repare que para
testar se o usurio digitou A ou a, foram usados 2 cases, um para cada letra, mas entre o primeiro case e o
segundo, propositalmente no foi utilizado o comando break.
Foram utilizadas as linhas contendo as instrues:
fflush(stdin);
para evitar erros de execuo que ocorrem pelo fato do programa no ter ler 2 seqencias de entrada de dados
pelo teclado. O erro pode ocorrer porque o programa no esvazia corretamente o buffer do teclado e acaba
passando para o segundo comando de leitura do teclado o prprio caracter correspondente tecla Return
ou Enter (cdigo 13 na tabelas ASCII) usado pelo usurio para entrar com o primeiro dado e assim, o
programa recebe um contedo vazio (string nula) para o segundo comando de entrada de dados.
Exemplo2 : O programa seguir executa repetidas o bloco presente dentro do while at que a varivel n
alcance um valor igual ou inferior 10.
Soluo:
a) Fluxograma:
b) Programa em C:
c) Sada do programa:
Incio
n=1
n10
No
Sim
n=,n
n=n+1
WHILE2.CPP
2 void main(){
3
int n=1;
4
5
while (n <= 10) {
6
printf("n= %2i\n", n);
7
n = n + 1;
8
}
9 }
n= 1
n= 2
n= 3
n= 4
n= 5
n= 6
n= 7
n= 8
n= 9
n= 10
Fim
Problema1 : Modifique o programa anterior (WHILE2.CPP) para que n comece com n = 10 e termine com
n = 1.
Soluo:
Sada do programa:
WHILE2.CPP
#include <stdio.h>
#include <conio.h>
void main(){
int n=10;
1
2
3
4
5
6
while(n>=1){
7
printf("n= %2i\n", n);
8
n=n-1;
9
}
10 }
n= 10
n= 9
n= 8
n= 7
n= 6
n= 5
n= 4
n= 3
n= 2
n= 1
59
Note:
toda estrutura de repetio deve possuir uma condio de parada. Quando isso no
acontece, ocorre o que chamamos de looping infinito.
Problema2 : E se fosse desejada uma sada como a mostrada abaixo?

n | t
----+---10 | 1
9 | 2
8 | 3
7 | 4
6 | 5
5 | 6
4 | 7
3 | 8
2 | 9
1 | 10
Soluo:
WHILE03.CPP
1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <conio.h>
void main(){
int n=10;
printf(" n | t\n");
printf("----+----\n");
while(n>=1){
printf(" %2i | %2i\n", n, (10-n)+1);
n=n-1;
}
}
60
Problema3 : Escreva um programa que gere uma tabela de converso de graus Fahrenheit para graus Clsius,
iniciando em -10o F at +80o F, avanando de 5 em 5o graus Fahrenheit, baseado na equao abaixo:
o
C=
5(o F 32)
9
Soluo:
Sada:
oF |
oC
----+-------10 | -23.3
-5 | -20.6
0 | -17.8
5 | -15.0
10 | -12.2
15 |
-9.4
20 |
-6.7
25 |
-3.9
30 |
-1.1
35 |
1.7
40 |
4.4
45 |
7.2
50 |
10.0
55 |
12.8
60 |
15.6
65 |
18.3
70 |
21.1
75 |
23.9
80 |
26.7
WHILEFAR.CPP
#include <stdio.h>
#include <conio.h>
void main(){
int f=-10;
float c;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 }
(4.1)
clrscr();
printf(" oF |
oC\n");
printf("----+-------\n");
//
1234 123456
while( f<=80 )
{
c=(5.0*(f-32))/9.0;
printf("%3i | %6.1f\n", f, c);
f= f+5;
}
Ateno:
No programa anterior, foram declaradas 2 tipos diferentes de variveis: int f
para graus Fahrenheit e float c para graus Clsius. Como a temperatura em
graus Fahrenheit s varia em torno de valores inteiros, esta varivel foi declarada
como int. Mas note que usando a equao 4.5, inevitvel o surgimento de casas
decimais na converso de graus Fahrenheit para graus Clsius pela diviso sendo
realizada. Note porm que para codificar corretamente a equao 4.5 devem ser
acrescentados .0 nas constantes 5 e 9 desta equao (ver linha 14 no programa
WHILEFAR.CPP), para forar o C a realizar o clculo da diviso em ponto flutuante (com casas decimais). Caso contrrio o C truncar a parte correspondente s
casas decimais, e o resultado (incorreto) ser uma coluna de graus Clsius com a
casa decimal zerada.
Problema4 : Escreva um programa que calcule o fatorial do nmero n digitado pelo usurio.
Embasamento terico: em teoria, o seguinte clculo deveria ser ralizado, por exemplo:
Fatorial de 5: 5! = 5 4 3 2 1. Levando-se ainda em conta que, por definio: 0! = 1 e que no
existem o fatorial de nmeros negativos.
Soluo1 : segue abaixo uma primeira verso para este programa:
FAT01.CPP
3 void main(){
4
int n, fat;
5
6
printf("\n\nFatorial de: ? "); scanf("%i", &n);
7
printf("%i! = ", n);
8
9
if (n<0){
10
printf("No existe (n negativo)\n");
11
}
61
12
else{
13
if (n==0){
14
printf("1\n");
15
}
16
else{
17
if (n==1){
18
printf("1\n");
19
}
20
else{
21
fat=n*(n-1);
22
n=n-2;
23
while (n>=2){
24
fat= fat*n;
25
n= n-1;
26
}
27
printf("%i\n", fat);
28
}
29
}
30
}
31 }
Note alguns detalhes no programa anterior:

1. As linhas 9 11 verificam se o caso do usurio tentar forar o programa a calcular o fatorial de um
nmero negativo;
2. Caso contrrio, as linhas 13 15 verificam ainda se o usurio est tentando obter o fatorial de zero que
por definio 1;
3. Caso ento o usurio tenha entrado com n > 0 o programa passa a tentar calcular o fatorial entre as
linhas 17 e 29.
4. Entretanto, pela maneira peculiar do programa calcular o fatorial de um nmero (linhas 21 28), as linhas
17 19 prevem o caso do usurio ter requisitado o clculo do fatoral de 1 que 1.
5. A principal rotina do programa do programa anterior que realmente calcula o fatorial de um nmero
est entre as linhas 21 28:
21
22
23
24
25
26
fat=n*(n-1);
n=n-2;
while (n>=2){
fat= fat*n;
n= n-1;
}
Seja n por exemplo, igual 5, ento, ser realizado o seguinte processamento:

21
22
23
24
25
26
23
24
25
26
23
27
fat=n*(n-1);
n=n-2;
while (n>=2){
fat= fat*n;
n= n-1;
}
while (n>=2){
fat= fat*n;
n= n-1;
}
while (n>=2){
printf("%i\n", fat);
f at = 5 (5 1) = 5 4 = 20
n=52=3
(3 2) ? Sim, ento entre no while:
f at = 20 3 = 60
n=31=2
Volte para o while (linha 23)
(2 2) ? Sim, ento entre no while:
f at = 60 2 = 120
n=21=1
Volte para o while (linha 23)
(1 2) ? No, fim do while, v para linha 27
Faz aparecer na tela: "120"
62
4.2. Repetio com teste no final: do..while
4.2 Repetio com teste no final: do..while

Estrutura de repetio de um bloco de comandos similar ao comando while, mas neste caso, a condio
testada apenas no final do bloco de repetio. Isto significa que o bloco de repetio vai ser executado no
mnimo uma vez.
Fluxograma:
bloco
Sintaxe:
do {
bloco de comandos serem repetidos
} while (codio);
condio?
Exemplo1 : Suponha que queremos montar um programa que continue repetindo um teste (como o do
programa WHILE1.CPP, pg 55), se ao final o usurio digitar S ou s (Sim). Mas agora este teste executado
apenas no final do bloco de repetio.
DOWHILE1.CPP
3 void main(){
4
char letra;
5
char continua;
6
7
clrscr();
8
do {
9
/*************************************************************/
10
11
12
13
switch (letra){
14
case A:
15
case a: printf("Vogal A\n"); break;
16
case E:
17
case e: printf("Vogal E\n"); break;
18
case I:
19
case i: printf("Vogal I\n"); break;
20
case O:
21
case o: printf("Vogal O\n"); break;
22
case U:
23
case u: printf("Vogal U\n"); break;
24
default: printf("No foi informada nenhuma vogal.\n");
25
}
26
/*************************************************************/
27
printf("\nDigite S para continuar no programa: ");
28
29
continua = getchar();
30
// scanf("%c", &continua);
31
// printf("continua = %c\n", continua);
32
} while (continua==S||continua==s); /* fecha o do..while */
33
34
getch();
63
35 }
Sada do programa
Entre com apenas uma letra: ? a
Vogal A
Digite S para continuar no programa: s
Entre com apenas uma letra: ? E
Vogal E
Digite S para continuar no programa: S
Entre com apenas uma letra: ? n
No foi informada nenhuma vogal.
Digite S para continuar no programa: n
Programa abortado
Exemplo2 : Programao de um menu.

MENU.CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <stdio.h>
#include <conio.h>
void main(){
char opcao;
do {
clrscr();
do {
printf("\n\nMenu:\n");
printf("1. Incluso\n");
printf("2. Alterao\n");
printf("3. Excluso\n\n");
printf("0. Sair do programa\n");
printf("\nDigite uma opo: ? ");
scanf("%c", &opcao);
switch (opcao){
case 1: printf("\nFoi escolhido Incluso\n"); break;
case 2: printf("\nFoi escolhido Alterao\n"); break;
case 3: printf("\nFoi escolhido Excluso\n"); break;
//case 0: printf("Foi escolhido Sair do programa\n"); break;
default: printf("\nNo foi digitada nenhuma opo vlida!");
}
} while (opcao!=1 && opcao!=2 && opcao!=3 && opcao!=0);
printf("\nContinuar no programa (S/N): ? ");
scanf("%c", &opcao);
} while (opcao!=N && opcao!=n);
printf("Ok... saindo do programa\n");
getch();
}
Sada do programa:
Menu:
1. Incluso
2. Alterao
64
3. Excluso
0. Sair do programa
Digite uma opo: ? 1
Foi escolhido Incluso
Continuar no programa (S/N): ? s
Menu:
1. Incluso
2. Alterao
3. Excluso
0. Sair do programa
Digite uma opo: ? g
No foi digitada nenhuma opo valida!
Menu:
1. Incluso
2. Alterao
3. Excluso
0. Sair do programa
Digite uma opo: ? 1
Continuar no programa (S/N): ? n
Ok... saindo do programa
Problema2 : Como voc modificaria o programa anterior para que o menu de operao do programa trabalhasse da forma mostrada abaixo?
Menu:
1. Incluso
2. Alterao
3. Excluso
0. Sair do programa
Digite uma opo: ? 1
Menu:
1. Incluso
2. Alterao
3. Excluso
0. Sair do programa
Digite uma opo: ? g
No foi digitada nenhuma opo valida!
Menu:
1. Incluso
2. Alterao
3. Excluso
0. Sair do programa
65
Digite uma opo: ? 0

Confirma sada do programa: ? s
Ok... Saindo do programa
Problema3 : Monte um programa capaz de determinar o valor do somatrio final, h, atingido para a srie
mostrada abaixo conforme o valor n digitado pelo usurio.
h=1+
1
1 1 1
+ + + ... +
2 3 4
n
(4.2)
Soluo: Para entender a lgica do algoritmo que deve ser construdo melhor simular antes o clculo de
alguns valores de h conforme o valor de n digitado pelo usurio, o que resulta numa tabela como a mostrada
seguir:
n
1
2
3
4
..
.
h
h=1
h = 1 + 1/2 = 1, 5
h = 1 + 1/2 + 1/3 = 1, 83
h = 1 + 1/2 + 1/3 + 1/4 = 2, 083
..
.
Repare:
h1 1
h2 h1 + 1/2
h3 h2 + 1/3
h4 h3 + 1/4
..
.
h=1+1/2+1/3+. . . +1/n
hn hn1 + 1/n
Tabela 4.1: Simulando valores de h n.

Reparamos pela tabela anterior, que entre uma interao e outra ocorre o seguinte tipo de clculo:
hn hn1 + 1/n
(4.3)
onde hn pode ser interpretado como o valor atual (ou novo valor) sendo buscado e hn1 pode ser interpretado
como o valor anterior. Percebemos que h sempre pode iniciar com 1 e que conforme n aumenta, novas
interaes para o clculo de h so necessrias conforme a equao 4.3. Notamos entretanto que necessrio
se controlar o nmero de vezes em que o clculo de h deve ser repetido conforme demonstra a tabela
4.1 levantada anteriormente. Necessitamos ento de uma varivel contadora para controlar o nmero de
vezes que a equao 4.3 deve ser repetida. Percebemos pela tabela 4.1, que esta varivel contadora deve iniciar em 1 e terminar em n conforme especificado pelo usurio, e que h deve ser inicializado com um valor nulo.
Programa:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
SERIE.CPP
/* Programa: calculo do somatorio de uma serie convergente...
h = 1 + 1/2 + 1/3 + 1/4 + ... + 1/n
*/
#include <stdio.h>
#include <conio.h>
void main(){
int n,cont;
float h;
printf("Entre com n: ? "); scanf("%i", &n);
h=0.0; cont=1;
do{
printf("%d | h=%f+1/%d=", cont, h, cont);
h=h+1.0/cont;
printf("%f\n", h);
cont=cont+1;
} while( cont<=n );
printf("\nValor final de h: %f\n", h);
}
66
4.3. Uso de flags para controle de programas
Obs.: Note que as linhas 14 e 16 no so necessrias para que o algoritmo funcione, apenas esto presentes
para mostrar na tela, como o valor de h est sendo evoludo.
Sada do Programa:
Entre com n: ? 5
1 | h=0.000000+1/1=1.000000
2 | h=1.000000+1/2=1.500000
3 | h=1.500000+1/3=1.833333
4 | h=1.833333+1/4=2.083333
5 | h=2.083333+1/5=2.283334
Valor final de h: 2.283334
Problema Proposto: Melhore o programa para clculo do fatorial (em comparao ao programa da pg. 61).
4.3 Uso de flags para controle de programas

Quando no sabemos priori o nmero de repeties que devem ser executadas para um certo bloco do
programa, podem ser criadas variveis Booleanas (Verdadeiro ou Falso) para verificar se certas condies que
caracterizam o fim do lao de repetio foram alcanadas. Estas variveis apenas sinalizariam este tipo de
condies e por isto mesmo so comumente chamadas de flags.
Exemplo1 : Escreva um programa que imprima: a) o menor, b) o maior e c) o valor mdio de um conjunto de
dados digitados pelo usurio. Detalhe: repare que o que determina o final da entrada de dados a digitao
de um nmero negativo. Note ento que a condio de sada do lao de repetio ser a leitura de um valor
negativo este seria o flag neste caso.
MEDIAIT.CPP
3 void main(){
4
float valor, soma, maior, menor, media;
5
int cont=0;
6
soma=0; // inicializa varivel que contem o somatrio dos nmeros entrados
7
8
printf("Programa para gerar a mdia dos valores informados\n");
9
printf("Entre com um nmero negativo para indicar o fim da entrada de dados\n\n");
10
11
do {
12
printf("No. %2i) ? ", (cont+1));
13
scanf("%f", &valor);
14
if (valor>=0){ // somente realiza clculos se valor entrado >= zero
15
cont=cont+1;
16
if (cont==1){
17
maior=valor; // supe que o maior valor o primeiro informado
18
menor=valor; // supe que o menor valor o primeiro informado
19
}
20
soma=soma+valor;
21
if (valor>maior)
22
maior=valor;
23
if (valor<menor)
24
menor=valor;
25
}
26
} while (valor >= 0);
67
4.4. Algoritmos Interativos

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41 }
if (cont>0){ // usurio entrou com ao menos 1 nmero >= zero

media=soma/cont;
printf("\nForam informados %i nmeros...\n", cont);
printf("\n
Mdia: %7.2f\n", media);
printf("Menor valor: %7.2f\n", menor);
printf("Maior valor: %7.2f\n", maior);
}
else {
printf("No foi informado nenhum nmero maior ou igual zero\n");
}
printf("\nAperte uma tecla para sair do programa ");
getch();
Sada gerada:
Programa para gerar a mdia dos valores informados Entre com um
nmero negativo para indicar o fim da entrada de dados
No.
No.
No.
1) ? 10
2) ? 5
3) ? -9
Foram informados 2 nmeros...

Mdia:
Menor valor:
Maior valor:
7.50
5.00
10.00
Aperte uma tecla para sair do programa
4.4 Algoritmos Interativos

Para resolver problemas cientficos, mtodos interativos so freqentemente empregados. Num mtodo
interativo, uma primeira aproximao para uma soluo obtida e ento algum mtodo que melhore a
preciso do resultado repetido at que duas aproximaes sucessivas alcancem a preciso desejada. O
processo pode ser descrito como:
Produza a primeira aproximao na varivel old;
Produza uma aproximao melhor com base no valor
da varivel old e guarde este novo resultado na varivel new;
while old e new no estejam prximos o suficiente
{
old = new;
Produza uma aproximao melhor com base no valor
da varivel old e guarde este novo resultado na varivel new;
}
68
Exemplo: Programa para determinar a raiz quadrada de um nmero.

Se old a primeira aproximao para a raiz quadrada do nmero x, ento, a melhor aproximao, new, pode
ser encontrada fazendo-se:
new = (old +
x
)/2
old
(4.4)
Por exemplo, supondo que 3 seja uma aproximao para a raiz quadrada do nmero 101 , aplicando-se a
equao 4.4 acima umas 3 vezes resulta em:
old
3
3.17
3.1623
new
(3+10/3)/2 = 3.17
(3.17+10/3.17)/2 = 3.1623
(3.1623+10/3.1623)/2 = 3.162278
Note
que
esta
seqencia
rapidamente
converge
para
o
valor
real
( 10
=
3.1622776601683793319988935444327). Isto pode no acontecer para todos os algoritmos interativos (eles
podem convergir ou divergir). Mas neste caso, este mtodo sempre converge desde que a primeira
aproximao seja um nmero positivo diferente de zero.
Na explicao genrica para um algoritmo interativo, foi utilizada a expresso while old e new no estejam prximos o suficiente. Como aplicar esta abordagem neste caso? Neste caso, podemos estabelecer que a
ltima nova aproximao aceitvel quando a diferena entre o valor anterior (old) e o ltimo valor (new) for
menor que 0.0005. Isto significa que a estimativa para a raiz quadrada de um nmero estar correta para as 3
primeiras casas decimais. Ento poderia ser realizado um teste como:
while ((new - old) > 0.0005) {
..
}
Entretanto, notar que se for aplicado o teste acima para o caso da estimativa da raiz quadrada do nmero
10, na 2a interao ser testado: 3.1623 3.17 > 0.0005, o que implica em testar se: 0.0077 > 0.0005 o que
infelizmente far com que a busca por uma nova aproximao pare abruptamente (o algoritmo no continua
dentro do while buscando por uma aproximao melhor). A soluo para este problema simples: basta testar
se o mdulo da diferena entre o novo valor e o valor antigo menor que 0.0005. Isto pode ser feito aplicandose a funo fabs(x) definida na biblioteca <math.h>, que retorna x no caso de x ser 0 ou x no caso de x ser
negativo. Seria o equivalente a realizar o seguinte teste: |(new old)| > 0.0005 ?, que em C ficaria ento como:
while ( fabs(new - old) > 0.0005) {
..
}
Entretanto ainda existe um outro problema. Em geral tentar convergir 2 valores dentro de uma certa tolerncia calculando-se simplesmente a diferena entre estes 2 valores, resulta no no clculo da tolerncia mas
sim na diferena absoluta entre os 2 valores (na escala original dos valores empregados. Como se determinar
esto esta tolerncia? Considere o caso abaixo:
Valor Exato
100
0.1
Aproximao
100.1
0.2
Para o caso acima, qual das 2 aproximaes acima a melhor? As duas resultam num erro absoluto de
0,1, porm note que num dos casos, o erro est em torno de 0,1% das grandezas sendo aproximadas, enquanto
no outro caso (o segundo), este erro de 100%! Note ento que precisamos escalonar os valores sendo
aproximados seno vamos acabar produzindo um mtodo interativo muito ruim se o caso de entrada for
similar ao segundo caso mostrado na tabela anterior. Desta forma, uma maneira de avaliar o erro relativo
fazer-se ento:
|new old|
erro =
new
que com certeza nos far realizar aproximaes na escala de porcentagem dos valores sendo tratados e no
como aproximaes com base em diferenas absolutas de 2 valores sendo tratados. Ento finalmente nosso
teste fica como:
1
10 = 3.1622776601683793319988935444327
69
while ( (fabs(new - old))/new ) > 0.0005) {
..
}
Para tornar nosso algoritmo a prova de falhas precisamos nos assegurar de que o usurio no
entre
com valores negativos ou nulos. No caso do valor ser nulo (zero) basta informar ao usurio que: 0 = 0
assim, este configuraria um caso especial, fcil de ser tratado. Para o caso do usurio ter entrado
com um nmero negativo, o programa simplesmente indica que no calcula a raiz quadrada de nmeros
negativos e para de ser executado. E por fim,
como aproximao inicial para a raiz quadrada de um
nmero, vamos simplesmente fazer com que: x =?; old = x e usamos a equao 4.4 para encontrar um
novo valor (new) at que uma tolerncia relativa de 0.000005 seja encontrada (o que resulta num erro de 0.05%).
Programa:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
SQUARE1.CPP
#include <stdio.h>
#include <conio.h>
#include <math.h>
void main(){
float tol, valor, old, new_v, erro;
/* new no pode ser usado pois confunde o
compilador: existe um operador chamado new usado para definir um novo
objeto - caso de programao orientada a objetos */
int cont=0; // apenas para contar o numero de interaes
tol=0.000005;
clrscr();
printf("Programa para extrair a raiz quadrada de um numero\n\n");
printf("Entre com o numero: ? ");
scanf("%f", &valor);
if (valor < 0.0){
printf("Este programa no pode encontrar a raiz quadrada\n");
printf("de nmeros negativos.\n");
}
else{
if (valor == 0){
printf("A raiz quadrada de 0 : 0.0\n");
}
else {
// realizando a primeira aproximao
old=valor;
new_v=(old+valor/old)/2.0;
erro=(fabs(new_v-old))/new_v;
//
1234567890
1234567890
123456789012
printf("Interao |
Old
|
New
| Tolerncia \n");
printf("
1
| %10.6f | %10.6f | %12.10f\n", old, new_v, erro);
cont=cont+1;
while (erro > tol) {
cont=cont+1;
old = new_v;
new_v=(old+valor/old)/2.0;
erro=(fabs(new_v-old))/new_v;
//
123456789
123456789
12345678901
printf("
%2i
| %10.6f | %10.6f | %12.10f\n", cont,
old, new_v, erro);
}
printf("\n A raiz quadrada de %f : %f\n", valor, new_v);
}
}
printf("\nAperte uma tecla para sair do programa ");
getch();
}
70
4.5. Repetio Automtica: for
Sada gerada:
Programa para extrair a raiz quadrada de um numero
Entre com o numero: ? 10
Interao
1
2
3
4
5
6
|
|
|
|
|
|
|
Old
10.000000
5.500000
3.659091
3.196005
3.162456
3.162278
|
|
|
|
|
|
|
New
5.500000
3.659091
3.196005
3.162456
3.162278
3.162278
|
|
|
|
|
|
|
Tolerncia
0.8181818128
0.5031055808
0.1448952258
0.0106087020
0.0000562444
0.0000000000
A raiz quadrada de 10.000000 : 3.162278

Aperte uma tecla para sair do programa
4.5 Repetio Automtica: for

Esta estrutura permite repetir um bloco de programao conforme varia o contedo de uma varivel contadora usada para controlar o lao de repetio. Note que diferente do while ou do..while, aqui o programador
obrigado saber de antemo o nmero de vezes que o bloco contido dentro do lao for deve ser repetido.
Sintaxe:
for ( var_contadora=valor_inicial ; condio_de_parada ; atualizao_var_contadora ) {
/* bloco de comandos ser repetido de acordo com var_contadora */
}
Note que o comando for composto internamente por 3 expresses:
for ( expresso_1; expresso_2; expresso_3 )

{
/* Bloco ser repetido */
}
onde:
expresso_1 especifica a inicializao do lao de repetio;

expresso_2 especifica um teste feito antes de cada interao, e;
expresso_3 especifica um incremento ou decremento que realizado aps cada iterao.
O lao termina conforme o teste executado pela expresso_2.
Note que este comando equivalente fazer:
expresso_1;
while ( expresso_2 ) {
/* Bloco ser repetido */
expresso_3;
}
71
Exemplos
Exemplo1 : Programa simples mostrando modo de operao do lao for. Incrementando e decrementando
uma varivel contadora.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
FOR1.CPP
/* Programa para demonstrar uso do FOR */
#include <stdio.h>
#include <conio.h>
void main(){
int cont;
clrscr();
// incrementando variavel contadora...
for(cont=1; cont<=10; cont=cont+1){
printf("%i, ", cont);
}
printf("\n\n");
// decrementando variavel contadora...
for(cont=10; cont>=1; cont--){
}
printf("\n\n");
// incrementado variavel contadora com passo qualquer...
for(cont=1; cont<=10; cont=cont+3){
}
printf("\n\n");
}
O programa acima gera a seguinte sada:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
1, 4, 7, 10,
Note que na linha 3 do programa anterior, foi usado um comando de decremento disponvel
apenas na linguagem C:
Acronismo de C
cont-;
cont++;
Equivalente fazer:
cont=cont-1;
cont=cont+1;
O fluxograma correspondente ao lao de repetio for aparece na figura 4.1 seguir.
72
Var_contadora
Var_contadora ==valor_inicial
valor_inicial at
at valor_final
valor_final passo
passo incremento_usado
incremento_usado
Bloco
Bloco sendo
sendo repetido
repetido
Figura 4.1: Fluxograma correspondente ao lao for.
Exemplo2 : Monte um Programa para gerar uma tabela de converso de graus Fahrenheit para graus Clsius,
iniciando em -10o F at +80o F, avanando de 5 em 5o graus Fahrenheit, baseado na equao abaixo:
o
C=
5(o F 32)
9
Algoritmo em C:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
FORTEMP.CPP
/* 2o Programa para demonstrar uso do FOR */
#include <stdio.h>
#include <conio.h>
void main(){
int fare; // note: o nome "far" e palavra reservada do Builder C++
float celsius;
clrscr();
printf(" Fahrenheit | Celsius\n");
printf("------------+-----------\n");
/*
100
| -67.46
123412312345|12123456123 */
for (fare=-10; fare<=80; fare=fare+5){
celsius=(5.0*(fare-32))/9.0;
printf("
%3i
| %6.2f\n", fare, celsius);
}
}
Sada gerada:
Fahrenheit | Celsius
------------+-----------10
| -23.33
-5
| -20.56
0
| -17.78
5
| -15.00
10
| -12.22
15
|
-9.44
20
|
-6.67
25
|
-3.89
30
|
-1.11
35
|
1.67
40
|
4.44
45
|
7.22
50
|
10.00
55
|
12.78
60
|
15.56
65
|
18.33
70
|
21.11
75
|
23.89
80
|
26.67
73
(4.5)
Compare a soluo deste problema com o mesmo j realizado na pgina 61, mas usando while.
Exemplo3 : Monte um programa que determina o fatorial no nmero n digitado pelo usurio, mas usando for.
Soluo:
FATFOR.CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <conio.h>
void main(){
int n,i;
int fat=1;
clrscr();
printf("Fatorial de ? ");
scanf("%i", &n);
for (i=n;i>=2;i--){
fat=fat*i;
}
printf("%i!= %i\n", n, fat);
}
Sada gerada:
Fatorial de ? 5
5!= 120
Exemplo4 : Monte um programa que gere n colunas com quantidades aleatrias de caracteres *s (entre 1 76
colunas). O valor de n especificado pelo usurio.
Dica: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Use a funo: int random (int num); do C para gerar nmeros aleatrios entre 0 e
num 1. Note que interessante antes de rodar a funo random(), preparar o gerador
de nmeros aleatrios chamando a funo: void randomize(void); este comando necessita ser executado apenas uma nica vez antes do comando random(). Veja o programa
exemplo a seguir que imprime uma lista de 10 nmeros aleatrios sorteados entre 0 99:
1
2
3
4
5
6
7
8
9
10
11
12
13
NUMALE.CPP
#include <stdio.h>
#include <conio.h>
#include <stdlib.h> // contem randomize() e random() - num aleatorios...
void main(){
int i;
// contador
int num;
// numero aleatorio
clrscr();
randomize();
for (i=1; i<=10; i++){
num=random(100);
printf("%2i) num= %i\n", i, num);
}
}
Sada gerada:
1)
2)
3)
4)
5)
6)
7)
8)
9)
10)
num=
num=
num=
num=
num=
num=
num=
num=
num=
num=
89
28
89
25
92
73
33
46
93
74
74
.................................................................................................
Soluo (para o Exemplo3 ):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
COLALE.CPP
#include <stdio.h>
#include <conio.h>
#include <stdlib.h> // contem randomize() e random()
void main(){
int i,n,cols,j;
clrscr();
randomize();
printf("Entre com n: ? ");
scanf("%i", &n);
for(i=1; i<=n; i++){
cols=random(77);
printf("%2i) ", i);
for(j=1; j<=cols; j++){
printf("*");
}
printf("\n");
}
}
Sada do programa:
Entre com n: ? 5
1) ****************
2) ********************************
3) **********************************
4) **************************************************************
5) ****************************
Observao: Note que usamos 2 for encadeados. O primeiro, da linha 12, traz dentro de si
o segundo for (mais interno), na linha 15. No h problemas em incluir um for dentro de outro.
Nestes casos, o programa termina de executar primeiro o lao de repetio que corresponde ao for
mais interno e depois termina de executar o lao de repetio do for mais externo. No caso
do programa anterior, o programa vai terminar primeiro de executar o for da linha 15 e depois
termina de executar o for da linha 12. Como o for da linha 15 est contido dentro do for da linha
12, o for da linha 15 vai acabar sendo repetido n vezes (conforme programado pelo for da linha
12). Justamente por este fato, estes for trabalham com variveis contadores que controlam o lao,
diferentes. O for da linha 12 trabalha com a varivel contadora i e o for da linha 15, com a varivel
contadora j. No podemos usar a mesma varivel contadora para estes dois for, por exemplo,
apenas a varivel i, porque seno, o for mais interno (da linha 15), vai acabar modificando a
prpria varivel i que tambm seria usada pelo for mais externo (linha 12) e assim, o for mais
externo iria perder o controle, uma vez que o contedo da varivel i seria modificado a todo
instante que rodasse o for mais interno. Portanto, os dois for trabalham com variveis contadoras
diferentes.
A figura 4.2 seguir traz um fluxograma que pretende esclarecer este caso.
.............................................................................................................
75
Incio
randomize
i=1 at n
cols=random(77)
%2i) , i
j=1 at cols
\n
Fim
Figura 4.2: Fluxograma para o programa COLALE.CPP.
76
4.6. while for
Note que C permite laos de repetio com mais de uma varivel contadora dentro do lao,
por exemplo:
FORDUPLO.CPP
1
2
3
4
5
6
7
8
9
10
11
12
/* Demonstrando uso do FOR "duplo" */

#include <stdio.h>
#include <conio.h>
void main(){
char upper, lower;
clrscr();
printf("Maiuscula\tMinuscula\n");
for (lower=a, upper=A; upper <= F; upper++, lower++){
printf("%c\t\t%c\n", upper, lower);
}
}
Que gera uma sada como:

Maiuscula
A
B
C
D
E
F
Minuscula
a
b
c
d
e
f
Ateno porm para a sintaxe correta das 3 expresses que fazem parte do for!
Note ainda que
4.6
Expresso
Valor
A + 1
B + 1
..
.
B
C
..
.
Converso Realizada
(Cdigo ASCII)
65 + 1 66
66 + 1 67
..
.
a + 1
97 + 1 98
while for
Tanto for quanto while so laos de repetio, mas com a diferena de que, o lao while continua a ser
executado enquanto a condio sendo verificada for verdadeira, no importando o valor de uma varivel
contadora como o exigido pelo lao for. Tanto o bloco de comandos contido dentro do lao de repetio while
ou for, somente sero executados se a condio ser testada for verdadeira, o que significa que os comandos
contidos dentro destes blocos podem nem chegar a serem executados.
Comparando ainda while com do..while notamos que o bloco de comandos contido dentro do lao de
repetio do..while sempre ser executado pelo menos uma nica vez, enquanto que no caso do while, pode
acontecer deste bloco nunca ser executado se a condio testada no incio do lao while se provar falsa.
Exemplos
Exemplo1 : Faa um programa que primeiro gere nmeros aleatrios na faixa entre 1 20 mostrando a equivalente quantidade na forma de *s na tela. O programa deve parar de mostrar as colunas de
*s quando o nmero sorteado for menor do que 5. O programa deve gerar uma sada similar
77
4.6. while for
mostrada abaixo:
12)
8)
17)
3)
************
********
*****************
Fim do programa
Soluo: O fluxograma correspondente a uma soluo para este problema aparece na figura 4.3.
Algoritmo em C:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
BARRAST.CPP
#include <stdio.h>
#include <conio.h>
#include <stdlib.h> // contemrandomize() e random()
void main(){
int cols,j;
clrscr();
randomize();
do{
cols=random(20);
printf("%2i) ", cols);
if (cols>=5)
for(j=1; j<=cols; j++){
printf("*");
} // fim do for
printf("\n");
} // fim do if
} while(cols>=5);
printf("Fim do programa\n");
}
78
4.6. while for
Incio
randomize
do {
cols=random(77)
%2i) , cols
cols5
No
if {
Sim
for {
j=1 at cols
// fim do for
\n
}
cols5
// fim do if
} while( .. );
Fim do programa\n
Fim
Figura 4.3: Fluxograma solucionando o problema relativo ao exemplo 1 (anterior).
79
4.7. Instrues break e continue
4.7 Instrues break e continue

As instrues vistas anteriormente podem sofrer desvios e interrupes em sua seqncia lgica normal
atravs do uso de break e continue. Entretanto, deve-se evitar de utilizar as instrues que veremos a seguir,
pois tendem a tornar um programa incompreensvel, fogem do que se chama de programao estruturada,
alm de caracterizar uma programao de baixo nvel (Assembly, C para alguns microcontroladores).
4.7.1 Instruo break

Esta instruo serve para terminar a execuo das instrues de um lao de repetio (for, do...while, while)
ou para terminar um conjunto switch...case.
Quando dentro de um lao de repetio, esta instruo fora a interrupo do lao independentemente da
condio de controle.
Exemplo1 No trecho de programa abaixo, um lao de repetio l valores para o clculo de uma mdia. O lao
possui uma condio de controle sempre verdadeira o que, a principio, um erro: constitui um lao infinito ou
looping perptuo. Porm, a sada do lao se d pela instruo break que executada quando um valor negativo
lido.
1
2
3
4
5
6
7
8
9
10
11
printf("Digite valores:");
do{
printf("Valor: ");
scanf("%f",&val);
if(val < 0.0){
break;
// sada do lao
}
num++;
soma += val; /* faz: soma = soma + val;
}while(1);
// sempre verdadeiro - looping infinito
printf("Mdia: %f",soma/num);
No exemplo anterior, o uso da instruo break deveria ter sido evitada, fazendo-se:
1
2
3
4
5
6
7
8
9
10
do{
printf("Valor: ");
scanf("%f",&val);
if(val >= 0.0){
num++;
soma += val;
}
}while(val >= 0.0);
printf("Mdia: %f",soma/num);
Admite-se o uso da instruo break, em estruturas switch...case, porque neste caso serve para separar os
conjuntos de instrues em cada case.
Exemplo2 : O programa PIANO.CPP abaixo mostra um programa que utiliza a estrutura switch..case com a
instruo break para simular um piano no teclado do computador.
1
2
3
4
5
6
7
8
9
10
11
12
PIANO.CPP
/********************************************************************
Programa: PIANO.CPP Proposito: Uso da estrutura switch com break
Ultima Revisao: 27/08/97
********************************************************************/
#include <dos.h> // contem funcao sound()
#include <stdio.h>
#include <conio.h>
#define DO 264
// definicao de escala musical
#define RE 297
#define MI 330
#define FA 352
#define SOL 396
80
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#define LA 440
#define SI 495
void main(){
int tecla;
clrscr();
printf("Digite teclas [z] [x] [c] [v] [b] [n] [m] para notas\n");
printf("ou [esc] para sair\n");
do{
tecla = getch();
// leitura do teclado
switch(tecla){
// conforme o valor de tecla...
case z:
// se tecla = z
sound(DO);
// nota do
break;
// cai fora do switch...
case x:
sound(RE);
break;
case c:
sound(MI);
break;
case v:
sound(FA);
break;
case b:
sound(SOL);
break;
case n:
sound(LA);
break;
case m:
sound(SI);
break;
}
delay(200);
// toca por 200 ms
nosound();
// desliga auto-falante
}while(tecla != 27); // repete enquanto tecla != [esc]
}
4.7.2 Instruo continue

Esta instruo opera de modo semelhante a instruo break dentro de um lao de repetio. Quando
executada, ela pula as instrues seguintes do lao de repetio sem entretanto sair do lao. Isto , a instruo
fora a avaliao da condio de controle do lao.
Exemplo: No trecho de programa abaixo revemos um lao de repetio que l valores para o clculo de uma
mdia. Se (val < 0.0) ento o programa salta diretamente para a condio de controle, sem executar o resto das
instrues.
1
2
3
4
5
6
7
8
9
10
11
do{
printf("Valor: ");
scanf("%f",&val);
if(val < 0.0){
// se val negativo...
continue;
// ...salta para...
}
num++;
// se (val < 0.0) estas instrues
soma += val;
// no so executadas!
}while(val >= 0.0);
// ...fim do lao
printf("mdia: %f",soma/num);
No exemplo anterior, o uso de continue tambm poderia ter sido evitado fazendo-se:
1 printf("Digite valores:");
2 do{
81
3
printf("Valor: ");
4
scanf("%f",&val);
5
if(val >= 0.0){
6
num++;
7
soma += val;
8
}
9 }while(val >= 0.0);
10 printf("Mdia: %f",soma/num);
Resumo
As estruturas de controle so as que definem a lgica de um programa. Fazendo operaes como laos
(loopings) e ifs encadeados, um comportamento complexo pode ser codificado.
Estruturas de Controle
if..
if..else
while..do
do..while
for..
break
continue
Estruturas que definem a lgica de um programa

Avaliao condicional de um bloco de cdigo
Escolha entre 2 alternativas e blocos exclusivos de cdigo
Construo de lao de repetio com condio prvia
Construo de lao de repetio com teste ao final
Lao de repetio automtico e determinstico
Sada imediata de um lao interno
Pule diretamente para o teste de condio do lao de repetio
82
4.8. Problemas Finais
4.8 Problemas Finais

Problema1 : Monte um programa que imprima nmeros entre 1 e 20, mas que indique (ao seu lado), se tratar
de um nmero mltiplo de 4.
Por exemplo, uma sada similar mostrada abaixo deve ser gerada:
1...
2...
3...
4... mltiplo de 4!
5...
6...
7...
8... mltiplo de 4!
9...
Dica: Usar o operador matemtico % do C para encontrar o resto de uma diviso inteira. Por
exemplo: 47 % 2 gera como resultado: 1, j (46%2) gera 0.
Rode o pequeno programa abaixo se continuar com dvidas:
1
2
3
4
5
6
7
8
9
RESTODIV.CPP
#include <stdio.h>
#include <conio.h>
void main(){
int i;
clrscr();
for (i=1; i<=10; i++){
printf("%i) %i%%3= %i\n", i, i, i%3);
}
}
Problema2 : Monte um programa que pea para o usurio entrar com nmeros inteiros positivos, mas o
programa deve parar de pedir mais dados de entrada assim que forem digitados 5 nmeros
pares. Dica: Use novamente o operador % do C.
Problema3 : Faa um programa que imprima os nmeros mpares no intervalo fechado [a, b] (sendo que a e b
so definidos pelo usurio).
Problema4 : Faa um programa que imprima os N primeiros nmeros da srie de Fibonacci:
1, 1, 2, 3, 5, 8, 13, . . ..
Note que a equao que gera esta srie pode ser definida como:
n[i] = n[i 1] + n[i 2] para i 2 j que n[0] = n[1] = 1.
Problema5 : Monte um programa que pea para o usurio adivinhar um nmero escolhido aleatoriamente
entre 1 e 100. Se o usurio digitar um nmero errado, o programa responde o novo intervalo do
nmero procurado. Se o usurio acertou o nmero procurado, o programa diz quantos palpites
foram dados. O programa deve permitir que o usurio faa no mximo 3 tentativas e ento deve
perguntar se o usurio prefere continuar no jogo. Caso positivo um novo nmero aleatrio
gerado. Caso contrrio, o programa terminado. Por exemplo:
O nmero procurado est entre 1 e 100:
Palpite: ? 45
Palpite: ? 27
Palpite: ? 36
Parabns! Voc acertou o nmero em 3 tentativas.
83
Solues para os Problemas Propostos

Seguem solues para os problemas anteriores.
Soluo problema1 : Nmeros mltiplos de 4 na faixa de 1 20.
1
2
3
4
5
6
7
8
9
10
11
12
13
FOR4.CPP
#include <stdio.h>
#include <conio.h>
void main(){
int i;
clrscr();
for (i=1; i<=20; i++){
printf("%i..", i);
if(i%4==0){
printf(" multiplo de 4..");
}
printf("\n");
}
}
Soluo problema2 : Digitao de at 5 nmeros pares.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
PROB2.CPP
#include <stdio.h>
#include <conio.h>
void main(){
int val, cont=1, pares=0;
clrscr();
do{
printf("Entre com o numero %i) ", cont);
scanf("%i", &val);
if(val%2==0){
pares++;
printf("Numeros pares entrados: %i\n", pares);
}
cont++;
} while(pares<5);
}
Soluo problema3 : Impresso de nmeros mpares dentro do intervalo [a, b].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
IMPARES.CPP
#include <stdio.h>
#include <conio.h>
void main(){
int a, b, i;
clrscr();
printf("Entre com valor inicial, a: ? ");
scanf("%i", &a);
printf("Enter com valor final, b: ? ");
scanf("%i", &b);
for (i=a; i<=b; i++){
if (i%2!=0){
// Note: se o resto da diviso no for nulo porque o nmero
//
mpar
printf(" %i,", i);
}
}
printf("\b \nFim\n");
}
Soluo problema4 : Imprimir os N primeiros nmeros da srie de Fibonacci.

???.CPP
1 falta....
Soluo problema5 : Joguinho da adivinhao de nmero sorteado pelo computador.

84

???.CPP
1 falta....
85
86
Parte III
Matrizes & Strings
87


Matrizes & Strings
Observao: Esta apostila est em fase de edio

Prof. Fernando Passold Semestre 2005/1
89
90
Captulo
Vetores, Matrizes
Contents
5.1
5.2
5.3
5.4
5.5
5.6
Conceito de array . . . . . . . . . . . . . . . . . . . . . . . . . . .
Declarao de Arrays unidimensionais . . . . . . . . . . . . . .
5.2.1 Inicializao de arrays . . . . . . . . . . . . . . . . . . . .
5.2.2 Problemas . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.3 Solues dos Problemas . . . . . . . . . . . . . . . . . . .
Arrays Bidimensionais . . . . . . . . . . . . . . . . . . . . . . . .
5.3.1 Inicializao alternativa de matrizes . . . . . . . . . . . . .
5.3.2 Observaes . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.3 Problemas . . . . . . . . . . . . . . . . . . . . . . . . . . .
Strings um caso especial de array de char . . . . . . . . . . . .
5.4.1 Inicializao de strings . . . . . . . . . . . . . . . . . . . .
5.4.2 Inicializao de strings no-dimensionadas . . . . . . . .
5.4.3 Sadas de dados do tipo string . . . . . . . . . . . . . . . .
5.4.4 Entradas de dados do tipo string . . . . . . . . . . . . . .
5.4.6 Outros exemplos . . . . . . . . . . . . . . . . . . . . . . .
5.4.7 Matrizes de strings . . . . . . . . . . . . . . . . . . . . . .
Matrizes multidimensionais . . . . . . . . . . . . . . . . . . . . .
Problemas Finais . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
91
92
93
93
95
98
99
100
102
112
112
112
113
113
115
116
116
116
118
Neste captulo voc aprender a lidar com vetores e matrizes de dados na linguagem C.
5.1 Conceito de array

Um array uma coleo de dados do mesmo tipo referenciados usando um nico nome de varivel, na
forma de um vetor ou matriz, tal qual se faz na matemtica tradicional. Cada elemento deste vetor acessado
por meio um ndice, que tanto pode ser um valor constante (e fixo) quanto varivel (uma varivel inteira
neste caso). Valores baixos de ndice correspondem aos primeiros termos deste vetor, o valor mais alto para
ndice corresponde ao ltimo elemento do vetor.
Por exemplo, na matemtica tradicional, podemos criar o vetor A composto por apenas 8 elementos, como
indicado abaixo:
A=[ 1 2 3 4 5 6 7 8 ]
onde o primeiro elemento seria referenciado como:
A1 = 1
o stimo elemento seria acessado como:
A7 = 7
note que os termos 1 e 7 usados correspondem aos ndices que permitem acessar os elementos de um vetor.
91
5.2. Declarao de Arrays unidimensionais
5. Vetores, Matrizes
5.2 Declarao de Arrays unidimensionais

Em C uma varivel pode ser declarada como um array unidimensional fazendo-se:
tipo nome_var [tamanho];
Onde:
tipo:
nome_var :
tamanho:
se refere ao tipo de dado que ser manipulado por este array, podendo ser: int, float, char e
suas variaes (long int, double, etc);
o nome que ser adotado para esta varivel que no caso um array;
define a quantidade de dados que este array ir guardar. Note que tamanho sempre ser um
valor inteiro.
Por exemplo, a matriz A usada como exemplo na seo anterior, poderia ser declarada como:
2 void main(){
3
int A[8];
4 }
para o caso de se desejar trabalhar apenas com valores inteiros dentro da matriz A (no caso, a varivel A).
Se fosse desejado armazenar valores R (ponto flutuante), deveria ser feito:
1 void main(){
2
float A[8];
3 }
A forma de acessar os elementos de um vetor em C realizado da seguinte maneira:

Matemtica
Tradicional
A1
A7
A8
Linguagem
C
A[0]
A[6]
A[7]
Observaes
primeiro elemento do array
penltimo elemento do array
ltimo elemento do array
Importante:
Note que em C, todo array inicia na posio 0 [ndice inicial = 0 (zero)] (e no
partir da posio 1 como ocorre em outras linguagens de programao).
Para atribuir valores determinadas posies de um array, faz-se:

1 A[0]=1; A[6]=7; A[7]=8;
Note que neste caso, os ndices utilizados para acessar os termos da matriz foram valores inteiros constantes, mas poderia ter sido utilizada uma varivel como ndice para acessar cada posio do array.
De fato, para inicializar a matriz A declarada anteriormente como:
A=[ 1
2 3
poderia ser feito em C, algo como:

2 void main(){
3
int A[8], i;
4
5
for (i=0; i<8; i++){
6
A[i]= i+1;
7
}
8 }
92
8 ]
que muito mais fcil que se atribuir valores mo, termo termo para cada um dos elementos da matriz
(imagine o caso de um array contendo 50 elementos voc digitaria 50 linhas atribuindo valores para cada
uma das 50 posies deste array?).
Pode-se imaginar os valores estocados num array, na forma de uma caixinha para cada um termos de
fato, cada elemento do array ocupa uma quantidade de bytes de acordo com o tipo de varivel utilizado para
definir este array veja a figura 5.1 seguir.
A[0]=
A[1]=
A[2]=
A[3]=
A[4]=
A[5]=
A[6]=
A[7]=
1
2
3
4
5
6
7
8
Figura 5.1: Ocupao de memria para uma varivel A do tipo array.

Exibir os termos que compem este array simples, basta fazer:
Programa:
O que gera uma sada como:
2 void main(){
3
int A[8], i;
4
5
for (i=0; i<8; i++){
6
A[i]= i+1;
7
printf("A[%i]= %i\n", i, A[i]);
8
}
9 }
A[0]=
A[1]=
A[2]=
A[3]=
A[4]=
A[5]=
A[6]=
A[7]=
1
2
3
4
5
6
7
8
5.2.1 Inicializao de arrays

Em C, podemos inicializar um array j no momento da sua declarao.
Por exemplo, o caso anterior, da matriz A poderia ser implementado como:
int A[8] = { 1, 2, 3, 4, 5, 6, 7, 8};
5.2.2 Problemas
Problema1 : Crie um programa que inicialize a matriz B conforme indicado abaixo:
B=[ 2
10
12 ]
Problema2 : Crie um programa para armazenar os seguintes valores na matriz Y:

Y = [ 1.5
0.5 0
0.5 1
1.5
2.5 3 ]
Problema3 : Monte um programa que leia um conjunto X com N elementos reais e que calcule a diferena
entre o maior e o menor elemento existente, alm de indicar as posies em que eles ocorrem.
93
Problema4 : Monte um programa onde o usurio entra com o valor das diversas notas alcanadas por uma
turma de alunos. O programa inicia perguntando o tamanho da turma e parte para a entrada
de dados. A seguir, o programa deve ser capaz de exibir um histograma na tela, alm de outras
informaes, conforme mostrado seguir:
Resultado da avaliao da TURMA A
Menor nota: 4.0
Maior nota: 10.0
Mdia da turma: 6.7
Histograma das notas:
0.0~ 3.0: ***
3.1~ 4.0: **
4.1~ 5.0: ****
5.1~ 6.0: *******
6.1~ 7.0: **********
7.1~ 8.0: *****
8.1~ 9.0: *
9.1~10.0: **
Note que 5 *s na linha 7.1 8.0 significa que 5 alunos alcanaram uma nota > 7.0 mas
8.0.
Problema5 : Monte um programa que realize o seguinte efeito visual conforme indicado abaixo:
Interao
1
2
3
4
..
.
20
Sada na tela
ooo
ooo
ooo
ooo
ooo
ooo
Note que este efeito visual o que ocorre nos painis de Leds usualmente empregados para
exibir mensagens rolantes numa tela. As mensagens correm sempre da esquerda para a direita.
O que ocorre na realidade o deslocamento dos bits que correspondem aos Leds acessos no
painel. O que se pede que seja criado um programa que mostre na tela uma tabela exatamente
igual mostrada anteriormente, imaginando que temos a disposio um painel formado por 20
colunas de leds no sentido horizontal (existem outras tantas linhas de leds que completam o
painel, mas neste caso, estamos interessados apenas numa das linhas).
94
5.2.3 Solues dos Problemas

Problema1 ) Soluo:
ARRAY_P1.CPP
2 void main(){
3
int B[6], i;
4
5
for (i=0; i<6; i++){
6
B[i]= 2+2*i;
7
printf("B[%i]= %i\n", i, B[i]);
8
}
9 }
Sada do programa:
B[0]=
B[1]=
B[2]=
B[3]=
B[4]=
B[5]=
2
4
6
8
10
12
Problema2 ) Soluo:
Sada do programa:
ARRAY_P2.CPP
2 void main(){
3
int i;
4
float Y[10];
5
6
for (i=0; i<10; i++){
7
//printf("A[%i]= %i\t->\t", i, A[i]);
8
Y[i]= -1.5+0.5*i;
9
printf("Y[%i]= %3.1f\n", i, Y[i]);
10
}
11 }
Y[0]= -1.5
Y[1]= -1.0
Y[2]= -0.5
Y[3]= 0.0
Y[4]= 0.5
Y[5]= 1.0
Y[6]= 1.5
Y[7]= 2.0
Y[8]= 2.5
Y[9]= 3.0
Problema3 ) Soluo:
Sada do programa:
ARRAY_P2.CPP
2 void main(){
3
int i;
4
float Y[10];
5
6
for (i=0; i<10; i++){
7
//printf("A[%i]= %i\t->\t", i, A[i]);
8
Y[i]= -1.5+0.5*i;
9
printf("Y[%i]= %3.1f\n", i, Y[i]);
10
}
11 }
Y[0]= -1.5
Y[1]= -1.0
Y[2]= -0.5
Y[3]= 0.0
Y[4]= 0.5
Y[5]= 1.0
Y[6]= 1.5
Y[7]= 2.0
Y[8]= 2.5
Y[9]= 3.0
Problema4 ) Soluo:
ARRAY_P3.CPP
1 #include<stdio.h>
2 void main(){
3
float X[50], maior, menor, dif;
4
int N, i, pos_maior=0, pos_menor=0;
5
6
printf("Programa para ...\n\n");
7
printf("Entre com N: ? ");
8
scanf("%i", &N);
9
if (N>50){
10
printf("Desculpe, este programa lida no maximo com 50 valores\n\n");
11
}
12
else{
13
printf("Entre com os %i valores:\n\n", N);
14
for(i=0; i<N; i++){
15
printf("Entre com o valor %i) ? ", i+1);
16
scanf("%f", &X[i] );
17
if (i==0){
18
maior=X[0]; menor=X[0];
19
}
20
else{
21
if (X[i]>maior){
22
maior= X[i];
95
23
pos_maior= i;
24
}
25
if (X[i]<menor){
26
menor=X[i];
27
pos_menor= i;
28
}
29
}
30
} // fecha o for...
31
printf("\n\nMaior valor: %5.2f - ocorre na posicao: %i\n", maior, pos_maior);
32
printf(
"Menor valor: %5.2f - ocorre na posicao: %i\n", menor, pos_menor);
33
dif=maior-menor;
34
printf(
"Diferenca : %5.2f\n", dif);
35
}
36
37 }
Sada do programa:
Programa para ...
Entre com N: ? 5 Entre com os 5 valores:
Entre
Entre
Entre
Entre
Entre
com
com
com
com
com
o
o
o
o
o
valor
valor
valor
valor
valor
1)
2)
3)
4)
5)
?
?
?
?
?
10
7
7.5
5
6
Maior valor: 10.00 - ocorre na posicao: 0

Menor valor: 5.00 - ocorre na posicao: 3
Diferenca : 5.00
Problema5 ) Soluo:
ARRAY_P4.CPP
1 #include<stdio.h>
2 void main(){
3
int alunos, i, maior, menor, j, h[10];
4
float nota[50], soma, media;
5
6
printf(".:Programa Estatistica de notas:...\n\n");
7
printf("Entre com numero de alunos: ? ");
8
scanf("%i", &alunos);
9
if (alunos>50){
10
printf("Desculpe, este programa lida no maximo com 50 alunos\n\n");
11
}
12
else{
13
printf("Entre com as notas de cada aluno:\n\n");
14
// inicializando variaveis...
15
maior=0; menor=0; soma=0;
16
for (i=0; i<10; i++){
17
h[i]=0;
18
}
19
20
for(i=0; i<alunos; i++){
21
printf("Nota do aluno %i) ? ", i+1);
22
scanf("%f", &nota[i]);
23
if (nota[i]>nota[maior]){
24
maior=i;
25
}
26
if (nota[i]<nota[menor]){
27
menor=i;
28
}
29
soma= soma+nota[i];
30
31
// acumulando dados para histograma...
32
for (j=0; j<10; j++){
33
if (( nota[i]>j )&&( nota[i] <= (j+1) )){
34
h[j]= h[j]+1;
35
printf("Nota atual na faixa de %i ~ %i --> %i notas\n", j,j+1, h[j]);
36
}
37
}
38
// Note: o if acima nao acumula notas = 0...
39
if (nota[i]==0){
40
h[0]= h[0]+1;
96
41
printf("Nota atual na faixa de %i ~ %i --> %i notas\n", 0,1, h[0]);
42
}
43
44
} // fecha o for...
45
46
media=soma/alunos;
47
printf("\n\nResultados...\n\n");
48
printf("Maior nota: %5.2f (Aluno %i)\n", nota[maior], maior+1);
49
printf("Menor nota: %5.2f (Aluno %i)\n", nota[menor], menor+1);
50
printf("Mdia turma: %5.2f\n\n", media);
51
52
printf("Distribuicao das Notas\n\n");
53
for (i=0; i<10; i++)
54
{
55
printf("%i.1 ~ %2i.0: ", i, i+1);
56
for (j=0; j<h[i]; j++)
57
{
58
printf("*");
59
}
60
printf("\n");
61
}
62
}
63
printf("\nFim do Programa\n");
64 }
Sada do programa:
.:Programa Estatistica de notas:...
Entre com numero de alunos: ? 7
Entre com as notas de cada aluno:
Nota
Nota
Nota
Nota
Nota
Nota
Nota
Nota
Nota
Nota
Nota
Nota
Nota
do aluno
atual na
do aluno
atual na
do aluno
atual na
do aluno
atual na
do aluno
atual na
do aluno
atual na
do aluno
1) ? 5
faixa de
2) ? 5.5
faixa de
3) ? 6
faixa de
4) ? 10
faixa de
5) ? 8
faixa de
6) ? 9
faixa de
7) ? 8.5
4 ~ 5 --> 1 notas
5 ~ 6 --> 1 notas
5 ~ 6 --> 2 notas
9 ~ 10 --> 1 notas
7 ~ 8 --> 1 notas
8 ~ 9 --> 1 notas
Resultados...
Maior nota: 10.00 (Aluno 4)
Menor nota:
5.00 (Aluno 1)
Mdia turma: 7.43
Distribuio das Notas
0.1
1.1
2.1
3.1
4.1
5.1
6.1
7.1
8.1
9.1
~ 1.0:
~ 2.0:
~ 3.0:
~ 4.0:
~ 5.0:
~ 6.0:
~ 7.0:
~ 8.0:
~ 9.0:
~ 10.0:
*
**
*
**
*
Fim do Programa
97
5.3. Arrays Bidimensionais
5.3 Arrays Bidimensionais

Recordando conceitos de lgebra matricial, sejam as matrizes a e b:
2 3 7
a=
1 1 5
1 3 1
b= 2 1 4
4 7 6
onde a uma matriz de 2 linhas 3 colunas e b uma matriz 3 3 (3 linhas 3 colunas). Cada um dos termos
destas matrizes pode ser acessado da seguinte forma:
a11 a12 a13

a=
a21 a22 a23
b11 b12 b13

b = b21 b22 b23
b31 b32 b33
assim, o termo a23 corresponde ao elemento da 2a linha e da 3a coluna, ou ao valor 5. Genericamente ento
bij = 4 se i = 3 (3a linha) e j = 1 (1a linha), ou, b31 = 4. Note que estas matrizes so bidimensionais, ou seja,
de dimenso 2, R2 , ou tambm ditas, matrizes 2D 1 .
Na linguagem C uma matriz pode ser declarada como se segue:
Sintaxe:
especificador_de_tipo nome_da_matriz [tamanho_1]. . .[tamanho_N];
onde:
especificador_de_tipo:
nome_da_matriz
tamanho_i
corresponde ao tipo de dados que sero guardados pela matriz, podendo ser:
int, float, double, char, etc.;
corresponde ao nome adotado para referenciar a varivel do tipo matriz;
especifica as dimenses da matriz;
Assim, por exemplo, as declaraes das matrizes a e b, em C, ficariam como:

2 void main(){
3
int a[2][3];
4
float b[3][3];
5 }
E para acessar cada um dos elementos destas matrizes, teramos de fazer:
a[i][j]=
0
1
j
0 1
2 3
1 -1
2
7
5
ou:
a[i][j] =
a[0][0] a[0][1]
a[1][0] a[1][1]
a[0][2]
a[1][2]
Lembre-se: em C, os ndices para acessar os elementos de uma matriz iniciam em 0 e no

em 1!
1 Um exemplo de especificao de matriz 3D, poderia ser: c = 3 3 3. Note que neste ltimo caso, a matriz c estaria guardando
3 3 3 = 27 elementos, enquanto as matrizes a e b esto estocando respectivamente: 6 e 9 elementos. Conforme a dimenso da matriz
aumenta, perceba que aumenta exponencialmente o nmero de termos contidos dentro da mesma isto implica em maior ateno no
momento de se declarar uma matriz quando se est programando um computador.
98
Em C, este cdigo ficaria como:
2 void main(){
3
int a[2][3];
4
float b[3][3];
5
int i, j;
6
7
a[0][0]=2; a[0][1]=3; a[0][2]=7;
8
a[1][0]=1; a[1][1]=-1; a[1][2]=5;
9
10
b[0][0]=1; b[0][1]=3; b[0][2]=1;
11
b[1][0]=2; b[1][1]=1; b[1][2]=4;
12
b[2][0]=4; b[2][1]=7; b[2][2]=6;
13
14
printf("Matriz a:\n\n");
15
for (i=0; i<2; i++){
16
for (j=0; j<3; j++){
17
printf("%2i\t", a[i][j]);
18
}
19
printf("\n");
20
}
21
printf("\n");
22
23
printf("Matriz b:\n\n");
24
for (i=0; i<3; i++){
25
for (j=0; j<3; j++){
26
printf("%2.0f\t", b[i][j]);
27
}
28
printf("\n");
29
}
30
printf("\n");
31 }
Resultando em:
Matriz a:
2
1
3
-1
7
5
Matriz b:
1
2
4
3
1
7
1
4
6
5.3.1 Inicializao alternativa de matrizes

Em C, outra forma de inicializar as matrizes a e b usadas anteriormente seria programar:
1 #include <stdio.h> void main(){
2
3
int a[2][3] = {
4
2, 3, 7,
5
1, -1, 5
6
};
7
8
float b[3][3] = {
9
1, 3, 1,
10
2, 1, 4,
11
4, 7, 6
12
};
13
14
int i, j;
15
16
printf("Matriz a:\n\n");
17
for (i=0; i<2; i++){
18
for (j=0; j<3; j++){
19
printf("%2i\t", a[i][j]);
20
}
21
printf("\n");
22
}
23
printf("\n");
24
25
printf("Matriz b:\n\n");
26
for (i=0; i<3; i++){
99
27
for (j=0; j<3; j++){
28
printf("%2.0f\t", b[i][j]);
29
}
30
printf("\n");
31
}
32
printf("\n");
33 }
Resulta tambm em:

Matriz a:
2
1
3
-1
7
5
Matriz b:
1
2
4
3
1
7
1
4
6
5.3.2 Observaes
Note que as matrizes mais utilizadas em computao so as matrizes bidimensionais. Mesmo para gerar
grficos 3D.
Por exemplo, para exibir um grfico ms inflao, so necessrias apenas 2 dimenses. Uma matriz
de 2 colunas n linhas seria capaz de guardar os dados necessrios para exibir este tipo de grfico. A
primeira coluna poderia estar relacionada com o ms (nmero do ms) e a segunda coluna, com o valor em
porcentagem correspondendo inflao daquele ms. Por exemplo, veja a tabela 5.1 e a figura 5.1 relacionada
com o grfico 2D resultante desta tabela de dados.
ms
janeiro
fevereiro
maro
abril
maio
junho
julho
agosto
setembro
outubro
novembro
dezembro
janeiro
fevereiro
maro
abril
maio
%
0,65
0,19
0,12
0,29
0,57
0,92
0,59
0,99
0,21
0,62
0,56
0,67
0,56
0,36
0,79
0,83
0,35
Tabela 5.1: Dados usados para gerar grfico 2D Inflao (IPC-FIPE).
100

Inflao (IPC-FIPE)
1,2
1
0,8
0,6
0,4
0,2
abril
maio
outu
bro
nove
mbro
deze
mbro
janeir
o
fever
eiro
mar
o
julho
agos
to
setem
bro
junho
abril
maio
janeir
o
fever
eiro
mar
o
Meses do Ano
Figura 5.2: Exemplo de grfico 2D.

J um grfico 3D como o mostrado na figura 5.3 seguir exige apenas 2 colunas, ou seja, uma matriz
2D, contendo n linhas 2 colunas, onde as linhas se referem s posies no eixo x e as colunas se referem
s posies no eixo y. O elemento apontado pela linha x, coluna y se refere altura z que a superfcie deve
possuir neste ponto (x, y) de interseco no plano XY ver tabela 5.2 seguir.
z=
linhas
17
18
19
20
colunas (x)
10
11
1.5069 2.7942
3.2876 4.9199
4.3742 6.1956
4.2896 5.9599
12
3.5855
6.0650
7.5413
7.2199
13
3.6886
6.3901
7.9966
7.6723
14
3.3404
5.9370
7.4805
7.1939
15
2.9344
5.0190
6.2513
5.9862
Tabela 5.2: Parte da matriz z usada para gerar grfico 3D.
Figura 5.3: Exemplo de grfico 3D.

101
A superfcie mostrada na figura 5.3 foi obtida atravs da equao:

1
z = 3(1 x)2 exp[(x2 ) (y + 1)2 ] 10(x/5 x3 y 5 )exp(x2 y 2 ) exp[(x + 1)2 y 2 ]
3
5.3.3 Problemas
Dadas duas matrizes, a e b, conforme indicado abaixo:
a=
1
4
2
5
3
6
1
b= 2
3
4
5
6
7
8
9
resolva o que se pede nos itens seguir:

Problema1 : Monte um algoritmo capaz de inicializar a matriz a, usando apenas laos for.
Problema2 : Inicialize a matriz b usando apenas laos for.

Cdigo para problemas 1 e 2:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
MATRIZAB.CPP
#include <stdio.h>
#include <conio.h>
void main(){
int a[2][3], b[3][3];
int i, j, cont;
// as linhas abaixo inicializam a[][]...
clrscr();
printf("matriz a:\n\n");
cont=0;
for(i=0; i<2; i++){
for(j=0; j<3; j++){
cont++;
a[i][j]=cont;
printf("%i\t", a[i][j]);
}
printf("\n");
}
// linhas abaixo, inicializam b[][]...
cont=0;
for(i=0; i<3; i++){
for(j=0; j<3; j++){
cont++;
b[j][i]=cont;
}
}
// Note: mostro matriz b depois...
printf("\nMatriz b:\n\n");
for (i=0; i<3; i++){
for (j=0; j<3; j++){
printf("%2i\t", b[i][j]);
}
printf("\n");
}
printf("\nFim\n");
}
102
Sada do cdigo:
Matriz a:
1
3 4
Matriz b:
1
2
3
Fim
4
5
6
7
8
9
Problema3 : Monte um programa para inicializar as matrizes c e d conforme indicado abaixo:
1 1
c= 2 2
3 3
1
2
3
1
d= 2
3
Cdigo:
3
4
5
Sada do programa:
MATRIZCD.CPP
#include <stdio.h>
#include <conio.h>
void main(){
int c[3][3], d[3][3];
int i, j, cont;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 }
2
3
4
Matriz c:
1
2
3
clrscr();
printf("Matriz c:\n\n");
for (i=0; i<3; i++){
for (j=0; j<3; j++){
c[i][j]=i+1;
printf("%i\t", c[i][j]);
}
printf("\n");
}
1
2
3
1
2
3
Matriz d:
1
2
3
2
3
4
3
4
5
Ok
printf("\nMatriz d:\n\n");
for(i=0; i<3; i++){
for(j=0; j<3; j++){
d[i][j]= i+j+1;
printf("%i\t", d[i][j]);
}
printf("\n");
}
printf("\nOk");
Problema4 : Monte um algoritmo para calcular o determinante da matriz b.
Difcil
Soluo:
Suponha a seguinte matriz, b =
2
b[0][0]
b = 4 b[1][0]
b[2][0]
b[0][1]
b[1][1]
b[2][1]
b[0][2]
b[1][2] 5
b[2][2]
seu determinante pode ser calculado como:

b[0][0]
b[1][0]
b[2][0]
b[0][0]
b[1][0]
b[0][1]
b[1][1]
b[2][1]
b[0][1]
b[1][1]
b[0][2]
b[1][2]
b[2][2]
b[0][2]
b[1][2]
onde a diagonal principal calculada como:

Diag_P rinc =
8
< b[0][0]
b[1][0]
:
b[2][0]
b[1][1]
b[2][1]
b[0][1]
b[2][2]
b[0][2]
b[1][2]
+
+
e a diagonal secundria como:

Diag_Sec =
8
< b[2][0]
b[0][0]
:
b[1][0]
b[1][1]
b[2][1]
b[0][1]
b[0][2]
b[1][2]
b[2][2]
+
+
e assim: = Diag_P rinc Diag_Sec.

Mas como calcular os elementos da Diag_P rinc e Diag_Sec de uma forma mais automatizada???
103
(a) Note que na expresso que forma a soma relativa aos termos da diagonal principal, nos termos relacionados com a multiplicao a coluna varia de 0 2 e a linha vai sendo incrementada entre um termo
e outro (inicia de 0):
b[0][0] b[1][1] b[2][2] +
b[1][0] b[2][1] b[0][2] +
b[2][0] b[0][1] b[1][2]
Do ponto de vista de programao usando linguagem C, isto resultaria num algoritmo conforme destacado abaixo:
diag_princ=0.0;
for (l=0; l<n; l++) // n=3 -- ordem da matriz
{
mult=1.0; aux=l; // aux comea na primeira linha....
for (c=0; c<n; c++)
{
mult= mult*b[aux][c];
aux++; // as linhas vo sendo incrementadas....
if (aux>=n)
{
aux=0;
}
}
diag_princ=diag_princ+mult;
}
printf("\nDiag_Princ= %f\n\n", diag_princ);
Um teste de mesa do algoritmo acima revela que conforme os laos de for(l=...) e for(c=...) vo sendo
executados, a seguinte operao seria desenvolvida:
diag_princ=0.0; l= 0;
mult= 1.0;
aux= 0;
c= 0;
mult= 1.0*b[0][0];
aux= 1;
c= 1;
mult= b[0][0]*b[1][1];
aux= 2;
c= 2;
mult= b[0][0]*b[1][1]*b[2][2];
aux= 3;
aux= 0; // entrou no if
diag_princ= 0 + b[0][0]*b[1][1]*b[2][2];
l= 1;
mult= 1.0;
aux= 1;
c= 0;
mult= 1.0*b[1][0];
aux= 2;
c= 1;
mult= b[1][0]*b[2][1];
aux= 3;
c= 2;
mult= b[1][0]*b[2][1]*b[0][2];
aux= 1;
diag_princ= b[0][0]*b[1][1]*b[2][2] +
b[1][0]*b[2][1]*b[0][2];
l= 2;
mult= 1.0;
aux= 2;
c= 0;
mult= 1.0*b[2][0];
aux= 3;
c= 1;
mult= b[2][0]*b[0][1];
aux= 2;
c= 2;
mult= b[2][0]*b[0][1]*b[1][2];
104

aux= 3;
diag_princ= b[0][0]*b[1][1]*b[2][2] +
b[1][0]*b[2][1]*b[0][2] +
b[2][0]*b[0][1]*b[1][2];
(b) No caso da expresso que forma o somatrio dos termos da diagonal secundrio, ocorre algo um
pouco parecido. As colunas de cada um dos termos da multiplicao varia de 0 2. E as linhas de
cada um destes termos, inicia de 0 e vai sendo decrementado conforme a coluna avana:
b[0][0]
b[1][0]
b[2][0]
b[2][1]
b[0][1]
b[1][1]
b[1][2]
b[2][2]
b[0][2]
+
+
O programa completo ficaria:

MATRIZP3.CPP
3 void main(){
4
float b[3][3] = {
5
1, 3, 1,
6
2, 1, 4,
7
4, 7, 6
8
};
9
int l, c, aux, n=3; // n= dimensao da matriz
10
float diag_princ, mult, diag_sec, det;
11
12
clrscr();
13
printf("Este programa calcula o determinante da matriz abaixo:\n\n");
14
for (l=0; l<n; l++){
15
for (c=0; c<n; c++){
16
printf("%2.0f\t", b[l][c]);
17
}
18
printf("\n");
19
}
20
printf("\n");
21
22
diag_princ=0.0;
23
printf("Diag_Princ= ");
24
for (l=0; l<n; l++)
25
{
26
mult=1.0; aux=l; // aux comea na primeira linha....
27
for (c=0; c<n; c++)
28
{
29
30
// mostrando na tela o que acontece...
31
printf("b[%i][%i](%3.1f)*", aux,c,b[aux][c]);
32
aux++; // as linhas vo sendo incrementadas....
33
if (aux>=n)
34
{
35
aux=0;
36
}
37
}
38
diag_princ=diag_princ+mult;
39
40
//
Diag_Princ= XXXX
41
printf("\b(=%3.1f) + (=%3.1f)\n
", mult,diag_princ);
42
}
43
clreol();
44
printf("\nDiag_Princ= %f\n\n", diag_princ);
45
46
diag_sec=0.0;
47
printf("Diag_Sec=
");
48
49
for (l=0; l<n; l++)
50
{
51
mult=1.0; aux=l;
52
for (c=0; c<n; c++)
53
{
54
55
56
printf("b[%i][%i](%3.1f)*", aux,c,b[aux][c]);
57
aux--;
58
if (aux<0)
59
{
105

60
61
62
63
64
65
66
67
68
69
70
71
72
73 }
aux=n-1;
}
}
diag_sec=diag_sec+mult;
//
Diag_Princ= XXXX
printf("\b(=%3.1f) + (=%3.1f)\n
", mult,diag_sec);
}
clreol();
printf("\nDiag_Sec=
%f\n", diag_sec);
det=diag_princ-diag_sec;
printf("\nDeterminante = %f\n", det);
Sada do programa:
Este programa calcula o determinante da matriz abaixo:
1
2
4
3
1
7
1
4
6
Diag_Princ= b[0][0](1.0)*b[1][1](1.0)*b[2][2](6.0)(=6.0) + (=6.0)

b[1][0](2.0)*b[2][1](7.0)*b[0][2](1.0)(=14.0) + (=20.0)
b[2][0](4.0)*b[0][1](3.0)*b[1][2](4.0)(=48.0) + (=68.0)
Diag_Princ= 68.000000
Diag_Sec=
b[0][0](1.0)*b[2][1](7.0)*b[1][2](4.0)(=28.0) + (=28.0)
b[1][0](2.0)*b[0][1](3.0)*b[2][2](6.0)(=36.0) + (=64.0)
b[2][0](4.0)*b[1][1](1.0)*b[0][2](1.0)(=4.0) + (=68.0)
Diag_Sec=
68.000000
Determinante = 0.000000
Problema5 : Monte um programa para realizar soma de matrizes: c = b + b. Note que so somas de matrizes.
Cdigo:
MATRIZP3.CPP
2 void main(){
3
int b[3][3], c[3][3];
4
int i, j, cont;
5
6
// linhas abaixo, inicializam b[][]...
7
cont=0;
8
for(i=0; i<3; i++)
9
{
10
for(j=0; j<3; j++)
11
{
12
cont++;
13
b[j][i]=cont;
14
}
15
}
16
17
// adio....
18
for (i=0; i<3; i++){
19
for (j=0; j<3; j++){
20
c[i][j]= b[i][j] + b[i][j];
21
}
22
}
23
24
// linhas abaixo: imprimem conteudo da matriz c
25
printf("Matriz c:\n\n");
26
for (i=0; i<3; i++){
27
for (j=0; j<3; j++){
28
printf("%2i\t", c[i][j]);
29
}
30
printf("\n");
31
}
32
printf("\n");
106
33
34 }
Resultado:
Matriz c:
2
4
6
8
10
12
14
16
18
Problema6 : Monte um programa que realize a multiplicao: d = a b. Repare que o resultado deve ser
uma matriz d de 2 3.
Soluo:
Suponha que as matrizes a e b sejam do tipo: anm e bmp .
Notamos que primeiramente, para que esta multiplicao possa ser realizada necessrio que o
nmero de colunas da matriz a seja igual ao nmero de linhas da matriz b. O que garantimos na
hiptese acima, atravs da varivel m. A matriz c gerada pela multiplicao das matrizes a e b
ao final vai ser de dimenso: cnp .
Podemos dar incio agora lgica que h por trs da multiplicao de matrizes. Vamos continuar
supondo nossas matrizes: cnp anm bmp .
Realizando alguns passos desta multiplicao manualmente obtemos:

b[0][0] b[0][1] b[0][2]
a[0][0] a[0][1] a[0][2]
c[0][0] c[0][1] c[0][2]
=
b[1][0] b[1][1] b[1][2]
a[1][0] a[1][1] a[1][2]
c[1][0] c[1][1] c[1][2]
b[2][0] b[2][1] b[2][2]
|
{z
} |
{z
}
|
{z
}
cnp
anm
bmp
Para obtermos o termo c1,1 , na notao da linguagem C, ficaria:

c1,1 = c[0][0] = a[0][0] b[0][0] + a[0][1] b[1][0] + a[0][2] b[2][0]
outros termos:
c1,2 = c[0][1] = a[0][0] b[0][1] + a[0][1] b[1][1] + a[0][2] b[2][1]
e:
c2,1 = c[1][0] = a[1][0] b[0][0] + a[1][1] b[1][0] + a[1][2] b[2][0]
Note, pelas diferentes cores adotadas anteriormente (e de forma proposital), o que acontece com
relao aos ndices que acessam cada um dos termos das matrizes responsveis pelas multiplicaes anteriores
Note que a linha da matriz a varia conforme a linha que est sendo computada da matriz b (cor
). Da mesma forma, perceba que a coluna da matriz b varia conforme varia a coluna da
matriz c sendo computada (cor ). Note ainda que existe um lao mais interno, variando
um 3o ndice que se refere aos termos sendo somados note que enquanto varia a coluna da
matriz a, varia da mesma forma a linha da matriz b (cor ).
Isto por fim resulta no fluxograma para cmputo da multiplicao de matrizes mostrada na
figura 5.4.
Cdigo:
MULT.CPP
3 void main(){
4
int a[2][3]={ 1, 2, 3,
107
Incio
i=0 at (n-1)
j=0 at (p-1)
c[i][j]=0
Inicializa
somatrio
t=0 at (m-1)
c[i][j]=c[i][j]+a[i][t]*b[t][j]
Fim
Figura 5.4: Fluxograma bsico de multiplicao de matrizes.

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36 }
4,
int b[3][3]={ 1,
2,
3,
int c[2][3];
int i, j, t;
5,
4,
5,
6,
6};
7,
8,
9};
// multiplicao abaixo:
for (i=0; i<2; i++)
{
for (j=0; j<3; j++)
{
c[i][j]= 0;
for (t=0; t<3; t++)
{
c[i][j]= c[i][j] + a[i][t]*b[t][j];
}
}
}
// imprimindo resultado:
clrscr();
printf("Matriz c resultante:\n\n");
for (i=0; i<2; i++){
for (j=0; j<3; j++){
printf("%3i ", c[i][j]);
}
printf("\n");
}
printf("\nFim");
Sada:
Matriz c resultante:
14
32
32
77
50
122
Fim
Problema7 : Monte um programa que realize multiplicao de matrizes genricas. O programa pergunta ao
usurio as dimenses de cada uma das matrizes, verifica se a multiplicao possvel. Em caso
108
afirmativo, o programa pede para o usurio informar o elementos de cada uma das matrizes e
mostra o resultado da multiplicao das duas matrizes.
Cdigo do programa:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
MULT2.CPP
// Programa para multiplicar matrizes quadradas
#include <stdio.h>
#include <conio.h>
#define TAM_MAX 10
#define TRUE 1
#define FALSE 0
void main(){
float a[TAM_MAX][TAM_MAX]; // matriz de entrada de dados
float b[TAM_MAX][TAM_MAX]; // matriz de entrada de dados
float c[TAM_MAX][TAM_MAX]; // matriz resultante
int n; // linhas matriz A
int m; // colunas matriz B
int p; // colunas matriz B
int i, j, t; // variaveis auxiliares para loopings internos
int problemas=FALSE; // indica se houve problemas com entrada de dados
// Segue entrada de dados
// primeiro os dados das matrizes a serem multiplicadas
clrscr();
printf(":: Multiplicacao de Matrizes ::\n\n");
printf("Obs: De dimensoes ate %i x %i\n\n", TAM_MAX, TAM_MAX);
printf("Entre com numero de linhas da matriz A: ");
scanf("%i", &n);
if (n>TAM_MAX){
problemas=TRUE;
}
if (!problemas){
printf("Enter com numero de colunas da matriz A: ");
scanf("%i", &m);
if (n>TAM_MAX){
problemas=TRUE;
}
}
if (!problemas){
printf("\nEstou supondo que a matriz B contem %i linhas\n", m);
printf("Entre agora com numero de colunas da matriz B: ? ");
scanf("%i", &p);
if (n>TAM_MAX){
problemas=TRUE;
}
}
if (problemas){
printf("\nERRO: Sinto muito, este programa trabalha com no maximo\n");
printf("matrizes de %i x %i\n", TAM_MAX, TAM_MAX);
printf("\nPrograma abortado\n");
printf("Tente entrar com matrizes menores\n");
}
else{
printf("\nPois bem, procedendo a entrada de dados da matrizes\n\n");
// entrada de dados da matriz A:
for (i=0; i<n; i++){
for (j=0; j<m; j++){
printf("A(%i,%i)= ? ", i+1, j+1);
scanf("%f", &a[i][j]);
}
printf("\n"); // pausa entre linhas da matriz...
}
// entrada de dados da matriz B:
for (j=0; j<m; j++){
for (t=0; t<p; t++){
printf("B(%i,%i)= ? ", j+1, t+1);
scanf("%f", &b[j][t]);
}
printf("\n"); // pausa entra linhas da mariz...
}
printf("\nMultiplicando matrizes");
// multiplicao abaixo:
for (i=0; i<2; i++){
for (j=0; j<3; j++){
109

73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
}
92 }
c[i][j]= 0; // inicializando soma com zero

for (t=0; t<3; t++){
c[i][j]= c[i][j] + a[i][t]*b[t][j]; // multiplicando termos...
printf("."); // apenas gera efeito visual - calculando...
}
}
}
// imprimindo resultado:
printf("\n\nResultado: matriz C: %i x % i:\n\n", n, p);
for (i=0; i<2; i++){
for (j=0; j<3; j++){
printf("%7.2f ", c[i][j]);
}
printf("\n");
}
printf("\nFim");
Exemplo de sada do programa:

:: Multiplicacao de Matrizes ::
Obs: De dimensoes ate 10 x 10
Entre com numero de linhas
colunas da matriz A: 3
da matriz A: 2 Enter com numero de
Estou supondo que a matriz B contem 3 linhas Entre agora com numero
de colunas da matriz B: ? 3
Pois bem, procedendo a entrada de dados da matrizes
A(1,1)= ? 1 A(1,2)= ? 2 A(1,3)= ? 3
A(2,1)= ? 4 A(2,2)= ? 5 A(2,3)= ? 6
B(1,1)= ? 1 B(1,2)= ? 4 B(1,3)= ? 7
B(2,1)= ? 2 B(2,2)= ? 5 B(2,3)= ? 8
B(3,1)= ? 3 B(3,2)= ? 6 B(3,3)= ? 9
Multiplicando matrizes..................
Resultado: matriz C: 2 x
14.00
32.00
32.00
77.00
3:
50.00
122.00
Fim
Note que: o programa anterior est preparado para o caso do usurio tentar multiplicar matrizes
cujo tamanho superam a capacidade do programa. Neste caso, surge uma mensagem de erro
como a mostrada no exemplo seguir:
:: Multiplicacao de Matrizes ::
Obs: De dimensoes ate 10 x 10
Entre com numero de linhas
da matriz A: 20
ERRO: Sinto muito, este programa trabalha com no maximo matrizes de

10 x 10
Programa abortado Tente entrar com matrizes menores
Note ainda que: no cdigo, a varivel problemas faz o papel de uma varivel booleana (s pode
conter 2 valores: TRUE ou FALSE Verdadeiro ou Falso), e que a entrada de dados respeito das
110
dimenses das matrizes s continua enquanto o limite TAM_MAX no superado linhas 27 e

34. Note que isto pode acontecer tanto com o nmero de linhas ou de colunas de alguma das
matrizes, por isto, o teste para verificar o tamanho deve ser realizado sempre depois da entrada
de cada um destes dados (linhas 2426, 3032 e 3840). E mais: a entrada dos dados restantes
que faltam para completar as informaes respeito das dimenses das matrizes s continua
caso o nmero de linhas ou de colunas para alguma das matrizes no tenha ultrapassado o valor
mximo. Caso este valor tenha sido ultrapassado, note que a varivel problemas passa a ser
TRUE e repare ento que o programa no vai mais continuar pedindo para o usurio entrar com
os prximos dados respeito das dimenses das matrizes.
111
5.4. Strings um caso especial de array de char
5.4
Strings um caso especial de array de char
O uso mais comum de matrizes unidimensionais (vetores), em C, como string de caracteres. Em C, uma
string definida como sendo uma matriz (um array) de caracteres que terminada com o valor nulo (zero).
Este caracter nulo especificado como \0. Por isto, necessrio se declarar as strings (arrays de caracteres)
como sendo 1 caractere mais longo que o comprimento da maior palavra ou frase que poder estar contido
dentro desta string. Isto porque a linguagem C no contempla o tipo de dado string. Mas permite constantes
string que so listas de caracteres estre aspas, por exemplo: alo aqui.
Exemplo: para declarar uma string capaz de guardar 10 caracteres teria de ser declarado algo como:
char str[11];
isto foraria organizar a memria da seguinte forma:
0
str =
10
\0
Detalhe: porm isto no significa que voc (o programador) precisa adicionar mo o caracter nulo, o
compilador C faz isto por voc automaticamente.
5.4.1 Inicializao de strings

Strings podem ser inicializandas no prprio instante da sua declarao, por exemplo:
char msg[19] = Isto uma string!;
Porm, no confundir variveis string com variveis do tipo char, por exemplo, para inicializar uma varivel
do tipo char, voc teria de fazer algo como:
char tecla = S;
Uma varivel do tipo string poderia ainda ser inicializada como:
char msg[19] = { I, s, t, o, , , , u, m, a, , s, t, r, i , n, g, !, \0 };
porm note que neste ltimo caso, voc que deve inserir o caracter nulo ao final da string.
O exemplo anterior deixa claro a forma como a string msg vai ficar organizada na memria com computador:
msg =
0
I
1
s
2
t
3
o
7
u
8
m
9
a
10
11
s
12
t
13
r
14
i
15
n
16
g
17
!
18
\0
Isto quer dizer que cada elemento da string pode ser acessado de forma independente, por exemplo:
msg[8]=m.
Da mesma forma, perceba que voc (o programador) que deve ter certeza de declarar um array de
char longo o suficiente para incluir a string desejada, caso contrrio, seu programa corre o risco de perder-se
durante a execuo do mesmo (o tipo de erro conhecido como run-time error note que estes tipos de erros
so difceis de se descobrir em grandes programas).
5.4.2 Inicializao de strings no-dimensionadas

Imagine que voc queira inicializar certos tipos de mensagens padro no seu programa, por exemplo, uma
tabela de mensagens de erro, como mostrado abaixo:
char erro1[17]= "erro de leitura\n";
char erro2[17]= "erro de escrita\n";
char erro3[29]= "arquivo no pode ser aberto\n";
112
Note que ligeiramente tedioso contar os caracteres presentes em cada mensagem. Voc pode deixar o
prprio Compilador C determinar automaticamente as dimenses de cada um dos arrays de char usando o
conceito de vetores no dimensionados. Desta forma, o Compilador C se v obrigado a criar vetores grandes
o suficiente para conter todos os caracteres dos vetores sendo declarados. Usando esta abordagem, o exemplo
anterior fica assim:
char erro1[]= "erro de leitura\n";
char erro2[]= "erro de escrita\n";
char erro3[]= "arquivo no pode ser aberto\n";
Este mtodo alm de ser menos tedioso, permite que o programador altere qualquer mensagem sem se
preocupar em declarar um vetor com a dimenso correta.
5.4.3 Sadas de dados do tipo string

Note que para imprimir o contedo de variveis do tipo string, necessitamos tomar alguns cuidados.
Se for usado o comando printf(), o especificador de tipo de dado ser exibido deve ser \%s (o s
indica se tratar de uma string). A funo printf vai exibir ento todos os caracteres presentes dentro da matriz
de caracteres sendo avaliada, at que o caracter nulo seja encontrado (este caracter evidentemente no
impresso; e to pouco a funo printf gera uma quebra de linha automaticamente - caracter \n).
Existe outra funo (comando) que pode ser utilizada para imprimir o contedo de uma string: a funo
puts(). Por exemplo:
1
2
3
4
5
6
7
8
9
10
11
12
testeput.CPP
#include <stdio.h>
#include <conio.h>
void main(){
char msg[]= "Teste";
clrscr();
printf("Testando impresso de strings\n\n");
printf("Teste com printf:\n");
printf("%s\n\n", msg);
printf("Teste com puts:\n");
puts(msg);
puts(" <- Note o que acontece aqui!");
}
Sada do programa anterior:

Testando impresso de strings
Teste com printf: Teste
Teste com puts: Teste
<- Note o que acontece aqui!
Note que a funo puts() imprime automaticamente o caracter \n no final da string, gerando a mudana
automtica de linha.
A funo puts() mais rpida que uma funo printf() porque puts() est preparada para escrever apenas
string de caracteres no pode escrever nmeros ou fazer converses de formato como printf().
5.4.4 Entradas de dados do tipo string

A funo scanf() normalmente utilizada para passar dados lidos atravs do teclado para dentro da
varivel declarada como segundo argumento da funo scanf() (aps o primeiro argumento que identifica o
tipo de dado ser lido).
J estudados como ler dados para uma varivel do tipo char:
113
char tecla;
printf("Digite Sim/No para continuar no programa: ");
scanf("%c", &tecla);
Note que para ler uma string usando o comando scanf() necessrio usar o especificador de formato "%s",
justamente para avisar esta funo de que deve realizar uma seqencia de leitura de caracteres. Alm disto,
para o caso especfico de leitura de dados para uma varivel do tipo string, no deve ser usado o caracter
& antes do segundo argumento da funo scanf(). Porm a funo scanf() l caracteres digitados partir
do teclado at que seja encontrado um caractere de espao em branco (alm do ENTER ou RETURN que o
usurio deve digitar para caracterizar o final da entrada de dados). Por exemplo:
1
2
3
4
5
6
7
8
9
10
testscan.CPP
#include <stdio.h>
#include <conio.h>
void main(){
char nome[60];
clrscr();
printf(":: :: Testando entrada de dados para string :: ::\n\n");
printf("Tente entrar com seu nome completo: ? ");
scanf("%s", nome);
printf("\nConteudo da variavel nome: %s\n", nome);
}
Sada gerada:
:: :: Testando entrada de dados para string :: ::
Tente entrar com seu nome completo: ? Fernando Passold
Conteudo da variavel nome: Fernando
Como resolver este problema ento ???

Nestes casos, o melhor utilizar outra funo do C para ler strings partir do teclado, como por exemplo,
a funo gets().
A funo gets() l uma string de caracteres inserida pelo teclado e a devolve para a varivel string passada
como argumento da funo. Por exemplo:
1
2
3
4
5
6
7
8
9
10
11
testgets.CPP
#include <stdio.h>
#include <conio.h>
void main(){
char nome[60];
clrscr();
printf(":: :: Testando entrada de dados para string :: ::\n\n");
printf("Tente entrar com seu nome completo: ? ");
// scanf("%s", &nome);
gets(nome);
printf("\nConteudo da variavel nome: %s\n", nome);
}
Sada gerada:
:: :: Testando entrada de dados para string :: ::
Tente entrar com seu nome completo: ? Fernando Passold
Conteudo da variavel nome: Fernando Passold
114

Outros detalhes da linguagem C: em C, no possvel se fazer atribuies diretas de valores para variveis
string. Por exemplo, tente fazer:
1
2
3
4
5
6
7
8
9
STRING1.CPP
#include <stdio.h>
#include <conio.h>
void main(){
char msg[60];
clrscr();
printf(":: :: Testando atribuicao de dados para string :: ::\n\n");
msg="Teste";
printf("\nConteudo da variavel msg: %s\n", msg);
}
Deve surgir o seguinte erro (de compilao):

Compiling STRING1.CPP:
*Error STRING1.CPP 7: Lvalue required
Como passar valores para variveis do tipo string ???

RESPOSTA: para atribuir valores para uma varivel do tipo string necessrio se apelar para a funo strcpy()
declarada dentro da biblioteca <string.h>.
O programa anterior fica ento como:
1
2
3
4
5
6
7
8
9
10
11
STRING1.CPP
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main(){
char msg[60];
clrscr();
printf(":: :: Testando atribuicao de dados para string :: ::\n\n");
// msg="Teste";
strcpy(msg,"Teste");
printf("\nConteudo da variavel msg: %s\n", msg);
}
A seguinte sada deve ser gerada agora:

:: :: Testando atribuicao de dados para string :: ::
Conteudo da variavel msg: Teste
Assim como no caso da funo strcpy(), existem outras funes especialmente desenvolvidas para lidar
com strings no C. Elas esto declaradas na biblioteca <string.h>. As principais funes desta biblioteca so
mostradas na tabela seguir:
Funo
strcpy(s1, s2)
strcat(s1, s2)
strlen(s1)
strcmp(s1, s2)
Comentrios
Copia s2 em s1, ou, s1 s2
Adiciona s2 ao final de s1, ou, s1 = s1 + s2
Retorna o tamanho de s1
Comparao de Strings. Retorna 0 se s1 = s2; Um nmero < 0 se
s1 < s2; um nmero > 0 se s1 > s2
115
5.5. Matrizes multidimensionais
5.4.6 Outros exemplos

Ex.1) Aumentando o contedo de uma varivel string:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
STRING2.CPP
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main(){
char msg1[40], msg2[40];
clrscr();
printf(":: :: Testando composicao de strings :: ::\n\n");
printf("Entre com um nome: ? ");
gets(msg1);
printf("Entre com um segundo nome: ? ");
gets(msg2);
strcat(msg1, msg2);
printf("\nJuntando os 2 nomes: %s", msg1);
}
Sada do programa:
:: :: Testando composicao de strings :: ::
Entre com um nome: ? Joao Entre com um segundo nome: ? Silva
Juntando os 2 nomes: JoaoSilva
Note que: o contedo original de msg1 foi perdido esta string aumentou de tamanho.
5.4.7 Matrizes de strings

Da mesma forma que se declaram matrizes numricas possvel se declarar matrizes de strings.
Para criar uma matriz de strings, declare uma matriz bidimensional de caracteres. Neste caso, o tamanho
do ndice do lado esquerdo da matriz indicaria o nmero de strings possveis e o tamanho do ndice do lado
direito, especificaria a quantidade mxima de caracteres possveis de serem estocadas em cada linha string
desta matriz. Por exemplo:
char texto[30][80];
o cdigo anterior declara uma varivel de nome texto do tipo matriz de strings, capaz de guardar o
equivalente 30 linhas de texto com comprimento mximo de 79 caracteres cada linha (no se esquea de
reservar 1 espao para o caracter nulo: \0).
Para acessar cada linha desta matriz, voc teria que especificar apenas o ndice esquerdo. Por exemplo, o
seguinte comando mostraria apenas a terceira linha da varivel texto declarada anteriormente:
printf("%s", texto[2]);
Da mesma forma, passar dados do teclado para a quinta linha da matriz texto declarada anteriormente,
poderia ser feito como:
gets(texto[4]);
5.5 Matrizes multidimensionais

C permite matrizes com mais de duas dimenses. O limite exato vai depender do compilador C utilizado.
A forma genrica de declarao de uma matriz multidimensional :
116
5.5. Matrizes multidimensionais
especificador_de_tipo nome_da_matriz [tamanho_1][tamanho_2][tamanho_3]. . .[tamanho_N];

Matrizes de 3 ou mais dimenses no so utilizadas com freqncia devido quantidade de memria que
elas necessitam. Por exemplo, uma matriz de quatro dimenses do tipo caractere e de tamanho: 10 6 9 4
requer 10 6 9 4 1 byte = 2.160 bytes.
A figura 5.5 mostra um exemplo de matriz 3D, de dimenso: de 3 3 3, onde alguns elementos foram
ressaltados.
u
p ro f
a
ndid
de
linhas
A[0][0][0]
2]
A[
]
[2
]
[2
A[2][2][0
]
col u
nas
Figura 5.5: Exemplo de matriz 3D

Grandes matrizes multidimensionais so geralmente alocadas dinamicamente, uma parte por vez, com
funes de alocao dinmica de memria disponvel na linguagem C e usando ponteiros. Esta abordagem
chamada de matriz esparsa. Neste tipo de matriz nem todos os elementos esto realmente presentes ou so
necessrios. Estas matrizes esto em grande parte vazias. Esta tcnica (matrizes esparsas) considerada
quando 2 condies acontecem: a) as dimenses da matriz so relativamente grandes (possivelmente acima da
memria disponvel no equipamento onde ser rodada a aplicao) e b) nem todas as posies da matriz so
utilizadas. Um exemplo tpico de aplicao de matriz esparsa um programa de planilha eletrnica. Embora
virtualmente uma planilha eletrnica possa ter capacidade para lidar com 999 linhas por 999 colunas (por
exemplo), isto no significa que realmente foi alocado fisicamente memria para conter 999 999 = 998.001
elementos. Existe ento o que chamamos de matriz lgica e matriz fsica (ou real). A matriz fsica que
realmente existe dentro da memria do computador e corresponde aproximadamente apenas s clulas
realmente ocupadas na planilha eletrnica. A aplicao (programa da planilha eletrnica) simula para o
usurio uma planilha real de 999 linhas 999 colunas (seria a matriz lgica). Naturalmente existem tcnicas
de programao para realizar mapeamentos entre o que seria a matriz lgica (enxergada pelo usurio) e
a matriz fsica (a realmente alocada dentro da memria do computador). No faz parte do escopo desta
disciplina estudar estas tcnicas agora. Entre elas: lista encadeada, rvore binria, matriz de ponteiros e
fragmentao.
117
5.6 Problemas Finais

P1) Monte um algoritmo para inicializar matrizes como indicado abaixo:
a) Matriz a:
1 2
1 2
a=
1 2
1 2
b) Matriz b:
1
b= 8
15
c) Matriz c:
2
9
16
1 2
c = 14 13
15 16
3
3
3
3
3 4
10 11
17 18
3
12
17
4
11
18
4
4
4
4
5
5
5
5
d) Matriz d:
6
6
6
6
1
2
d=
3
4
5 6 7
12 13 14
19 20 21
5
10
19
6
9
20
8
7
6
5
9
10
11
12
16
15
14
13
0
0
e=
0
0
1
0
0
0
0
1
0
0
17
18
19
20
24
23
22
21
e) Matriz e:
7
8
21
0
0
1
0
0
0
0
1
P2) E se agora fosse pedido para gerar uma matriz f , como a mostrada seguir, onde o usurio entra com a
posio (linha e coluna) do seu elemento central (contm valor 1)?
5 5 5 5 5 5 5
5 4 4 4 4 4 4
5 4 3 3 3 3 3
f =
5 4 3 2 2 2 3
5 4 3 2 1 2 3
5 4 3 2 2 2 3
5 4 3 3 3 3 3
Note que no caso anterior, a posio do elemento central : f5,5 = 1 (= f [4][4] na notao da linguagem
C). [Dificuldade: Difcil]
P3) Monte um programa que leia 10 nmeros inteiros fornecidos pelo usurio e que depois, separe numa
outra varivel (um vetor), apenas os nmeros que forem divisveis por 3.
P4) Faa um programa que gere aleatriamente n nmeros inteiros positivos variando entre 1 e 10 e que
depois, separe estes nmeros em 3 vetores diferentes. No primeiro vetor, A, devem ser colocados o
nmeros menores que 3 (excluindo o 3, x < 3); no vetor B, devem ser colocados os nmeros entre 3 e 7
(ou, 3 x 7), e no vetor C, o nmeros maiores e iguais 7 (x > 7). [Dificuldade mdia]
P5) Monte um programa capaz de preencher uma matriz de 10 10, colocando 0 (zero) nas posies onde
linha + coluna formam um nmero par e 1 (um) nas outras posies.
P6) Monte um programa para determninar a transposta de uma matriz quadrada.
P7) Monte um programa que pede ao usurio o tamanho desejado para a matriz; seguir, o programa pede
o nmero da linha inicial partir da qual ser gerado um efeito visual como o mostrado abaixo: por
exemplo, neste caso, a matriz de 10 7 e a linha inicial = 5.
0 0 0 0 1 0 0 0 0 0
0 0 0 1 0 1 0 0 0 0
0 0 1 0 0 0 1 0 0 0
0 1 0 0 0 0 0 1 0 0
1 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0
118
P8) Monte um programa que crie uma variao visual em relao ao problema anterior. Neste caso, desejado
um efeito visual como o que segue:
0 0 0 0 1 0 0 0 0 0
0 0 0 1 1 1 0 0 0 0
0 0 1 1 1 1 1 0 0 0
0 1 1 1 1 1 1 1 0 0
1 1 1 1 1 1 1 1 1 0
1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1
119
120

Apendice
Ferramentas de Eng. de Software

Na internet encontram-se duas timas ferramentas para projeto de sistemas em UML. A primeira delas,
a ArgoUML, uma ferramenta livre e tem o cdigo fonte disponvel, entretanto um pouco instvel e
temperamental. O endereo pra quem se interessar : http://argouml.tigris.org (Disponvel
em 07/03/2005). Esta ferramenta bem completa e gera inclusive cdigo em Java para os projetos nela
desenvolvidos, realiza engenharia reversa e utiliza o padro XSI como formato para armazenamento dos
diagramas. A figura A.1 mostra uma das janelas deste software.
Figura A.1: Tela do software ArgoUML.

A outra ferramenta: poseidon for uml, uma extenso comercial da ArgoUML. Entretanto a
verso Community Edition 3.0 pode ser baixada livremente (free) e no tem qualquer tipo de limi121
A. Ferramentas de Eng. de Software

tao. Todos os diagramas e elementos da UML esto l. O endereo pra quem se interessar :
http://www.gentleware.com/products/download.php3 (Disponvel em 07/03/2005).
Uma
grande vantagem da poseidon para a ArgoUML que esta implementa o padro UML de maneira mais rgida
e mais estvel. A figura A.2 mostra algumas telas do software poseidon.
Figura A.2: Posseidon: Diagrama de Classes Propriedades.
122
Figura A.2: (Cont.) Posseidon: Diagrama de Atividades.
123
Figura A.2: (Cont.) Posseidon: Diagrama de Sequncias.
124
Figura A.2: (Cont.) Posseidon: Diagrama de Estados.

Vale lembrar que essas duas ferramentas so feitas em Java, logo requerem um pouco de memria e uma
mquina virtual Java JDK 1.4 instalada. Mas podem ser utilizadas em qualquer plataforma (Unix, Linux, Mac
OSX, Windows). Outro ponto a se destacar que estas ferramentas ocupam pouco espao em disco e podem
ser utilizadas livremente. Talvez sejam uma boa alternativa a ferramentas absurdamente caras como o Rational
Rose e/ou extremamente pesadas como a Thogether for Java.
125
126

Apendice
Erros Comuns de Compilao
A seguir, uma lista dos erros de compilao mais comuns e sua possvel correo.
1.
Exemplo (com erro)

Esquecendo o ;
#include <stdio.h>
void main(){
printf("Oi")
}
Correo
#include <stdio.h>
void main(){
printf("Oi");
}
Error TESTE.CPP 4: Statement missing ;
Error TESTE.CPP 4: Compound statement missing }
2.
Falta incluir bibliotecas: #include<???.h>

#include <stdio.h>
#include <stdio.h>
#include <conio.h>
void main(){
clrscr();
printf("Oi");
}
void main(){
clrscr();
printf("Oi");
}
Error TESTE.CPP 3: Function clrscr should have a
prototype.
3.
Erro: declarao esquecida: ;, ou seja, o programador

simplesmente esqueceu do ponto-e-vrgula
Significa que o compilador no encontrou o final do
programa. Esperava o ; antes do }. Este erro foi
gerado como efeito cascata do erro anterior. Pode ser
ignorado.
A mensagem de erro se refere funo clrscr() que

no foi declarada.
No caso, faltou no cabealho do programa, incluir
a biblioteca onde esta funo definida: #include
<conio.h>.
Confundindo , com . informando incorretament casas decimais no C

#include <stdio.h>
#include <stdio.h>
void main(){
void main(){
float r= 3,5;
float r= 3.5;
}
}
Error TESTE.CPP 3: Declaration terminated incorrec- Erro: declarao terminada de forma incorreta, isto , o
tly
usurio digitou 3,5 quando deveria ser 3.5.
Advertncia: a varivel r foi declarada mas nunca
Warning TESTE.CPP 4: r is assigned a value that is
usada. Esta apenas uma advertncia. No significa
never used
erro de programao.
127
B. Erros Comuns de Compilao
4.
Erro de sintaxe na declarao falta do operador #

include <stdio.h>
void main(){
printf("Teste");
}
#include <stdio.h>
void main(){
printf("Teste");
}
Declarao com erro de sintaxe. O programador esqueceu o # na frente do include.
Error TESTE.CPP 1: Declaration syntax error

5.
Fechando printf() de maneira incorreta, usar: "

#include <stdio.h>
void main(){
printf("Teste );
}
#include <stdio.h>
void main(){
printf("Teste");
}
Error TESTE.CPP 3: Unterminated string or character

constant
O compilador no reconheceu o ) do final de funo

printf(). Efeito cascata do primeiro erro.
O compilador no reconheceu o ; efeito cascata do
primeiro erro.
O compilador no encontrou o final do programa. No
reconheceu o } no final do programa efeito cascata
do primeiro erro.
Error TESTE.CPP 4: Function call missing )

Error TESTE.CPP 4: Compound statement missing }
6.
Uso incorreto de ( e )
#include <stdio.h>
void main(){
printf
"Teste" ;
}
#include <stdio.h>
#include <stdio.h>
printf ("Teste");
}
O compilador esperava um ; antes de encontrar o
incio da mensagem para impresso ".

7.
String no terminada; faltou " ao invs de .
Separando incorretamente parmetros de um funo, usar ,)

#include <stdio.h>
#include <stdio.h>
void main(){
void main(){
int a=4;
int a=4;
float b=1.5;
float b=1.5;
printf ("a + b = %d + %f = %f"; a, b,
printf ("a + b = %d + %f = %f", a, b,
a+b);
a+b);
}
}
Faltou o ) na declarao da funo. Isto , o compilador imaginou que a funo printf() terminasse desta
forma: printf ("a + b = %d + %f = %f");.
Idem ao anterior, mas neste caso o compilador esperava
o ; para indicar o fim da funo printf().
Error TESTE.CPP 5: Function call missing )

128
ERROS DURANTE A EXECUO DO PROGRAMA (run-time errors):

8.
Falta do operador & com a funo scanf()

#include <stdio.h>
void main(){
float a;
printf("a ? ");
scanf("%f", a);
printf ("a = %5.2f\n",a);
}
#include <stdio.h>
void main(){
float a;
printf("a ? ");
scanf("%f", &a);
printf ("a = %5.2f\n",a);
}
Sem erros de compilao, mas...

Sada do programa:
ERRO: foi informado na funo scanf() que seria lida
uma varivel do tipo float, mas no foi especificado de
forma correta a varivel com a qual a entrada de dados
estaria ligada. Faltou o & na linha com scanf().
Trmino anormal do programa. Consequncia do erro
anterior.
a ? scanf: floating point formats not linked

Problema de associao de dados com scanf()
Abnormal program termination
9.
Esquecendo-se de terminar a mensagem dentro de printf()

#include <stdio.h>
#include <stdio.h>
#include <conio.h>
#include <conio.h>
void main(){
void main(){
int a=4;
int a=4;
float b=1.5;
float b=1.5;
clrscr();
clrscr();
printf ("a + b = %d + %f = %f , a, b,
printf ("a + b = %d + %f = %f", a, b,
a+b");
a+b");
}
}
Warning TESTE.CPP 8: b is assigned a value that is
never used
Warning TESTE.CPP 8: a is assigned a value that is
never used
Advertncia: varivel b recebeu valor que nunca foi

utilizado.
Advertncia: varivel a recebeu valor que nunca foi
utilizado.
Sada do programa:
A funo printf() incluia a impresso de variveis
do tipo ponto flutuante (%f) que no entando nunca
foram indicadas ao final de printf().
O erro anterior provocou o trmino anormal do programa na realidade, falha na execuo do printf()
anterior.
printf: floating point formats not linked
Abnormal program termination
129
130
ndice Remissivo
EXERCCIOS
Expresses Matemticas, 18
Introduo Programao, 12
Primeiros Programas, 27
Tipos de Dados, 14
Abstrao
de Dados, 11
Algoritmos, 6
Caractersticas, 7
Definio, 5, 6
Melhores, 8
ANSI-C
Padro, 20
Aritmtica
Expresses, 16
Operadores, 16
Arquivos
.c, 20
.cpp, 20
.h, 20
Atribuio
de Variveis, 15
BASIC, 2
Bibliotecas em C, 20
<math.h>, 17
<conio.h>, 24
<stdio.h>, 21
Blocos
de Incio e Fim, 21
C++, 2
Caracteres
&, 26
/* e */, 26
{ e }, 21
Codificao, 19
Comentrios, 26
Compilao
Linguagem C, 20
Computador pensa?, 1
Dados
Tipos de, 12
Declaraes
return, 21
void, 21
Desenvolvimento
de Software, 2
Top-Down, 4
Diagramas IPO, 12
Engenharia
de Software, 2
Tcnicas, 3
Erros de Programao, 29
Expresses Aritmticas, 16
Cuidados
com Declarao de Variveis, 19
Fluxogramas, 5, 8
FORTRAN, 2
Funes
clrscr(), 24
getch(), 22
main(), 20
printf(), 20, 22
Caracteres de Escape, 22
Especificadores de Formato, 23
scanf(), 20, 25
Bibliotecas de, 20
Linguagem C, 20
Matemticas, 17
Hierarquia
de Operadores Aritmticos, 16
Java, 2
Linguagem
Assembly, 2
de Alto Nvel, 2
de Mquina, 2
Linguagem C, 2
Bloco bsico, 20
Histrico, 20
Seqncia de Compilao, 20
Lisp, 2
main(), 20
MATLABr , 14
Memria
RAM, 11
Mensagens de Erro, 127
Modularidade, 20
Nmero Caractere, 13
Operador
&, 26
Operadores
Aritmticos, 16
Hierarquia, 16
Ordem de Precedncia, 16
131
NDICE REMISSIVO
NDICE REMISSIVO
Padres
de Programa em C, 20
Palavras Reservadas, 15
Pascal, 2
PIC 16FXX, 2
Portabilidade, 20
Portugol, 5
Precedncia
Ordem de, 16
Programa
Definio, 1
Programao
Codificao, 19
Estruturada, 8
Blocos Bsicos, 8
Orientada Objetos, 14
Projeto
de Software, 3
Prolog, 2
Ritchie
Denis, 20
Sintaxe, 19
Tabela ASCII, 13
Tipos de Dados, 12
Bsicos, 12
Extendidos, 13
Modificadores, 13
Preciso Pretendida, 14
Variveis, 11
Atribuies, 15
Declarao, 19
Cuidados, 19
Identificadores, 14
Nomes, 14
Palavras Reservadas, 15
Regras, 14
132

Info1 PDF

Enviado por

Dados do documento

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?

Direitos autorais:

Formatos disponíveis

Info1 PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Curso de Engenharia Eltrica

Informtica Aplicada Engenharia Eltrica I

Prof. Fernando Passold

Observao: material ainda est em fase de edio!

1 Introduo Lgica de Programao

2 Programao (ou Codificao)

II Estruturas de Controle de Fluxo

Instrues break e continue

III Matrizes & Strings

A Ferramentas de Eng. de Software

B Erros Comuns de Compilao

1. Introduo Lgica de Programao

(a) Operadores Aritmticos

(b) Seqncia Lgica

(b) Operadores Relacionais

(c) Operadores Lgicos

8. Estruturas de Deciso e Repetio

(a) Estruturas de Deciso

(b) Regras para construo do Algoritmo

(b) Comandos de Repetio

3. Diagrama de Bloco (Fluxogramas)

i. Repetio com Teste no Incio: Enquanto x,

(a) O que um diagrama de bloco?

(c) Tipos de Variveis

10. Manipulao De Strings

(a) O Tipo De Dado String

(b) Comandos de Entrada e Sada com Strings

Curso de Engenharia Eltrica

1a Parte da Apostila de ANSI C

Observao: Esta apostila est em constante fase de edio

Introduo Lgica de Programao

1.1 Programas e processos

1.2. Desenvolvimento de software

1. Introduo Lgica de Programao

Michelngelo viu um Davi. E o esculpiu.

1.2 Desenvolvimento de software

1. Introduo Lgica de Programao

1.3. Projeto de Software

Figura 1.1: Conjunto de instrues Assembly da famlia PIC16Cxx de microcontroladores.

1.3 Projeto de Software

1.3. Projeto de Software

1. Introduo Lgica de Programao

Figura 1.2: Exemplo de cdigo Assembly para PIC16C84.

1. Introduo Lgica de Programao

1.3. Projeto de Software

Figura 1.3: Exemplo de Metodologia top-down.

1. Introduo Lgica de Programao

Figura 1.4: Fluxogramas.

1. Introduo Lgica de Programao

Receita 1 (Soluo 1):

Receita 2 (Soluo 2):

Um algoritmo deve sempre terminar aps um nmero finito de passos.

1.5. Programao Estruturada e Fluxogramas

1. Introduo Lgica de Programao

Por analogia, um pacote de Software pronto = pacote de bolo industrializado.

1.5 Programao Estruturada e Fluxogramas

1. Introduo Lgica de Programao

1.5. Programao Estruturada e Fluxogramas

Figura 1.5: Principais blocos de uma programao estruturada.

Figura 1.6: Incio e fim de cada bloco.

Figura 1.7: Fluxogramas utilizados neste curso.

1.5. Programao Estruturada e Fluxogramas

1. Introduo Lgica de Programao

delta= bb - 4a*i;