Pré-texto Livro de Introdução a Programação com C

Sumário
1 Introdução 5
1.1 Histórico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Arquitetura de Computadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.1 Memória . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.2 Processador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3 Algoritmos e Programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4 Técnica de Desenvolvimento de Programas . . . . . . . . . . . . . . . . . . . . . . . . 8
1.5 Partes de um Programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.6 Tradução de Programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.6.1 Compilação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.6.2 Interpretação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.7 Resumo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.8 Exercícios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 Conceitos Básicos 14
2.1 Variáveis e Células de Memória . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3 Comando de Atribuição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4 Tipos de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.4.1 Declaração de Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4.2 Tipo Inteiro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4.3 Tipo Ponto Flutuante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4.4 Tipo Booleano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4.5 Tipo Caractere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4.6 Conversão de Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.5 Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.6 Expressões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.6.1 Expressões Aritméticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.6.2 Expressões Relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.6.3 Expressões Lógicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.7 Comando de Entrada de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.8 Comando de Saída de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.9 Comandos de Seleção . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.9.1 Comando de seleção simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.9.2 Comando de seleção dupla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.9.3 Comando de seleção múltipla . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.10 Comandos de Repetição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.10.1 Comando de repetição com pré-condição . . . . . . . . . . . . . . . . . . . . . . 39
2.10.2 Comando de repetição com pós-condição . . . . . . . . . . . . . . . . . . . . . . 45
2.10.3 Comando de repetição condensado . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.11 Problema dos Lotes Encaixantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
2.12 Exercícios Resolvidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
2.13 Resumo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
DRAFT
1

2 SUMÁRIO
2.14 Exercícios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
2.15 Trabalhos Sugeridos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3 Modularização 64
3.1 Resolvendo por Partes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
3.2 Subprogramas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.3 Partes de um Subprograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3.3.1 Cabeçalho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3.3.2 Dicionário de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
3.3.3 Corpo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
3.3.4 Comentários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
3.4 Chamada de subprogramas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3.5 Passagem de parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3.6 Retorno de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
3.6.1 Encerramento antecipado de execução . . . . . . . . . . . . . . . . . . . . . . . 74
3.7 Funções sem lista de parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
3.8 Funções sem retorno de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
3.9 Recursividade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
3.9.1 Implementação não recursiva equivalente . . . . . . . . . . . . . . . . . . . . . 79
3.10 Exercícios Resolvidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
3.11 Resumo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.12 Exercícios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
3.13 Trabalhos Sugeridos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
4 Tipos Abstratos de Dados 94
4.1 Técnicas de Programação Top-down e Bottom-up . . . . . . . . . . . . . . . . . . . . . 94
4.2 Tipos Compostos Heterogêneos (Estruturas) . . . . . . . . . . . . . . . . . . . . . . . . 95
4.2.1 Definição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
4.2.2 Uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
4.2.3 O Comando Typedef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
4.2.4 Simplificação na Passagem de Parâmetros e Retorno de Função . . . . . . . . . 98
4.3 Tipos Abstratos de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
4.3.1 Definição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
4.3.2 Definição de Atributos de um TAD . . . . . . . . . . . . . . . . . . . . . . . . . 103
4.3.3 Definição de Operações de um TAD . . . . . . . . . . . . . . . . . . . . . . . . 103
4.3.4 Uso do TAD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
4.3.5 Tipos de TADs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
4.4 Exercícios Resolvidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
4.5 Resumo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
4.6 Exercícios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
4.7 Trabalhos Sugeridos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
DRAFT
5 Vetores 117
5.1 Vetores e sua importância . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
5.2 Representação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
5.3 Definição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
5.4 Operações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
5.5 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
5.6 O TAD Implementacional Lista Vetorial de Inteiros . . . . . . . . . . . . . . . . . . . . 127
5.6.1 Atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
5.6.2 Operações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
5.7 Exercícios Resolvidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
5.8 Resumo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
5.9 Exercícios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

SUMÁRIO 3
5.10 Trabalhos Sugeridos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
6 Matrizes 155
6.1 Matrizes e sua importância . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
6.2 Definição e Acesso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
6.2.1 Definição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
6.2.2 Acesso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
6.2.3 Definição dinâmica de uma matriz . . . . . . . . . . . . . . . . . . . . . . . . . 158
6.3 O TAD Implementacional Matriz de Inteiros . . . . . . . . . . . . . . . . . . . . . . . . 158
6.3.1 Atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
6.3.2 Operações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
6.3.3 Exemplo de utilização do TAD tMatrizInt . . . . . . . . . . . . . . . . . . . . . 163
6.4 Exercícios Resolvidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
6.5 Resumo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
6.6 Exercícios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
6.7 Trabalhos Sugeridos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
7 Apontadores 175
7.1 Variáveis Apontadoras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
7.2 A Sintaxe dos Apontadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
7.2.1 Operador Endereço de Memória . . . . . . . . . . . . . . . . . . . . . . . . . . 177
7.2.2 Acesso a Variável por Meio de Apontadores . . . . . . . . . . . . . . . . . . . . 178
7.2.3 O Operador Seta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
7.3 Uso de Apontadores nas Passagens de Parâmetros . . . . . . . . . . . . . . . . . . . . 180
7.4 Alocação Dinâmica de Memória . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
7.5 Problemas Gerados por Apontadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
7.5.1 Apontadores Não Inicializados . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
7.5.2 Objetos Pendentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
7.5.3 Referência Pendente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
7.5.4 Programação Macarrônica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
7.6 TAD Implementacional Lista Encadeada de Inteiros . . . . . . . . . . . . . . . . . . . 187
7.6.1 Definição do Tipo tNo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
7.6.2 Atributos de tLista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
7.6.3 Operações de tLista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
7.6.4 Uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
7.7 Exercícios Resolvidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
7.8 Resumo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
7.9 Exercícios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
7.10 Trabalhos Sugeridos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
DRAFT
8 Arquivos 211
8.1 Variáveis Transientes X Variáveis Persistentes . . . . . . . . . . . . . . . . . . . . . . . 211
8.2 Tipos de Arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
8.2.1 Tipos de Arquivos - Arquivos Texto . . . . . . . . . . . . . . . . . . . . . . . . 212
8.2.2 Tipos de Arquivos - Arquivos Binários . . . . . . . . . . . . . . . . . . . . . . . 212
8.3 Definição de arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
8.4 Operações sobre arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
8.4.1 Abertura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
8.4.2 Fechamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
8.5 Operações sobre arquivos texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
8.5.1 Leitura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
8.5.2 Escrita . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
8.6 Operações sobre arquivos binários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
8.6.1 Leitura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

4 SUMÁRIO
8.6.2 Escrita . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
8.7 Outras funções úteis para arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
8.7.1 feof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
8.7.2 fseek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
8.8 Exercícios Resolvidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
8.9 Resumo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
8.10 Exercícios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
8.11 Trabalhos Sugeridos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
DRAFT

Capítulo 1
Introdução
Objetivos:
ˆ
ˆ
ˆ
ˆ
ˆ
Apresentar um breve histórico da Computação;
Coautores:
André Boechat
Ivan Nunes
Marcos Couto
Apresentar noções sobre arquitetura de computadores, como funcionam o processador e a memória;
Definir o que são algoritmos e programas, além de apresentar algumas técnicas para desenvolvêlos;
Definir as partes de um programa e a importância da documentação;
Introduzir o conceito de tradução de programas.
Este capítulo visa descrever um pouco da história da evolução dos computadores e apresentar
alguns conceitos fundamentais para o entendimento de programas e algoritmos.
1.1 Histórico
Dado o alto grau tecnológico dos computadores atuais, pode ser difícil imaginar que os primeiros
computadores eram totalmente mecânicos. Diversos tipos foram projetados e construídos ao longo da
evolução, chegando aos modernos computadores digitais; porém, alguns se destacam pela inovação e
complexidade que marcaram suas épocas.
A primeira máquina programável que se tem notícia foi construída pelo professor de matemática
da Universidade de Cambridge, Charles Babbage (1792-1871). A “máquina analítica”, como ficou
conhecida, era totalmente mecânica, composta basicamente por engrenagens que formavam quatro
componentes: a memória, a unidade de cálculo ou computação, a unidade de entrada e a de saída. A
unidade de computação recebia operandos da memória para realizar sobre eles as operações de soma,
subtração, multiplicação ou divisão, e depois armazenar o resultado na memória.
Como a máquina analítica executava as instruções lidas pela unidade de entrada, era possível executar
diferentes seqüências de cálculos, bastando para isso que um programa diferente fosse utilizado.
Assim, a primeira pessoa no mundo a programar um computador foi a jovem Ada Augusta Lovelace,
contratada pelo próprio Babbage a fim de produzir o software necessário para o funcionamento da
máquina.
A procura por máquinas calculadoras cresceu com a Segunda Guerra Mundial, estimulando o surgimento
dos primeiros computadores eletrônicos. O professor de física da Universidade da Pensilvânia,
John Mauchley, junto com seu aluno de mestrado, J. Presper Eckert, construiu um computador chamado
ENIAC (Electronic Numerical Integrator And Computer)[1], o qual detinava-se ao cômputo de
trajetórias táticas que exigissem conhecimento substancial em matemática. O ENIAC tinha 18.000
DRAFT
5

6
CAPÍTULO 1. INTRODUÇÃO
válvulas e 1.500 relés, pesava 30 toneladas e consumia 140 quilowatts de energia elétrica. Para programar
o ENIAC, era necessário ajustar a posição de 6.000 chaves de várias posições e conectar um
número imenso de soquetes por meio de uma verdadeira floresta de cabos. Este gigantesco computador
só ficou pronto em 1946, após o término da guerra.
Um dos pesquisadores envolvidos no projeto do ENIAC, John von Neumann, construiu para o
Instituto de Estudos Avançado de Princeton (Princeton Institute of Advanced Studies — IAS) a
máquina IAS[2], a qual ainda é a base de praticamente todas as máquina atuais. Ele imaginou que os
programas poderiam ser representados em formato digital na memória, junto com os dados.
A invenção do transístor e o desenvolvimento de circuitos integrados revolucionaram os projetos
de computadores do final da década de 1950, tornando obsoletos os computadores valvulados. Nas
décadas de 1960 e 1970, as famílias de computadores da IBM 1 (International Business Machines),
System/360, e da DEC 2 (Digital Equipament Corporation), PDP-11, dominavam o mercado.
Nesse período surgiu uma das linguagens de programação mais usadas para o desenvolvimento de
softwares e também adotada neste livro, a linguagem C[3]. Ela é, ainda hoje, muito utilizada para a
criação de programas diversos, como processadores de texto, planilhas eletrônicas, programas para a
solução de problemas de engenharia, e muitos outros.
Diversos fatores, como a criação de linguagens de programação mais semelhantes à linguagem
humana, o que facilitava a vida dos programadores, e a integração de circuitos em escala muito alta, o
que aumentou o desempenho e diminuiu o tamanho das máquinas, deram início a era dos computadores
pessoais. E foi nesse contexto, na década de 80, que a IBM construiu o computador mais vendido de
toda a história, o Personal Computer — o famoso PC. Desde então, a evolução dos computadores tem
se baseado principalmente no desenvolvimento de softwares de melhor qualidade e seguido a tendência
de miniaturização de componentes, aumentando continuamente o poder de processamento e espaço de
memória disponíveis, a custos cada vez menores.
1.2 Arquitetura de Computadores
Para melhor compreender a programação, é necessário conhecer um pouco mais sobre o funcionamento
dos computadores. Nesta Seção é apresentada uma noção básica sobre processadores e memórias.
1.2.1 Memória
A memória é a parte do computador onde as operações a serem executadas pelo computador (instruções)
e as informações a serem processadas pelo mesmo (dados) são armazenadas.
Na memória, o processador lê e escreve informações ao executar as instruções de um programa.
Existem dois tipos de memória: a principal e a secundária. A principal, conhecida também como
RAM (Random Access Memory), possui as seguintes características:
ˆ
ˆ
ˆ
DRAFT
Armazena dados e instruções do programa em execução;
Proporciona ao computador acesso rápido aos dados e instruções armazenados por ela;
Só mantem as informações armazenadas enquanto o computador estiver ligado.
A memória secundária geralmente possui maior capacidade de armazenamento de dados e instruções,
porém o tempo necessário para acessá-los é bem maior quando comparado ao da memória
principal. As informações permanecem armazenadas mesmo após o desligamento do computador.
Discos rígidos e CD-ROMs são exemplos de memórias secundárias.
A unidade básica da memória é o dígito binário, conhecido como “bit”. Um bit pode assumir
apenas dois valores, normalmente 0 ou 1.
A memória é formada por um conjunto de células, ou posições, sendo que cada uma pode guardar
uma informação e possui um número de reconhecimento, conhecido como “endereço de memória”. É
por meio desse endereço que os programas podem acessar uma determinada célula. Se uma célula
1 http://www.ibm.com
2 http://www.hp.com

1.3. ALGORITMOS E PROGRAMAS 7
possuir k bits, ela poderá armazenar qualquer uma das 2 k combinações possíveis para os bits. A
Figura 1.1 mostra um exemplo de memória com seis células endereçáveis, onde cada célula possui
dezesseis bits.
1.2.2 Processador
Figura 1.1: Exemplo de uma memória de 16 bits e 6 endereços.
O processador é o “cérebro” do computador. Basicamente, o processador é responsável por buscar
instruções na memória, decodificá-las para determinar seus operandos (dados que serão usados ao
processar a instrução) e quais operações devem ser realizadas com os mesmos, e executar tais operações.
Essas tarefas compõem o processo de execução de um programa.
1.3 Algoritmos e Programas
Apesar do nome pouco comum, diversos algoritmos são executados por pessoas comuns todos os dias.
Ao escovar os dentes, fazer um bolo ou trocar o pneu de um carro, diversos procedimentos são feitos
em seqüência, seguindo uma certa ordem lógica.
Para exemplificar a execução de um algoritmo, descreve-se a seguir alguns passos necessários para
fazer algo simples, cotidiano, como o ato de escovar os dentes.
1. Pegar a escova e a pasta de dentes;
2. Colocar um pouco de pasta sobre as cerdas da escova;
3. Escovar os dentes do maxilar inferior;
4. Escovar os dentes do maxilar superior;
DRAFT
5. Expelir da boca o excesso de espuma;
6. Bochechar com um pouco de água;
7. Lavar a escova e guardá-la;
8. Enxugar o rosto.
Após conhecer um exemplo comum de algoritmo, torna-se mais fácil compreender a sua definição:
Algoritmo é uma seqüência de operações que deve ser executada em uma ordem
definida e não-ambígua, com o propósito de solucionar um determinado
problema.
Apesar de conseguirem executar operações muito complexas, os computadores não são dotados da
mesma capacidade de compreensão que os humanos. Uma seqüência de tarefas considerada simples e
óbvia para uma pessoa qualquer pode ser incompreensível e pouco detalhada para um computador.
Voltando ao exemplo da escovação, um computador poderia considerá-lo incompleto, pois há diversas
questões sobre como algum passo pode ser executado, por exemplo:

8
CAPÍTULO 1. INTRODUÇÃO
1. Onde está a escova a ser usada?
2. Quanto, exatamente, se deve colocar de pasta sobre as cerdas?
3. O que fazer se não houver pasta? Escovar mesmo sem a pasta ou interromper o processo de
escovação?
Questões como essas são facilmente contornadas por um humano, decididas instantâneamente de
acordo com o ambiente que o cerca. Então, para que uma máquina também possa “decidir” o que fazer
em situações semelhantes, é necessário que se estabeleçam as condições iniciais (condições de entrada)
e as finais (condições de saída) do problema. Dessa forma, ela saberá quais ferramentas poderão ser
usadas para atingir a condição de saída desejada.
Assim, o problema da escovação seria mais bem definido da seguinte maneira:
Condições de Entrada: Dentes sujos com restos de alimentos, uma escova dental em condições de
uso, 90 gramas de creme dental e 300 mililitros de água tratada.
Condições de Saída: Dentes limpos (sem restos de alimentos visíveis), uma escova dental em condições
de uso e 85 gramas de creme dental. Toda a quantidade de água deve ser utilizada.
Portanto, para um computador, os algoritmos definem o conjunto de atividades que ele deve
desempenhar para solucionar um problema.
Contudo, tão importante quanto saber “o que” escrever para a máquina é saber “como” escrever.
Para que um computador possa executar um algoritmo, é necessário que esse algoritmo seja
traduzido para uma linguagem de programação. Ao se traduzir um algoritmo para uma linguagem de
programação, obtém-se um programa.
1.4 Técnica de Desenvolvimento de Programas
Na maioria das vezes, o ato de programar não é uma tarefa simples. A sintaxe das linguagens de
programação é bem rígida e deve ser respeitada fielmente para que o computador a compreenda. Esquecer
de um “;” no lugar onde é necessário, por exemplo, significa comprometer a execução de todo o
programa (na verdade, o computador pode nem começar a executá-lo). Ou pior, um programa teoricamente
correto, que não apresente erros de sintaxe, pode fornecer um resultado incorreto. Encontrar
o erro torna-se um enorme problema à medida que o programa cresce em tamanho e complexidade.
Para contornar a complexidade dos programas, os construtores de software costumam fazer uso de
uma poderosa técnica de programação, conhecida como “técnica dos refinamentos sucessivos” 3 . Ela
consiste basicamente em dividir um processo complexo em processos-componentes menores, especificando
apenas a entrada e a saída de cada um deles. E se, mesmo assim, alguns processos menores
continuarem complexos, repete-se a divisão no interior dos processos-componentes, gerando processos
cada vez mais simplificados.
Um exemplo prático do uso dos refinamentos sucessivos segue abaixo:
=⇒ Algoritmo “Escovação dentária”:
DRAFT
1. Pegar a escova e a pasta de dentes;
2. Colocar um pouco de pasta sobre as cerdas da escova;
3. Escovar os dentes do maxilar inferior;
4. Escovar os dentes do maxilar superior;
5. Expelir da boca o excesso de espuma;
6. Bochechar com um pouco de água;
3 Também conhecida como “dividir para conquistar”.

1.5. PARTES DE UM PROGRAMA 9
7. Lavar a escova e guardá-la;
8. Enxugar o rosto.
=⇒ Processo-componente “Pegar a escova e a pasta de dentes”:
1. Enquanto não encontrar a escova e o tubo de pasta, continuar procurando por cada gaveta do
armário;
2. Caso tenham acabado as gavetas e não tenha encontrado a escova e o tubo, interromper a tarefa.
=⇒ Processo-componente “Escovar os dentes do maxilar inferior”:
1. Com as cerdas da escova na posição vertical, fazer movimentos de vai-e-vem na região superior
dos dentes;
2. Com as cerdas na posição horizontal, escovar a região frontal dos dentes;
3. Com as cerdas na posição horizontal, escovar a região detrás dos dentes.
=⇒ Processo-componente “escovar a região detrás dos dentes”:
1. Abrir bem a boca;
2. Afastar a língua da região a ser escovada;
3. Esfregar as cerdas da escova atrás dos dentes.
O exemplo anterior mostra apenas parte do processo de refinamentos, que deve prosseguir até
que cada atividade esteja suficientemente detalhada, possibilitando que o computador as reconheça e
execute.
1.5 Partes de um Programa
Como dito anteriormente, os programas podem ser comparados a diversas atividades do dia-a-dia de
qualquer pessoa. Um exemplo é o de receitas culinárias. Geralmente, essas seguem uma determinada
estrutura, como abaixo:
ˆ
ˆ
ˆ
ˆ
Nome da receita;
DRAFT
Ingredientes: descreve todo o material necessário para o preparo da receita;
Modo de preparo: descreve a forma de trabalhar com os ingredientes para que se obtenha o
resultado esperado;
Comentários sobre certos procedimentos ou ingredientes a fim de detalhar alguma peculiaridade
que o cozinheiro poderia não conhecer previamente.
A estrutura de um bom programa segue um modelo semelhante. Basicamente, um programa deve
conter quatro partes:
ˆ
ˆ
Cabeçalho: contém informações sobre o programa, como o seu nome;
Dicionário de dados: define quais são os dados manipulados pelo programa;
ˆ
Corpo: define os procedimentos que o programa deve executar;

10
CAPÍTULO 1. INTRODUÇÃO
ˆ
Documentação: explica certos aspectos não muito claros do programa, tanto no corpo do programa
quanto no cabeçalho ou no dicionário de dados.
Um dos principais objetivos deste tipo de estrutura é aumentar a legibilidade do programa, ou seja,
facilitar o entendimento dos diversos processos que o programa executa. Um programa deve valorizar
a formatação, disposição física das linhas de código, para facilitar seu entendimento. Colocar cada
comando em uma linha e inserir uma linha em branco entre blocos de comandos de finalidade comum
são regras básicas para uma boa formatação. Os programas devem ser lidos e entendidos por quem os
escreveu e por outras pessoas, uma vez que podem necessitar de correção, manutenção, modificação
ou apenas de serem compreendidos por um simples usuário.
Para ilustrar essa estrutura, apresenta-se a seguir um programa, Pseudocódigo 1.1, que efetua o
cálculo das raízes reais de uma equação de segundo grau. Os dados de entrada do programa são os
três coeficientes da equação e ele deverá apresentar ao usuário as raízes reais da mesma, caso existam.
Pseudocódigo 1.1 Cálculo das raízes reais de uma equação de segundo grau.
Descrição: Calcula as raízes reais de uma equação de segundo grau.
Dados de Entrada: Os três coeficientes da equação.
Saída do Programa: Raízes reais da equação.
Obter os coeficientes da equaç~ao;
Calcular o discriminante ( delta );
Calcular as raízes pelo processo componente "Cálculo das Raízes ";
Utilizando a técnica dos refinamentos sucessivos, na última linha do Pseudocódigo 1.1 ocorre
a execução do processo componente Cálculo das Raízes, que, a partir dos valores dos coeficientes
lidos e do discriminante calculado, encontra os valores das raízes reais da equação. No geral, o processo
componente Cálculo das Raízes deve conter os passos descritos no Pseudocódigo 1.2.
Pseudocódigo 1.2 Processo componente para o cálculo das raízes.
Processo - componente "Cálculo das Raízes ":
Verificar a exist^encia de raízes reais ;
SE possuir raízes reais :
Calcular as raízes ;
Apresentar na tela os valores das raízes ;
SEN~AO:
Apresentar na tela a mensagem : "N~ao existem raízes reais !";
FIM -SE
FIM - Processo componente "Cálculo das Raízes "
DRAFT
No Exemplo 1.1, o programa para o cálculo das raízes está transcrito para a linguagem de programação
C. Deve-se destacar que o texto escrito entre os símbolos “/*” e “*/” é sempre ignorado
pelo computador, não alterando em nada o funcionamento do programa. Porém, esse texto serve para
comentar o código e deixá-lo mais claro. Pode-se fazê-los também utilizando o símbolo “//”, que
transforma em comentário tudo aquilo que estiver a sua direita, até o final da linha.
1 /*
2 Programa para calculo das raizes de segundo grau .
3 Dados de entrada : Os coeficientes a, b e c de uma equacao
4 da forma ax ^2 + bx + c = 0
5 Dados de saida : Imprime na tela as raizes reais da equacao , caso existam .
6 Restricao : Nao se considera o zero como um possivel valor de a.
7 */
8
9 # include
10 # include // Biblioteca de funcoes primitivas como scanf e printf

1.6.
TRADUÇÃO DE PROGRAMAS 11
11
12 int main (){
13 float a; // Coeficiente angular .
14 float b; // Coeficiente linear .
15 float c; // Termo independente .
16 float delta ; // Discriminante .
17 float raiz1 ; // A primeira raiz .
18 float raiz2 ; // A segunda raiz .
19
20 // Obtencao dos coeficientes .
21 scanf ("%f %f %f", &a, &b, &c);
22
23 // Calculo do discriminante ( delta ).
24 delta = b * b - 4 * a * c;
25
26 // Calculo das raizes .
27 if( delta < 0){
28 printf ("A equacao nao possui raizes reais ");
29 } else {
30 raiz1 = (-b + sqrt ( delta )) / (2 * a);
31 raiz2 = (-b - sqrt ( delta )) / (2 * a);
32 printf ("As raizes da equacao sao : %f e %f", raiz1 , raiz2 );
33 }
34
35 return 0;
36 }
Exemplo 1.1: Programa para o cálculo das raízes reais de uma equação de segundo grau.
Na linguagem C, o cabeçalho dos programas sempre corresponde à frase int main() e o início do
corpo do programa é marcado pela primeira chave “{”, assim como o final é marcado pela última chave
“}”. As linhas 9 e 10 permitem o uso dos comandos sqrt e printf (o significado desses comandos é
explicado no próximo capítulo). O final do programa return 0 é o retorno da função e será explicado
detalhadamente na seção 3.6. De acordo com a estrutura de programa apresentada no início desta
seção, as linhas 13 a 18 compõem o dicionário de dados e o restante compõe o corpo do programa. A
documentação está inserida no programa em forma de comentários, como as linhas 1 a 7, 20, 23 e 26.
Vale destacar a importância da disposição física das linhas de código para o fácil entendimento do
programa. A hierarquização de elementos por meio de espaços em branco é chamada de indentação.
O trecho de programa relacionado ao cálculo das raízes no Exemplo 1.1 demonstra como a indentação
pode facilitar a visualização da mudança do fluxo do programa.
Normalmente, linhas de código com mesma indentação são executadas de maneira contínua, uma
após a outra. Uma mudança na indentação indica uma mudança nesse fluxo de execução do programa.
No próximo capítulo são apresentadas diversas maneiras de mudar esse fluxo.
DRAFT
1.6 Tradução de Programas
Apesar do que foi dito na seção 1.3, para ser executado pelo computador, um programa ainda precisa
ser traduzido para uma linguagem mais simples que as linguagens de programação: a linguagem de
máquina. Chama-se de “código fonte” o arquivo que contém o conjunto de instruções escritas em
uma determinada linguagem de programação, normalmente familiar ao programador. Já o arquivo
que contém estas instruções traduzidas para linguagem de máquina é chamado de “código objeto”.
Para efetuar essa tradução, é necessário aplicar um programa, ou conjunto de programas, que
receba o código fonte e gere o código objeto. A seguir, descrevem-se dois métodos básicos para um
programa tradutor efetuar essa tarefa: a compilação e a interpretação de um código fonte.
1.6.1 Compilação
O processo de compilação efetua a tradução integral do programa fonte para o código de máquina.
Uma vez traduzido, o programa em linguagem de máquina pode ser executado diretamente. A Figura

12
CAPÍTULO 1. INTRODUÇÃO
1.2 ilustra esse processo.
A grande vantagem desse método de tradução é a rapidez na execução dos programas, pois não é
necessário fazer qualquer tradução durante a execução. Porém, o código objeto gerado pela compilação
é, geralmente, específico para um determinado tipo de arquitetura de computador. Assim, é necessário
uma nova compilação do programa para cada tipo diferente de arquitetura.
A linguagem C, adotada neste livro, é um exemplo de linguagem de programação compilada.
1.6.2 Interpretação
No processo de interpretação, cada instrução do código fonte é traduzida no instante imediatamente
anterior à execução dela. Desse modo, em contraste com a compilação, a tradução e execução de
programas interpretados podem ser vistas como um processo único (veja as Figuras 1.2 e 1.3).
Figura 1.2: Processo de compilação.
Figura 1.3: Processo de interpretação.
Apesar de ser um processo mais lento que a compilação, a interpretação apresenta ocasionalmente
vantagens em relação ao outro método como flexibilidade na construção de programas e depuração de
códigos.
1.7 Resumo
ˆ
ˆ
ˆ
DRAFT
O processador é o componente do computador responsável por executar os programas armazenados
na memória.
A memória é responsável por armazenar os programas e os dados. A unidade básica da memória
é o bit.
Algoritmo é uma seqüência de operações que deve ser executada em uma ordem definida e nãoambígua,
com o propósito de solucionar um determinado problema. Ao traduzir-se um algoritmo
para uma linguagem de programação, obtém-se um programa.
ˆ
A Técnica de Refinamentos Sucessivos consiste, basicamente, em dividir sucessivamente problemas
complexos em diversos problemas menores e mais simples.
ˆ
Um programa bem estruturado deve conter as seguintes partes bem definidas: cabeçalho, dicionário
de dados, corpo e documentação.

1.8.
EXERCÍCIOS PROPOSTOS 13
ˆ
Basicamente, existem dois mecanismos de tradução de programas para linguagem de máquina:
compilação e interpretação. Na compilação, o código fonte é totalmente traduzido antes de ser
executado. Já na interpretação, a tradução do código fonte e a execução do programa ocorrem
quase simultaneamente, como um processo único.
1.8 Exercícios Propostos
1. Qual é o papel do processador?
2. Qual é o papel da memória?
3. Considere uma memória que possua células de 8 bits cada uma. Qual o número de possíveis
informações diferentes que cada célula pode armazenar?
4. Utilizando o conceito de algoritmo apresentado no capítulo, descreva o ato de trocar um pneu
furado de um carro. Não se esqueça de estabelecer as condições iniciais do problema (por
exemplo, carro com um pneu dianteiro furado, se a chave de roda está no carro, se o carro está
parado em uma ladeira etc) e as condições de saída (por exemplo carro parado, freado etc).
5. Use a Técnica de Refinamentos Sucessivos para detalhar as seguintes atividades:
(a) Montagem de uma barraca de camping;
(b) Preparação de um bolo de aniversário;
(c) Cálculo da distância entre dois pontos no plano cartesiano.
DRAFT

Capítulo 2
Conceitos Básicos
Objetivos:
ˆ
ˆ
ˆ
ˆ
Coautores:
André Boechat
Bruno Pandolfi(in memoriam)
Juan de Souza
Luiz Bueloni
Thales Carvalho
Apresentar o conceito de variável: declaração, inicialização, atribuição e manipulação;
Estudar os principais tipos de dados básicos e expressões válidas;
Mostrar como é feita a definição de variáveis e constantes;
Apresentar os comandos elementares usados em programas.
A ideia de resolver problemas formalizando a solução através do emprego de algoritmos é a espinha
dorsal da programação procedural, na qual as tarefas são prescritas ao computador por meio de uma
sequência de operações básicas.
Este capítulo trata do estudo dos conceitos e operações elementares da programação, fornecendo
uma base sólida que, mais adiante, serve para construir algoritmos progressivamente mais complexos
e resolver problemas cada vez mais elaborados.
2.1 Variáveis e Células de Memória
DRAFT
Qualquer algoritmo tem por finalidade produzir algum resultado útil para compor a solução de um
problema. Os algoritmos computacionais, em sua maioria, operam sobre um conjunto de dados para
produzir resultados de acordo com a necessidade da tarefa em questão.
Quando corretamente transcritos para uma linguagem de programação, os algoritmos são chamados
de programas e podem ser executados pelo computador. É necessário, todavia, armazenar as
informações utilizadas pelos programas em um local organizado e seguro, para que as consultas e
alterações sejam efetuadas de maneira coerente e livre de erros. Os computadores utilizam a memória
para armazenar os dados de um programa em execução.
Como dito na Seção 1.2.1, a memória pode ser entendida como uma sequência de células, cada
célula contém um número pré-definido de bits que varia de acordo com a arquitetura do computador
podendo armazenar uma porção dos dados de um programa. Graças a essa ordenação sequencial,
cada célula possui um número identificador chamado endereço, que está relacionado com a posição
que a célula ocupa na sequência. Por meio dos endereços é possível acessar qualquer célula para ler
ou alterar seu conteúdo. A Figura 2.1 esboça essa ideia, porém, em contraste com a Figura 1.1, omite
a representação dos bits.
As seis células de memória da Figura 2.1 podem guardar valores em seus interiores. Cada célula é
apontada por um endereço único e sequencial.
14

2.1.
VARIÁVEIS E CÉLULAS DE MEMÓRIA 15
Figura 2.1: Modelo para a estrutura da memória do computador, mostrando uma fração de seis células,
seus endereços e conteúdos.
A estrutura da memória favorece a execução de suas duas operações básicas: leitura e escrita. A
leitura é o processo de consulta do conteúdo da célula. Essa operação não altera o valor guardado na
célula.
A escrita é o processo de armazenamento de um novo dado na célula indicada por um endereço
conhecido. Após a execução da escrita, o valor que estava anteriormente armazenado na célula é
perdido.
Um algoritmo para o cálculo do valor da conta mensal de energia elétrica é um bom exemplo para
compreender as operações básicas da memória. Os dados de entrada desse algoritmo são: a leitura
atual do medidor, a leitura registrada no mês anterior e o preço do quilowatt-hora (kWh) — unidade
comercial de energia elétrica.
Na prática, o que se faz para calcular o valor da conta é encontrar a diferença entre a leitura
atual do medidor e a leitura do mês anterior e multiplicar esse valor pelo preço do quilowatt-hora. O
algoritmo computacional, por sua vez, é descrito no Pseudocódigo 2.1.
Pseudocódigo 2.1 Cálculo da conta de energia elétrica utilizando os endereços das células de
memória.
Descrição: Calcular o valor da conta de energia elétrica.
Dados de Entrada: Células 43 e 46 contendo, respectivamente, a leitura atual e a anterior; e valor unitário
do kWh na célula 44.
Saída do Programa: Valor da conta, armazenada na célula 42.
Subtrair o conteúdo da célula 43 do conteúdo da 46 e guardar na célula 41;
Multiplicar o conteúdo da célula 41 pelo conteúdo da 44 e guardar na célula 42;
No Pseudocódigo 2.1, o computador lê os conteúdos das células 43 e 46 (que guardam os valores
das leituras atual e anterior, respectivamente), realiza a subtração e o resultado é guardado na célula
41. Posteriormente, essa diferença é lida e seu valor multiplicado pelo conteúdo da célula 44, que
guarda o valor do preço unitário do kWh. Finalmente, o valor da conta é guardado na célula 42.
Acompanhando a descrição acima é possível chegar à situação encontrada na Figura 2.2.
DRAFT
Figura 2.2: Conteúdo da memória após execução do algoritmo que calcula o valor de uma conta de energia
elétrica.
No início da história da programação, percebeu-se que acessar a memória por meio de endereços
era trabalhoso demais e causa constante de erros. Isso porque o programador deveria escolher os
endereços das células com as quais iria trabalhar, tanto das células que teriam valores a serem lidos
quanto das que seriam usadas para a escrita de resultados.
Essa situação confusa é observável no exemplo da conta de energia elétrica. Sem o comentário no
início do Pseudocódigo 2.1, seria impossível ter a mínima ideia do que o programa faz em cada passo.

16
CAPÍTULO 2. CONCEITOS BÁSICOS
Isso torna difícil não só a escrita, mas também a correção dos programas.
Para resolver essa questão, o conceito de variável foi criado. Uma variável nada mais é do que
uma abstração para o endereço de memória. Com o emprego de variáveis, as células de memória são
referenciadas nos programas por meio de rótulos, definidos com ajuda do bom-senso do programador.
O compilador fica encarregado do trabalho de transformar rótulos em endereços para que as operações
de acesso à memória sejam realizadas.
O Pseudocódigo 2.2 mostra como fica o programa que calcula o valor da conta de energia elétrica,
agora escrito utilizando variáveis.
Pseudocódigo 2.2 Cálculo da conta de energia elétrica utilizando variáveis.
Descrição: Calcular o valor da conta de energia elétrica.
Dados de Entrada: A leitura atual, a anterior e o preço unitário do kWh.
Saída do Programa: Valor da conta.
Subtrair o conteúdo da variável " leituraAtual " do conteúdo da variável
" leituraAnterior " e guardar na variável " diferenca ";
Multiplicar o conteúdo da variável " diferenca " pelo conteúdo da variável
" valorUnitario " e guardar na variável " valorConta ";
Figura 2.3: Uma possível tradução para endereços de memória, a partir dos rótulos do código que utiliza
variáveis.
A partir do Pseudocódigo 2.2, um compilador pode converter os rótulos para posições na memória,
evitando que o programador tenha que se preocupar em manipulá-las. Uma possível tradução é exibida
na Figura 2.3.
Como visto nos exemplos desta seção, o uso de variáveis em um algoritmo reduz a quantidade de
comentários explicativos, pois sua leitura é mais simples e seu entendimento é mais fácil. Em caso de
erros, a correção do programa é muito mais rápida e eficiente.
Apresentados os conceitos de variável e células de memória, é válido abordar um outro significado
de programa. Trata-se de considerar os programas como sendo processos de mudança de estados.
Nessa abordagem, os dados de entrada, escritos em suas respectivas variáveis, são considerados
o estado inicial do programa. A partir daí, realiza-se uma sequência de operações para chegar a um
estado final. A cada operação, diz-se que o programa está em um novo estado intermediário. O estado
final é atingido quando a tarefa em questão é considerada como realizada.
A transição do estado inicial para o estado final pode ser efetuada de diversas maneiras. Conforme
pode ser visto mais adiante neste capítulo, é possível escolher entre duas ou mais sequências de
comandos, bem como repeti-las, de acordo com o estado intermediário em que o programa se encontra.
2.2 Identificadores
DRAFT
Em geral, as linguagens de alto nível possuem elementos definidos pela própria linguagem — símbolos
para operadores, nome de comandos, etc — e os elementos definidos pelo programador — identificadores,
comentários, etc.
Um identificador é um símbolo que pode representar alguma entidade criada pelo programador,
como uma variável, por exemplo. Cada linguagem define uma regra para formação de identificadores.
Em geral, sempre é possível utilizar uma sequência de caracteres alfanuméricos — letras ou dígitos,

2.3. COMANDO DE ATRIBUIÇÃO 17
sem acentos e sem cedilha — sendo que o primeiro caractere deve ser obrigatoriamente alfabético. Os
Exemplos 2.1 e 2.2 apresentam, respectivamente, nomes corretos e nomes inválidos de variáveis na
linguagem C.
Algumas linguagens, como C, fazem diferenciação entre letras maiúsculas e minúsculas. Desta
forma, uma variável de nome Saldo é considerada diferente de outra de nome saldo, ou, ainda, de
nome SALDO. É importante ressalvar que não é uma boa prática de programação criar identificadores
que apenas se diferenciem pelo formato das letras, como no exemplo do saldo, pois isso tem impacto
negativo na legibilidade dos programas.
1 abc
2 x1
3 y2
4 letra
5 SOMA_TOTAL
6 B_32
Exemplo 2.1: Nomes válidos de variáveis, concordando com as regras de nomenclatura.
1 fim ? // "?" nao e um caractere alfanumerico
2 % percentual % // "%" nao e um caractere alfanumerico
3 123 quatro // Iniciado por numero
4 ! hola ! // "!" nao e um caractere alfanumerico
5 @ARROBA // "@" nao e um caractere alfanumerico
Exemplo 2.2: Nomes inválidos de variáveis.
Normalmente, em grandes projetos de software, são adotados padrões para a escrita dos identificadores
a fim de que os programadores possam trocar seus códigos, entendê-los e alterá-los sem grande
dificuldade. Neste texto, é adotado como regra na escrita:
ˆ
ˆ
Nomes simples: começados com letra minúscula e demais caracteres minúsculos;
Nomes compostos: primeira parte é iniciada por letra minúscula e as demais partes iniciadas
por letra maiúscula. Os demais caracteres são minúsculos.
Como dito na Seção 1.5, um bom programa deve necessariamente ser legível e de fácil compreensão.
A escolha dos nomes dos identificadores influenciam diretamente esses dois aspectos. Logo, é muito
importante que os nomes sejam significativos, deixando bem clara a sua referência.
A fim de contrastar com o que foi proposto no Exemplo 2.1, o Exemplo 2.3 ilustra a convenção
proposta, apresentando nomes significativos para variáveis. Neste, o rótulo das variáveis já é suficiente
para informar a funcionalidade das mesmas, tornando rápida a compreensão do programa que as utiliza
e dispensando a necessidade de comentários.
1 delta
2 raiz1
3 idade
4 letra
5 percentualDeLucro
6 primeiraLetra
7 indiceBovespa
DRAFT
Exemplo 2.3: Nomes significativos para variáveis.
2.3 Comando de Atribuição
Os pseudocódigos da Seção 2.1 não mostram como os conteúdos das variáveis de entrada são alterados
para que o cálculo seja efetuado coerentemente. Em outras palavras, não é mostrado como as variáveis

18
CAPÍTULO 2. CONCEITOS BÁSICOS
leituraAtual, leituraAnterior e valorUnitario são inicializadas. O responsável pela alteração dessas
variáveis, assim como de qualquer outra, é o comando de atribuição.
O comando de atribuição é muito importante e, com certeza, é o mais utilizado. É por meio dele
que as variáveis podem ter seus valores (conteúdos) alterados. Por isso, o comando de atribuição está
diretamente ligado às operações de memória.
No Exemplo 2.4 é transcrito o algoritmo do cálculo da conta de energia elétrica para um trecho de
código na linguagem C.
1 leituraAtual = 125;
2 leituraAnterior = 25;
3 valorUnitario = 2;
4 diferenca = leituraAtual - leituraAnterior ;
5 valorConta = diferenca * valorUnitario ;
Exemplo 2.4: Cálculo do valor da conta de energia elétrica.
No Exemplo 2.4, o símbolo “=” representa o comando de atribuição. Em seu lado esquerdo sempre
haverá a variável destino, na qual será escrito o resultado da expressão do lado direito do comando.
As expressões mais simples são as que contêm valores constantes, tais como as que ocorrem nas linhas
1, 2 e 3 do Exemplo 2.4.
Essas três linhas são omitidas propositalmente do Pseudocódigo 2.2 para torná-lo mais simples.
Entretanto, elas não são difíceis de compreender, pois apenas informam ao computador quais valores
ele deve manipular para encontrar o resultado esperado: o valor da conta mensal de energia elétrica.
Dessa forma, o comando da linha 2 do Exemplo 2.4 simplesmente realiza a atribuição do valor
125 à variável leituraAtual. A partir da efetivação desse comando, o conteúdo dessa variável pode ser
usado para os cálculos. O mesmo vale para as demais variáveis.
As linhas 4 e 5 do Exemplo 2.4 são transcrições diretas dos dois passos do algoritmo da conta
de energia. O que ocorre de diferente é que o valor a ser atribuído às variáveis do lado esquerdo é
primeiramente calculado na expressão para, em seguida, ser guardado na variável correspondente. A
Figura 2.4 representa graficamente esse processo.
DRAFT
Figura 2.4: Representação gráfica da linha 4 do Exemplo 2.4.
O comando de atribuição é executado sempre da mesma maneira pelo computador. Em primeiro
lugar a expressão que está do lado direito do comando é calculada e, para isso, todas as variáveis que
aparecem têm seus valores lidos e lançados na expressão. Após o fim dos cálculos na expressão, o
computador escreve o resultado na variável destino, no lado esquerdo. Basicamente, a forma geral do
comando de atribuição em C é a seguinte:
= ;
É muito importante compreender a diferença significativa existente entre o comando de atribuição
e a igualdade matemática. Em muitas linguagens de programação (C, por exemplo) a atribuição
é representada pelo símbolo “=”, o que pode provocar interpretações equivocadas. O Exemplo 2.5
mostra um trecho de programa que geralmente causa confusão para os programadores iniciantes.

2.4. TIPOS DE DADOS 19
1 contador = 10;
2 contador = contador + 1;
Exemplo 2.5: Incremento de uma variável usando o comando de atribuição.
No Exemplo 2.5 ocorrem duas atribuições. A primeira ocorre na linha 1, sendo mais um exemplo
simples de inicialização de uma variável, como já discutido anteriormente. Na linha 2, a variável
contador aparece em ambos os lados da expressão, o que pode parecer um absurdo matemático.
Porém, é necessário lembrar que, nesse contexto, o símbolo “=” atribui o valor da expressão da direita
à variável que aparece à esquerda. Ou seja, avalia-se primeiro o resultado da expressão à direita
(10 + 1 = 11) e, posteriormente, atribui-se o valor à variável à esquerda (contador = 11). Isso é
representado graficamente na Figura 2.5.
Figura 2.5: Representação gráfica do incremento de uma variável.
Mais uma observação é necessária: O programador deve ficar atento aos tipos de dados manipulados
em um comando de atribuição, pois o tipo da expressão à direita deve ser compatível com o tipo da
variável à esquerda. A manipulação dos tipos de dados é detalhada na Seção 2.4.
2.4 Tipos de Dados
Um tipo de dados delimita o conjunto de valores possíveis que uma determinada variável pode representar.
Além disso, define as operações básicas possíveis para suas variáveis.
Sua necessidade decorre do fato de que as células de memória, sozinhas, conseguem representar
apenas conjuntos de dados muito limitados. Entretanto, a maioria dos valores de interesse pertence a
conjuntos extensos, os quais não podem ser representados com o uso de apenas uma célula de memória.
Os programadores, então, passaram a utilizar múltiplas células para representar um único valor.
Essa atitude resolveu a dificuldade de armazenar dados complexos, mas criou um outra questão: os
processos de leitura e escrita para valores de múltiplas células, bem como as demais operações sobre
tais valores, exigiam códigos que, além de não triviais, fugiam do foco do problema a ser resolvido.
Não demorou para que as linguagens de programação incorporassem a definição dos tipos de
dados e suas operações essenciais, poupando os programadores da tarefa de defini-los em seu código e
tornando-o mais enxuto e legível.
Tipos de dados, portanto, abstraem a forma de implementação e disponibilizam operações sobre
os elementos do conjunto para que o programador possa utilizá-las sem ter que implementá-las.
Os tipos básicos mais importantes são o tipo inteiro, o ponto flutuante, o booleano e o tipo
caractere. Cada linguagem de programação possui certas particularidades em relação aos tipos de
dados.
Primeiramente, é preciso abordar um conceito imprescindível da escrita de programas em linguagem
C: a declaração de variáveis. Em seguida, são descritas as características mais comuns dos tipos
básicos principais.
DRAFT

20
CAPÍTULO 2. CONCEITOS BÁSICOS
2.4.1 Declaração de Variáveis
De acordo com o problema abordado, diferentes conjuntos de dados são necessários. Conforme visto,
os tipos de dados representam os conjuntos de valores possíveis para suas variáveis, assim como as
operações válidas sobre elas. Também já foram abordadas a necessidade e as vantagens do uso de
variáveis em um programa. Entretanto, ainda não foi mencionado como as variáveis são criadas, ou
seja, como o programador declara formalmente uma variável em seu código.
Na linguagem C, o ato de declarar uma variável é simples e imprescindível. Afinal, sem esse
procedimento, não é possível usá-la. Quando a declaração de variáveis é esquecida, uma mensagem de
erro é apresentada ao programador, e a compilação do código é interrompida. Por isso, toda variável
deve ser declarada antes de ser utilizada.
A declaração de variáveis tem uma estrutura simples e algumas regras básicas. Em primeiro lugar,
escreve-se o nome do tipo de dados ao qual a variável pertence. Em seguida, separado por um espaço
em branco, escreve-se o identificador da variável.
;
É possível declarar mais de uma variável em uma mesma linha, desde que todas sejam do mesmo tipo,
conforme mostra o Exemplo 2.6.
1 float valorFracionado , saldo , salarioMinimo ;
2 char letra , ultimaLetra ;
3 int entrada1 , entrada2 , entrada3 ;
Exemplo 2.6: Declaração múltipla de variáveis em uma mesma linha de código.
2.4.2 Tipo Inteiro
O tipo inteiro, como o próprio nome sugere, representa um intervalo finito do conjunto matemático
dos números inteiros.
De fato, uma linguagem de programação pode definir vários tipos inteiros, cada um com intervalo
diferente. Na linguagem C, por exemplo, existem vários tipos inteiros, tais como o int, long int,
unsigned int, short int. Neste livro, para bem da simplicidade, usa-se apenas o tipo int.
O intervalo de valores para o tipo int depende do compilador que está sendo empregado. Assumimos
aqui que o intervalo do tipo int sempre varia de entre −2147483648 a 2147483647.
Em C, como na maioria das linguagens, as operações sobre as variáveis do tipo inteiro já estão
implementadas e à disposição do programador. As operações disponíveis são as de soma, subtração,
multiplicação, divisão e resto de divisão, conforme o Exemplo 2.7.
O uso dessas funções é bastante simples e intuitivo, pois há até certa relação com os símbolos da
escrita matemática. No Exemplo 2.7, as variáveis x e y são relacionadas entre si e os resultados são
armazenados nas variáveis de a a f.
Os operadores de soma e subtração funcionam tal qual na aritmética. O operador de subtração
pode ser aplicado para um único valor quando se deseja inverter seu sinal. A linha 12 do Exemplo 2.7
mostra essa situação.
Um destaque deve ser dado ao operador de multiplicação. Seu único símbolo é “*” (não há o
símbolo “×” ou o “·”). Além disso, em oposição ao que ocorre na aritmética, a escrita do “*” não
pode ser omitida. Logo, a operação da linha 13 do Exemplo 2.7 geraria erro se não estivesse comentada,
pois o compilador trataria xy como uma variável não declarada.
DRAFT
1 int main (){
2 int x, y, a, b, c, d, e, f;
3
4 x = 10;
5 y = 3;
6
7 a = x + y; // a armazena 13

2.4. TIPOS DE DADOS 21
8 b = x - y; // b armazena 7
9 c = x * y; // c armazena 30
10 d = x / y; // d armazena 3
11 e = x % y; // e armazena 1
12 f = -a; // f armazena -13
13 // c = xy;
14
15 return 0;
16 }
Exemplo 2.7: Operações básicas com o tipo inteiro int.
Também é importante destacar o resultado da operação de divisão. No caso do Exemplo 2.7, o
resultado correto da divisão de x — que armazena o valor 10 — por y — cujo valor é 3 — é a dízima
periódica 3, 333 . . . Entretanto, como as variáveis envolvidas na linha 10 são todas do tipo inteiro,
o compilador trata de truncar o resultado, desconsiderando a parte decimal e fornecendo 3 como
resultado da operação.
Ainda no Exemplo 2.7, deve-se notar o uso do operador de resto de divisão inteira. Seu símbolo
— “%” — deve ficar entre os valores do dividendo e do divisor. A linha 11 mostra a obtenção do resto
da divisão de x por y. Após a execução dessa operação, a variável e guardará o valor 1, que é o resto
da divisão de 10 por 3.
2.4.3 Tipo Ponto Flutuante
Esse tipo de dados representa um intervalo dos números racionais. Assim como o tipo inteiro, há mais
do que um intervalo possível, dependendo da precisão escolhida.
Na linguagem C, os tipos de ponto flutuante são o float e o double. Neste livro, apenas o tipo
float é empregado.
Dependendo do compilador utilizado, os tipos de dados de ponto flutuante apresentam diferentes
precisões. Aqui se considera que o tipo float provê seis casas decimais de precisão.
As operações pré-definidas são as mesmas que as disponíveis para o tipo int, exceto, é claro, pela
inexistência do operador de resto de divisão. O Exemplo 2.8 mostra o uso de variáveis do tipo float
em um programa.
1 int main (){
2 float p, q, x, z;
3 int y;
4
5 x = 10;
6 y = 4;
7
DRAFT
8 p = 50 / 30; // p guardara 1.0
9 q = 10.0 / 4; // q guardara 2.5
10
11 z = x / y; // z guardara 2.5
12
13 return 0;
14 }
Exemplo 2.8: Operações com variáveis do tipo float.
As operações entre variáveis do tipo float são escritas com os mesmos símbolos das operações do
tipo int. O Exemplo 2.8 mostra particularidades do processo de compilação que podem gerar erros
nos programas.
A linha 8 do Exemplo 2.8 possui um comentário explicando que a variável p recebe 1.0 como
resultado da operação de divisão. A justificativa para essa situação é que, conforme mostrado na
Seção 2.3, o computador primeiro calcula o resultado da expressão do lado direito do comando de
atribuição para, em seguida, escrever esse valor na correspondente variável de destino.

22
CAPÍTULO 2. CONCEITOS BÁSICOS
Durante a compilação, o compilador checa os tipos das variáveis envolvidas nos cálculos para
realizar as operações correspondentes. Entretanto, quando há apenas valores numéricos envolvidos, o
compilador considera os números escritos sem ponto decimal como sendo do tipo inteiro. É por isso
que a divisão realizada na linha 8 do Exemplo 2.8 resulta em 1. O computador entende a operação
50/30 como uma divisão inteira, descartando a parte decimal do resultado. Já na linha 9, o compilador
enxerga o valor 10.0 como sendo do tipo float devido à presença explícita do ponto decimal, e realiza
a divisão real, resultando no valor esperado.
No caso da última linha do Exemplo 2.8, nenhum resultado inesperado ocorre porque o tipo
mais abrangente — tipo float da variável x — encontrado na expressão é considerado nas operações,
garantindo o resultado esperado. Caso a variável x também fosse do tipo int, então o mesmo efeito
da linha 8 ocorreria.
2.4.4 Tipo Booleano
O tipo booleano é o tipo de dados mais simples. Ele contém apenas dois valores possíveis: verdadeiro
e falso. É usado principalmente quando se precisa verificar condições no programa, em expressões
lógicas (Seção 2.6.3) e relacionais (Seção 2.6.2).
Na linguagem C não há uma representação específica para esse tipo de dados e são utilizados
valores inteiros para codificá-lo. Desta forma, todo valor inteiro diferente de zero é considerado valor
“verdadeiro”e o valor zero é considerado “falso”.
2.4.5 Tipo Caractere
Como o próprio nome indica, o tipo caractere registra os códigos para letras, números e caracteres
especiais ($, &, #, @ etc). Normalmente, esses códigos e caracteres variam para as diversas regiões
do planeta, conforme suas particularidades linguísticas. Um padrão largamente utilizado é o ASCII
(American Standards Code of Information Interchange — Padrão Americano para Intercâmbio de
Informações), especificado pelo ANSI (American National Standards Institute — Instituto Americano
Nacional de Padrões).
O padrão ASCII é uma tabela. Cada posição da tabela simboliza um caractere. Na linguagem C,
o tipo char é empregado para conter o índice para a posição da tabela que codifica um determinado
caractere.
Originalmente, essa tabela era composta por apenas 128 símbolos, os quais incluíam todos os
caracteres alfanuméricos do Inglês, sinais de pontuação e alguns outros símbolos. Os primeiros 32
caracteres eram utilizados para controle de fluxo de dados (em comunicações entre o computador e
seus periféricos) e não imprimíveis. A Tabela 2.1 mostra os 128 caracteres da tabela ASCII original.
Para fazer com que uma variável do tipo char armazene um símbolo de interesse, o programador
precisa apenas atribuir a essa variável o caractere desejado, colocando-o entre aspas simples. O
Exemplo 2.9 exibe essa situação.
1 int main (){
DRAFT
2 char letraA , letraFMaiuscula , simboloSoma ;
3
4 letraA = ‘a’;
5 letraFMaiuscula = ‘F’;
6 simboloSoma = ‘+’;
7
8 return 0;
9 }
Exemplo 2.9: Uso de variáveis do tipo caractere.
2.4.6 Conversão de Tipos
Agora, conhecidas algumas informações sobre os tipos de dados básicos, torna-se mais simples compreender
o problema existente na atribuição entre tipos diferentes, mencionada na Seção 2.3.

2.4. TIPOS DE DADOS 23
Código Caractere Código Caractere Código Caractere Código Caractere
0 NUL (null) 32 SPACE 64 @ 96 `
1 SOH (start of heading) 33 ! 65 A 97 a
2 STX (start of text) 34 ” 66 B 98 b
3 ETX (end of text) 35 # 67 C 99 c
4 EOT (end of transmission) 36 $ 68 D 100 d
5 ENQ (enquiry) 37 % 69 E 101 e
6 ACK (acknowledge) 38 & 70 F 102 f
7 BEL (bell) 39 ’ 71 G 103 g
8 BS (backspace) 40 ( 72 H 104 h
9 HT (horizontal tab) 41 ) 73 I 105 i
10 LF (NL line feed,new line) 42 * 74 J 106 j
11 VT (vertical tab) 43 + 75 K 107 k
12 FF (NP from feed,new page) 44 , 76 L 108 l
13 CR (carriage return) 45 - 77 M 109 m
14 SO (shift out) 46 . 78 N 110 n
15 SI (shift in) 47 / 79 O 111 o
16 DLE (data link escape) 48 0 80 P 112 p
17 DC1 (device control 1) 49 1 81 Q 113 q
18 DC2 (device control 2) 50 2 82 R 114 r
19 DC3 (device control 3) 51 3 83 S 115 s
20 DC4 (device control 4) 52 4 84 T 116 t
21 NAK (negative acknowledge) 53 5 85 U 117 u
22 SYN (synchronous idle) 54 6 86 V 118 v
23 ETB (end of trans. block) 55 7 87 W 119 w
24 CAN (cancel) 56 8 88 X 120 x
25 EM (end of medium) 57 9 89 Y 121 y
26 SUB (substitute) 58 : 90 Z 122 z
27 ESC (escape) 59 ; 91 [ 123 {
28 FS (file separator) 60 < 92 \ 124 |
29 GS (group separator) 61 = 93 ] 125 }
30 RS (record separator) 62 > 94 ˆ 126 ˜
31 US (unit separator) 63 ? 95 127 DEL
Tabela 2.1: Os 128 caracteres da tabela ASCII original.
Considera-se que os tipos int, float e char ocupam a quantidade de memória representada na
Figura 2.6.
DRAFT
Figura 2.6: Tamanho da memória utilizada pelos tipos de dados básicos.
As diferenças nos tamanhos são justificáveis, uma vez que, quanto maior o conjunto a ser representado,
mais células de memória são necessárias para acomodar uma variável. Desta forma, sendo
o conjunto dos caracteres o menor, é preciso apenas um byte (uma célula) para representá-lo. Já o
conjunto do tipo float, que é o maior dos três, precisa de 4 bytes (4 células) para uma representação
coerente de seus valores.
É preciso ter em mente que, devido a essas restrições de implementação, não se deve utilizar
operações de atribuição entre variáveis sem tomar algum cuidado. Se elas forem de tipos diferentes,
problemas podem acontecer.
Não há problemas em atribuir uma variável do tipo int a outra do tipo float. Tal qual ocorre
na matemática, toda variável do tipo int é possível de ser representada por outra do tipo float, pois
o conjunto dos números racionais contém o conjunto dos inteiros. Um raciocínio similar pode ser

24
CAPÍTULO 2. CONCEITOS BÁSICOS
empregado para justificar as atribuições de variáveis char a variáveis de tipo int ou float, que também
ocorrem sem problemas.
O problema é quando se tenta atribuir uma variável de um conjunto mais amplo a uma de um
conjunto mais restrito. Veja o Exemplo 2.10.
Observando o Exemplo 2.10, um programador distraído pode pensar que houve uma atribuição
correta. Entretanto, o valor armazenado pela variável teste é 125. Não havendo condições de armazenar
corretamente, o compilador simplesmente descarta a parte decimal do número, armazenando
apenas sua parte inteira na variável. Logo, é preciso permanecer atento às atribuições desse tipo para
não se equivocar sobre o valor armazenado por uma variável.
1 int main (){
2 int teste ;
3
4 teste = 125.568;
5
6 return 0;
7 }
2.5 Constantes
Exemplo 2.10: Atribuição entre tipos diferentes com perda de informação.
Em algumas situações surge a necessidade de se utilizar um determinado valor constante em diversas
partes do código. Para simplificar a alteração dessas constantes e facilitar a leitura do código, é possível
definir um nome significativo para elas de maneira simples, por meio de uma estrutura específica.
Essa estrutura é iniciada pela diretiva #define, seguida pelo identificador da constante e pelo seu
respectivo valor, todos separados por um espaço em branco.
#define
Na linguagem C, a declaração de constantes deve ser feita no início do código, antes da função main,
que é a parte principal de um código pois é o ponto de partida do programa.Será datalhada melhor
ao longo do livro. O Exemplo 2.11 apresenta declarações válidas de constantes.
1 # define PI 3.141593
2 # define FALSO 0
3 # define VERDADEIRO 1
4 # define RAIZDEDOIS 1.414214
5
6 int main (){
7 float raio , comprimento , area ;
8
9 raio = 10;
10 area = PI * raio * raio ;
11 comprimento = 2 * PI * raio ;
12
13 return 0;
14 }
DRAFT
Exemplo 2.11: Definição de constantes.
Na declaração de constantes, a escolha dos nomes segue as mesmas regras para a escrita dos nomes
de variáveis. Geralmente, para diferenciar as constantes no código, opta-se por escrever seus nomes
com todas as letras maiúsculas. O Exemplo 2.11 mostra um exemplo simples onde diversas constantes
são declaradas de acordo com a convenção proposta.

2.6.
EXPRESSÕES 25
2.6 Expressões
As variáveis e constantes podem ser combinadas com os operadores associados a cada tipo de dados,
gerando expressões.
2.6.1 Expressões Aritméticas
A expressão aritmética é aquela cujos operadores e operandos são de tipos numéricos (int ou float,
por exemplo).
Nas expressões aritméticas, é guardada sempre a seguinte relação de prioridade:
1. Multiplicação, divisão e resto de divisão;
2. Adição e subtração.
Para se obter uma sequência diferente de cálculos, vários níveis de parênteses podem ser usados
para quebrar as prioridades definidas. Não é permitido o uso de colchetes e chaves, uma vez que
estes símbolos já são utilizados com outras finalidades. O Exemplo 2.12 exibe uma série de expressões
aritméticas válidas.
1 int main (){
2 int x, y, z;
3
4 x = 10 * 10 + 25; // x = 125
5 y = 5 * (7 + 3); // y = 50
6 z = 10 * ((x - 25) / y + (x - 25) * 2); // z = 2020
7
8 return 0;
9 }
Exemplo 2.12:
operações.
Expressões aritméticas e o uso de parênteses para determinar a precedência das
No Exemplo 2.12, é importante notar que, no comando de atribuição à variável x, a multiplicação
10 × 10 é executada primeiro. Na linha seguinte, a soma 7 + 3 é executada primeiro e seu valor é, em
seguida, multiplicado por 5 e atribuído à variável y. A análise da linha 6 é deixada para o leitor.
Além das operações básicas já citadas, é possível usar, nas expressões aritméticas, outras operações
bastante comuns na matemática, definidas dentro da linguagem na forma de funções. A sintaxe geral
para o uso dessas funções é a seguinte:
()
DRAFT
Algumas funções matemáticas são mostradas na Tabela 2.2.
Nome Descrição Tipo do valor
abs Módulo ou valor absoluto de um valor Inteiro
fabs Módulo ou valor absoluto de um valor racional Inteiro e Ponto Flutuante
sin Seno de um ângulo em radianos Inteiro e Ponto Flutuante
cos Cosseno de um ângulo em radianos Inteiro e Ponto Flutuante
sqrt Raiz quadrada de um número Inteiro e Ponto Flutuante
pow Potenciação Inteiro e Ponto Flutuante
floor Maior inteiro não maior que o valor Inteiro e Ponto Flutuante
ceil Menor inteiro não menor que o valor Inteiro e Ponto Flutuante
log Logaritmo neperiano Inteiro e Ponto Flutuante
exp Exponencial Inteiro e Ponto Flutuante
Tabela 2.2: Funções matemáticas pré-definidas na linguagem C.
O Exemplo 2.13 exibe vários usos de funções matemáticas e expressões aritméticas.

26
CAPÍTULO 2. CONCEITOS BÁSICOS
1 # include
2 # define PI 3.1415
3
4 int main (){
5 float a, b, c, delta , raiz1 , raiz2 ;
6 float x, y, z;
7
8 a = 10;
9 b = 50;
10 c = 30;
11
12 delta = b * b - 4 * a * c;
13 raiz1 = -b + sqrt ( delta ) / (2 * a);
14 raiz2 = -b - sqrt ( delta ) / (2 * a);
15
16 x = sin (-PI / 2);
17 y = fabs (x);
18 z = pow (y ,2) ; // y elevado a potencia 2
19
20 return 0;
21 }
Exemplo 2.13: Uso de funções matemáticas pré-definidas.
Para o uso das funções matemáticas apresentadas no Exemplo 2.13 é necessário a inclusão da
biblioteca math.h, como expresso na linha 1. Os mesmos cálculos para a procura das raízes de uma
equação de segundo grau são executados nas linhas 13 a 15, onde a função sqrt calcula a raiz quadrada
do seu operando — a variável delta. Já as linhas 15 a 17 apresentam cálculos avulsos: a linha 17
executa o cálculo do seno de −π/2 e armazena o resultado na variável x; a linha 18 armazena, na
variável y, o módulo do valor armazenado em x; e a linha 19 calcula o valor armazenado em y elevado
à potência de 2 e armazena o resultado na variável z.
2.6.2 Expressões Relacionais
As expressões relacionais comparam valores entre si. Tal qual se faz na prática, o operador relacional
trabalha com dois valores: o da expressão que está a sua direita e o da expressão que está a sua
esquerda. É importante destacar que uma variável ou uma constante isolada, por si só, pode ser
considerada uma expressão.
DRAFT
A Tabela 2.3 mostra exemplos de operadores relacionais da linguagem C e alguns casos de uso.
Símbolo Nome Exemplo
< menor que a < 10
0
>= maior ou igual a delta >= 0
!= diferente de x != 9+8*8
Tabela 2.3: Operadores relacionais.
As expressões relacionais resultam sempre em 0 (zero) para uma comparação falsa ou 1 para uma
comparação verdadeira.
É importante atentar que, embora sejam escritos de maneira parecida, há uma grande diferença
entre o operador de comparação “==” e o comando de atribuição “=”. Essa semelhança é uma fonte
comum de erros de programação, geralmente difíceis de detectar.

2.7. COMANDO DE ENTRADA DE DADOS 27
2.6.3 Expressões Lógicas
As expressões lógicas são utilizadas para relacionar os resultados de um conjunto de expressões relacionais.
Elas realizam as principais operações da lógica booleana e, na linguagem C, têm como
operadores:
ˆ
“&&” (AND): Realiza o “E” lógico;
ˆ
ˆ
“||” (OR): Realiza o “OU” lógico;
“!” (NOT): Realiza a negação.
Os resultados obtidos das expressões lógicas também são valores do tipo inteiro: 0 para falso e 1
para verdadeiro.
Para melhor entender o que cada operador realiza, são levados em conta duas variáveis p e q de
entrada, que podem ser consideradas verdadeiras (V) ou falsas (F). Veja as tabelas abaixo:
p q p && q
V V V
V F F
F V F
F F F
Tabela 2.4: Tabela verdade para o operador “&&”
O operador “&&” analisa se todas as variáveis são verdadeiras (q ≠ 0 “E” p ≠ 0). Se forem, a
expressão retornará 1 (V). Caso contrário, retornará 0 (F).
p q p || q
V V V
V F V
F V V
F F F
Tabela 2.5: Tabela verdade para o operador “||”
O operador “||” analisa se, pelo menos, uma das variáveis são verdadeiras (q ≠ 0 “OU” p ≠ 0).
Se for, retornará 1 (V). Caso contrário, retornará 0 (F).
p q !p !q
V V F F
V F F V
F V V F
F F V V
DRAFT
Tabela 2.6: Tabela verdade para o operador “!”
O operador “!” retorna o oposto do que as variáveis são consideradas. Portanto, se uma variável
for considerada verdadeira (p≠0), a expressão retornará 0 (F). Caso contrário (com p igual a 0),
retornará 1 (V).
O uso dos operadores relacionais e lógicos fica bem mais claro adiante, neste capítulo, quando os
comandos de seleção e repetição são estudados.
2.7 Comando de Entrada de Dados
O comando de entrada de dados serve para captar do usuário do programa um ou mais valores
necessários para a execução das tarefas. Na verdade, o que se faz é ler os dados de uma fonte externa,
normalmente do teclado, para depois usá-los de alguma maneira dentro do programa.

28
CAPÍTULO 2. CONCEITOS BÁSICOS
Por meio desse comando de leitura de dados, uma ou mais variáveis podem ter seus valores lidos
durante a execução do programa. Essa característica permite criar programas mais flexíveis.
Na linguagem C, a sintaxe para o uso do comando é a seguinte:
scanf(" ... ", &var1, &var2, ..., &varN);
Essa estrutura é dividida em duas partes distintas. A primeira, colocada entre aspas duplas,
contém os formatos, os quais são relacionados diretamente com os tipos das variáveis a serem lidas. A
segunda parte é uma lista dos nomes dessas variáveis, com uma relação direta entre a posição nessa
lista e o respectivo formato descrito na primeira parte do comando. Conforme mostra a descrição da
sintaxe, os nomes das variáveis devem ser precedidos pelo caractere “&”(O motivo disso será explicado
no capítulo 7 deste livro).
A Tabela 2.7 mostra alguns dos possíveis formatos.
Código Significado
%c Lê um único caracter
%d Lê um inteiro decimal
%f Lê um número em ponto flutuante
Tabela 2.7: Códigos para formatos de dados do comando de entrada scanf .
Um exemplo claro da utilidade do comando de entrada de dados é o cálculo da conta de energia
elétrica. O exemplo apresentado até agora tinha os valores de consumo e do preço do quilowatt-hora
escritos diretamente no código. Isso é bastante incômodo, pois, quando se quer calcular o valor de
uma conta diferente, o código deve ser alterado e recompilado.
Uma maneira de tornar o programa mais flexível é utilizar o comando de entrada de dados. Com
ele, é possível digitar os valores desejados para as variáveis e efetuar os cálculos para diferentes contas,
bastando, para isso, executar novamente o programa. O código modificado é exibido no Exemplo 2.14.
De acordo com o formato descrito no comando de leitura, os valores das variáveis leituraAtual,
leituraAnterior e valorUnitario devem ser digitados pelo usuário, nesta ordem, separados por espaços
em branco.
1 # include
2
3 int main (){
4 int leituraAtual , leituraAnterior , diferenca ;
5 float valorUnitario , valorConta ;
6
7 scanf ("%d %d %f", & leituraAtual , & leituraAnterior , & valorUnitario );
8 diferenca = leituraAtual - leituraAnterior ;
9 valorConta = diferenca * valorUnitario ;
10
11 return 0;
12 }
DRAFT
Exemplo 2.14: Emprego do comando de entrada de dados para o algoritmo do Exemplo 2.4.
Observando o código do Exemplo 2.14, é importante ressaltar que não há mais a parte de inicialização
das variáveis. Essa tarefa foi substituída pelo comando de entrada de dados e os valores
são, agora, passados pelo usuário do programa. Esses valores podem ser alterados a cada execução do
programa para que várias contas diferentes possam ser calculadas.Observe também que há necessidade
de inserir a biblioteca stdio.h para utilização da função scanf .
2.8 Comando de Saída de Dados
Até agora, os exemplos de códigos e os conceitos estudados não mostravam como os programas comunicavam
seus resultados ao usuário no final do programa, as variaveis armazenavam os resultados,
mas o usuario não tinha como acessá-los. De fato, esse é o papel do comando de saída de dados.

2.8. COMANDO DE SAÍDA DE DADOS 29
O comando de saída de dados serve para escrever mensagens e exibir valores de expressões, proporcionando
mais informação e legibilidade tanto para o usuário quanto para o próprio programador.
Na linguagem C, a sintaxe para o uso do comando de saída é mostrada a seguir.
printf(" ... ", exp1, exp2, ..., expN);
A estrutura do comando de saída de dados é bastante semelhante à do comando de entrada. A
principal diferença é que na segunda parte podem ser colocadas expressões. Além disso, no comando
de saída, o caractere “&” não deve ser escrito à das expressões. Ressalva-se que a segunda parte do
comando é opcional, conforme será mostrado logo adiante nesta seção.
A Tabela 2.8 mostra alguns dos possíveis formatos a serem usados.
Código Significado
%c Caracter
%d Inteiros decimais com sinal
%e Notação científica
%f Ponto flutuante decimal
%% Escreve o símbolo “%”
Tabela 2.8: Códigos para formatos de dados para o comando de saída printf .
Conforme já mencionado, o comando de saída é muito utilizado para exibir mensagens para o
usuário. Não é obrigatório que as mensagens contenham apenas valores ou caracteres armazenados
em variáveis, sendo possível escrever textos como mensagem. O Exemplo 2.15 demonstra essa possibilidade.
1 # include
2
3 int main (){
4 printf (" Bom dia a todos !");
5 printf (" Outra mensagem ");
6
7 return 0;
8 }
Exemplo 2.15: Escrevendo mensagens para o usuário do programa.
Observe no 2.15 que há necessidade de inserir a biblioteca stdio.h para uso da função printf . Podese,
ainda, mesclar uma mensagem de texto com valores de variáveis. O Exemplo 2.16 ilustra essa ideia.
Nele, é possível notar que, para cada especificador de formato na primeira parte do comando, deve
existir uma expressão de tipo correspondente posicionada adequadamente na segunda parte.
DRAFT
1 printf (" Valor do saldo : %f", saldo );
2 printf ("A metade de %d vale %d", numero , metade );
3 printf ("O menor numero digitado foi %d", menor );
Exemplo 2.16: Escrevendo mensagens que incluem valores de variáveis.
1 printf (" Valor do saldo total : %f", saldo1 + saldo2 );
2 printf ("A metade do saldo vale : %f", ( saldo1 + saldo2 ) / 2);
Exemplo 2.17: Escrevendo mensagens que incluem manipulação de expressões
Conforme mostra o 2.17 é permitido o uso de expressões ao invés de um único valor. Uma versão mais
completa do código para o cálculo da conta de energia elétrica é exibida no Exemplo 2.18. Nele, o
comando de saída é usado antes de cada comando de entrada de dados (linhas 7, 10 e 13), escrevendo
mensagens para indicar ao usuário do programa qual valor ele deverá informar. A última linha de

30
CAPÍTULO 2. CONCEITOS BÁSICOS
código utiliza o comando de saída para exibir o valor do cálculo da conta. Trata-se de uma mensagem
mista, em que o especificador %f será substituído pelo valor da variável valorConta. Supondo que,
após os cálculos, essa variável armazene o valor 187.0, a mensagem apresentada na tela seria:
Valor da conta: R$ 187.000000
1 # include
2
3 int main (){
4 int leituraAtual , leituraAnterior , diferenca ;
5 float valorUnitario , valorConta ;
6
7 printf (" Digite o valor da leitura ATUAL : ");
8 scanf ("%d", & leituraAtual );
9
10 printf (" Digite o valor da leitura ANTERIOR : ");
11 scanf ("%d", & leituraAnterior );
12
13 printf (" Digite o preco do Quilowatt - hora : ");
14 scanf ("%f", & valorUnitario );
15
16 diferenca = leituraAtual - leituraAnterior ;
17 valorConta = diferenca * valorUnitario ;
18
19 printf (" Valor da conta R$: %f", valorConta );
20
21 return 0;
22 }
Exemplo 2.18: Algoritmo mais interativo para o exemplo de cálculo da conta de energia elétrica.
Quando se usa o comando printf , o caractere especial “\n” é bastante útil. Ele serve para quebrar
a linha exatamente na posição onde for inserido no texto. A Tabela 2.9 explica melhor o funcionamento
desse caractere.
Código
Resultado
printf("OI.\nComo vai?");
OI.
Como vai?
int x;
O valor de x eh:
x = 10; 10
printf("O valor de x eh:\n%d", x);
int a;
Primeira linha.
a = 20; Segunda linha (a = 20).
printf("Primeira linha.\nSegunda linha (a = %d). \n\nFIM.", a);
FIM.
DRAFT
Tabela 2.9: Exemplos de uso do caractere especial “\n”.
2.9 Comandos de Seleção
O comando de seleção permite que um programa possa realizar diferentes alternativas de sequências
de instruções durante sua execução. Dependendo do valor de uma expressão, o programa segue
executando uma ou outra sequência de comandos.
Existem três categorias distintas: seleção simples, seleção dupla e seleção múltipla, as quais são
abordadas a seguir.

2.9. COMANDOS DE SELEÇÃO 31
2.9.1 Comando de seleção simples
É possível imaginar diversas situações cotidianas que se assemelham ao comportamento do comando
de seleção simples. Uma comparação clássica leva em conta a tomada de um desvio durante uma
viagem.
Quando o carro é utilizado para ir a algum lugar, é normal conhecer uma rota sequenciada de
lugares intermediários pelos quais se passa antes de chegar ao destino. Entretanto, é possível que
ocorra algum imprevisto e seja necessário tomar um desvio.
Há tarefas computacionais que também se deparam com tais cenários. Antes de exemplificar, é
melhor apresentar a estrutura do comando de seleção simplificado. Ela pode ser observada a seguir.
1
if(){
}
Não é difícil entendê-la. Quando o computador executa esse comando, o que é realizado em primeiro
lugar é o teste da expressão lógica. Se ela resultar “verdadeiro”, então a sequência de comandos é
executada. Caso contrário, o programa segue executando normalmente as instruções posteriores.
Desta forma, a decisão de desviar a execução normal do programa é condicionada ao resultado da
expressão lógica escrita no início do comando.
O uso do comando de seleção simples é exibido no Pseudocódigo 2.3, o qual descreve um algoritmo
que faz a leitura de dois números inteiros e os imprime como foram digitados e, também, em ordem
crescente.
Pseudocódigo 2.3 Ordena dois números inteiros digitados pelo usuário.
Descrição: Apresentar, em ordem crescente, dois números inteiros digitados pelo usuário.
Dados de Entrada: Dois números inteiros.
Saída do Programa: Números inteiros impressos na ordem em que foram digitados e em ordem crescente.
Funç~ao Principal :
Ler dois valores inteiros .
Apresentar os valores coletados .
SE o primeiro número lido for maior que o segundo :
Ordenar os valores .
FIM -SE
Apresentar os valores ordenados .
FIM - Funç~ao Principal
DRAFT
No Pseudocódigo 2.3, a operação SE é executada tal qual o comando de seleção simples if. O
Exemplo 2.19 apresenta um código em linguagem C para o algoritmo do referido pseudocódigo.
2 # include
3
4 int main (){
5 int num1 , num2 , aux ;
6
7 printf (" Digite dois numeros inteiros separados por espacos : ");
8 scanf ("%d %d", &num1 , & num2 );
9 printf (" Valores digitados : %d %d.\n", num1 , num2 );
10
11 if( num1 > num2 ){
12 aux = num1 ;
13 num1 = num2 ;
14 num2 = aux ;
15 }
16
17 printf (" Valores ordenados : %d %d.\n", num1 , num2 );

32
CAPÍTULO 2. CONCEITOS BÁSICOS
18
19 return 0;
20 }
Exemplo 2.19: Comando de seleção simples if
O Exemplo 2.19 inicia exibindo uma mensagem ao usuário (linha 7), solicitando que sejam digitados
dois números. Esses valores são armazenados em variáveis correspondentes (linha 8) e, em seguida, são
mostrados ao usuário por meio de uma mensagem (linha 9). A expressão lógica do comando de seleção
da linha 11 determina se há necessidade de inverter os números antes de exibi-los ordenadamente. É
importante ressaltar que não há necessidade de ordenar os números caso o usuário já os tenha digitado
na sequência correta. Nesse caso, o programa pode seguir normalmente e exibir na tela os valores das
variáveis. Por último, os valores são exibidos em ordem crescente (linha 17).
Ainda no Exemplo 2.19, as linhas 12, 13 e 14 são importantes o bastante para serem destacadas.
Elas tratam da operação de troca de valores entre duas variáveis, a qual é muito utilizada e deve ser
bem entendida.
O comando de atribuição é ideal para copiar o valor de uma variável para outra. A questão é que
a variável de destino tem seu valor alterado permanentemente após a realização do comando. Ou seja,
o valor que estava escrito nessa variável antes da execução da atribuição é apagado e o novo valor é
escrito em seu lugar.
No caso da operação de troca de valores, se fossem usadas apenas as duas variáveis envolvidas,
uma delas teria seu valor perdido quando a primeira atribuição fosse realizada. Esse problema ocorre
no Exemplo 2.20, no qual o valor inicial da variável var1 é perdido.
1 int main (){
2 int var1 , var2 ;
3
4 var1 = 100;
5 var2 = 200;
6
7 var1 = var2 ; // var1 guarda 200
8 var2 = var1 ; // var2 guarda 200
9
10 return 0;
11 }
Exemplo 2.20: Tentativa equivocada de trocar os valores de duas variáveis.
A solução para o problema da perda de valores é simples e pode ser encontrada nas linhas 12, 13
e 14 do Exemplo 2.19. Basta usar uma variável auxiliar e copiar para ela o valor da primeira variável
de destino usada nas atribuições. Naquele exemplo, o valor da variável num1 foi salvo na variável aux
para não ser perdido na atribuição da linha 13. Em seguida, esse valor pôde ser copiado corretamente
para a variável num2 na linha 14.
2.9.2 Comando de seleção dupla
DRAFT
O comando de seleção dupla pode ser comparado com a bifurcação de um caminho. É preciso escolher
uma das alternativas e segui-la.
Em programação, o comando de seleção dupla serve para executar sempre uma de duas alternativas
de sequências de instruções, de acordo com a verificação de uma condição. A estrutura do comando
na linguagem C é mostrada a seguir.
if (){
}else{
}

2.9. COMANDOS DE SELEÇÃO 33
Primeiramente, o computador testa a expressão lógica. Caso resulte “verdadeiro”, então a sequência
de comandos 1 é executada. Caso contrário, a sequência de comandos 2 é realizada. Assim, apenas uma
e sempre uma das sequências de comandos é executada durante uma mesma realização do comando
de seleção dupla.
Após a operação de uma das sequências de comando, o programa continua sua execução na primeira
linha de código após o conjunto de instruções do comando de seleção.
Para exemplificar o uso do comando de seleção dupla, o algoritmo do Pseudocódigo 2.4 mostra
como se faz para decidir se um aluno está aprovado em uma disciplina, com base na média de suas
notas semestrais.
Pseudocódigo 2.4 Informa se um aluno está aprovado ou não, de acordo com a média das notas
obtidas no semestre.
Descrição: Decidir se um aluno está aprovado ou não, com base na média das notas semestrais.
Dados de Entrada: Matrícula do aluno e notas.
Saída do Programa: Mensagem dizendo se o aluno está aprovado ou não.
Funç~ao Principal :
Ler a matrícula e as notas do aluno .
Calcular a média parcial .
SE a média parcial for menor que 7:
Apresentar uma mensagem dizendo que o aluno deve fazer prova final .
SEN~AO
Apresentar uma mensagem dizendo que o aluno está aprovado .
FIM -SE
FIM - Funç~ao Principal
O comando SE-SENÃO do Pseudocódigo 2.4 deve ser interpretado da mesma maneira que é
o comando de seleção dupla if. No Exemplo 2.21, é listado o código em C para o algoritmo do
pseudocódigo recém-mencionado.
1 # include
2
3 int main (){
4 int matricula ;
5 float n1 , n2 , n3 , mediaParcial ;
6
7 printf (" Digite a matricula e as notas parciais do aluno : ");
8 scanf ("%d %f %f %f", & matricula , &n1 , &n2 , &n3);
9 mediaParcial = (n1 + n2 + n3) / 3.0;
10
DRAFT
11 if ( mediaParcial < 7.0) {
12 printf ("\nO aluno %d deve fazer prova final .", matricula );
13 } else {
14 printf ("\nO aluno %d foi aprovado com media %f", matricula , media );
15 }
16
17 return 0;
18 }
Exemplo 2.21: Uso do comando de seleção if para a verificação da média parcial de um aluno.
No Exemplo 2.21, as linhas 4 e 5 correspondem à declaração das variáveis; a linha 8, à inicialização
delas. Após o cálculo da média parcial das notas (linha 9), o comando de seleção verifica se tal média
é menor que 7, 0 e, assim, executa a instrução da linha 12 ou da linha 14.
Como pode ser visto no Exemplo 2.22, é possível usar comandos de seleção de forma aninhada,
ou seja, pode-se colocar um comando de seleção dentro de uma das sequências de comandos de outro.
Nesse programa, compara-se dois números inteiros digitados pelo usuário, informando se foram
digitados em ordem crescente, decrescente ou se são iguais. Antes, entretanto, é bom observar o

34
CAPÍTULO 2. CONCEITOS BÁSICOS
Pseudocódigo 2.5, que corresponde ao código do Exemplo 2.22.
Pseudocódigo 2.5 Compara dois números e informa se foram digitados em ordem crescente, decrescente
ou se são iguais.
Descrição: Decidir se dois números digitados estão em ordem crescente, decrescente ou se são iguais.
Dados de Entrada: Dois números.
Saída do Programa: Mensagem dizendo se estão em ordem crescente, decrescente ou se são iguais.
Funç~ao Principal :
Ler dois números inteiros .
SE o primeiros for maior que o segundo :
Apresentar uma mensagem dizendo que é ordem crescente .
SEN~AO
SE o segundo for maior que o primeiro :
Apresentar uma mensagem dizendo que é ordem decrescente .
SEN~AO
Apresentar uma mensagem dizendo que os números s~ao iguais .
FIM -SE
FIM -SE
FIM - Funç~ao Principal
1 # include
2
3 int main (){
4 int num1 , num2 ;
5
6 printf (" Digite dois numeros inteiros quaisquer : ");
7 scanf ("%d %d", &num1 , & num2 );
8
9 if ( num1 > num2 ){
10 printf ("\ nOrdem decrescente .");
11 } else {
12 if ( num2 > num1 ){
13 printf ("\ nOrdem crescente .");
14 } else {
15 printf ("\ nNumeros iguais .");
16 }
17 }
18
19 return 0;
20 }
DRAFT
Exemplo 2.22: Comando de seleção if aninhado em outro comando if.
A estrutura dos comandos de seleção do Exemplo 2.22 permite testar todos os casos. Observe que
não há uma verificação explícita para a igualdade dos números. Isso acontece porque todos os demais
casos possíveis são testados antes e, se não se tratar de nenhum desses, então os números certamente
são iguais. Nesse caso, basta apenas exibir a mensagem correspondente.
Em muitos casos, além de ser elegante, o uso da estrutura de seleção aninhada pode ser mais
eficiente. Verifica-se esse fato nos Exemplos 2.23 e 2.24. Ambos os programas leem três números
digitados pelo usuário e identificam o maior deles, porém, um dos programas faz menos verificações
que o outro, ganhando eficiência.
1 # include
2
3 int main (){
4 int n1 , n2 , n3;
5
6 printf (" Entre com os tres numeros : ");

2.9. COMANDOS DE SELEÇÃO 35
7 scanf ("%d %d %d", &n1 , &n2 , &n3);
8
9 if (( n1 > n2) && (n1 > n3)){
10 printf ("O maior numero digitado foi : %d.", n1);
11 }
12
13 if (( n2 > n1) && (n2 > n3)){
14 printf ("O maior numero digitado foi : %d.", n2);
15 }
16
17 if (( n3 > n1) && (n3 > n2)){
18 printf ("O maior numero digitado foi : %d.", n3);
19 }
20
21 return 0;
22 }
Exemplo 2.23: Programa que identifica o maior de três números sem o uso do comando de seleção
aninhado.
1 # include
2
3 int main (){
4 int n1 , n2 , n3;
5
6 printf (" Entre com os tres numeros separados por espacos : ");
7 scanf ("%d %d %d", &n1 , &n2 , &n3);
8
9 if (n1 > n2){
10 if (n1 > n3){
11 printf ("O maior numero digitado foi : %d.", n1);
12 } else {
13 printf ("O maior numero digitado foi : %d.", n3);
14 }
15 } else {
16 if (n2 > n3){
17 printf ("O maior numero digitado foi : %d.", n2);
18 } else {
19 printf ("O maior numero digitado foi : %d.", n3);
20 }
21 }
22
23 return 0;
24 }
Exemplo 2.24:
aninhado.
DRAFT
Programa que identifica o maior de três números, usando o comando de seleção
No caso do Exemplo 2.23, o uso de vários comandos if isolados acarreta em perda de eficiência.
Quando o primeiro número digitado pelo usuário for o maior, o programa realiza dois testes desnecessários
(linhas 13 e 17). E quando o segundo número for o maior, o programa realiza um teste
desnecessário (linha 17).
No Exemplo 2.24, apenas dois testes são executados (linhas 9 e 10 ou linhas 9 e 16), diminuindo
significativamente o número de comparações em relação ao Exemplo 2.23.
O programa do Exemplo 2.25 recebe do usuário três números inteiros e verifica se eles podem
ser lados de um triângulo. Caso verdadeiro, o programa ainda indica a classificação do triângulo. O
Pseudocódigo 2.6 lista o algoritmo para esse exemplo.
Pseudocódigo 2.6 Informa se três números podem constituir os lados de um triângulo e o tipo do
triângulo que pode ser formado.

36
CAPÍTULO 2. CONCEITOS BÁSICOS
Descrição: Calcular se três números podem representar os lados de um triângulo e, caso seja possível, o tipo
do triângulo.
Dados de Entrada: Três valores inteiros.
Saída do Programa: Mensagem dizendo o tipo do triângulo ou se não pode ser formado um triângulo.
Funç~ao Principal :
Ler tr^es números inteiros .
SE os tr^es valores forem iguais :
Apresentar uma mensagem dizendo que é tri^angulo equilátero .
SEN~AO
SE cada valor é menor do que a soma dos outros dois :
SE os tr^es valores forem diferentes :
Apresentar uma mensagem dizendo que é tri^angulo escaleno .
SEN~AO
Apresentar uma mensagem dizendo que é tri^angulo isósceles .
FIM -SE
SEN~AO
Apresentar uma mensagem dizendo que os valores n~ao podem ser lados de
um tri^angulo .
FIM -SE
FIM -SE
FIM - Funç~ao Principal
1 # include
2
3 int main (){
4 int lado1 , lado2 , lado3 , soma1 , soma2 , soma3 ;
5
6 printf (" Entre com tres numeros inteiros : ");
7 scanf ("%d %d %d", & lado1 , & lado2 , & lado3 );
8
9 if (( lado1 == lado2 ) && ( lado2 == lado3 )){
10 printf (" Triangulo equilatero \n");
11 } else {
12 soma1 = lado1 + lado2 ;
13 soma2 = lado1 + lado3 ;
14 soma3 = lado2 + lado3 ;
15
16 if (( soma1 > lado3 ) && ( soma2 > lado2 ) && ( soma3 > lado1 )){
17 if (( lado1 != lado2 ) && ( lado1 != lado3 ) && ( lado2 != lado3 )){
18 printf (" Triangulo escaleno \n");
19 } else {
20 printf (" Triangulo isosceles \n");
21 }
22 } else {
DRAFT
23 printf ("Os tres lados nao formam um triangulo \n");
24 }
25 }
26
27 return 0;
28 }
Exemplo 2.25: Programa que indica se três números formam um triângulo.
No Exemplo 2.25, o comando if mais externo (linha 9) confere se os números formam um triângulo
equilátero, verificando se os três números são iguais. Caso não formem um triângulo equilátero, na
linha 16 é verificado se os três números formam realmente um triângulo, comparando a soma de dois
lados com a medida do terceiro (para todas as possibilidades). Caso verdadeiro, o if mais interno
confere se os três lados são diferentes um do outro, formando um triângulo escaleno; o resultado
“falso”para esse último teste implica necessariamente na formação de um triângulo isósceles.

2.9. COMANDOS DE SELEÇÃO 37
2.9.3 Comando de seleção múltipla
O comando de seleção if é bastante poderoso e largamente utilizado. Entretanto, ele não é o único
comando de seleção existente. Há um comando que, embora seja menos abrangente que o comando
if, resolve muitas situações de forma clara e simples. Trata-se do comando de seleção múltipla.
O comando de seleção múltipla sempre pode ser substituído por um ou mais comandos if aninhados,
mas ele torna o código muito mais claro quando se quer executar várias sequências de comandos
diferentes, sendo que cada sequência deva corresponder a um determinado valor de uma expressão. A
estrutura seguinte facilita a compreensão do comando.
switch (){
case :
break;
case :
break;
.
.
.
case :
break;
default:
}
Na estrutura do comando de seleção múltipla, a expressão normalmente é uma expressão aritmética
ou uma variável de tipo numérica, e associa-se o valor da expressão ao valor de um determinado case.
Assim, apenas a sequência de comandos do bloco case correspondente será executada. É importante
observar que cada sequência de comandos é encerrada pelo comando break.
A cláusula default é opcional. Ela marca a sequência de comandos padrão, que deve ser executada
quando nenhuma comparação obtiver sucesso. Se não estiver presente, nada será executado nesse caso.
Na linguagem C, cada case deve servir para comparar o resultado da expressão com um valor
específico. Não se permite comparações com o resultado de outras expressões.
No Exemplo 2.26 usa-se o comando switch na construção de um programa que simula o funcionamento
de uma urna eletrônica. O Pseudocódigo 2.7 exibe o algoritmo desse exemplo.
DRAFT
Pseudocódigo 2.7 Simulação de uma urna eletrônica simplificada.
Descrição: Simular uma urna eletrônica simplificada. Não há a opção para voto em branco.
Dados de Entrada: Número do candidato.
Saída do Programa: Mensagem dizendo o nome do candidato escolhido ou se o voto foi anulado.
Funç~ao Principal :
Ler o número do candidato .
CASO o número do candidato SEJA :
1, ENT~AO apresentar uma mensagem dizendo que Hort^encia da Silva foi
escolhida .
2, ENT~AO apresentar uma mensagem dizendo que José dos Cravos foi escolhido .
3, ENT~AO apresentar uma mensagem dizendo que Margarida S. Pereira foi
escolhida .
OUTRO VALOR , ENT~AO imprima uma mensagem dizendo que o voto foi anulado .
FIM - CASO
FIM - Funç~ao Principal

38
CAPÍTULO 2. CONCEITOS BÁSICOS
O comportamento do comando CASO-SEJA do Pseudocódigo 2.7 deve ser pensado da mesma
maneira que o do comando de seleção múltipla switch.
1 # include
2
3 int main (){
4 int numero ;
5
6 printf (" URNA ELETR^ONICA - SEU VOTO PARA PREFEITO : ");
7 scanf ("%d", & numero );
8
9 switch ( numero ){
10 case 1:
11 printf (" Candidato escolhido : Hort^encia da Silva ");
12 break ;
13 case 2:
14 printf (" Candidato escolhido : José dos Cravos ");
15 break ;
16 case 3:
17 printf (" Candidato escolhido : Margarida S. Pereira ");
18 break ;
19 default :
20 printf ("Número digitado inválido . Voto anulado .");
21 }
22
23 return 0;
24 }
Exemplo 2.26: Uso do comando switch para simular uma urna eletrônica de eleição.
No programa do Exemplo 2.26, os números de 1 a 3 estão associados a determinados candidatos
e, para qualquer outro número, a cláusula default é associada.
Após a inicialização da variável numero com o comando de entrada de dados (linha 7), o comando
de seleção compara o número digitado com os números dos três candidatos inscritos. Em cada caso,
se o número digitado coincide com a constante, a sequência de comandos correspondente ao candidato
escolhido é executada. Se nenhuma comparação obtiver sucesso, então o usuário digitou um número
de candidato que não existe. Nesse caso, o programa exibe uma mensagem de alerta para o usuário,
avisando-lhe que o número digitado é inválido para a eleição (linha 20).
Quando o comando break não termina uma sequência de comandos cuja comparação resultou verdadeira,
a sequência de comandos seguinte é executada sem que o teste correspondente seja efetuado.
Na prática, o que acontece é que quando uma comparação do switch resultar em verdadeiro, todas as
sequências de comando seguintes são executadas até que o primeiro comando break seja encontrado.
É preciso, portanto, ficar atento e finalizar cada sequência de comandos com o comando break
evitando, assim, erros de programação muitas vezes difíceis de detectar.
DRAFT
2.10 Comandos de Repetição
A capacidade que as máquinas possuem de repetir tarefas exaustivamente com a mesma qualidade é
uma das principais razões do sucesso de sua invenção. Os computadores podem repetir uma ou mais
sequências de comandos quantas vezes forem necessário, e é o programador quem decide o critério de
parada das repetições.
As aplicações para os comandos de repetição são praticamente infinitas porque quase todas as
tarefas contêm partes que devem ser executadas mais de uma vez.
Na linguagem C, existem três principais estruturas de repetição. A opção pelo uso de uma ou
outra depende normalmente da preferência do programador e do problema em questão, normalmente
buscando-se o máximo de clareza ou facilidade de escrita do código. Essas três estruturas são abordadas
a seguir.

2.10. COMANDOS DE REPETIÇÃO 39
2.10.1 Comando de repetição com pré-condição
A estrutura do comando while é a mais simples das três e seu funcionamento é igualmente simples de
compreender. A estrutura é a seguinte:
while (< express~ao lógica >){
}
O computador inicia o comando testando a validade da expressão lógica. Se for verdadeira, então
ele executa a sequência de comandos e retorna ao teste de validação da expressão lógica, reiniciando
o ciclo. O computador repete esse processo até que o resultado da expressão lógica seja falso.
No caso em que o primeiro teste de validação da expressão lógica resulta em falso, a sequência de
comandos não é executada nenhuma vez.
O Pseudocódigo 2.8 representa um algoritmo que recebe um número inteiro positivo n e apresenta
na tela os n primeiros inteiros positivos.
Pseudocódigo 2.8 Apresentar os n primeiros números positivos.
Descrição: Apresentar na tela os n primeiros números positivos.
Dados de Entrada: n (quantidade de inteiros a serem impressos).
Saída do Programa: Números inteiros de 1 a n.
Funç~ao Principal :
Ler n.
Valor recebe 1.
ENQUANTO Valor for menor ou igual a n FAÇA:
Apresentar Valor .
Incrementar Valor .
FIM - ENQUANTO
FIM - Funç~ao Principal
O comando ENQUANTO do Pseudocódigo 2.8 funciona da mesma maneira que o comando de
repetição com pré-condição while. O programa do Exemplo 2.27 mostra um código em C que realiza
as operações do referido pseudocódigo.
1 # include
2
3 int main (){
4 int n, valor ;
5
DRAFT
6 printf (" Digite um numero inteiro positivo : ");
7 scanf ("%d", &n);
8
10
9 valor = 1;
11 while ( valor

40
CAPÍTULO 2. CONCEITOS BÁSICOS
(linhas 12 e 13) é executado enquanto o número armazenado em valor for menor ou igual ao número
armazenado em n.
A condição de parada em qualquer comando de repetição é um fator muito importante que se
deve escolher com bastante cuidado. É preciso garantir que o computador efetue um número finito de
repetições para que, em algum momento, o programa possa seguir seu fluxo normal de execução. Além
de resultados incorretos, uma condição de parada errônea pode acarretar uma execução de programa
sem término (nessa situação, diz-se que o programa está em “loop infinito”).
A Tabela 2.10 apresenta o resultado da execução do programa do Exemplo 2.27, quando o usuário
informa o valor 4 para a variável n.
n valor valor

2.10. COMANDOS DE REPETIÇÃO 41
Saída do Programa: Mensagem indicando o candidato escolhido.
Funç~ao Principal :
Resposta recebe zero .
ENQUANTO resposta for igual a zero FAÇA:
Ler o número do candidato .
Apresentar o nome do candidato escolhido .
Ler a resposta da confirmaç~ao.
FIM - ENQUANTO .
FIM - Funç~ao
Principal
No código do Exemplo 2.29, o usuário tem a possibilidade de corrigir o seu voto sem que o programa
termine.
1 # include
2
3 int main (){
4 int numero , confirma ;
5
6 confirma = 0;
7
8 while ( confirma == 0){
9 printf (" URNA ELETRONICA - SEU VOTO PARA PREFEITO : \n");
10 scanf ("%d", & numero );
11
12 switch ( numero )
13 {
14 case 1:
15 printf (" Candidato escolhido : Hortencia da Silva \n");
16 break ;
17 case 2:
18 printf (" Candidato escolhido : Jose dos Cravos \n");
19 break ;
20 case 3:
21 printf (" Candidato escolhido : Margarida S. Pereira \n");
22 break ;
23 default :
24 printf (" Numero digitado invalido . Voto NULO .\n");
25 }
26
27 printf ("\ nDigite 1 para CONFIRMAR ou 0 para CORRIGIR ");
28 scanf ("%d", & confirma );
29 }
30
31 return 0;
32 }
DRAFT
Exemplo 2.29: Comando de repetição while utilizado para melhorar o código do Exemplo 2.26.
O critério de parada escolhido no Exemplo 2.29 é a alteração do valor da variável confirma.
Enquanto essa variável armazena o valor zero, o programa repetirá o processo de votação e perguntará
ao usuário se confirma o voto ou se gostaria de corrigi-lo. Quando o valor da variável confirma é
alterado, a expressão lógica da linha 8 retorna falso, encerrando o comando de repetição.
No Exemplo 2.30, o usuário fornece como entrada números inteiros positivos e o programa retorna
o maior valor dentre os digitados pelo usuário.
Pseudocódigo 2.10 Cálculo do maior número dentre os digitados pelo usuário.
Descrição: Calcular o maior número dentre os digitados pelo usuário

42
CAPÍTULO 2. CONCEITOS BÁSICOS
Dados de Entrada: Números inteiros positivos
Saída do Programa: Maior número dentre os digitados
Funç~ao Principal :
Ler um número n
Inicializar contador i
ENQUANTO contador i for menor que n FAÇA:
Ler um número inteiro positivo .
SE número é maior que o maior número anterior :
Atualizar o maior número .
FIM -SE
Incrementar o contador i.
FIM - ENQUANTO
Apresentar maior número .
FIM - Funç~ao Principal
1 # include
2
3 int main (){
4 int i = 0, n, numero , maiornumero = 0;
5
6 printf (" Digite o numero ’n’ inteiro positivo :);
7 scanf ("%d", &n);
8
9 while (i < n){
10 printf (" Digite um numero inteiro positivo :");
11 scanf ("%d" ,& numero );
12
13 if ( numero > maiornumero ) maiornumero = numero ;
14 i ++;
15 }
16
17 printf (" Maior numero :%d\n", maiornumero );
18
19 return 0;
20 }
DRAFT
Exemplo 2.30: Comando de repetição while utilizado para ler ’n’ números de entrada e comparar cada um
com o maior adquirido até atingir a quantidade ’n’.
O critério de parada do Exemplo 2.30 é a contagem dos números até atingir o valor ’n’ fornecido
pelo usuário. Portanto, o laço (while) só termina quando a quantidade de números que o usuário
forneceu for atingida. Enquanto ’i’ < ’n’, a variável ’numero’ é atribuída pelo usuário e comparada
com o maior número dentre os digitados anteriormente e a variável ’i’ é incrementada com o valor 1,
em cada iteração. Entende-se por iteração como a leitura dos comandos existentes no laço, portanto,
o comando ’while’ deste exemplo possui ’n’ iterações.
Um outro exemplo simples para o uso do comando while é um algoritmo no qual o usuário informa
uma sequência de valores positivos e, em seguida, a média desses valores é apresentada. O usuário
deverá digitar zero quando quiser finalizar a sequência e saber a média. O algoritmo desse programa
está listado no Pseudocódigo 2.11.
O Exemplo 2.31 exibe o programa para o Pseudocódigo 2.11.
Pseudocódigo 2.11 Cálculo da média de números positivos digitados pelo usuário.
Descrição: Calcular a média de números positivos digitados pelo usuário.
Dados de Entrada: Números não negativos.
Saída do Programa: Média dos valores digitados.

2.10. COMANDOS DE REPETIÇÃO 43
Funç~ao Principal :
Ler valor .
Inicializar soma .
ENQUANTO valor digitado for positivo FAÇA:
Atualizar a soma dos números digitados .
Incrementar a quantidade de números digitados .
Ler valor .
FIM - ENQUANTO .
SE a quantidade de números digitados for maior que zero :
Calcular a média dos valores digitados .
Apresentar a média .
FIM -SE
FIM - Funç~ao Principal
No código do Exemplo 2.31, a variável soma precisa ser inicializada com zero, pois, caso contrário,
irá receber como atribuição: valor inexistente da soma mais valor fornecido pelo usuário.
1 # include
2
3 int main (){
4 float valor , soma , media ;
5 int quantidade ;
6
7 soma = 0;
8 quantidade = 0;
9
10 printf (" Informe um valor negtivo ou zero para encerrar o programa : ");
11 scanf ("%f", & valor );
12
13 while ( valor > 0){
14 soma = soma + valor ;
15 quantidade = quantidade + 1;
16 printf (" Informe um valor negativo ou zero para encerrar o programa : ");
17 scanf ("%f", & valor );
18 }
19
20 if ( quantidade > 0){
21 media = soma / quantidade ;
22 printf (" Media dos valores digitados : %f\n", media );
23 }
24
25 return 0;
26 }
DRAFT
Exemplo 2.31: Programa que calcula a média dos valores de uma sequência digitada pelo usuário.
O funcionamento do programa do Exemplo 2.31 é simples. A variável soma guarda a soma dos
valores digitados pelo usuário e deve ser inicializada com zero. A cada novo valor positivo digitado,
seu valor deve ser atualizado. Essa atualização ocorre na linha 14.
A variável valor é a condição de parada do comando de repetição. Sempre que o usuário digita
zero (ou até mesmo um número negativo), o comando de repetição é encerrado.
Para saber quantos números foram digitados, a variável quantidade é empregada. Ela é inicializada
com zero e, sempre que o usuário digita um número, ela é incrementada (linha 15).
Quando o comando de repetição é encerrado, é preciso verificar se o usuário digitou algum valor.
Essa verificação se deve ao fato de que o primeiro valor digitado pode ser zero, indicando que o
usuário saiu do programa e não quis calcular nada. No caso de algum valor válido ter sido informado
(expressão lógica da linha 20), então a média é calculada e uma mensagem com o resultado é exibida
ao usuário (linhas 21 e 22).

44
CAPÍTULO 2. CONCEITOS BÁSICOS
Há determinados códigos que possuem um padrão ao se utilizar o comando while. Como exemplo,
temos o código do Exemplo 2.31. No Pseudocódigo 2.12, a exemplificação do padrão:
Pseudocódigo 2.12 Padrão de código.
Descrição: Padrão de código.
Inicializar os dados de saída
Ler dado de entrada
ENQUANTO n~ao há finalizaç~ao FAÇA:
Atualizar os dados de saída.
Ler o próximo dado de entrada .
FIM - ENQUANTO
Finalizar os dados de saída
Apresentar os dados de saída
Ao final deste capítulo, o Problema dos Lotes Encaixantes (Seção 2.11) será detalhado utilizando
este padrão.
O Exemplo 2.32 exibe o programa para o Pseudocódigo 2.13.
Pseudocódigo 2.13 Cálculo do maior número, menor e da média de números inteiros positivos
digitados pelo usuário.
Descrição: Calcular o maior número, menor e a média de números inteiros positivos digitados pelo usuário.
Dados de Entrada: Números inteiros não negativos.
Saída do Programa: Maior número, menor e média dos números digitados.
Funç~ao Principal :
Ler número .
Menor número recebe número .
ENQUANTO número digitado for positivo FAÇA:
SE número é maior que o maior número :
Maior número recebe número .
FIM -SE
DRAFT
SE número é menor que o menor número :
Menor n m e r o recebe número .
FIM -SE
Atualizar a soma dos números digitados .
Incrementar a quantidade de números digitados .
Ler número .
FIM - ENQUANTO .
Média recebe soma dividida pela quantidade de números digitados .
Apresentar maior número , menor e média .
FIM - Funç~ao Principal
1 # include
2
3 int main (){
4 int numero , maiornumero , menornumero , qtdnumeros , soma , media ;
5
6 maiornumero = 0;
7 qtdnumeros = 0;
8 soma = 0;
9

2.10. COMANDOS DE REPETIÇÃO 45
10 printf (" Digite um numero inteiro positivo (0 para finalizar ):");
11 scanf ("%d", & numero );
12 menornumero = numero ;
13
14 while ( numero > 0){
15 if ( numero > maiornumero )
16 maiornumero = numero ;
17 if ( numero < menornumero )
18 menornumero = numero ;
19
20 soma += numero ;
21 qtdnumeros ++;
22
23 printf (" Digite um numero inteiro positivo (0 para finalizar ):");
24 scanf ("%d", & numero );
25 }
26
27 media = soma / qtdnumeros ;
28 printf (" Maior Numero : %d\n Menor Numero : %d\n Mudia : %d\n", maiornumero ,
menornumero , media );
29
30 return 0;
31 }
Exemplo 2.32: Comando de repetição while utilizado para ler números de entrada, calcular média e comparar
cada um com o maior adquirido e menor adquirido.
O programa do Exemplo 2.32 é uma junção dos exemplos 2.30 e 2.31 com uma funcionalidade
adicional que é calcular o menor número dentre os digitados pelo usuário.
2.10.2 Comando de repetição com pós-condição
Em contraste com o comando de pré-condição, o comando de repetição com pós-condição só efetua o
teste da expressão lógica (condição de parada) após a primeira execução da sequência de comandos.
Logo, o bloco de comandos é executado pelo menos uma vez, independente da expressão lógica. A
própria sintaxe do comando sugere essa diferença:
do{
} while (< express~ao lógica >);
DRAFT
O Pseudocódigo 2.9 pode ser modificado para melhorar sua legibilidade.
comando FAÇA-ENQUANTO, o algoritmo fica mais simples.
Pseudocódigo 2.14 Urna eletrônica com opção de corrigir voto (versão melhorada).
Descrição: Urna eletrônica com opção de corrigir voto.
Dados de Entrada: Número do candidato, resposta da confirmação.
Saída do Programa: Mensagem indicando o candidato escolhido.
Com o emprego do
Funç~ao Principal :
Ler número .
Menor número recebe número .
ENQUANTO número digitado for positivo FAÇA:
SE número é maior que o maior número :
Maior número recebe número .
FIM -SE
SE número é menor que o menor número :

46
CAPÍTULO 2. CONCEITOS BÁSICOS
Menor número recebe número .
FIM -SE
Atualizar a soma dos números digitados .
Incrementar a quantidade de números digitados .
Ler número .
FIM - ENQUANTO .
Média recebe soma dividida pela quantidade de números digitados .
Apresentar maior número , menor e média .
FIM - Funç~ao Principal
O programa do Exemplo 2.29 pode ser reescrito utilizando-se o comando do-while. Nesse caso, o
uso do do-while permite ao programador ter a opção de não inicializar a variável confirma antes da
execução da sequência de comandos, responsabilizando o usuário pela inicialização (conforme se nota
no Exemplo 2.33).
1 # include
2
3 int main (){
4 int numero , confirma ;
5
6 /* A variavel confirma nao e mais inicializada pelo programador */
7 do{
8 printf (" URNA ELETRONICA - SEU VOTO PARA PREFEITO : \n");
9 scanf ("%d", & numero );
10
11 switch ( numero )
12 {
13 case 1:
14 printf (" Candidato escolhido : Hortencia da Silva \n");
15 break ;
16 case 2:
17 printf (" Candidato escolhido : Jose dos Cravos \n");
18 break ;
19 case 3:
20 printf (" Candidato escolhido : Margarida S. Pereira \n");
21 break ;
22 default :
23 printf (" Numero digitado invalido . Voto NULO .\n");
24 }
25
26 printf ("\ nDigite 1 para CONFIRMAR ou 0 para CORRIGIR ");
27 scanf ("%d", & confirma );
28 } while (! confirma );
29
30 return 0;
31 }
DRAFT
Exemplo 2.33: Aplicação para o comando do-while, modificando o código do Exemplo 2.29.
No Exemplo 2.33, nota-se que não há mais a inicialização explícita da variável confirma. Com
o comando do-while, garante-se que a variável será inicializada pelo usuário antes de seu valor ser
testado na expressão lógica da linha 28, utilizada como critério de parada.
Pode parecer estranho, à primeira vista, como a expressão lógica !confirma funciona. Na verdade
essa expressão é equivalente ao teste confirma==0.
Para entender essa equivalência, basta lembrar que o operador lógico de negação inverte o valor
lógico da variável ao qual ele é aplicado. É bom recordar também que, para os números inteiros, o
valor zero equivale a falso enquanto que qualquer número diferente de zero é tomado como valor lógico
verdadeiro. Assim sendo, sempre que o programador desejar testar se um valor inteiro é igual a zero,
basta testar o resultado do operador de negação, pois o único caso em que ele retornará verdadeiro
será quando o valor numérico testado for zero.

2.10. COMANDOS DE REPETIÇÃO 47
2.10.3 Comando de repetição condensado
O comando de repetição condensado permite agrupar, em um único comando, a inicialização de uma
variável, o incremento desta variável e o teste de parada. Seu uso mais comum é em situações nas
quais o número de repetições da sequência de comandos é conhecido antes mesmo do início do for.
A estrutura do comando é exibida a seguir:
for (< inicializaç~ao >; < expressao lógica >; ){
}
Inicialização é um comando de atribuição usado para colocar um valor na variável de controle
utilizada na expressão lógica. Assim como os demais comandos de repetição, a expressão lógica
representa a condição de parada das iterações. Incremento define como a variável de controle que será
modificada a cada iteração.
Um exemplo de como utilizar o comando for está listado no código do Exemplo 2.34. Esse programa
serve para imprimir os n primeiros termos de uma PG (progressão geométrica). O usuário deve
informar os valores do primeiro termo, da razão e da quantidade de termos a serem exibidos.
Pseudocódigo 2.15 Cálculo dos n primeiros termos de uma PG (progressão geométrica).
Descrição: Calcular os n primeiros termos de uma PG.
Dados de Entrada: Primeiro termo da PG, razão da PG e quantidade de termos da PG a serem impressos.
Saída do Programa: Termos da PG.
Funç~ao Principal :
Ler primeiro termo .
Ler raz~ao da PG.
Ler quantidade de termos .
ENQUANTO i menor que n FAÇA:
Apresentar termo .
Termo recebe termo multiplicado pela raz~ao.
FIM - ENQUANTO .
FIM - Funç~ao
Principal
1 # include
2
3 int main (){
DRAFT
4 float primeiroTermo , razao , n, i, termo ;
5
6 printf (" Informe o valor do primeiro termo da PG: \n");
7 scanf ("%f", & primeiroTermo );
8
9 printf (" Informe o valor da razao da PG: \n");
10 scanf ("%f", & razao );
11
12 printf (" Informe quantos termos devem ser impressos : \n");
13 scanf ("%f", &n);
14
15 termo = primeiroTermo ;
16
17 for (i = 0; i < n; i = i + 1) {
18 printf ("%f ", termo );
19 termo = termo * razao ;
20 }
21
22 return 0;
23 }

48
CAPÍTULO 2. CONCEITOS BÁSICOS
Exemplo 2.34: Programa para exibir os n primeiros termos de uma progressão geométrica utilizando o comando
de repetição for.
No Exemplo 2.34, as variáveis primeiroTermo, razao e n são inicializadas pelo usuário, usando o
comando de entrada de dados. A linha 15 trata da inicialização da variável termo, que guarda o valor
do termo da PG a ser impresso a cada repetição (iteração) do comando for.
O comando de repetição, em primeiro lugar, inicializa a variável de controle i com o valor zero.
Em seguida, ocorre a verificação da expressão lógica. Caso o usuário tenha digitado zero, o comando
não executa sua sequência de instruções nenhuma vez, pois tanto i quanto n armazenam zero e tornam
falso o resultado da expressão lógica. Nesse caso, nada é impresso na tela.
Mas se o usuário digitou um valor maior que zero, a sequência de comandos será repetida até que
a quantidade solicitada de termos seja impressa. Para isso, o comando de saída de dados é chamado
logo no início da sequência de comandos (linha 18). No caso em que i é igual a zero (primeira iteração),
o primeiro termo é exibido. A linha 19 conclui a sequência de comandos atualizando a variável termo
para guardar o próximo termo da sequência.
Um passo implícito é que o comando realiza o incremento da variável i no momento após a
execução da última instrução da sequência de comandos. Feita essa atualização, a condição de parada
é novamente verificada e, caso seja verdadeira, uma nova repetição é começada para imprimir outro
termo da PG.
A Tabela 2.11 mostra passo a passo a execução completa do comando de repetição para o programa
do Exemplo 2.34. Os valores informados são para uma PG de razão igual a 2, primeiro termo igual
a 2 e quantidade de termos a serem impressos igual a 4. As colunas mostram as variáveis principais
do comando de repetição (i, termo e n), o resultado da expressão lógica a cada iteração e o que foi
impresso na tela.
i termo n i < n Tela
0 4 4 Verdadeiro 2
1 8 4 Verdadeiro 2 4
2 16 4 Verdadeiro 2 4 8
3 32 4 Verdadeiro 2 4 8 16
4 32 4 Falso 2 4 8 16
Tabela 2.11: Detalhes da execução do comando for do Exemplo 2.34
.
O programa do Exemplo 2.35 realiza a operação de exponenciação de um número, utilizando o
comando de repetição for.
DRAFT
Pseudocódigo 2.16 Cálculo da exponenciação de um número n
Descrição: Calcular a exponenciação de um número n usando o comando for.
Dados de Entrada: Base e expoente.
Saída do Programa: Resultado da exponenciação.
Funç~ao Principal :
Ler base .
Ler expoente .
Inicializar i.
ENQUANTO i menor que expoente FAÇA:
AtualizaR resultado .
Incrementar i.
FIM - ENQUANTO .
FIM - Funç~ao
Principal

2.11. PROBLEMA DOS LOTES ENCAIXANTES 49
1 # include
2
3 int main (){
4 int base , expoente , resultado , i;
5
6 printf (" Informe os valores para base e expoente : \n");
7 scanf ("%d %d", &base , & expoente );
8
10
9 resultado = 1;
11 for (i = 0; i < expoente ; i = i + 1)
12 resultado = resultado * base ;
13
14 printf ("%d elevado a %d = %d\n", base , expoente , resultado )
15
16 return 0;
17 }
Exemplo 2.35: Programa para realizar a operação de exponenciação utilizando o comando de repetição for.
No Exemplo 2.35, os valores da base e do expoente são fornecidos pelo usuário via comando de
entrada de dados (linha 7). O valor 1 é atribuído a variável resultado, pois é o elemento neutro da
multiplicação. Caso fosse atribuído o valor zero repare que não iria funcionar. A variável de controle i
é inicializada com o valor zero dentro do comando for e, a cada iteração, é incrementada de 1. Quando
o valor de i atinge valor igual ao valor da variável expoente, as iterações são terminadas e o programa
segue para a linha 14, imprimindo os valores da base, do expoente e do resultado da exponenciação.
Assim como o comando while, o comando for efetua primeiramente o teste da condição de parada
antes de executar a sequência de comandos pela primeira vez.
2.11 Problema dos Lotes Encaixantes
Nesta seção será discutido o Problema dos Lotes Encaixantes. Este problema corresponde a situações
em que se precisa executar uma varredura em uma massa de dados e extrair dela algumas informações
estatísticas.
O termo lotes encaixantes refere-se ao fato de que, na maioria das vezes, problemas como esse
envolvem entidades complexas compostas por outras mais simples. As entidades mais simples se
encaixam para formar outras com um grau de complexidade ainda maior. Assim sendo, é possível
visualizar vários níveis que variam desde os mais simples e com muitos elementos até os mais complexos
e com algumas dezenas de integrantes.
A Figura 2.7 ajuda a explicar a ideia. Nela, os quadrados de bordas contínuas e finas representam o
nível mais simples. Eles se agrupam para formar os quadrados de bordas pontilhadas, que representam
um nível intermediário de complexidade. Juntos, os quadrados pontilhados compõem o nível mais
complexo, representado pelo grande quadrado de borda grossa. Na prática, podem existir não apenas
três, mas quantos níveis forem necessários para caracterizar os dados de um programa.
Considera-se, como exemplo, o problema de um professor que ministra uma disciplina para diversas
turmas. Nesse caso, é interessante saber qual turma obteve melhor aproveitamento, ou seja, qual turma
adquiriu a maior porcentagem de aprovações sobre o número total de alunos da turma. Também é
interessante obter o aluno que mais se destacou em cada turma e o que menos rendeu nos estudos, ou
seja, o que alcançou a maior média de suas notas na turma e o que obteve a menor média na turma.
Os dados, nesse caso, podem ser observados em quatro níveis: nível da disciplina, turma, alunos e
notas.
O nível de notas é o mais simples. Ele é indivisível e é caracterizado pelas notas dos trabalhos e
provas realizados no período letivo. O nível seguinte é o de alunos, nos quais são obtidas as médias das
notas de cada aluno. O terceiro agrupamento é o das turmas. Os alunos são reunidos de acordo com
as turmas a que pertencem. Por último, o nível mais complexo, é a própria disciplina. Ela é a entidade
mais abrangente, que é composta diretamente pelas turmas existentes no determinado semestre.
DRAFT

50
CAPÍTULO 2. CONCEITOS BÁSICOS
Figura 2.7: Uma representação gráfica para os lotes encaixantes
Problemas de lotes encaixantes, normalmente, são resolvidos por meio do emprego de comandos de
repetição aninhados. Quanto mais externo for o comando de repetição, maior o nível de complexidade
das entidades que estão sendo examinadas. Normalmente os lotes seguem o padrão apresentado na
seção 2.10.1 A Figura 2.8 exibe essa ideia, usando como exemplo o problema das notas escolares.
DRAFT
Figura 2.8: Comandos de repetição aninhados para resolver um problema de lotes encaixantes.
A Figura 2.8 será explicada passo a passo:
1. Primeiramente, é inicializado o processamento da disciplina.
2. Inicializa-se o processamento de uma turma da disciplina.
3. Começa o processamento de um aluno da turma.
4. Cada nota do aluno é lida e computada terminando o processamento deste aluno.
5. O item 3 é repetido para cada aluno, até que todos os alunos desta turma sejam considerados.
Assim finaliza-se o processamento de uma turma.
6. O item 2 é repetido até que todas as turmas em que foi ministrada a disciplina sejam consideras.
Assim finaliza-se o processamento da disciplina.

2.11. PROBLEMA DOS LOTES ENCAIXANTES 51
O Pseudocódigo 2.17 descreve um algoritmo para realizar um levantamento estatístico do desempenho
de alunos e turmas de uma disciplina hipotética em um determinado semestre.
Pseudocódigo 2.17 Problema dos Lotes Encaixantes aplicado às notas escolares
Descrição: Analisar as notas de uma disciplina escolar.
Dados de Entrada: Código da turma, matrículas dos alunos, notas dos alunos.
Saída do Programa: Média de cada aluno, matrículas dos alunos de melhor e de pior médias de cada turma,
código da turma com melhor rendimento.
Funç~ao Principal :
INICIO - PROCESSAMENTO DA DISCIPLINA .
Inicializar as variáveis usadas para determinar a turma de melhor
aproveitamento .
Ler a primeira turma .
ENQUANTO há turmas da disciplina FAÇA:
INICIO - PROCESSAMENTO DA TURMA
Inicializar as variáveis usadas para determinar o aluno de maior média , o
aluno de menor
média da turma e o aproveitamento da turma .
Ler a matrícula do primeiro aluno .
ENQUANTO há alunos na turma FAÇA:
INICIO - PROCESSAMENTO DO ALUNO
Inicializar as variáveis usadas para determinar a média do aluno .
Ler a primeira nota .
ENQUANTO há notas do aluno FAÇA:
Atualizar as variáveis usadas para determinar a média do aluno .
Ler a próxima nota .
FIM - ENQUANTO
Calcular média do aluno .
Apresentaç~ao da média do aluno .
FIM - PROCESSAMENTO DO ALUNO
DRAFT
Atualizaç~ao de variáveis usadas para determinar o aproveitamento da
turma e
os alunos de menor e maior média da turma .
Ler próximo aluno .
FIM - ENQUANTO
Apresentar os alunos de menor e maior média da turma .
FIM - PROCESSAMENTO DA TURMA
Atualizar as variáveis usadas para determinar a turma de melhor
aproveitamento .
Ler próxima turma
FIM - ENQUANTO
Apresentar a turma de melhor aproveitamento
FIM - PROCESSAMENTO DA DISCIPLINA
FIM - Funç~ao Principal
O Exemplo 2.36 ilustra o código para um programa que lê os dados das notas dos alunos e exibe
a média de cada um. Para cada turma, será exibida a melhor e a pior média. Ao final, exibe a turma
com maior percentual de aprovações da disciplina.
1 # include
2 # define MEDIAMINIMA 7.0
3
4 int main (){

52
CAPÍTULO 2. CONCEITOS BÁSICOS
5 int codTurma , matricula , numNotasAluno , numAlunosTurma , alunoMaiorMedia ,
alunoMenorMedia , melhorTurma ;
6 float nota , mediaAluno , numAprovadosTurma , somaNotasAluno , maiorMediaTurma ,
menorMediaTurma , aproveitamentoTurma , melhorAproveitamento ;
7
8 melhorAproveitamento = -1;
9
10 printf (" Informe o codigo da turma : ");
11 scanf ("%d", & codTurma );
12
13 while ( codTurma != -1){
14 maiorMediaTurma = -1;
15 menorMediaTurma = 11;
16 numAprovadosTurma = 0;
17 numAlunosTurma = 0;
18
19 printf (" Informe o numero de matricula do aluno : ");
20 scanf ("%d", & matricula );
21
22 while ( matricula != -1){
23 numNotasAluno = 0;
24 somaNotasAluno = 0;
25 numAlunosTurma = numAlunosTurma + 1;
26
27 printf (" Informe a nota do aluno : ");
28 scanf ("%f", & nota );
29
30 while ( nota != -1){
31 somaNotasAluno = somaNotasAluno + nota ;
32 numNotasAluno = numNotasAluno + 1;
33 printf (" Informe a nota do aluno ou ’-1’ para encerrar : ");
34 scanf ("%f", & nota );
35 }
36
37 if ( numNotasAluno != 0){
38 mediaAluno = somaNotasAluno / numNotasAluno ;
39
40 if ( mediaAluno >= MEDIAMINIMA ){
41 numAprovadosTurma = numAprovadosTurma + 1;
42 }
43
44 if ( mediaAluno >= maiorMediaTurma ) {
45 maiorMediaTurma = mediaAluno ;
46 alunoMaiorMedia = matricula ;
47 }
48
49 if ( mediaAluno

2.11. PROBLEMA DOS LOTES ENCAIXANTES 53
67
68 printf ("O aluno %d obteve a melhor media (%f) da turma %d\n",
alunoMaiorMedia , maiorMediaTurma , codTurma );
69 printf ("O aluno %d obteve a pior media (%f) da turma %d\n",
alunoMenorMedia , menorMediaTurma , codTurma );
70 printf (" Informe o codigo da turma ou ’-1’ para encerrar : ");
71 scanf ("%d", & codTurma );
72 }
73
74 if ( melhorAproveitamento != -1){
75 printf ("A turma %d obteve o melhor aproveitamento (%f %%) ", melhorTurma ,
melhorAproveitamento );
76 }
77 }
78 return 0;
79 }
Exemplo 2.36: Problema dos lotes encaixantes aplicado a notas de uma disciplina
Fazendo uma comparação com a Figura 2.8 e com o Pseudocódigo 2.17, não fica complicado
entender o funcionamento do código do Exemplo 2.36. Após a declaração das variáveis, o programa
inicializa a variável melhorAproveitamento (linha 8), que armazenará o percentual de aprovações da
turma de melhor aproveitamento. O valor ajustado é menor (−1) que o menor valor possível (zero) e
sua escolha será justificada adiante. Em seguida, o programa solicita ao usuário que digite um código
para identificar a primeira turma que será analisada (linhas 10 e 11).
O primeiro comando de repetição, na linha 13, serve para percorrer todas as turmas, uma a uma.
Sempre que sua expressão lógica resultar verdadeiro, é sinal que uma nova turma terá seus dados
digitados.
Aqui vale destacar um artifício útil que é empregado nesse código. Todos os comandos de repetição
fazem a verificação de suas variáveis de controle comparando-as com o mesmo valor −1. Ocorre que,
para evitar que o usuário seja obrigado a saber, a priori, da quantidade de elementos de um conjunto
de dados que será passado ao programa, utiliza-se um valor absurdo (qualquer valor que não pertença
ao conjunto em questão) para servir de sinalização para o programa de que o conjunto de dados foi
inteiramente percorrido. Esse valor é, comumente, chamado de flag.
No Exemplo 2.36, considera-se que os códigos das turmas e das matrículas são inteiros positivos e
que as notas são valores racionais não negativos. Assim sendo, o valor −1 foi utilizado para indicar
ao programa quando todas as notas de um aluno já foram digitadas. Ou que todos os dados dos
alunos de uma determinada turma foram digitados. Ou ainda, que todas as turmas tiveram seus
dados informados.
A sequência de comandos começa, então, com a inicialização das variáveis da turma em questão
(linhas 14 a 17). As variáveis maiorMediaTurma e menorMediaTurma guardam, respectivamente, a
melhor e a pior média obtidas na turma. Já numAprovadosTurma e numAlunosTurma armazenam,
respectivamente, a quantidade de alunos aprovados na turma e a quantidade total de alunos da turma.
Os valores dessas duas variáveis servem para calcular o aproveitamento da turma.
Nas linhas 19 e 20, o programa solicita ao usuário que informe a matrícula do primeiro aluno da
turma que terá suas notas lidas. Na linha seguinte aparece o segundo comando de repetição, o qual
interage com os dados dos alunos de uma turma.
Assim como no comando de repetição mais externo, o comando da linha 22 inicia sua sequência
de comandos realizando a inicialização das variáveis pertinentes. As variáveis numNotasAluno e
somaNotasAluno servem para calcular a média aritmética simples das notas do aluno em questão
armazenando, respectivamente, a quantidade de notas do aluno e a soma delas. Na linha 25, a
variável numAlunosTurma é incrementada, indicando a adição dos dados de mais um aluno.
As linhas 27 e 28 requerem ao usuário que ele digite o valor da primeira nota do aluno em questão.
Em seguida, o programa executa o comando de repetição mais interno, que serve para registrar todas
as notas de um determinado aluno.
Esse comando coleta os dados das notas, solicitando ao usuário que digite o valor da nota (linhas
31 e 32) e atualizando os valores das variáveis que calculam a média do aluno no semestre.
DRAFT

54
CAPÍTULO 2. CONCEITOS BÁSICOS
Encerrada a digitação das notas, o usuário deve digitar −1 para encerrar e, quando o faz, o
programa passa para a rotina de cálculo da média (linha 37).
Com o valor da média, algumas verificações são feitas para atualizar as estatísticas da turma em
questão. Em primeiro lugar, é verificado se a média alcançada pelo aluno é suficiente para aprovação.
Em caso afirmativo, a variável numAprovadosTurma é incrementada.
É verificado, em seguida (linha 44), se a média do aluno é maior que a maior média encontrada
até então. Em caso verdadeiro, a variável maiorMediaTurma é atualizada, assim como a variável
alunoMaiorMediaTurma, que guardará a matrícula desse aluno.
O comando de seleção da linha 49 é equivalente ao da linha 40. Desta vez, a intenção é atualizar
os dados do aluno com pior rendimento.
Vale um comentário sobre os valores de inicialização das variáveis maiorMediaTurma e menorMediaTurma.
É preciso ter em mente que, para a primeira verificação de melhor e pior aluno de cada
turma, os respectivos comandos de seleção devem comparar o valor da média calculada com os valores
já armazenados. O problema é que, para o primeiro aluno de cada turma, essas variáveis ainda não
contém valores válidos. Sendo assim, para evitar erros, a variável maiorMediaTurma é inicializada
com um valor menor que o menor valor nominal possível para a média e a variável menorMediaTurma,
ao contrário, é inicializada com o um valor maior que o maior valor possível. Essa inicialização garante
que os dados do primeiro aluno serão corretamente assimilados como o melhor e o pior resultado
encontrado. Essa condição é correta no início, pois os dados do primeiro aluno são os únicos passados
ao sistema até então.
O comando da linha 54 imprime os dados do aluno, informando sua matrícula e a média alcançada.
Em seguida o usuário deve informar o código da matrícula do próximo aluno ou encerrar o cadastro
dos dados da turma em análise, digitando −1.
Caso tenha encerrado as digitações de uma turma, o programa executa o cálculo do respectivo
aproveitamento (linha 60).
Feito isso, um comando de seleção verifica se o aproveitamento calculado é melhor que o melhor já
encontrado. Em caso afirmativo, as variáveis melhorAproveitamento e melhorTurma são atualizadas
para apontar para a turma recém analisada (linhas 64 e 65, respectivamente).
Terminando a sequência de instruções do segundo comando de repetição, os dados do melhor e do
pior aluno da turma são exibidos (linhas 68 e 69). Por último, é perguntado ao usuário se ele deseja
incluir os dados de uma outra turma, bastando, para isso, digitar seu código. Se digitar a flag −1,
o comando de repetição é encerrado e o programa exibirá, em sua última linha, os dados da melhor
turma (linha 74).
2.12 Exercícios Resolvidos
DRAFT
Exercício Resolvido 2.1 - Raízes reais de uma equação do segundo grau
Faça um programa que calcule as raízes reais da equação do segundo grau ax 2 + bx + c.
Solução Possível:
Para solucionar este problema usaremos a Fórmula de Báskara. Esta descrita por: raizes = − b±√ δ
2a .
O discriminante δ é obtido por δ = b 2 − 4ac. No Pseudocódigo 2.18 está detalhado o algoritmo.

2.12.
EXERCÍCIOS RESOLVIDOS 55
Pseudocódigo 2.18 Cálculo das raízes da equação do segundo grau ax 2 + bx + c.
Descrição: Calcular as raízes de uma equação do segundo grau ax 2 + bx + c.
Dados de Entrada: Coeficientes a, b e c.
Saída do Programa: Raízes da equação.
Funç~ao Principal :
Ler os coeficientes discriminante .
Calcular o discriminante .
SE o discriminante for maior ou igual a zero :
SE delta for igual a zero :
Calcular a única raiz .
Apresentar o valor da raiz .
SEN~AO
Calcular a primeira raiz .
Calcular a segunda raiz .
Apresentar os valores das raízes .
FIM -SE
SEN~AO
Apresentar uma mensagem dizendo que n~ao há raízes reais .
FIM -SE
FIM - Funç~ao Principal
No Exemplo 2.37 está exemplificado o Pseudocódigo 2.18 .
1 # include
2 int main (){
3 float a, b, c, delta , raizDelta , raiz1 , raiz2 ;
4
5 printf (" Informe os valores das constantes ’a ’, ’b’ e ’c’ ( separados por espacos ):
");
6 scanf ("%f %f %f", &a, &b, &c);
7
8 delta = b * b - 4 * a * c;
9
10 if ( delta >= 0){
11 if ( delta == 0){
12 raiz1 = -b / (2 * a);
13 printf ("As duas raizes sao iguais a: %f.\n", raiz1 );
14 } else {
15 raizDelta = sqrt ( delta );
16 raiz1 = (-b + raizDelta ) / (2 * a);
17 raiz2 = (-b - raizDelta ) / (2 * a);
18 printf ("As duas raizes sao : %f e %f.\n", raiz1 , raiz2 );
19 }
20 } else {
DRAFT
21 printf (" Nao existem raizes reais desta equacao !\n");
22 }
23
24 return 0;
25 }
Exemplo 2.37: Programa para calcular as raízes reais de uma equação do segundo grau.
Exercício Resolvido 2.2 - Cálculo dos n primeiros termos de Fibonacci
Escreva um programa que escreva os n primeiros termos da sequência de Fibonacci. Essa sequência
tem zero como primeiro termo e 1 como segundo. Do terceiro termo em diante, a fórmula para obtenção
é a soma dos dois anteriores.
Solução Possível:
A lei de formação está descrita no enunciado. Sendo assim, defina dois termos iniciais em 0 e 1 e
calcule o terceiro termo a partir destes dois termos. Em seguida, repita o processo para achar o quarto

56
CAPÍTULO 2. CONCEITOS BÁSICOS
termo a partir do terceiro e segundo termo. Observe que é um laço e constantemente os termos estão
sendo atualizados. Uma forma de implementar está detalhada no Pseudocódigo 2.19.
Pseudocódigo 2.19 Cálculo dos n primeiros termos da sequencia de Fibonacci.
Descrição: Calcular os n primeiros termos da sequência de Fibonacci.
Dados de Entrada: Valor inteiro n.
Saída do Programa: Exibir os n termos.
Funç~ao Principal :
Ler o número n.
Inicializar termo com valor zero .
Inicializar novo com valor um.
ENQUANTO i for menor que n FAÇA:
Exibir valor de termo .
Anterior recebe o valor de termo .
Termo recebe o valor de novo .
Novo recebe o valor de novo somado com anterior .
Incrementar i.
FIM - ENQUANTO
FIM - Funç~ao Principal
Segue no Exemplo 2.38 a implementação em C do Pseudocódigo 2.19.
1 int main (){
2 int n, termo , novo , anterior , i;
3
4 printf (" Informe o numero de termos a serem impressos : ");
5 scanf ("%d", &n);
6
7 termo = 0;
8 novo = 1;
9
10 for (i = 0; i < n; i = i + 1) {
11 printf ("%d ", termo );
12 anterior = termo ;
13 termo = novo ;
14 novo = novo + anterior ;
15 }
16
17 return 0;
18 }
DRAFT
Exemplo 2.38: Programa para calcular os n primeiros termos da sequência de Fibonacci
Exercício Resolvido 2.3 - Tabuada de 1 a 9
Fazer um programa para imprimir a tabuada de 1 a 9.
Solução Possível:
A resolução deste exercício é simples. Observe que cada número de 1 a 9 é multiplicado por outro
número que também pode ser de 1 a 9. Uma possível solução são laços aninhados, onde um número
é fixo e o outro varia de acordo com a variável de controle do laço. Segue no Pseudocódigo 2.20 uma
possível solução.

2.12.
EXERCÍCIOS RESOLVIDOS 57
Pseudocódigo 2.20 Cálculo da tubuada.
Descrição: Calcular a tabuada de 1 a 9.
Dados de Entrada: Não possui entrada.
Saída do Programa: Apresentar a tabuada de 1 a 9.
Funç~ao Principal :
Inicializar n1 com 1.
Inicializar n2 com 1.
ENQUANTO n1 for menor que 10 FAÇA:
ENQUANTO n2 for menor que 10 FAÇA:
Exibir o valor da multiplicaç~ao entre n1 e n2.
FIM - ENQUANTO
FIM - ENQUANTO
FIM - Funç~ao Principal
1 int main (){
2 int n1 , n2 , r;
3
4 printf ("\ nTABUADA de 1 a 9\n\n");
5
6 for (n1 = 1; n1 < 10;) {
7 for (n2 = 1; n2 < 10) {
8 r = n1 * n2;
9 printf ("%d * %d = %d\n", n2 , n1 , r);
10 }
11 printf ("\n");
12 }
13
14 return 0;
15 }
Exemplo 2.39: Programa para exibir a tabuada de 1 a 9.
Exercício Resolvido 2.4 - Cálcular MDC entre dois números
DRAFT
Calcular o Maximo Divisor Comum (MDC) de dois números.
Solução Possível: O MDC de dois números pode ser obtido escolhendo o maior deles e subtraindolhe
o valor do menor. Esta operação é repetida até que os dois sejam iguais, cujo valor será o MDC
dos números iniciais:
33 15 45 18
18 15 27 18
03 15 09 18
03 12 09 09
03 09 MDC = 09
03 06
03 03
MDC = 03

58
CAPÍTULO 2. CONCEITOS BÁSICOS
Pseudocódigo 2.21 Cálculo do M.D.C. entre dois números.
Descrição: Calcular o M.D.C. entre dois números.
Dados de Entrada: Números inteiros n1 e n2.
Saída do Programa: Apresentar o valor do M.D.C. entre n1 e n2.
Funç~ao Principal :
Ler o número n1.
Ler o número n2.
Auxiliar1 recebe o valor de n1.
Auxiliar2 recebe o valor de n2.
ENQUANTO Auxiliar1 for diferente de Auxiliar2 FAÇA:
SE Auxiliar1 for maior que Auxiliar2 :
Auxiliar1 recebe Auxiliar1 s u b t r a d o de Auxiliar2 .
S E N O
Auxiliar2 recebe Auxiliar2 s u b t r a d o de Auxiliar1 .
FIM -SE
FIM - ENQUANTO
M.D.C. recebe o valor de Auxiliar1 .
Exibir o valor de M.D.C.
FIM - Funç~ao Principal
1 int main (){
2 int numero1 , numero2 , auxiliar1 , auxiliar2 ;
3
4 printf (" Digite dois numeros para calcular seu MDC : ");
5 scanf ("%d %d", & numero1 , & numero2 );
6
7 auxiliar1 = numero1 ;
8 auxiliar2 = numero2 ;
9
10 while ( auxiliar1 != auxiliar2 ) {
11 if ( auxiliar1 > auxiliar2 )
12 auxiliar1 = auxiliar1 - auxiliar2 ;
13 } else {
14 auxiliar2 = auxiliar2 - auxiliar1 ;
15 }
16 }
17
18 printf ("O MDC vale %d\n", auxiliar1 );
19
20 return 0;
21 }
DRAFT
Exemplo 2.40: Programa para exibir o MDC de dois números.
Exercício Resolvido 2.5 - Conversão de base binária para decimal
Faça um programa que converta um valor em base binária para base decimal.
Solução Possível:
Para solucionar este problema deve-se pensar na estrutura de um número binário. Por exemplo,
o número 111 equivale a 7 na base dez. Pois, 2 2 + 2 1 + 2 0 = 7. Assim como, 1111 equivale a 15
pois 2 3 + 2 2 + 2 1 + 2 0 = 15. Com base nesses exemplos e observando padrões, podemos estabeler o
Pseudocódigo 2.22.

2.13. RESUMO 59
Pseudocódigo 2.22 Conversão de um valor de base binária para base decimal.
Descrição: Converter um valor de base binária para base decimal.
Dados de Entrada: Número em binário.
Saída do Programa: Exibir o valor de entrada em base decimal.
Funç~ao Principal :
Ler o número n em base binária ;
Inicializar Decimal com valor zero ;
Inicializar Auxiliar2 com valor 1;
Auxiliar1 recebe o valor de n;
ENQUANTO Auxiliar1 for maior que zero FAÇA:
Auxiliar3 recebe o resto da divis~ao de Auxiliar1 por 10;
Decimal recebe Decimal somado com Auxiliar2 vezes Auxiliar3 ;
Auxiliar2 recebe o dobro de Auxiliar2 ;
Auxiliar1 recebe o quociente da divis~ao de Auxiliar1 por 10;
FIM - ENQUANTO
Apresentar o valor de Decimal ;
FIM - Funç~ao Principal
1 int main (){
2 int binario , aux1 , aux2 , aux3 , decimal ;
3
4 printf (" Digite um valor em base binaria : ");
5 scanf ("%d", & binario );
6
7 aux1 = binario ;
8 aux2 = 1;
9 decimal = 0;
10
11 while ( aux1 > 0) {
12 aux3 = aux1 % 10;
13 decimal = decimal + aux3 * aux2 ;
14 aux2 = aux2 * 2;
15 aux1 = aux1 / 10;
16 }
17
18 printf ("O valor %d em base binaria equivale a %d em base decimal \n", binario ,
decimal );
19
20 return 0;
21 }
2.13 Resumo
ˆ
DRAFT
Exemplo 2.41: Programa para converter números de binário para decimal.
O computador guarda as informações dos programas na memória. A memória pode ser entendida
como uma sequência de células, cada uma identificada por um número conhecido como endereço
de memória. Nas linguagens de programação, as variáveis permitem o acesso às células de
memória sem a necessidade de manipular seus endereços diretamente.
ˆ
Na linguagem C, para a declaração de uma variável, o programador deve informar qual o tipo
de dados que ela irá manipular.
ˆ
O comando de atribuição permite atribuir uma determinada informação (ou valor) a uma variável
do programa.

60
CAPÍTULO 2. CONCEITOS BÁSICOS
ˆ
ˆ
Os identificadores são nomes que identificam uma variável ou constante. Eles são formados por
caracteres alfanuméricos, sendo que o primeiro deve ser obrigatoriamente alfabético.
Na programação, os quatro tipos de dados mais comuns são: tipo inteiro, tipo ponto flutuante,
tipo booleano e tipo caractere.
ˆ
ˆ
ˆ
ˆ
Variáveis e constantes podem ser combinadas com operadores para formarem expressões. No
comando de atribuição, o valor da expressão (termos à direita do comando) é atribuído à variável
(à esquerda do comando).
Os principais tipos de expressões são aritmética, relacional e lógica.
Na maioria dos problemas de computação, os comandos de entrada de dados, saída de dados,
seleção e repetição, são imprescindíveis.
Diversos problemas computacionais encaixam-se na modelagem do Problema dos Lotes Encaixantes.
Essa classe de problemas é facilmente resolvida com o aninhamento de comandos de
repetição, os quais destinam-se a examinar um nível específico da massa de dados.
2.14 Exercícios Propostos
1. Faça um programa, em C, que converta valores de temperatura de Fahrenheit para Celsius. A
proporção utilizada é:
T emperatura Celsius
= (T emperatura F ahrenheit − 32)
5
9
2. Faça um programa que calcule e escreva uma tabela de graus centígrados em função de graus
farenheit que variam de 0 a 150 de 1 em 1.
3. Faça um programa que calcule a soma
4. Faça um programa que calcule a soma
S = 1 1 + 3 2 + 5 3 + . . . + 99
50
37 × 38 36 × 37 35 × 36
S = − + − . . . + 1 × 2
1 2 3
37
5. Faça um programa para ler uma seqüência de n números inteiros positivos (um por vez), e
verificar se eles são pares ou ímpares.
DRAFT
6. Suponha que a população de um país A seja de 9.000 habitantes com uma taxa anual de crescimento
de 3% e que a população de um país B seja, aproximadamente, de 20.000 de habitantes
com uma taxa anual de crescimento de 1,5%, fazer um programa que calcule e escreva o número
de anos necessários para que a população de país A ultrapasse ou se iguale à população do país
B, mantidas estas taxas de crescimento.
7. Uma certa firma fez uma pesquisa de mercado para saber se as pessoas gostaram ou não de um
novo produto lançado no mercado. Para isso, obteve, para cada pessoa entrevistada, informações
a respeito do sexo do entrevistado e sua resposta (S = Sim ou N = Não). Sabe-se que foram
entrevistados 2000 pessoas, fazer um programa que calcule e escreva:
ˆ
ˆ
ˆ
ˆ
O número de pessoas que responderam sim
O número de pessoas que responderam não
A porcentagem de pessoas do sexo feminino que responderam sim
A porcentagem de pessoas do sexo masculino que responderam não

2.14.
EXERCÍCIOS PROPOSTOS 61
8. Refazer o Exemplo 2.38 sem utilizar a variável anterior.
9. Faça um programa em C que verifique se o número 26 é o único no intervalo entre 2 e 999999
que se encontra entre um quadrado (52=25) e um cubo (33=27). Dica: para verificar isso basta
elevar ao cubo todo número no intervalo entre 2 e 100 e mostrar que não existe número elevado
ao quadrado cuja diferença para o cubo seja igual a dois, além obviamente do número 26.
10. O gerente de uma agência bancária te contratou para fazer um programa em C para extrair
algumas informações das contas dos correntistas de sua agência. Para tanto o gerente te forneceu
uma listagem contendo, em cada linha, os dados do número da conta (um valor inteiro) e valor
da operação (um valor ponto flutuante positivo para as operações de crédito e negativo para as
operações de débito) realizadas no último mês. Seu programa deve usar os dados da listagem
para informar:
(a) As operações suspeitas, isto é, aquelas que movimentaram acima de 20.000 reais.
(b) O saldo das operações realizadas em cada conta.
(c) Os dois correntistas que produziram o maior saldo nas suas operações.
(d) O saldo total das operações na agência. Considere que os dados de cada conta são fornecidos
contiguamente, isto é, são fornecidos todos os dados das operações de uma conta, depois
todos os dados de outra conta e assim sucessivamente. O processamento deve ser encerrado
quando for lido um número de conta igual a zero. Um exemplo de listagem é apresentado
a seguir:
Número de conta Valor de Operaç~ao
1 123,02
1 -22,54
2 1000,01
3 22222,22
... ...
0 0.00
11. O comitê organizador dos jogos pan-americanos de 2007, no Rio de Janeiro, deseja apresentar os
resultados da competição indicando o total de medalhas de ouro, prata e bronze de cada país,
bem como o país vencedor dos jogos e o país vencedor das competições da modalidade natação.
Faça um programa em C para apresentar esses resultados.. Os dados a serem inseridos no
programa devem ser organizados por código de país e de competição, tal como no
exemplo seguinte:
DRAFT
123
55123 100
3412 011
176665 001
0
222
54321 002
557 010
0
0
Considere que as competições de natação sempre se iniciam com 55. Note, porém, que o número
de dígitos do código das competições não é fixo, como pode ser observado no exemplo utilizado
(observe que tanto a competição 55123 quanto a 557 são de natação). Considere ainda que a

62
CAPÍTULO 2. CONCEITOS BÁSICOS
classificação dos países é feita primeiramente pelo critério total de medalhas de ouro, depois
pelo critério total de medalhas de prata e, por fim, pelo critério total de medalhas de bronze.
Desconsidere a hipótese de haver empate nos três critérios: total de medalhas de ouro, prata e
bronze.
12. Um banco do país deseja conhecer os dados dos maiores correntistas (aqueles com maior quantidade
total de recursos aplicados) em cada uma de suas agências e também os dados dos três
maiores correntistas do banco. Para isso, o banco possui uma lista com o número da conta, o
saldo em conta corrente, o saldo em fundos e o saldo em poupança de todos os correntistas de
cada agência do banco. Faça um programa em C para apresentar esses resultados. Crie um tipo
abstrato de dados Correntista que armazene os dados de um correntista (agência, conta, saldo
em conta, saldo em fundos, saldo em poupança) e implemente as operações de leitura de dados de
um correntista, apresentação dos dados de um correntista, cálculo de total de recursos aplicados
(isto é, a soma dos saldos em conta, em fundos e em poupança). Utilize o tipo Correntista na
implementação do programa. Os dados a serem inseridos no programa devem ser lidos seguindo
uma ordem equivalente ao do exemplo seguinte. Desconsidere a hipótese de haver correntistas
com o mesmo total de recursos aplicados no banco.
123
55123 125.00 2500.00 300.00
43145 100.00 750.00 3000.00
17666 10.00 9000.00 5000.00
0
222
54321 900.00 0.00 3000.00
55711 35.00 95000.00 0.00
0
0
2.15 Trabalhos Sugeridos
1. Registro de Médias Finais no Sistema Acadêmico
DRAFT
Ao final de cada período letivo em uma universidade, o colegiado de Ciência da Computação
necessita atualizar o sistema acadêmico com a lista das médias finais obtidas pelos alunos em
todas as disciplinas ofertadas naquele período. Considere que a média mínima de aprovação é 5.0
(cinco). Os dados a serem inseridos no sistema devem ser organizados por código de disciplina e
de turma. Assim, para cada disciplina existem várias turmas. A lista de médias finais deve ser
inserida para cada turma.
Exemplo:
2628
1
10.0 9.6 4.5 7.8 8.9 5.0 9.0 6.4 3.7 8.8 -1
2
0.2 3.4 5.6 2.7 8.9 4.5 9.0 8.0 3.0 4.5 6.5 4.5 6.8 9.5 -1
3
2.7 8.9 4.5 9.0 10.0 9.6 4.5 7.0 -1
-1
2777
1
4.0 7.8 5.6 3.6 8.9 0.9 1.2 6.9 5.6 10.0 9.0 -1
2

2.15. TRABALHOS SUGERIDOS 63
8.6 7.8 8.9 5.0 3.4 5.6 -1
-1
3445
1
8.9 5.0 3.4 9.0 10.0 9.6 4.5 7.0 1.2 6.9 2.7 8.9 4.5 -1
-1
-1
Desta forma, o formato de entrada dos dados deve ser o seguinte:
Códigos e flags são números inteiros. Notas são números em ponto flutuante. Não se sabe a priori
o número de disciplinas, o número de turmas por disciplina e o número de alunos por turma.
Para tanto é preciso utilizar o recurso de flags. Consideramos um flag como uma constante
cujo valor é diferente dos valores fornecidos como entrada e que serve como um delimitador de
interrupção de um laço de repetição. No exemplo dado, o valor do flag utilizado é −1.
Seu programa deve ler iterativamente cada linha da entrada (obedecendo ao formato descrito
acima) e gerar as seguintes informações:
(a) O índice de reprovação de cada turma (em percentual). Além do índice de reprovação, deve
ser apresentado o código da turma e o código da disciplina.
(b) De cada disciplina, a turma que obteve o menor rendimento, ou seja, menor média das
médias finais. Desconsidere a situação de empate. Apresentar o código da disciplina, da
turma e o valor do seu rendimento.
(c) As três disciplinas mais difíceis do curso, ou seja, as três disciplinas com maior índice
de reprovação. Em caso de empate no índice de reprovação, considerar como segundo
critério o rendimento (isto é, considerar como mais difícil a disciplina de menor rendimento).
Desconsidere a situação de empate no segundo critério (menor rendimento). Apresente cada
disciplina em ordem decrescente (da mais difícil para a menos difícil). Para cada disciplina
difícil é preciso mostrar o seu código, seu índice de reprovação e seu rendimento.
(d) A melhor nota relativa de todo o curso. A nota relativa é obtida através da divisão da nota
pela média da turma. Além da nota relativa deve ser apresentada a nota absoluta, o código
da turma e o código da disciplina nas quais essa nota ocorreu.
DRAFT

Capítulo 3
Modularização
Objetivos:
ˆ
ˆ
ˆ
ˆ
Definir o que é modularização;
Apresentar as vantagens de um programa modularizado;
Apresentar métodos de como criar e adaptar programas modularizados;
Introduzir o conceito de recursividade e como usá-la;
Coautores:
Gilberto Segundo
Ramon Schiavo
Thaylo de Freitas
Os programas são escritos a fim de resolverem vários tipos de problemas. Alguns desses problemas
exigem mais tempo e maiores esforços do programador. Por isso, é indispensável que o programador
utilize técnicas que visam uma maior organização e consequente entendimento facilitado do programa.
Uma das técnicas mais utilizadas é a modularização.
Este capítulo trata do conceito de modularização e da prática de construir programas modularizados.
3.1 Resolvendo por Partes
Quando se trabalha em qualquer problema complexo, seja em programação, seja em outra área, o ser
humano sente a necessidade de dividir esse problema maior em problemas menores. Cada problema
menor é então trabalhado de forma a solucionar as questões que lhe cabem e, juntando-se cada uma
dessas soluções, tem-se a solução do problema maior. Esse processo é chamado de modularização e
baseia-se na conhecida técnica de “dividir para conquistar”e é o fundamento de modularização.
Pode-se aplicar a modularização em diversas áreas na vida cotidiana. Para a fabricação de um
automóvel, por exemplo, são necessários diversos serviços: funilaria, montagem, estofamento, pintura,
soldagem, etc. A princípio, poderia existir apenas um robô que fizesse todas as etapas da fabricação do
carro, mas isso acarretaria em alguns problemas, tais como: complexidade do robô, que deveria fazer
todos os serviços de forma completa e eficiente; alto prejuízo em eventuais serviços de manutenção,
pois teria que parar todo o processo de montagem. Uma ótima alternativa para esse problema é
fazer vários robôs, cada um com sua função específica. O que se estaria fazendo na verdade é uma
modularização.
Pode-se facilmente transladar a ideia contida no problema apresentado para a elaboração de um
programa. O programa pode ser dividido em várias partes, sendo que cada parte trata de uma
determinada funcionalidade.
Dessa forma, o programa tem a sua legibilidade melhorada, uma vez que fica mais fácil entender o
que o programa faz por completo ou como o programa faz determinada subtarefa. A modificabilidade
DRAFT
64

3.2. SUBPROGRAMAS 65
do programa também é melhorada, uma vez que, ao alterar determinada funcionalidade, é necessário
apenas mudar uma pequena parte do código, não sendo necessário modificá-lo em vários pontos.
Com as funcionalidades do programa separadas logicamente, o programador tem a oportunidade
de reutilizar uma parte do programa para escrever um outro programa que utilize, em uma de suas
tarefas, o mesmo bloco de instruções. A confiabilidade do programa também é aumentada pelo fato
dele ser mais fácil de ser entendido e corrigido.
Por fim, a produtividade para a elaboração de um programa também é aumentada, uma vez que
cada parte do programa pode ser trabalhada por uma equipe diferente, além de que cada equipe só
precisa saber o que as partes da outra equipe fazem e não como fazem.
Nas seções seguintes serão mostradas técnicas de como fazer um programa modularizado utilizando
a linguagem C.
3.2 Subprogramas
Um subprograma é um trecho de um programa que realiza uma operação computacional. Ele efetua
parte de uma tarefa que um algoritmo maior deveria executar, ou seja, ele é uma parte do programa,
especializado em alguma funcionalidade. Subprogramas são uma das principais formas de modularização.
Na linguagem C subprogramas existem na forma de função.
Uma função matemática f(x) é uma relação que mapeia um dado valor x de um domínio em um
único valor y de um conjunto imagem. Em programação, a ideia é semelhante: uma função é um
conjunto de instruções que recebe alguns valores como dados de entrada e, a partir deles, produz um
valor como saída. A Figura 3.1 ilustra o funcionamento de uma função matemática simples, a função
y = x 2 , para x e y pertencentes aos naturais.
Figura 3.1: Função matemática y = x 2
DRAFT
Em programação, os dados de entrada são chamados de parâmetros e o valor da saída é chamado
de retorno. Durante a execução da função, os dados de entrada são manipulados de maneira a produzir
o resultado esperado. Durante essa manipulação de dados a função pode chamar outras funções, que
contêm rotinas que auxiliam na elaboração do resultado final. A Figura 3.2 ilustra esse processo.
Figura 3.2: Função usando outras funções.

66
CAPÍTULO 3. MODULARIZAÇÃO
Na fabricação de um automóvel, algum processo realizado por um determinado robô pode solicitar
serviços de outros robôs. Por exemplo, o robô que faz a colocação das peças no carro pode solicitar
por diversas vezes o serviço do robô de soldagem de peças. Após a finalização da soldagem da peça,
o robô de montagem poderá colocar outra peça no carro.
3.3 Partes de um Subprograma
As partes de um subprograma são as mesmas de um programa, ou seja: cabeçalho, dicionário de
dados, corpo e comentário. O Exemplo 3.1 mostra um subprograma em C com todas essas partes,
que serão comentadas a seguir, enfocando sua importância nos subprogramas.
1 float calculaMedia ( float a, float b);
3.3.1 Cabeçalho
Exemplo 3.1: Cabeçalho de um subprograma na linguagem C.
O cabeçalho do subprograma é onde estão definidos o nome do subprograma, os tipos dos seus
parâmetros de entrada e o tipo de dado de retorno.
Os parâmetros da função são os ingredientes que ela precisa para executar as suas instruções e
seus tipos devem ser respeitados. O tipo dos parâmetros informam qual o tipo de ingrediente que
precisa ser fornecido para o subprograma realizar sua tarefa. O tipo de retorno da função simboliza
o tipo de produto gerado por ela. Se a função diz retornar um número float, quer dizer que o
programador deve esperar receber apenas esse tipo de dado e tomar as medidas necessárias para
manipulá-lo posteriormente.
O nome do subprograma serve para identificá-lo. O programador deve escolher nomes autoexplicativos
sobre a funcionalidade da função, ou seja, nomes que indiquem para que ela serve. Isso torna
o código mais legível e menos susceptível a erros por parte do programador.
O Exemplo 3.1, mostra o cabeçalho da calculaMedia. Ela possui dois parâmetros de entrada
do tipo float e retorna um valor também do tipo float. O primeiro parâmetro recebe o nome a e o
segundo recebe o nome b. A função retorna um dado do tipo float, ou seja, retornará um número
que contém casas decimais. Mais detalhes sobre passagem de parâmetros, assim como o retorno de
funções serão mostrados posteriormente.
Pseudocódigo 3.1 Processo componente para o cálculo da distância entre dois pontos.
Descrição: Calcular a distância entre dois pontos.
Dados de Entrada: Coordenadas x e y dos dois pontos
Saída do Programa: Distância entre os pontos.
Processo componente " dist^ancia ":
Usar o teorema de Pitágoras para calcular a dist^ancia dos pontos dados
Retornar o valor da dist^ancia
FIM - Processo componente " dist^ancia "
DRAFT
O Exemplo 3.2 mostra a implementação na linguagem C de uma função que calcula a distância
entre dois pontos no plano cartesiano. O corpo é composto de atribuição de valores às variáveis dx,
dy e dist através de cálculos matemáticos e pelo retorno do valor contido em dist. O retorno de dados
é estudado na Seção 3.6.
Essa função recebe como parâmetros as coordenadas de dois pontos no plano cartesiano e retorna a
distância entre esses pontos. Para fazer o cálculo dessa distância, primeiramente calcula-se a distância

3.3. PARTES DE UM SUBPROGRAMA 67
entre as coordenadas x (armazenando esse valor em dx) e a distância entre as coordenadas y (armazenando
esse valor em dy). Posteriormente, usa-se o teorema de Pitágoras para calcular a distância
entre os pontos dados.
1 float distancia ( float x1 , float y1 , float x2 , float y2){
2 float dx , dy , dist ;
3
4 dx = x2 - x1;
5 dy = y2 - y1;
6 dist = sqrt (dx * dx + dy * dy);
7
8 return dist ;
9 }
Exemplo 3.2: O corpo do subprograma são as instruções contidas nele.
Percebe-se que o nome da função já nos dá a ideia do que ela faz: calcula a distância entre dois
pontos. Porém, maiores explicações sobre essa distância, se é por um caminho mínimo ou qualquer
outro arbitrário, devem ser explicadas nos comentários da função.
Quando a quantidade de parâmetros de uma função não é respeitada, a função não tem todos
os dados necessários para a realização de suas instruções. Na função do Exemplo 3.1, quando o
programador chama a função distancia passando apenas um número, ao invés de dois, o compilador
avisa o programador sobre tal erro, não deixando que o programa seja gerado. Assim, evitam-se erros
de execução.
Também podem ocorrer erros quando a ordem ou tipo dos parâmetros não são respeitadas. No
cotidiano, também ocorrem esses tipos de erros. Por exemplo, para que um carro funcione, ele precisa,
entre outras coisas, de água e óleo lubrificante. Caso a água seja colocada no lugar do óleo lubrificante,
ou o contrário, é previsível que o carro, em algum momento, apresente falhas na execução de suas
operações, não se locomovendo. Assim, fica fácil perceber que um bom programador deve sempre
verificar se está respeitando os tipos dos parâmetros das funções.
3.3.2 Dicionário de dados
DRAFT
O dicionário de dados é onde se faz a declaração de variáveis e constantes usadas no subprograma e
não declaradas no cabeçalho da função. Normalmente, são declaradas após o cabeçalho.
Quando se declara variáveis em subprogramas, estas só podem ser utilizadas naquele subprograma.
Qualquer outro subprograma, mesmo aquele que chamou a função, não tem acesso a essas variáveis.
Assim, por existirem e serem acessíveis apenas naquele subprograma, são chamadas de variáveis locais.
Considere novamente o exemplo do funcionamento da fábrica de automóveis. Enquanto o subprograma
“Robô de solda” estiver fazendo seu trabalho (soldagem de peças), algumas informações usadas
em alguns procedimentos necessitam ser utilizadas, tais como: quantidade de solda, qualidade da solda,
método de soldagem, etc. Quando o “Robô de solda” termina seu trabalho, essas informações não
são mais necessárias. Note que os outros robôs não precisam saber dessas informações para poderem
executar seus trabalhos.
Para representar em um programa o funcionamento de uma fábrica de automóveis, cada robô
poderia ser representado por um subprograma. As informações seriam representadas por variáveis
locais. A Figura 3.3 ilustra essa correspondência. O “Robô de pintura” tem duas variáveis: quantidade
de tinta e cor da tinta. Essa variáveis não são visíveis para os outros robôs; em particular, para o robô
de solda.

68
CAPÍTULO 3. MODULARIZAÇÃO
3.3.3 Corpo
Figura 3.3: Dicionário de dados.
O corpo do subprograma é onde estão contidas as instruções a serem executadas pelo subprograma.
Nele, podem ser realizadas operações, tais como: atribuições de valores às variáveis, chamadas de
outras funções, cálculos de expressões, leitura de dados e apresentação de resultados.
3.3.4 Comentários
Para melhor legibilidade e entendimento do código do subprograma, é recomendável fazer comentários.
Antes de cada subprograma deve-se colocar comentários com as seguintes finalidades: dizer para
quê a função serve, quais os parâmetros que recebe, explicitando como devem ser esses parâmetros
(unidade de medida, relevância para a função, etc), restrições para aplicações, entre outras.
No dicionário de dados, os comentários devem ser usados para explicar o significado de alguma
variável cujo nome não é suficientemente significativo. No corpo da função, os comentários devem ser
usados para explicar o que foi feito em determinado conjunto de instruções cujo entendimento não é
fácil.
O Exemplo 3.3 mostra um comentário geral da função distancia, explicando os parâmetros da
função e como é feito o cálculo.
1 /*
2 Funcao para calcular a distancia entre dois pontos no plano cartesiano .
3 Dados de entrada :
4 float x1: a coordenada x do primeiro ponto .
5 float y1: a coordenada y do primeiro ponto .
6 float x2: a coordenada x do segundo ponto .
7 float y2: a coordenada y do segundo ponto .
8
9 Dados de saida :
DRAFT
10 Retorna a distancia entre os pontos passados
11 */
12
13 float distancia ( float x1 , float y1 , float x2 , float y2){
14 float dx , dy , dist ;
15
16 dx = x2 - x1;
17 dy = y2 - y1;
18 dist = sqrt (dx * dx + dy * dy);
19
20 return dist ;
21 }
Exemplo 3.3: Comentários em um subprograma.

3.4. CHAMADA DE SUBPROGRAMAS 69
3.4 Chamada de subprogramas
Em programação, quando um subprograma solicita serviços de um outro subprograma dizemos que foi
feita uma chamada ao subprograma. Durante a execução de um programa, podem ser feitas diversas
chamadas a um mesmo subprograma.
Considere o exemplo do funcionamento da fábrica de automóveis. O “Robô de Solda” pode ser
chamado diversas vezes durante o processo de fabricação de um carro e, é claro, em pontos de montagem
diferentes. Toda vez que ele é chamado, executa novamente o seu serviço, considerando as
particularidades de cada caso.
Em programação acontece o mesmo. Um mesmo subprograma pode ser chamado em diversos
pontos do código. A função distancia, descrita no Exemplo 3.2, pode ser usada para fazer vários
cálculos de distâncias entre pontos diferentes e em vários lugares diferentes de um mesmo programa.
A chamada de um subprograma na linguagem C é feita digitando o nome da função e, em seguida,
digitando os dados de entrada necessários entre parênteses, para que assim o subprograma execute
suas instruções.
No Exemplo 3.4, a função distancia é chamada duas vezes. Na primeira vez, ela é chamada
para calcular a distância entre duas cidades, sendo fornecidas as coordenadas x e y em quilômetros
de distância das cidades. A segunda chamada da função é feita para calcular a distância entre dois
móveis de um escritório.
Note que as coordenadas passadas para o subprograma em cada momento podem ser diferentes,
fazendo com que o programa calcule distâncias diferentes. A interpretação física das coordenadas
passadas também pode ser diferente, não alterando a funcionalidade do subprograma.
1 # include
2 # include
3
4 // local onde deve ser incluido o codigo da funcao distancia .
5 int main (){
6 float xa , xb , ya , yb , dist ;
7
8 printf (" Forneca as coordenadas x e y (em quilometros ) das cidades A e B,
9 respectivamente : ");
10 scanf ("%f%f%f%f", &xa , &ya , &xb , &yb);
11 dist = distancia (xa , ya , xb , yb);
12 printf (" Distancia em quilometros entre as cidades A e B: %f\n", dist );
13 printf (" Forneca as coordenadas x e y (em metros ) da cadeira e da mesa do
14 seu escritorio : ");
15 scanf ("%f%f%f%f", &xa , &ya , &xb , &yb);
16 dist = distancia (xa , ya , xb , yb);
17 printf (" Distancia em metros entre a cadeira e a mesa do seu
18 escritorio : %f\n", dist );
19
20 return 0;
21 }
DRAFT
3.5 Passagem de parâmetros
Exemplo 3.4: Chamadas de um mesmo subprograma
Os parâmetros de uma função são os dados iniciais necessários para que ela possa realizar o seu
trabalho. Por exemplo, a função matemática: y(x) = x 2 calcula o quadrado do número x, que foi
passado como parâmetro para a função. Voltando ao exemplo da fabricação de um carro, pode-se
dizer que a fábrica é o programa principal. Ao final do processo, ela deve fornecer um carro pronto
para o uso. Mas a fábrica, como já foi dito, não conta apenas com um robô para fazer todo o processo
e sim com vários robôs, cada um com sua função específica.
Cada robô deve receber uma entrada e fornecer uma saída. Para o “Robô de Pintura”, as entradas
são: a carroceria do carro, feita por outro robô, e a cor usada para pintá-la. A partir dessas entradas,

70
CAPÍTULO 3. MODULARIZAÇÃO
o “Robô de Pintura” executa as instruções estabelecidas para pintar a carroceria. Ao final da pintura,
o robô está pronto para fornecer a saída: a carroceria pintada. Essa saída pode servir como entrada
para outro robô.
Cada parâmetro de uma função possui um tipo, declarado no cabeçalho da função, como mostrado
no Exemplo 3.1, onde os parâmetros a e b são do tipo float. Quando é feita uma chamada ao
subprograma, podem ser passados como parâmetro os valores de variáveis do programa principal, que
obrigatoriamente devem ser do mesmo tipo dos parâmetros da função chamada.
No Exemplo 3.4, são feitas várias chamadas ao subprograma distancia. Em cada uma dessas
chamadas são passadas entradas distintas, nesse caso, pontos diferentes no plano cartesiano. Considere
que na primeira chamada os pontos passados são: xa = 10, ya = 30, xb = 20, yb = 60. Já na segunda
chamada foram passados os pontos: xa = 15, ya = 18, xb = 5, yb = 53. A Figura 3.4 ilustra esse
processo.
Figura 3.4: Passagem de parâmetros.
Quando o programa principal chama o subprograma distancia, os valores que estão contidos nas
variáveis xa, ya, xb e yb são passados para as variáveis x1, y1, x2 e y2 do subprograma.
É importante perceber que, quando é feita uma passagem de parâmetros, apenas os valores das
variáveis são passados para o subprograma chamado e não as variáveis em si.
A primeira implicação dessa regra é a não necessidade de se usar variáveis como entrada para
outra função, podendo-se usar diretamente um valor. O Exemplo 3.5 ilustra essa ideia. No programa
principal é feita a chamada ao subprograma distancia passando-se os valores 10, −15, 26 e −23 como
parâmetros. Na função distancia, as variáveis x1, y1, x2 e y2 recebem esses valores, para só então a
função iniciar suas instruções.
1 # include
2
3 int main (){
4 int dist ;
5
DRAFT
6 dist = distancia (10 , -15, 26 , -23);
7
8 return 0;
9 }
Exemplo 3.5: Passagem de parâmetros.

3.5. PASSAGEM DE PARÂMETROS 71
Outra implicação do fato de que apenas valores são passados como parâmetro para uma função é
a impossibilidade de mudar o conteúdo das variáveis que são usadas como entrada para a função. No
Exemplo 3.6, a variável a, da função dobraValor, recebe apenas o valor da variável x da função principal.
Com isso, a variável x permanece com o seu valor anterior à chamada da função dobraValor,
apesar da variável a dessa função ter o seu valor alterado.
1 # include
2
3 void dobraValor ( int a){
4 printf (" Numero original : %d \n", a);
5 a = 2 * a;
6 printf ("O seu dobro e: %d \n", a);
7 }
8
9 int main (){
10 int x = 10;
11 dobraValor (x);
12 printf ("O valor de x e: %d \n", x);
13
14 return 0;
15 }
Exemplo 3.6: Passagem de parâmetro na chamada de subprogramas.
Note que a função dobraValor é de tipo void. Quando uma função apenas manipula informações,
sem retornar nenhum tipo de dado, ela é definida como tal.
A saída da execução do programa do Exemplo 3.6 é mostrada no Exemplo 3.7. Note que, como
esperado, a variável x permaneceu com o seu valor original.
1 Número original : 10
2 O seu dobro é: 20
3 O valor de x é: 10
Exemplo 3.7: Saída da execução do programa do Exemplo 3.6.
Uma outra implicação da passagem de parâmetros é a não visibilidade das variáveis do programa
principal no subprograma chamado. Isso significa que o subprograma não pode utilizar as variáveis do
programa principal ou de algum outro subprograma. No Exemplo 3.8, as variáveis x e y não podem ser
acessadas dentro da função alteraValor. Se isso for tentado, o compilador emitirá um erro quando
o programa é compilado, dizendo que as variáveis x e y não foram definidas.
DRAFT
1 void alteraValor ( void ){ // Ocorre erro na compilacao
2 x = 20;
3 y = x * 5;
4 }
5
6 int main (){
7 int x = 10 , y = 15;
8
10
9 alteraValor ();
11 return 0;
12 }
Exemplo 3.8: Erro na visibilidade das variáveis.
Note que além da função dobraValor ser do tipo void ela não recebe nenhuma variável como
parâmetro. Portanto este parâmetro pode ser descrito como void ou simplesmente ser suprimido.
O que ocorre no Exemplo 3.8 também pode ser comparado com os robôs da fábrica de automóveis.
O “Robô de Solda” não pode usar a variável local cor do automóvel do “Robô de Pintura”. O “Robô
de Solda” não sabe o que é essa variável, nem que ela existe, assim, não pode usá-la.

72
CAPÍTULO 3. MODULARIZAÇÃO
3.6 Retorno de dados
Esta seção trata da forma como os dados são retornados em cada subprograma, isto é, como se produz
uma saída da função.
Um subprograma produz, no decorrer das suas instruções, um valor final (uma saída), que deverá
ser passado para o programa ou subprograma que o chamou. O valor retornado pelo subprograma
será atribuído a alguma variável do programa que chamou essa função, ou então usado em alguma
expressão.
Na linguagem C, deve-se definir o tipo de dado retornado pela função em seu cabeçalho e usa-se
o comando return para especificar o valor que deve ser retornado. Após a execução do comando, a
função corrente termina, mesmo que existam mais instruções após o return. Na implementação da
função distancia, feita no Exemplo 3.2, o valor contido na variável dist é retornado.
Como a main também é uma função, também temos que especificar o tipo de dado retornado por
ela. Por padrão, na linguagem C, a função main retorna um valor do tipo int. Quando o programador
não coloca nenhum valor para ser retornado pela main (como no Exemplo 3.9), alguns compiladores
fazem com que o valor 0 seja retornado por padrão. O valor 0 também é usado para simbolizar que
nada aconteceu de errado na execução do programa.
Considere um programa que calcula a média de um aluno e diz se ele foi aprovado ou não. O
Pseudocódigo 3.2 mostra os passos a serem realizados pelo programa.
Pseudocódigo 3.2 Programa para calcular a média de um aluno.
Descrição: Calcular a média de um aluno.
Dados de Entrada: As notas do aluno.
Saída do Programa: A média do aluno.
Funç~ao Principal :
Chamar " calculaMedia " passando as 2 notas de provas do aluno como
par^ametros .
SE a média retornada é maior ou igual a sete :
O aluno está aprovado .
SEN~AO:
Chamar " calculaMedia " passando a média anterior
e a nota da prova final do aluno como par^ametros .
SE a nova média retornada é maior ou igual a cinco :
O aluno está aprovado .
SEN~AO:
O aluno está reprovado .
FIM -SE
FIM -SE
FIM - Funç~ao Principal
DRAFT
Processo componente " calculaMedia ":
Somar os dois números passados como par^ametros e dividir o resultado
por dois .
Retornar o resultado acima .
FIM - Processo componente " calculaMedia "
Uma possível implementação do Pseudocódigo 3.2 está transcrita no Exemplo 3.9. Primeiramente,
o programa pede que o usuário digite os valores das notas das duas provas realizadas pelo aluno. Essas
notas são armazenadas nas variáveis nota1 e nota2 respectivamente e, logo em seguida, são passadas
como parâmetros para a função calculaMedia. A função calculaMedia recebe dois valores do tipo
float e faz a média aritmética deles, retornando, ao final da sua execução, o valor dessa média. O valor
retornado é armazenado na variável resultado da função principal, que por sua vez serve de condição
para a aprovação do aluno. Caso o valor armazenado em resultado seja maior ou igual a sete, o aluno
está aprovado; caso contrário, o programa pede a nota da prova final do aluno, que é armazenada na

3.6. RETORNO DE DADOS 73
variável notaFinal. As variáveis notaFinal e resultado são então usadas como parâmetros da função
calculaMedia. Caso o resultado retornado seja maior ou igual a cinco, o aluno está aprovado.
1 # include
2
3 float calculaMedia ( float a, float b){
4 float media ;
5
6 media = (a + b) / 2;
7
10
8 return media ;
9 }
11 int main (){
12 float nota1 , nota2 , notaFinal , resultado ;
13
14 printf (" Forneca as notas das duas provas do aluno : ");
15 scanf ("%f%f", & nota1 , & nota2 );
16
17 resultado = calculaMedia ( nota1 , nota2 );
18
19 printf ("A media do aluno foi : %f\n", resultado );
20
21 if( resultado >= 7){
22 printf ("O aluno passou de semestre .\n");
23 } else {
24 printf ("O aluno teve que fazer prova final . Forneca a nota da prova
25 final do aluno : ");
26 scanf ("%f", & notaFinal );
27
28 if( calculaMedia ( resultado , notaFinal ) >= 5){
29 printf ("O aluno passou de semestre .\n");
30 } else {
31 printf ("O aluno nao obteve o rendimento minimo para passar de
32 semestre .\n");
33 }
34 }
35 return 0;
36 }
Exemplo 3.9: Retorno de dados.
Note que, na primeira chamada da função calculaMedia, o valor retornado foi armazenado em
uma variável, pois precisa ser usado posteriormente. Já na segunda chamada da função, o valor
retornado é usado diretamente na condicional de aprovação ou não do aluno, não sendo necessário
seu armazenamento em alguma variável. Mas atenção: caso fosse necessário usar esse valor posteriormente,
deveríamos guardá-lo em alguma variável, ao invés de chamar outra vez a função calculaMedia
usando os mesmos parâmetros. Essa chamada sendo feita novamente acarretaria em perda de desempenho
do programa, já que a função teria que recalcular valores, o que levaria um certo tempo para
ser feito.
Em muitos casos é interessante, ou até necessário, que o subprograma altere as variáveis criadas
no programa que o chamou. No exemplo da fábrica de automóveis é isso que deve acontecer. A Figura
3.5 ilustra esse processo.
Nesse exemplo, o carro que é passado para o robô de solda está com várias peças soltas. Então, o
robô solda essas peças e passa o carro para o robô de pintura. Nesse caso, percebe-se que deve-se passar
o mesmo carro para o próximo robô e não apenas um cópia das suas características, que simbolizam
os valores das variáveis em programas. Então, o carro recebe a pintura e é passado como parâmetro
para uma próxima função, ou seja, para um outro robô.
Como discutido na Seção 3.5, não é possível para um subprograma que recebe o valor de uma
variável de um outro subprograma, alterar diretamente o valor da variável do subprograma que o
chamou. Nesse caso, pode-se retornar o valor calculado e então armazená-lo na variável desejada. A
DRAFT

74
CAPÍTULO 3. MODULARIZAÇÃO
Figura 3.5: Passagem de parâmetro por referência.
expressão geral é x = f(x).
Por exemplo, pode-se fazer uma variação do uso da função dobraValor usada no Exemplo 3.6
para alterar o valor da variável do programa que a chamou. Essa alteração está descrita no Exemplo
3.10. Nesse exemplo, o valor retornado pela função dobraValor agora é armazenado na variável x.
1 # include
2
3 int dobraValor ( int a){
4 printf (" Numero original : %d \n", a);
5 a = 2 * a;
6 printf ("O seu dobro e: %d \n", a);
7
10
8 return a;
9 }
11 int main (){
12 int x = 10;
13
14 x = dobraValor (x);
15 printf ("O valor de x e: %d \n", x);
16
17 return 0;
18 }
Exemplo 3.10: Atualização da variável de outra função.
DRAFT
A saída da execução do programa do Exemplo 3.10 é mostrada no Exemplo 3.11.
variável x passou a ter o valor 20.
1 Número original : 10
2 O seu dobro e: 20
3 O valor de x e: 20
Exemplo 3.11: Saída da execução do programa do Exemplo 3.6.
Note que a
3.6.1 Encerramento antecipado de execução
Observando a definição de calculaMedia, implementada no Exemplo 3.9, nota-se que o valor só é
retornado ao final da função, quando todas as outras instruções foram executadas. No entanto, é
possível ocorrer de um subprograma ter vários pontos de retorno distintos.
No Pseudocódigo 3.3 são mostrados os passos realizados pela função ehDivisor, que verifica se
um número é divisor do outro. Para evitar um erro matemático, é importante verificar se o divisor

3.6. RETORNO DE DADOS 75
é diferente de zero. Se for igual a zero, então a execução da função deve ser interrompida e o erro
deverá ser indicado de alguma forma. Nesse caso, escolheu-se retornar o valor negativo −1.
Pseudocódigo 3.3 Função que determina se um número é divisor do outro.
Descrição: Determinar se um número é divisor de outro.
Dados de Entrada: Dois números
Saída do Programa: 1, 0 ou -1 de acordo com o resultado
Processo componente " eDivisor ":
SE o divisor é igual a zero :
Retornar o valor -1
FIM -SE
SE o resto da divis~ao do dividendo pelo divisor é igual a zero :
Retornar o valor 1
SEN~AO:
Retornar o valor 0
FIM -SE
FIM - Processo componente " eDivisor "
No Exemplo 3.12 é apresentada a implementação, na linguagem C, do Pseudocódigo 3.3. Note
que a função apresenta três pontos distintos de retorno. No primeiro, é verificado se o divisor é zero
e caso isso seja verdade é retornado o valor −1, caso contrário, a função continua executando suas
instruções. No segundo, é verificado se o resto da divisão inteira de x por y é zero, ou seja, é verificado
se y é divisor de x. Caso isso seja verdade é retornado o valor 1, caso contrário, é retornado o valor 0,
simbolizando que y não é divisor de x. Aqui, o valor 1 foi usado para simbolizar sucesso na verificação.
Note ainda que esse recurso torna a função mais eficiente e legível.
1 int eDivisor ( int x, int y){
2 if (!y){
3 return -1;
4 }
5
6 if(x % y){
7 return 1;
8 } else {
9 return 0;
10 }
11 }
DRAFT
Exemplo 3.12: Encerramento antecipado para evitar erros
No Exemplo 3.12, o encerramento antecipado foi feito para evitar um erro na execução do programa.
Porém, o encerramento antecipado de execução pode não objetivar evitar erros de execução.
Considere o caso do Exemplo 3.9. O programa principal poderia ser na verdade um subprograma
que retorna 1 caso o aluno seja aprovado e 0 caso contrário. Se o aluno obtiver média 7 apenas com as
duas primeiras notas, a execução do programa é interrompida e o valor 1 é retornado. Essa alteração
é descrita no Exemplo 3.13.
1 # include
2
3 float calculaMedia ( float a, float b){
4 float media ;
5
6 media = (a + b) / 2;
7
8 return media ;
9 }

76
CAPÍTULO 3. MODULARIZAÇÃO
10
11 int aprovado ( float nota1 , float nota2 , float notaPF ){
12 float resultado ;
13
14 resultado = calculaMedia ( nota1 , nota2 );
15
16 if( resultado >= 7){
17 return 1;
18 }
19
20 if( calculaMedia ( resultado , notaPF ) >= 5){
21 return 1;
22 }
23
24 return 0;
25 }
26 int main (){
27 float nota1 , nota2 , notaPF ;
28
29 printf (" Forneca as notas das duas provas do aluno e a nota da prova final .
30 Caso o aluno nao tenha feito prova final , digite zero : ");
31 scanf ("%f%f%f", & nota1 , & nota2 , & notaPF );
32
33 if( aprovado ( nota1 , nota2 , notaPF )){
34 printf ("O aluno passou de semestre .\n");
35
36 } else {
37 printf ("O aluno nao obteve o rendimento minimo para passar
38 de semestre .\n");
39 }
40
41 return 0;
42 }
Exemplo 3.13: Encerramento antecipado natural.
3.7 Funções sem lista de parâmetros
Até agora as funções mostradas continham dados de entrada, ou seja, uma lista de parâmetros. Mas
há casos em que isso não é necessário, pois a função executa suas instruções sem precisar de dados de
entrada. Alguns leitores podem achar que isso faz com que o subprograma retorne sempre o mesmo
dado, afinal, a ausência de dados de entrada tornaria a função uma função constante.
Esse pensamento estaria correto se o subprograma não pudesse coletar dados externos, usando por
exemplo a função scanf.
No Exemplo 3.14 a função lerNumeros não tem nenhum parâmetro de entrada. Isso foi feito
pois ela sempre executará a mesma rotina: lerá 5 números digitados pelo usuário e fará a soma deles.
É fácil perceber que o resultado retornado pode variar a cada chamada da função. Isso acontece pois
essa função usa os dados retornados por scanf para completar suas instruções. Note que usa-se void
na lista de parâmetros para simbolizar que a função não possui parâmetros de entrada.
1 int lerNumeros ( void ){
2 int x = 0, temp , i;
3
4 for (i = 0; i < 5; i ++) {
5 printf (" digite um numero : ");
6 scanf ("%d", & temp );
7 x += temp ;
8 }
9
10 return x;
11 }
DRAFT

3.8.
FUNÇÕES SEM RETORNO DE DADOS 77
Exemplo 3.14: Lista de parâmetros vazia
3.8 Funções sem retorno de dados
Assim como há funções que não têm nenhum parâmetro, também há funções que não retornam nenhum
tipo de dado. Na linguagem C, para simbolizar essa situação usa-se void como tipo de dado retornado.
O Exemplo 3.15 exibe uma função que não retorna dados para a função que a chamou. A função
apresentaMultiplicacao recebe três números e exibe o resultado da multiplicação destes. Nota-se
que nenhum dado é retornado, nem mesmo o valor da multiplicação. O programador pode decidir por
este tratamento caso o resultado da multiplicação não seja usado posteriormente.
1 void apresentaMultiplicacao ( float a, float b, float c){
2 printf (" Resultado = %f", a * b * c);
3 }
Exemplo 3.15: Função sem retorno.
Funções sem retorno de dados podem guardar os valores gerados em algum arquivo. Caso isso seja
feito, os dados podem ser recuperados lendo-se esses arquivos. A manipulação de arquivos, tanto para
leitura, tanto para escrita, é discutida no capítulo 8.
Há também a opção da função não ter nenhum parâmetro de entrada e nenhum dado retornado. O
Exemplo 3.16 mostra uma função para exibir uma saudação ao usuário. Note que a função não possui
parâmetros de entrada nem valor de retorno. O objetivo de uma tal função é apenas de organização
ou para evitar repetição de código, caso seja chamado em diferentes pontos do programa.
1 void saudacao ( void ){
2 printf ("Bem - vindo ao programa Calculo Eletronico , onde seus
3 calculos sao resolvidos rapidamente \ nPara mais informacoes e atualizacoes
4 acesse o site : www . programaemc . com .br");
5 }
3.9 Recursividade
Exemplo 3.16: Função sem parâmetro e sem retorno.
DRAFT
A recursividade ocorre quando algo é definido a partir de si mesmo. Uma recursão sempre é definida a
partir de uma ou mais relações recursivas (quando o próximo elemento é definido a partir do anterior),
e uma ou mais bases de recursão (pontos de parada).
Em programação, o método recursivo pode ser usado para definir uma função. Por exemplo, o
cálculo do fatorial de um número inteiro não negativo pode ser implementado através de uma função
recursiva. Pode-se definir o fatorial de um número n como sendo o próprio número n multiplicado
pelo fatorial do número n-1. A definição de fatorial pode ser representada por:
fatorial (0) = 1 ⇒ base da recursão
fatorial (n) = n * fatorial (n-1) ⇒ relação recursiva
Na definição recursiva anterior é usado critério de parada a fim de que o processo recursivo tenha
um limite. Se o fatorial de um número fosse definido somente como um número multiplicado pelo
fatorial do seu antecessor o fatorial ficaria indefinido, pois todo número possui um antecessor. Para
evitar isso usa-se um critério de parada, chamado de base da recursão. No exemplo do fatorial de um
número, a base da recursão pode ser o número 0, ou seja, é como seguir o comando: “quando chegar
ao número 0 pare”.

78
CAPÍTULO 3. MODULARIZAÇÃO
O Pseudocódigo 3.4 mostra os passos a serem seguidos para o cálculo do fatorial de um número
de forma recursiva.
Pseudocódigo 3.4 Fatorial de um número de forma recursiva.
Descrição: Calcular o fatorial de um número natural.
Dados de Entrada: Número natural.
Saída do Programa: Fatorial do número natural.
Processo componente " fatorial ":
SE o número passado como par^ametro é igual a zero :
Retornar o valor 1.
SEN~AO:
Retornar o número passado como par^ametro multiplicado
pelo valor do fatorial do seu antecessor .
FIM -SE
FIM - Processo componente " fatorial "
A implementação recursiva do fatorial na linguagem C é mostrada no Exemplo 3.17. O programa
chama ele mesmo quantas vezes forem necessárias até que o parâmetro n seja 0. Quando isso acontece,
a função retorna 1 e a execução prossegue a partir da última chamada da função, multiplicando o valor
retornado (1) pelo valor 1 da chamada anterior da função e assim sucessivamente, até se obter o fatorial
do número n inicial.
1 int fatorial ( int n){
2 if (!n){
3 return 1;
4 } else {
5 return n * fatoria (n - 1);
6 }
7 }
Exemplo 3.17: Implementação recursiva do fatorial.
É importante compreender que a cada chamada do programa fatorial é reservado um novo espaço
de memória, ou seja, os dados do programa fatorial anterior são preservados e caso a função recursiva
tivesse variáveis locais, novas instâncias dessas variáveis seriam criadas a cada chamada, sem qualquer
relação com as variáveis da outra chamada do subprograma. Por isso, funções recursivas tendem a
necessitar de mais memória do computador.
DRAFT
Figura 3.6: Fatorial utilizando recursão.

3.10.
EXERCÍCIOS RESOLVIDOS 79
Chamando a função fatorial passando-se como argumento o número 5, tem-se o esquema ilustrado
na Figura 3.6. As setas direcionadas para baixo significam a chamada do programa apontado, exibindo
o valor passado como parâmetro. As setas direcionadas para cima significam o retorno do dado do
programa chamado, mostrando o valor retornado pela função.
3.9.1 Implementação não recursiva equivalente
Em geral, toda função recursiva pode ser implementada sem recursão, através do uso de comandos de
repetição. A vantagem da versão não recursiva é a eficiência. Já a vantagem da recursiva é a elegância,
legibilidade e redigibilidade.
O Exemplo 3.18 mostra uma forma não recursiva da implementação da função fatorial. O comando
for é utilizado para multiplicar o f por i a cada valor de i, até que i assuma o valor de n, passado como
parâmetro.
1 int fatorial2 ( int n){
2 int i, f;
3
4 f = 1;
5
6 for (i = 2; i

80
CAPÍTULO 3. MODULARIZAÇÃO
Pseudocódigo 3.5 Passos a serem realizados pela função soma.
Descrição: Calcular a soma dos n primeiros inteiros.
Dados de Entrada: Número inteiro.
Saída do Programa: Somatório dos números.
Processo componente " soma ":
Inicializar soma com o valor zero
Inicializar i com o valor 1
ENQUANTO i for menor ou igual a n:
Acumular em soma o valor corrente de i
FIM - ENQUANTO
Retornar o valor soma
FIM - Processo componente " soma ".
O Exemplo 3.19 mostra a implementação desse algoritmo. Note que o pseudocódigo foi seguido
fielmente, acrescentado-se apenas instruções necessárias e específicas da linguagem C.
1 int soma ( int n){
2 int i, soma ;
3
4 soma = 0;
5 for (i = 1; i

3.10.
EXERCÍCIOS RESOLVIDOS 81
Funç~ao Principal :
Ler os valores de n, i e j
Chamar o processo componente multiplos passando como par^ametros n, i e j.
FIM - Funç~ao Principal
Processo componente " multiplos ":
Inicializar a variável do número atual e a variável indicando o número
de múltiplos com o valor zero .
ENQUANTO o número de múltiplos for menor que n:
SE o número atual é múltiplo de i ou de j através do processo
componente Multiplo :
Incrementar a variável contadora de múltiplos e
exibir o valor do número atual .
FIM -SE
Incrementar a variável do número atual
FIM - loop
FIM - Processo componente " multiplos "
Processo componente " Multiplo ":
SE o resto da divis~ao de x por y é zero :
Retornar o valor 1, indicando sucesso .
SEN~AO:
Retornar o valor 0.
FIM -SE
FIM - Processo componente " Multiplo "
Nº Natural Múltiplo de b ? Múltiplo de a ? Nº de múltiplos de a ou b
0 sim sim 1
1 não não 1
2 não sim 2
3 sim não 3
4 não sim 4
5 não não 4
6 sim sim 5
7 não não 5
8 não sim 6
DRAFT
Figura 3.8: Solução para n = 6, a = 2 e b = 3.
O Exercício 3.20 mostra a implementação do algoritmo do Pseudocódigo 3.6. Na função eMultiplo
usou-se como convenção o valor 1 para indicar sucesso na verificação de x ser múltiplo de y e 0 caso
contrário. Note também que no comando de repetição for da função múltiplos foi omitido o terceiro
parâmetro. Isso foi necessário pois a variável cont só deverá ser incrementada se natural for múltiplo
de i ou j, o que nem sempre é verdade.
1 # include
2
3 int eMultiplo ( int x, int y){
4
5 if(x % y){
6 return 0;
7 } else {
8 return 1;
9 }
10 }
11
12 void multiplos ( int i, int j, int n){
13 int natural , cont ;

82
CAPÍTULO 3. MODULARIZAÇÃO
14
15 natural = 0;
16 cont = 0;
17
18 printf ("Os %d primeiros multiplos de %d ou de %d sao :", n, i, j);
19
20 while ( cont < n){
21 if( eMultiplo ( natural , i) || eMultiplo ( natural , j) ){
22 printf (" %d", natural );
23 cont = cont + 1;
24 }
25 natural = natural + 1;
26 }
27 printf ("\n");
28 }
29
30 int main (){
31 int n, i, j;
32
33 printf (" Digite 3 numeros naturais ( quantidade n de multiplos que serao impressos ,
34 e dois geradores )");
35 scanf ("%d%d%d", &n, &i, &j);
36 multiplos (i, j, n);
37
38 return 0;
39 }
Exemplo 3.20: Programa que calcula os n primeiros naturais multiplos de dois geradores.
Exercício Resolvido 3.3 - Triângulo Retângulo
Faça uma função que dados três números naturais, verifique se eles formam os lados de um triângulo
retângulo. Os números dados simbolizam o comprimento de cada lado do triângulo.
Solução Possível:
Na geometria, o Triângulo Retângulo é um triângulo que possui um ângulo reto e outros dois
ângulos agudos. Sabe-se ainda que o quadrado da hipotenusa (o maior lado do retângulo) é igual a
soma dos quadrados dos catetos.
Sendo assim, para resolver esse exercício, precisamos primeiro saber qual dos três lados dados, a,
b ou c, corresponde à hipotenusa. Para tanto, compara-se todos os lados, dois a dois, colocando-se o
maior lado na variável a.
Como o maior lado estará guardado em a é certo dizer que os lados dados correspondem a um
triângulo retângulo se, e somente se, a 2 = b 2 + c 2 .
O Pseudocódigo 3.7 mostra um algoritmo que descreve os passos a serem realizados pela função.
Pseudocódigo 3.7 Passos a serem realizados pela função.
DRAFT
Descrição: Verificar se 3 valores de comprimento podem descrever os lados de um triangulo retângulo.
Dados de Entrada: Os 3 valores.
Saída do Programa: Retorna 1 caso seja possível, caso contrário retorna 0.
Processo componente " trianguloRetangulo ":
SE o lado b e maior do que o lado a:
Trocar os valores de a e b.
FIM -SE
SE o lado c e maior do que o lado a:
Trocar os valores de a e c.
FIM -SE

3.10.
EXERCÍCIOS RESOLVIDOS 83
SE a * a = b * b + c * c:
Retornar o valor 1
SEN~AO:
Retornar o valor 0
FIM -SE
FIM - Processo componente " trianguloRetangulo "
O Exemplo 3.21 mostra a implementação desse algoritmo.
1 int trianguloRetangulo ( int a, int b, int c){
2 int aux ;
3
4 if(b > a){
5 aux = a;
6 a = b;
7 b = aux ;
8 }
9
10 if(c > a){
11 aux = a;
12 a = c;
13 c = aux ;
14 }
15
16 if(a * a == b * b + c * c){
17 return 1;
18 } else {
19 return 0;
20 }
21 }
Exemplo 3.21: Programa que verifica se 3 comprimentos formam um triangulo retangulo
Exercício Resolvido 3.4 - Tabuada
Faça um programa que dado dois números inteiros, m e n, gere uma tabuada conforme a Figura
3.9, sendo que para esse exemplo os números fornecidos foram: 2 e 3.
0 x 1 = 0
0 x 2 = 0
...
0 x 22 = 0
1 x 1 = 1
...
1 x 22 = 22
2 x 1 = 2
...
2 x 22 = 44
...
37 x 22 = 814
DRAFT
Figura 3.9: Solução para m = 22 e n = 37.
Solução Possível:
Para gerar cada linha da tabuada proposta deve-se imprimir combinações de a * b = c onde a
pode assumir valores entre 0 e n e b varia entre 1 e m. Todas as linhas podem ser geradas utilizando
um comando de repetição que incrementa o valor de a dentro de outro comando de repetição que
incrementa o valor de b imprimindo a linha calculada e fazendo uma quebra de linha a cada iteração
interna.

84
CAPÍTULO 3. MODULARIZAÇÃO
O Pseudocódigo 3.8 mostra um algoritmo que descreve os passos a serem realizados pela função.
Pseudocódigo 3.8 Passos a serem realizados pela função.
Descrição: Gera tabuada considerando dois multiplicadores máximos.
Dados de Entrada: Os dois valores.
Saída do Programa: Gera a tabuada
Processo componente " geraLinhaTabuada ":
PARA cont variando de 1 a n:
Guardar o resultado da multiplicaç~ao de x por cont em uma nova variável r e
exibir o resultado
FIM - PARA
FIM - Processo componente " geraLinhaTabuada "
Funç~ao Principal :
Coletar os valores das duas variáveis (n e m)
PARA cada valor de x variando de 0 a m:
Chamar processo componente " geraLinhaTabuada ", passando como par^ametro n e
x
FIM - PARA
FIM - Funç~ao Principal
O Exemplo 3.22 mostra a implementação desse algoritmo. Note que a variável a da função mult
contém o valor da variável n da função main, enquanto a variável b da função mult contém o valor
da variável x da função main.
1 # include
2
3 void geraLinhaTabuada ( int a, int b){
4 int r, cont ;
5
6 for ( cont = 1; cont

3.10.
EXERCÍCIOS RESOLVIDOS 85
se um dado número x é primo ou não. Por definição: “Número primo é um número natural que é
divisível apenas pelo número 1 (um) e por ele mesmo, com exceção do número 1, que não é considerado
primo”.
Sabe-se também que o único número primo par é o número 2. Logo, qualquer número par que não
seja o dois, não é primo.
Então, o que se tem a fazer para saber se determinado número é primo é verificar se ele não é o
número 1, par (com exceção do zero e do dois), ou não tiver um divisor ímpar, então ele é primo.
Após feitas as verificações se o número é 0, 1 ou 2 ou divisível por 2, para encontrar algum outro
divisor do número, basta ir dividindo-o por todos os números ímpares maiores ou iguais a 3 e menores
ou iguais a raiz quadrada do número em questão. Caso não encontremos divisores nesse intervalo,
então não existem outros divisores além do 1 e o próprio número.
O critério de parada da raiz quadrada pode ser facilmente demonstrado. Suponha um número n
que não pode ser dividido por nenhum valor entre 3 e r sendo r a raiz quadrada de n. Agora suponha
que existe um número m maior que r (exceto n) que é divisor de n (provaria que ele não é primo).
Como m >r, m*m >r*r então m*m >n, portanto deve existir algum valor x divisor de n menor que
r capaz de satisfazer mx = n, o que ja foi descartado pois esse x não existe. Portanto, se nenhum
divisor menor ou igual a r for encontrado, a busca pode ser encerrada pois o número é primo. Vale
ressaltar que a função raiz quadrada, é implementada na biblioteca math.h com o rótulo sqrt() sendo
necessário importar a biblioteca para utilizá-la.
O Pseudocódigo 3.9 mostra um algoritmo que descreve os passos a serem realizados pela função.
O Exemplo 3.23 mostra a implementação desse algoritmo. Note que caso o número passado seja
primo, a função retornará o valor um, caso contrário retornará o valor zero.
Pseudocódigo 3.9 Passos a serem realizados pela função.
Descrição: Verifica se o número passado como parâmetro é primo.
Dados de Entrada: Um número inteiro positivo diferente de zero.
Saída do Programa: Retorna um quando o número informado for primo e zero caso contrario
Processo componente " ePrimo ":
SE x é igual a um:
Retornar o valor zero
FIM -SE
SE x é igual a 2:
Retornar o valor um
FIM -SE
SE x é divisível por 2:
Retornar o valor zero
FIM -SE
PARA i variando de 3 a raiz quadrada de x:
SE x é divisível por i:
Retornar o valor zero
FIM -SE
Incrementar o valor de i em 2 unidades
FIM - PARA
Retornar o valor um
FIM - Processo componente " ePrimo "
DRAFT
Funç~ao Principal :
Coletar o valor da variável quant que representa o número de primos a serem
apresentados
Iniciar número com valor 0.
PARA cont variando de zero a quant :
SE cont for primo :
Apresentar cont na tela

86
CAPÍTULO 3. MODULARIZAÇÃO
Incrementar
FIM -SE
FIM - PARA
FIM - Funç~ao Principal
cont
1 # include
2 # include
3
4 int ePrimo ( int x){
5 int i;
6
7 if(x == 1){
8 return 0;
10
9 }
11 if(x == 2){
12 return 1;
13 }
14
15 if(x % 2 == 0){
16 return 0;
17 }
18
19 for (i = 3; i

3.10.
EXERCÍCIOS RESOLVIDOS 87
Solução Possível: Para fazer essa função é necessário reconstruir o número de trás para frente.
Para ler o último algarismo de um número guardado numa variável x basta guardamos numa variável
m o resto da divisão inteira desse número por 10. Após isso, guarda-se em x a parte inteira da divisão
de x por 10, excluindo-se assim o último algarismo do número. Nesse momento a variável m possui o
último algarismo original de x, enquanto esta possui agora apenas os primeiros algarismos originais,
excluindo-se apenas o último.
Então, multiplicando-se m por 10 e somando-se a esse resultado o resto da divisão inteira do novo
valor de x por 10, teremos em m os últimos dois algarismos de x na ordem inversa.
Pode-se perceber que basta fazer os passos acima repetidamente para obter em m o número x
original, mas na ordem inversa. Tendo-se esse número, basta compará-lo com o valor original, guardado
anteriormente em uma outra variável.
A Figura 3.10 ilustra o comportamento das variáveis x e m com o decorrer das iterações para um x
inicial igual a 52325. A coluna x /10 mostra a parte inteira da divisão de x por 10, enquanto a coluna
x % 10 mostra o resto dessa divisão. Percebe-se que o processo iterativo deve acabar quando o x final
for igual a zero. Note que no final desse exemplo a variável m contém o número inicial x do processo,
mostrando que 52325 é palíndromo.
x x / 10 x % 10 m
52325 5232 5 5
5232 523 2 52
523 52 3 523
52 5 2 5232
5 0 5 52325
Figura 3.10: Solução para x = 52325.
O Pseudocódigo 3.10 mostra o algoritmo que descreve os passos a serem realizados pela função.
Pseudocódigo 3.10 Passos a serem realizados pela função.
Descrição: Verifica se um número
Dados de Entrada: Um numero inteiro.
Saída do Programa: Retorna verdadeiro para palíndromo e falso para não palíndromo
Processo componente " palíndromo ":
Fazer cópia do número
Iniciar invertido
ENQUANTO número for diferente de zero :
Atualizar invertido
Atualizar número
FIM - ENQUANTO
SE número é igual ao invertido :
Retornar verdadeiro
SEN~AO:
Retornar falso
FIM -SE
FIM - Processo componente " palíndromo "
DRAFT
O Exemplo 3.24 mostra a implementação desse algoritmo. Note que a variável c guarda o valor
inicial de x e que esta variável é comparada com o valor de m ao final do processo. Aqui também
usou-se a convenção de usar o valor de retorno 1 para indicar sucesso na verificação e zero caso
contrário.
1 int palindromo ( int x){

88
CAPÍTULO 3. MODULARIZAÇÃO
2 int c, m;
3
4 c = x;
5 m = 0;
6
7 while (x){
8 m = m * 10 + (x % 10) ;
9 x = x / 10;
10 }
11
12 if(m == c){
13 return 1;
14 } else {
15 return 0;
16 }
17 }
Exemplo 3.24: Programa que verifica se um número é palíndromo.
Exercício Resolvido 3.7 - Máximo Divisor Comum
Faça uma função que calcule o máximo divisor comum entre dois números naturais. Implemente
a função na forma recursiva e na forma iterativa.
Solução Possível:
A solução adotada pode ser é a mesma apresentada no Exemplo 2.40 no capítulo 2.
O Pseudocódigo 3.11 mostra o algoritmo que descreve os passos a serem realizados pela função
iterativa.
Pseudocódigo 3.11 Passos a serem realizados pela função.
Descrição: Calcula o mdc de dois números de forma recursiva.
Dados de Entrada: Dois números inteiros.
Saída do Programa: Retorna o mdc
Processo componente " mdcRecursivo ":
SE iguais :
retornar um deles
SEN~AO:
SE distintos :
retornar o mdc entre o menor e a subtraç~ao do maior pelo menor
FIM -SE
FIM -SE
FIM - Processo componente " mdcRecursivo "
DRAFT
O Exemplo 3.25 mostra a implementação desse algoritmo.
1 int mdcRecursivo ( int a, int b){
2 if(a == b){
3 return a;
4 }
5
6 if(a > b){
7 return mdcRecursivo (a - b, a);
8 } else {
9 return mdcRecursivo (a, b - a);
10 }
11 }
Exemplo 3.25: Programa que calcula o M.D.C. de dois números (modo recursivo).

3.11. RESUMO 89
O Pseudocódigo 3.12 mostra o algoritmo que descreve os passos a serem realizados pela função
iterativa.
Pseudocódigo 3.12 Passos a serem realizados pela função.
Descrição: Calcula o mdc de dois números de forma iterativa.
Dados de Entrada: Dois números inteiros.
Saída do Programa: Retorna o mdc
Processo componente " mdcIterativo ":
ENQUANTO numeros diferentes
Retirar menor do maior
FIM - ENQUANTO
FIM - Processo componente " mdcIterativo "
O Exemplo 3.26 mostra a implementação desse algoritmo. Note que nesse caso a implementação
na forma iterativa é obtida facilmente a partir da forma recursiva.
1 int mdcIterativo ( int a, int b){
2
3 while (a != b){
4 if(a > b){
5 a = a - b;
6 } else {
7 b = b - a;
8 }
9 }
10
11 return a;
12 }
Exemplo 3.26: Programa que calcula o M.D.C. de dois números (modo iterativo).
3.11 Resumo
ˆ
A modularização baseia-se na conhecida técnica de “dividir para conquistar”e pode ser definida
como a divisão de um problema em várias partes. Cada uma dessas partes pode ser resolvida
independentemente das outras.
DRAFT
ˆ As partes principais de um subprograma são: cabeçalho, dicionário de dados, corpo e comentários.
ˆ
ˆ
Os parâmetros de um subprograma são os dados iniciais necessários para o subprograma poder
realizar o seu trabalho. O subprograma pode também não receber nenhum parâmetro para
realizar suas funções. Na linguagem C, quando a função não têm parâmetros usa-se void na
declaração da função, em sua lista de parâmetros.
Um subprograma poderá produzir no decorrer das suas instruções um valor que será retornado,
chamado de valor de retorno. Na linguagem C, quando o subprograma não produz nenhum valor
de retorno usa-se void para simbolizar o tipo de dado retornado.
ˆ
ˆ
ˆ
Algumas vezes é interessante antecipar o encerramento da execução de programas.
A programação recursiva é uma técnica muito utilizada na implementação de funções.
Geralmente é possível criar versões recursivas e não recursivas de uma mesma função.
ˆ
As vantagens encontradas em um programa modularizado são:

90
CAPÍTULO 3. MODULARIZAÇÃO
1. Legibilidade: facilidade de leitura e entendimento do código fonte;
2. Manutenibilidade: facilidade de modificar o código fonte;
3. Reusabilidade: facilidade de reutilizar total ou parcialmente o código fonte;
4. Confiabilidade: como o programa é fácil de ser entendido e corrigido, torna-se mais confiável;
5. Produtividade: o programa pode ser dividido em módulos e cada módulo pode ser trabalhado
por uma equipe diferente. Além disso, uma equipe só precisa saber o que determinado
módulo de outra equipe faz e não como faz;
3.12 Exercícios Propostos
1. Faça uma função que receba como entrada dois valores inteiros, a e b, e exiba a sequência de
números pares do intervalo (a, b), com a < b.
2. Faça uma função que receba como argumento os lados de um triângulo e calcule o seu perímetro
e em seguida o valor da área.
3. Considere o valor de π = 3.141592. Construa uma função para calcular a área de um círculo
tendo como dado de entrada, o valor do raio. Em seguida, fazer outra função para calcular o
raio do círculo que possui como área, a metade da área calculada anteriormente.
4. Faça uma função que receba como parâmetro uma quantia em reais (valor inteiro). Calcule
o número de cédulas de cada tipo (1, 2, 5, 10, 20, 50, 100), necessário para pagar a quantia
(minimizando o número total de cédulas a serem entregues). Exiba apenas o número não nulo
de cédulas de cada tipo.
5. Faça uma função que calcule e retorne o n-ésimo termo de uma PA (progressão aritmética) sendo
fornecidos como entrada o número de termos, o primeiro termo e a razão.
6. Implemente uma sequencia de Fibonacci de forma recursiva.
7. Uma loja de material de construção precisa de um programa para saber a quantidade de metros
quadrados (m2) que devem ser usados para colocar piso nas casas dos clientes. É fornecido o
número de cômodos, os lados dos quadriláteros de cada cômodo e o preço do piso que o cliente
escolheu. Faça uma função que receba essas informações como dados de entrada e apresente a
quantidade de piso (em m2 ) e o valor da compra. Obs.: Todos os cômodos da casa têm a forma
de quadriláteros.
DRAFT
8. Elabore uma função em C que calcule o valor aproximado de π com precisão de cinco décimos
através da série:
π = 1 1 3 − 1 3 3 + 1 5 3 . . .
Considere que a precisão de cinco décimos requer que a soma dos elementos da série só deve ser
interrompida quando o valor do termo é inferior a 0,00001. Para implementar a função, use uma
subfunção que, dados x e y, calcule x y .
9. a) Construa uma função encaixa que, dados dois inteiros positivos a e b, verifica se b corresponde
aos últimos dígitos de a.
Ex.:

3.12.
EXERCÍCIOS PROPOSTOS 91
a b
567890 890 =>encaixa
1243 1243 =>encaixa
2457 245 =>não encaixa
457 2457 =>não encaixa
b) Usando a função do item anterior, faça um programa que lê dois inteiros positivos a e b e
verifica se o menor deles é segmento do outro.
Exemplo:
a b
567890 678 => b é segmento de a
1243 2212435 => a é segmento de b
235 236 => um não é segmento do outro
10. Faça um programa em C que leia vários números inteiros positivos e determine quais são abundantes
(a soma dos seus divisores é superior ao dobro do número), perfeitos (a soma dos seus
divisores é igual ao dobro do número), deficientes (a soma dos seus divisores é inferior ao dobro
do número), levemente imperfeito (a soma dos seus divisores é igual ao dobro do número menos
um) ou não se encaixam em alguma dessas opções. O programa deve ser encerrado quando for
lido o valor zero. Você deve usar uma função para calcular a soma dos divisores de um número.
11. Elabore uma função em C que calcule o valor de o valor aproximado de π com precisão de cinco
décimos através da série:
π = 1/1 3 - 1/3 3 + 1/5 3 - 1/7 3 ...
Considere que a precisão de cinco décimos requer que a soma dos elementos da série só deve ser
interrompida quando o valor do termo é inferior a 0,00001. Para implementar a função não é
permitido utilizar qualquer função da biblioteca de C.
12. Faça um programa em C que:
a) Implemente uma função que calcule o fatorial de um número natural.
b) Implemente uma função que calcule a n-ésima potência de um número x. Leve em conta
que tanto x quanto n são números inteiros, isto é, podem ser positivos, negativos ou zero. Não
é permitido utilizar a função pow(x,y) da biblioteca math.h.
DRAFT
c) Elabore uma função que calcule o valor de e x com precisão de dois décimos através da
série:
e x = x 0 + x 1 /1! + x 2 /2! + x 3 /3! + ...
Considere que a precisão de dois décimos requer que a soma dos elementos da série só deve
ser interrompida quando o valor do termo é inferior a 0,01. Não é permitido usar as funções
implementadas nos ítens a e b desta questão para calcular os termos da série.
d) Elabore uma função que calcule o valor da seguinte expressão (para n > 0):
n 1! + (n–1) −2! + (n–2) 3! + (n–3) −4! + ... + 1 ±n!
Para fazer esta função você pode utilizar as funções implementadas nos ítens a e b desta questão.
e) Faça um programa interativo que permita ao usuário usar todas as funções definidas nos
ítens anteriores. O programa só deve ser encerrado quando o usuário quiser.

92
CAPÍTULO 3. MODULARIZAÇÃO
13. Implemente em C:
a) Uma função que calcule e i . Para isso, considere que o valor do número neperiano é 2,71828
e que i é um número natural.
b) Uma função que calcule e x , para 0 < x < 1. Para isso, considere que e x pode ser
aproximada pela seguinte série:
e x = x 0 + x 1 /1! + x 3 /3! + x 5 /5! + ...
Considere ainda que o valor de e x deve ser aproximado com precisão de cinco décimos, isto é,
a soma dos elementos da série só deve ser interrompida quando o valor do termo é inferior a
0,00001. Não é permitido usar as funções de fatorial e potência para calcular os termos da série.
c) Uma função que calcule e x , onde x é um valor real e maior ou igual a zero. Para tanto,
use as duas funções implementadas nos ítens a e b, considerando que e x = e i+y = e i .e y , para i
natural e 0 < y < 1.
d) Uma função que calcule e x , onde x é um valor real negativo, nulo ou positivo. Para tanto,
use a função do item c e considere que e −y = 1/e y .
3.13 Trabalhos Sugeridos
1. Aplicando Conhecimentos de Cálculo
Um professor de Cálculo teve uma simples ideia para facilitar seu trabalho. Percebendo que
vários alunos tinham dúvidas sobre derivadas e integrais de polinômios, resolveu pedir a um
programador que implementasse um programa para aplicar sua ideia.
O projetor restringiu o programa a polinômios de até grau nove e passou as seguintes especificações
ao programador:
Exemplos de Dados de Entrada
Uma função seria digitada da seguinte maneira: (Opção 1)
+2x4+0x3-25x2+1x1-5x0=
ou seja, a leitura deverá ser pelo teclado e sempre na mesma ordem:
. Observação: a leitura do teclado deve ser feita termo a termo, por
exemplo, “+2x4 [enter] +0x3 [enter]”. Apenas o caractere “=” poderá ser lido separadamente.
Uma função f(x) = 2x 4 − 25x 2 + x − 5 seria digitada da seguinte maneira: (Opção 2)
DRAFT
+2x4-25x2+1x-5=
Ou seja, a leitura deverá ser pelo teclado, porém com algumas diferenças em relação à opção
anterior. Serão omitidos a potência “1”, a variável com potência “0” e os termos com coeficiente
“0”. Observação: nesse caso a leitura também deve ser feita termo a termo, porém, deve-se
lembrar que alguns termos podem ser menores que outros (“+2x4” e “1x”, por exemplo).
Em ambos os casos, a flag de final de leitura será o caractere “=” e os coeficientes serão número
reais (float). A ideia é que, se o programador optar pela segunda opção, o algoritmo deverá ser
genérico ao ponto de receber as duas formas de entrada.
Armazenada a função de entrada, o programa deverá apresentar, no mesmo formato de entrada,
a derivada e a integral da função. O professor ainda deseja que o programa apresente também
as raízes das funções quando estas forem do primeiro ou do segundo grau.
Exemplos de Saída
Usando a função de entrada: f(x) = x 2 − 5x + 6

3.13. TRABALHOS SUGERIDOS 93
ˆ Derivada 2.00x1-5.00x0= (Opção 1) 2.00x-5.00= (Opção 2)
ˆ Integral 0.33x3-2.50x2+6.00x1+C= (Opção 1) 0.33x3-2.50x2+6.00x+C= (Opção 2)
ˆ
Raízes (apenas para funções de primeiro e segundo grau) x1=2.00 x2=3.00 Os coeficientes
e as raízes deverão ser apresentados com 2 casas decimais.
DRAFT

Capítulo 4
Tipos Abstratos de Dados
Objetivos:
ˆ
ˆ
ˆ
Introduzir o conceito de Tipos Compostos Heterogêneos;
Explicar as vantagens da utilização de Tipos Abstratos de dados;
Simplificar a confecção de aplicações mais complexas.
Coautores:
Bruna Vello Colnago
Glaice Quirino
Matheus Dilem
Rodrigo Lopes Batista
Este capítulo busca esclarecer como a criação e manipulação de novos tipos de dados permite
facilitar o entendimento, a confecção e o reaproveitamento de código.
4.1 Técnicas de Programação Top-down e Bottom-up
Para escrever um programa, os programadores podem adotar duas técnicas: a Top-down e a Bottomup.
A técnica Top-down consiste em primeiramente definir a estrutura global do programa e posteriormente
definir cada uma das partes que detalham as suas tarefas. Já a técnica Bottom-up consiste em
considerar o programa como um conjunto de módulos correlacionados, implementar cada um desses
módulos e depois juntá-los por meio de uma estrutura global.
Analogamente, um projetista de automóveis pode inicialmente definir como será o carro, velocidade,
rapidez, rotações máximas entre outros, e posteriormente confeccionar seus componentes (motor,
rodas, freios, suspensão...), conforme a necessidade, agindo de forma Top-down. Ou confeccionar cada
um dos componentes separadamente, garantir seu funcionamento e depois juntá-los em um carro cujas
metas sejam compatíveis com as possibilidades dos componentes, agindo de forma Bottom-up.
Na abordagem Bottom-up, cada módulo é implementado segundo suas funcionalidades e objetivos,
independentemente do restante do programa, assim torna-se mais simples redigir o código do programa,
facilitando o trabalho do programador. Além do mais, a separação do programa em módulos permite a
realização de testes específicos, facilitando a depuração de erros. Outra importância dessa abordagem
é a facilidade de alterar partes do programa, sendo necessário alterar apenas alguns módulos sem se
importar com os demais.
Por fim, o programa torna-se muito mais fácil de ser entendido, ao passo que o leitor não precisa
ler todo o código do programa, bastando saber as funcionalidades de cada módulo. A implementação
dos mesmos importa somente ao programador. Assim, a abordagem Bottom-up é, em muitos casos,
mais vantajosa em relação à Top-down, ao passo que é também mais intuitiva ao programador.
DRAFT
94

4.2. TIPOS COMPOSTOS HETEROGÊNEOS (ESTRUTURAS) 95
4.2 Tipos Compostos Heterogêneos (Estruturas)
As formas de representação de dados apresentadas até agora neste livro são insuficientes para que o
programador possa representar em sua totalidade as possíveis coleções de dados existentes. Programadores
há muito tempo reconhecem o valor de organizar itens de dados correlacionados em uma única
entidade computacional. As Estruturas são entidades que representam tipos de dados e que permitem
o agrupamento de várias variáveis de diversos tipos.
Suponha um programa que faça o cadastro de estudantes de uma universidade, cada um possuindo
um conjunto de atributos correlacionados, como por exemplo: matrícula, idade, coeficiente
de rendimento e período. Utilizando as entidades de programação já conhecidas, no cadastro de um
único aluno seriam necessárias quatro variáveis para representar todos os seus atributos; para dois
estudantes, seriam necessárias oito variáveis; já para diversos estudantes seria necessário um conjunto
de variáveis consideravelmente grande.
A utilização de muitas variáveis aumenta o trabalho do programador e dificulta que outra pessoa
entenda a aplicação. Para solucionar esse problema, muitas linguagens de programação, entre elas
a linguagem C, possibilitam ao programador criar tipos compostos heterogêneos. Na linguagem C,
os tipos compostos heterogêneos são chamados struct (estruturas). As estruturas são conjuntos de
dados correlacionados, que podem ser representados em sua totalidade por uma única variável. No
exemplo mencionado, cada estudante poderia ser representado por uma única variável, dessa forma,
seria necessário adicionar apenas uma variável para cada novo estudante a ser cadastrado.
Dada a impossibilidade de se antecipar todos os tipos de dados utilizados por um programa, uma
linguagem de programação apenas implementa tipos de dados simples. Desse modo, fica a cargo do
programador usar desses dados para a definição de novos tipos de dados.
Além de facilitar e tornar mais clara a implementação, os tipos compostos heterogêneos têm como
finalidades principais a possibilidade de retorno de mais de um valor por função e a criação de tipos
abstratos de dados. Essas características serão discutidas mais adiante neste capítulo.
4.2.1 Definição
Uma estrutura é uma coleção de variáveis, que podem ou não ser de tipos diferentes, colocadas sob
um único nome para manipulá-las. As estruturas ajudam na organização do código e facilitam a vida
do programador, pois juntam variáveis relacionadas e permitem que elas sejam tratadas como uma
unidade maior.
Na prática, uma estrutura é uma “caixa” onde podem ser agrupados diversos dados correlacionados.
Essa caixa, na verdade, é o conjunto de alguns bytes de memória correspondente ao somatório dos
tamanhos dos dados que se pretende agrupar.
A Figura 4.1 ilustra uma estrutura que representa um estudante, tEstudante. Note que a estrutura
tEstudante ocupa um espaço equivalente ao espaço necessário para guardar todos os seus atributos.
DRAFT
Figura 4.1: Estrutura tEstudante.
Sintaxe
Para criar uma estrutura com n atributos, deve-se obedecer à sintaxe exposta abaixo.

96
CAPÍTULO 4. TIPOS ABSTRATOS DE DADOS
struct {
;
;
...
;
};
A palavra struct indica que a entidade criada é uma estrutura e as chaves delimitam o trecho
onde os atributos da estrutura são definidos. Cada atributo é definido por seu tipo seguido de um
identificador.
O Exemplo 4.1 apresenta a sintaxe de uma estrutura para o caso do estudante.
1 struct tEstudante {
2 int idade ;
3 int matricula ;
4 float coeficiente ;
5 int periodo ;
6 };
4.2.2 Uso
Exemplo 4.1: Sintaxe da estrutura tEstudante.
Como as estruturas são conjuntos de dados, existem duas formas básicas de manipulá-las, selecionando
um único elemento de dado (modo seletivo), ou manipulando toda a estrutura (modo integral).
Seletivo
Para manipular cada um dos atributos da estrutura se utiliza o mecanismo de seleção conforme a
sintaxe apresentada a seguir.
.
O Exemplo 4.2 ilustra o uso seletivo da estrutura tEstudante. Nesse Exemplo, a leitura de dados
é feita atribuindo-se cada valor lido a um atributo da estrutura.
1 # include
2
3 struct tEstudante {
4 int idade ;
5 int matricula ;
6 float coeficiente ;
7 int periodo ;
8 };
9
10 int main (){
11 struct tEstudante aluno ;
12
DRAFT
13 printf (" Digite os dados do estudante \n");
14 scanf ("%d %d %f %d", & aluno . idade , & aluno . matricula , & aluno . coeficiente , & aluno
. periodo );
15
16 return 0;
17 }
Exemplo 4.2: Acesso seletivo a atributos da estrutura tEstudante.
No Exemplo 4.2, primeiramente é feita a definição da estrutura tEstudante antes da função main
(linhas 3 a 8) e em seguida, dentro da função main, é feita a criação da variável aluno (linha 11),
do tipo tEstudante. Na função scanf é feito, então, o acesso seletivo aos atributos da variável aluno
(linha 14).

4.2. TIPOS COMPOSTOS HETEROGÊNEOS (ESTRUTURAS) 97
Integral
Quando se deseja manipular a estrutura como um todo, se utiliza simplesmente o nome da variável
onde a mesma está armazenada. O uso integral em atribuições é descrito pela sintaxe a seguir.
= ;
O Exemplo 4.3 ilustra o uso integral da estrutura tEstudante.
1 # include
2
3 struct tEstudante {
4 int idade , matricula , periodo ;
5 float coeficiente ;
6 };
7
10
8 int main (){
9 struct tEstudante aluno , outro ;
11 printf (" Digite os dados do estudante \n");
12 scanf ("%d %d %f %d", & aluno . idade , & aluno . matricula , & aluno . coeficiente , & aluno
. periodo );
13
14 outro = aluno ;
15
16 return 0;
17 }
Exemplo 4.3: Acesso integral à estrutura.
No Exemplo 4.3, os atributos idade, matricula e periodo da estrutura tEstudante foram declarados
na mesma linha (linha 5) por serem do mesmo tipo, tipo int. Do mesmo modo, na função main, as
variáveis aluno e outro foram declaradas na mesma linha (linha 10) por serem do mesmo tipo, tipo
tEstudante. No final da função main é feita uma cópia dos valores dos atributos da variável aluno
para a variável outro. Com isso, ao final da execução do programa, os valores dos atributos de outro
são iguais aos valores dos atributos de aluno.
4.2.3 O Comando Typedef
DRAFT
A forma de definição de uma estrutura apresentada até agora neste livro é inconveniente, pois requer a
repetição da palavra struct sempre que ela for utilizada. O comando typedef pode ser utilizado para
resolver este problema, renomeando tanto tipos simples como compostos. Para utilizar o comando
typedef, deve-se obedecer à sintaxe exposta abaixo.
typedef ;
Na prática, a renomeação de tipos facilita o entendimento e a escrita de código.
O Exemplo 4.4 apresenta a utilização do typedef.
1 typedef struct tEstudante tEstudante ;
2
3 typedef float distancia ;
Exemplo 4.4: Uso do comando typedef.
O Exemplo 4.5 apresenta a adaptação do Exemplo 4.3 para a utilização do comando typedef,
permitindo que o tipo composto heterogêneo struct tEstudante seja utilizado através da palavra
tEstudante.

98
CAPÍTULO 4. TIPOS ABSTRATOS DE DADOS
1 # include
2
3 struct tEstudante {
4 int idade ;
5 int matricula ;
6 float coeficiente ;
7 int periodo ;
8 };
9
10 typedef struct tEstudante tEstudante ;
11
12 int main (){
13 tEstudante aluno , outro ;
14
15 printf (" Digite os dados do estudante \n");
16 scanf ("%d %d %f %d" ,& aluno . idade ,& aluno . matricula ,& aluno . coeficiente ,& aluno .
periodo );
17
18 outro = aluno ;
19
20 return 0;
21 }
Exemplo 4.5: Uso de uma estrutura renomeada com o comando typedef.
4.2.4 Simplificação na Passagem de Parâmetros e Retorno de Função
Conforme comentou-se anteriormente, as estruturas são conjuntos de dados inter-relacionados, dessa
forma a passagem de parâmetros de função é simplificada, pois ao invés de cada um dos atributos ser
um parâmetro da função, apenas a estrutura é passada. Note a diferença entre a lista de parâmetros
das duas funções representadas no Exemplo 4.6.
1 void funcao1 ( int idade , int matricula , float coeficiente , int periodo ){ ... }
2
3 void funcao2 ( tEstudante aluno ){ ... }
Exemplo 4.6: Passagem de estrutura por parâmetro.
DRAFT
A mesma função pode ser escrita dos dois modos apresentados no Exemplo 4.6. Na funcao1 ,
quatro variáveis relacionadas ao estudante são passadas como parâmetro. Na funcao2 , o próprio
estudante é passado como parâmetro. A funcao2 é mais compreensível que a funcao1 , pois a pessoa
que ler o código da funcao1 terá que inferir que aquelas quatro variáveis referem-se a um mesmo
estudante.
Da mesma forma, o retorno de funções pode ser simplificado pelo uso de estruturas. Suponha que
se deseja criar uma função para fazer a leitura de dados de um estudante. O Exemplo 4.7 mostra
duas maneiras de fazer isso: utilizando funções que retornam estruturas ou funções que retornam tipos
simples. Além disso, observa-se uma nova forma de declarar estruturas no mesmo Exemplo 4.7: o
typedef renomeia a própria estrutura no momento de sua declaração, ao invés de se renomear após a
declaração.
1 # include
2
3 typedef struct {
4 int idade ;
5 int matricula ;
6 float coeficiente ;
7 int periodo ;
8 } tEstudante ;
9
10 int leituraPeriodo (){

4.2. TIPOS COMPOSTOS HETEROGÊNEOS (ESTRUTURAS) 99
11 int periodo ;
12
13 scanf ("%d", & periodo );
14
15 return periodo ;
16 }
17
18 int leituraMatricula (){
19 int matricula ;
20
21 scanf ("%d", & matricula );
22
23 return matricula ;
24 }
25
26 float leituraCoeficiente (){
27 float coeficiente ;
28
29 scanf ("%f", & coeficiente );
30
31 return coeficiente ;
32 }
33
34 int leituraIdade (){
35 int idade ;
36
37 scanf ("%d", & idade );
38
39 return idade ;
40 }
41
42 tEstudante leituraEstudante (){
43 tEstudante aluno ;
44
45 scanf ("%d %d %f %d", & aluno . idade , & aluno . matricula , & aluno . coeficiente , & aluno
. periodo );
46
47 return aluno ;
48 }
49
50 int main (){
51 tEstudante aluno1 , aluno2 ;
52
53 aluno1 . periodo = leituraPeriodo ();
54 aluno1 . matricula = leituraMatricula ();
55 aluno1 . coeficiente = leituraCoeficiente ();
56 aluno1 . idade = leituraIdade ();
57 aluno2 = leituraEstudante ();
58
59 return 0;
60 }
DRAFT
Exemplo 4.7: Estrutura como retorno de função.
No Exemplo 4.7 é realizada a leitura de dados de aluno1 sem utilizar o retorno de estruturas, e de
aluno2, utilizando-o. Para realizar a leitura de aluno1 foram necessárias a criação de quatro funções
diferentes, uma para cada atributo, e quatro chamadas a estas funções na sub-rotina principal, main.
Para realizar a leitura de aluno2 foram necessárias a criação de apenas uma função e uma chamada
a esta função função na main. Assim, pode-se perceber que o retorno de estruturas torna o código
mais coeso, compacto, legível e eficiente, por ter menos chamadas de função.

100
CAPÍTULO 4. TIPOS ABSTRATOS DE DADOS
4.3 Tipos Abstratos de Dados
Tipos abstratos de dados (TADs) são novos tipos de dados implementados pelo programador, nos
quais ele define tanto as estruturas de dados quanto as operações a elas aplicáveis, conforme suas
necessidades para a resolução de um determinado problema.
Os TADs podem ser considerados generalizações de tipos primitivos de dados, assim como funções
são generalizações de operações primitivas, tais como adição, subtração e multiplicação. Da mesma
forma que funções podem ser usadas para encapsular partes de algoritmos, o TAD pode ser usado
para encapsular tipos de dados.
O TAD pode ser discutido pela perspectiva do implementador e do usuário do tipo. O implementador
cria as estruturas de dados e implementa as funções para manipulá-las. Já o usuário utiliza
esse TAD como se fosse um tipo de dados fornecido pela linguagem de programação. Deste modo, o
usuário só deve manipular os atributos do TAD através das funções definidas pelo implementador do
tipo.
4.3.1 Definição
Um tipo abstrato de dados é um tipo de dado definido em termos do seu comportamento e não em
termos de sua representação. A ideia de tipo abstrato de dados é desvincular o tipo de dado (valores
e operações) de sua implementação, ou seja, quando definimos um tipo abstrato de dados estamos
preocupados com o que ele faz e não como ele faz.
Os programas que usam um determinado tipo abstrato de dados são chamados clientes; e o programa
que define sua estrutura e comportamento é conhecido como implementação. Um TAD pode
ser definido como a composição de uma estrutura de dados e das operações definidas sobre estes dados.
Exemplo da Definição de um Tipo Composto com Operações Pré-definidas
Suponha que se deseja definir um tipo abstrato de dados tData, considerando os atributos dia, mês
e ano. Primeiramente, deve-se decidir as operações a serem definidas para o TAD, que podem ser as
seguintes:
ˆ
ˆ
ˆ
ˆ
ˆ
ˆ
inicializacaoData: função que inicializa uma data a partir de valores passados como parâmetro.
leituraData: função que inicializa uma data a partir de valores lidos do teclado.
DRAFT
alteracaoData: função que altera uma data a partir de valores passados como parâmetro.
serBissexto: função que indica se um ano é bissexto ou não.
diasNoMes: função que indica a quantidade de dias do mês em questão.
diaSeguinte: função que altera a data para o dia seguinte.
Pode-se então implementar o TAD na linguagem desejada. No Exemplo 4.8, observa-se a implementação
do TAD tData na linguagem C.
1 # include
2
3 typedef struct data {
4 int dia ;
5 int mes ;
6 int ano ;
7 } tData ;
8
9 tData inicializacaoData ( int d, int m, int a){
10 tData dt;
11
12 dt.dia = d;
13 dt.mes = m;

4.3. TIPOS ABSTRATOS DE DADOS 101
14 dt.ano = a;
15
16 return dt;
17 }
18
19 tData leituraData (){
20 tData d;
21
22 printf (" Entre com a data \n");
23 scanf ("%d %d %d", &d.dia , &d.mes , &d. ano );
24
25 return d;
26 }
27
28 tData alteracaoData ( int d, int m, int a){
29 tData dt;
30
31 dt.dia = d;
32 dt.mes = m;
33 dt.ano = a;
34
35 return dt;
36 }
37
38 int serBissexto ( tData d){
39 if(d. ano %400 == 0){
40 return 1;
41 }
42
43 if(d. ano %100 == 0){
44 return 0;
45 }
46
47 if(d. ano %4 == 0){
48 return 1;
49 } else {
50 return 0;
51 }
52 }
53
54 int diasNoMes ( tData d){
DRAFT
55 if(d. mes == 4 || d. mes == 6 || d. mes == 9 || d. mes == 11) {
56 return 30;
57 } else {
58 if (d. mes == 2){
59 if( serBissexto (d)){
60 return 29;
61 } else {
62 return 28;
63 }
64 } else {
65 return 31;
66 }
67 }
68 }
69
70 tData diaSeguinte ( tData d){
71 if(d. dia < diasNoMes (d)){
72 d. dia ++;
73 } else {
74 d. dia = 1;
75 if(d. mes < 12) {
76 d. mes ++;
77 } else {
78 d. mes = 1;
79 d. ano ++;

102
CAPÍTULO 4. TIPOS ABSTRATOS DE DADOS
80 }
81 }
82
83 return d;
84 }
Exemplo 4.8: Definição do TAD tData.
O código do Exemplo 4.8 ilustra a definição de um Tipo Composto com Operações Pré-definidas. O
tipo tData contém os atributos de uma data. Uma variável desse tipo é inicializada através da função
inicializacaoData e essa função permite a inicialização dos atributos sem que estes sejam acessados
pelo usuário, ou seja, o acesso aos atributos ocorre no padrão estipulado de dentro da função, não
permitindo, assim, que o usuário inicialize os atributos acessando-os erroneamente. A função de leitura
leituraData obtém uma data do teclado e retorna uma variável do tipo tData contendo os valores
lidos. A função alteracaoData apresenta o mesmo código que a função de inicialização, contudo sua
utilização destina-se a datas já inicializadas. A função serBissexto verifica se uma dada data está
em um ano bissexto, o algoritmo considera a seguinte regra: São bissextos todos os anos múltiplos
de 400, não são bissextos todos os múltiplos de 100 e não de 400, são bissextos todos os múltiplos de
4 e não múltiplos de 100, por fim, não são bissextos todos os demais anos. A função diasNoMes
determina o número de dias do mês de uma determinada data. Os meses de abril, junho, setembro e
novembro possuem 30 dias. Caso a data seja do mês de fevereiro, verifica-se se o ano é bissexto, se for
bissexto o mês tem 29 dias, se não for bissexto o mês tem 28 dias. Caso a data não esteja em nenhum
dos meses citados, o mês tem 31 dias.
Importância de Definir Tipos com Operações Próprias
A criação de um conjunto de operações próprias de um TAD tem como finalidade torná-lo, aos olhos
do usuário, um tipo de dados da própria linguagem, ou seja, o usuário não deve se preocupar em
como são implementados os TADs. Além do mais, utilizar as operações do TAD torna o código mais
confiável. Suponha uma aplicação que utilize o TAD tData conforme o Exemplo 4.9.
1 # include
2
3 // A definicao do TAD , bem como suas operacoes , estao no Exemplo 4.6
4
5 int main (){
6 tData d;
7
8 d = leituraData ();
9
10 printf (" Passou um dia !\n");
11
12 d. dia ++;
13
DRAFT
14 printf (" Hoje e %d/%d/%d.\n", d.dia , d.mes , d. ano );
15
16 return 0;
17 }
Exemplo 4.9: Problema de Confiabilidade no uso do TAD tData.
Observe que, no Exemplo 4.9, a intenção do programador foi adicionar um dia à data lida, entretanto,
ele não utilizou a função do tipo diaSeguinte. Para grande parte dos valores de data, o
programa funcionaria corretamente, entretanto, para datas que são o último dia do mês, esse programa
gera inconsistência, pois a data obtida não será uma data válida. No decorrer da aplicação,
um valor inválido de data será repassado para outras partes do programa, acarretando problemas no
código. Sendo assim, é altamente recomendável que se utilizem apenas as operações já definidas para
manipular as estruturas do TAD e que não ocorra a manipulação direta de atributos.

4.3. TIPOS ABSTRATOS DE DADOS 103
Vantagens de Usar TADs
As vantagens de utilizar um TAD são:
ˆ
Facilidade de Manutenção: pode-se alterar o tipo usado sem alterar a aplicação. Por exemplo,
pode-se incluir novos atributos ou operações sem que o código que utilize o tipo seja alterado.
ˆ
Reutilização: um TAD bem generalizado pode ser utilizado em diversas aplicações.
ˆ
Abstração: a abstração de informações através do TAD permite a melhor compreensão dos
algoritmos e maior facilidade de programação.
ˆ
Ocultamento: separa o código de implementação do código de uso do TAD, que funciona como
um tipo de dados fornecido pela linguagem.
ˆ Integridade: a manipulação dos atributos por operações definidas sobre o tipo impedem a
ocorrência de inconsistências.
Na prática, essas vantagens tornam o código mais fácil de se escrever, mais compreensível para
quem lê e mais fácil de se modificar.
4.3.2 Definição de Atributos de um TAD
Os atributos de um TAD são os dados que se relacionam a ele. Por exemplo, no caso do estudante,
seus atributos são: idade, matrícula, coeficiente de rendimento e período. Conforme definido na Seção
4.2.1.
4.3.3 Definição de Operações de um TAD
As operações de um TAD são funções utilizadas para acesso aos dados. Estas operações visam impedir
o acesso direto aos dados, assim, o usuário só deve acessar os dados através dessas operações.
Tipos de Operações de um TAD
Um TAD não é definido por seus atributos, mas sim por suas operações. As operações são a interface do
programador usuário com a própria representação interna. Existem cinco tipos diferentes de operações
que podem ser realizadas sobre um TAD:
Construtoras
DRAFT
Operações construtoras são aquelas que inicializam variáveis, logo devem ser utilizadas antes de qualquer
outra para garantir que o TAD foi inicializado corretamente. Observe no Exemplo 4.10 diferentes
implementações de funções construtoras para o TAD estudante.
1 tEstudante inicializacao (){
2 tEstudante novo ;
3
4 novo . idade = 0;
5 novo . matricula = 0;
6 novo . coeficiente = 0;
7 novo . periodo = 0;
8
9 return novo ;
10 }
11
12 tEstudante inicializacaoValores ( int idade , int matricula , float coeficiente , int
periodo ){
13 tEstudante novo ;
14
15 novo . idade = idade ;
16 novo . matricula = matricula ;

104
CAPÍTULO 4. TIPOS ABSTRATOS DE DADOS
17 novo . coeficiente = coeficiente ;
18 novo . periodo = periodo ;
19
20 return novo ;
21 }
Exemplo 4.10: Diferentes formas de Implementação da função construtora para o TAD tEstudante.
A função inicializacao inicia com zero todos os atributos de uma variável do tipo tEstudante,
esta variável é retornada pela função de inicialização. A função inicializacaoValores exerce o mesmo
papel de inicializar que a função inicializacao. Contudo, esta recebe os valores a serem inicializados
como parâmetros.
Analisadoras
As operações analisadoras ou consultoras analisam o conteúdo de um TAD e retornam propriedades,
ou seja, essas operações obtêm informações do TAD. O Exemplo 4.11 mostra uma função analisadora.
1 int bomAluno ( tEstudante aluno ){
2 if( aluno . coeficiente > 7.0) {
3 return 1;
4 } else {
5 return 0;
6 }
7 }
Exemplo 4.11: Função analisadora.
Observa-se, no Exemplo 4.11, que a função bomAluno é um exemplo de função analisadora para
o TAD tEstudante, pois retorna uma propriedade do mesmo (se é um bom aluno).
Modificadoras
As operações modificadoras, ou atualizadoras, permitem alterações de atributos do TAD. O Exemplo
4.12 mostra uma função modificadora para o TAD tEstudante.
DRAFT
1 tEstudante alteracaoIdade ( tEstudante aluno , int novaIdade ){
2 aluno . idade = novaIdade ;
3
4 return aluno ;
5 }
Produtoras
Exemplo 4.12: Função modificadora.
As operações produtoras são aquelas que, a partir dos dados de um TAD, produzem uma nova informação.
A função calculoPeriodosRestantes, do Exemplo 4.13, produz um resultado (os períodos
restantes) a partir dos dados de um estudante.
1 int calculoPeriodosRestantes ( tEstudante estudante ){
2 int periodosTotais , periodosRestantes ;
3
4 printf (" Entre com a quantidade de periodos do curso do estudante de matricula %
d:", estudante . matricula );
5 scanf ("%d", & periodosTotais );
6
7 periodosRestantes = periodosTotais - estudante . periodo ;
8
9 return periodosRestantes ;

4.3. TIPOS ABSTRATOS DE DADOS 105
10 }
Exemplo 4.13: Exemplo de função produtora.
Destrutoras
As operações destrutoras são utilizadas para realizar algum tipo de finalização quando o valor do TAD
não é mais necessário. Por exemplo, no caso do estudante, poderia ser uma função que solicitasse que
o aluno fosse removido do quadro de estudantes da instituição.
4.3.4 Uso do TAD
Considere o Exemplo 4.21 que faz uso do TAD tData.
operações pré-definidas.
1 # include
2
Note que o TAD é acessado apenas pelas
3 // A definicao do TAD , bem como suas operacoes , estao no Exemplo 4.8
4
5 int main (){
6 tData data ;
7 int anoBissexto ;
8 int nDias ;
9
10 data = leituraData ();
11 anoBissexto = serBissexto ( data );
12
13 if( anoBissexto ){
14 printf (" Ano Bissexto .\n");
15 } else {
16 printf (" Ano nao Bissexto .\n");
17 }
18
19 nDias = diasNoMes ( data );
20 printf (" Numero de dias no mes : %d\n", nDias );
21
22 return 0;
23 }
Exemplo 4.14: Uso do TAD tData.
O Exemplo 4.21 determina se uma data digitada pelo teclado é de um ano bissexto e o número
de dias no mês da data digitada. Pode-se afirmar que o programa usuário manipula o TAD somente
através das operações predefinidas pelo implementador, assim o código usuário fica mais legível. Podese
observar que as operações separam o código usuário do código de implementação do TAD. A
redigibilidade também aumenta, visto que o acesso aos dados é realizado apenas por simples operações.
O código também fica mais confiável, pois o usuário não altera livremente os dados, isso só pode ser
feito através das operações do TAD. E, por fim, caso a implementação do TAD precise ser alterada, o
código usuário não sofrerá mudanças, a menos que os cabeçalhos das funções sejam alterados.
4.3.5 Tipos de TADs
DRAFT
Os TADs podem se dividir em TADs de Domínio e TADs Implementacionais, conforme sua relação
com o problema ou com sua solução.
TADs de Domínio
São aqueles que definem um tipo de dados que está no domínio do problema. Como por exemplo, os
TADs tEstudante e tData.

106
CAPÍTULO 4. TIPOS ABSTRATOS DE DADOS
TADs Implementacionais
São objetos de programação que não tem relação direta com o problema, mas sim com sua implementação.
Nos próximos capítulos, serão apresentados alguns tipos de TADs implementacionais.
4.4 Exercícios Resolvidos
Exercício Resolvido 4.1 - Operações sobre a estrutura tData
Faça um programa com a estrutura do tipo data que realize operações (sobre este tipo) de edição
e consulta.
Solução Possível:
Este programa utiliza operações de alteração e apresentação sobre o TAD para datas. A estrutura
para datas é declarada como um tipo utilizando o comando typedef. A operação alteracaoData
recebe como parâmetros o dia, o mês e o ano de uma determinada data e retorna a estrutura tData
com a data informada. A operação apresentacaoData realiza a apresentação de uma data. Assim,
pode-se observar as vantagens da utilização de TADs. Essas duas operações possibilitam escrever
menos, visto que, uma vez definidas, podem ser reaproveitadas. A data é inicializada no corpo do
programa em 30/01/1984, em seguida é alterada. A saída do programa é a apresentação da data
16/05/2007.
Pseudocódigo 4.1 Manipulação do TAD tData.
Descrição: Operações sobre um TAD que representa data.
Dados de Entrada: Valores inteiros correspondentes a datas.
Saída do Programa: Apresentação da data predefinida na tela.
Tipo abstrato de dados " tData ":
Variável do tipo inteiro dia .
Variável do tipo inteiro m^es.
Variável do tipo inteiro ano .
FIM - Tipo abstrato de dados
DRAFT
Funç~ao Principal :
Declarar uma variável do TAD tData chamada dt.
Usar o Processo componente " alterarData " para definir a data armazenada em dt ,
passando como par^ametro tr^es valores inteiros ( novo dia , novo m^es e novo ano )
.
Usar o Processo componente " alterarData " para alterar a data armazenada em dt ,
passando como par^ametro tr^es valores inteiros (dia , m^es e ano ).
Usar o Processo componente " apresentarData " para apresentar o valor de dt na
tela , passando como par^ametro a própria variável dt.
FIM - Funç~ao Principal
Processo componente " alterarData ":
Armazenar na variável dia do TAD tData o valor do par^ametro novo dia .
Armazenar na variável m^es do TAD tData o valor do par^ametro novo m^es.
Armazenar na variável ano do TAD tData o valor do par^ametro novo ano .
FIM - Processo componente " alterarData "
Processo componente " apresentarData ":
Apresentar na tela o valor de dia , m^es e ano , armazenados no par^ametro do tipo
tData .
FIM - Processo componente " apresentarData "
1 # include
2

4.4.
EXERCÍCIOS RESOLVIDOS 107
3 typedef struct data {
4 int dia ;
5 int mes ;
6 int ano ;
7 } tData ;
8
9 tData alterarData ( int d,int m,int a){
10 tData dt;
11
12 dt.dia =d;
13 dt.mes =m;
14 dt.ano =a;
15
16 return dt;
17 }
18
19 void apresentarData ( tData data ) {
20 printf (" Data : %d/%d/%d\n", data .dia , data .mes , data . ano );
21 }
22
23 int main () {
24 tData dataNascimento ;
25
26 dataNascimento = alterarData (30 ,01 ,1984) ;
27 dataNascimento = alterarData (16 ,05 ,2007) ;
28
29 apresentarData ( dataNascimento );
30
31 return 0;
32 }
Exemplo 4.15: Programa que realiza operações de alteração e apresentação.
Exercício Resolvido 4.2 - Menor Data
Escreva um programa em C que leia duas datas e retorne a menor data cronologicamente. As
datas devem ser armazenadas em estruturas.
Solução Possível:
O programa determina qual é a menor data entre duas. A inicialização das datas é realizada
por leitura do teclado. O retorno da operação menorData é a menor entre duas datas, a primeira
verificação é realizada quanto ao ano, caso o ano das datas sejam iguais verifica-se o mês, se os meses
são iguais verifica-se o dia.
Pseudocódigo 4.2 Manipulação do TAD tData.
DRAFT
Descrição: Leitura e comparação de datas utilizando operações em TAD.
Dados de Entrada: Valores inteiros correspondentes a datas.
Saída do Programa: Apresentação na tela da data mais antiga.
Tipo abstrato de dados " tData ":
Variável do tipo inteiro dia .
Variável do tipo inteiro m^es.
Variável do tipo inteiro ano .
FIM - Tipo abstrato de dados
Funç~ao Principal :
Declarar duas variáveis do TAD tData chamadas data0 e data1 .
Usar o Processo componente " leituraData " para definir a data armazenada em
data0 .
Usar o Processo componente " leituraData " para definir a data armazenada em
data1 .

108
CAPÍTULO 4. TIPOS ABSTRATOS DE DADOS
Usar o Processo componente " menorData " para determinar a data mais antiga ,
passando como par^ametro data0 e data1 .
Apresentar a data mais antiga na tela .
FIM - Funç~ao Principal
Processo componente " menorData ":
SE o ano de data0 é menor que o ano de data1 :
A data mais antiga será data0 .
FIM -SE
SE o ano de data1 é menor que o ano de data0 :
A data mais antiga será data1 .
FIM -SE
SE o m^es de data0 é menor que o m^es de data1 :
A data mais antiga será data0 .
FIM -SE
SE o m^es de data1 é menor que o m^es de data0 :
A data mais antiga será data1 .
FIM -SE
SE o dia de data0 é menor que o dia de data1 :
A data mais antiga será data0 .
FIM -SE
SE o dia de data1 é menor que o dia de data0 :
A data mais antiga será data1 .
FIM -SE
FIM - Processo componente " menorData "
Processo componente " leituraData ":
Pedir ao usuário que entre com a data .
Ler a entrada do usuário .
Retornar a data lida do teclado .
FIM - Processo componente " leituraData "
1 # include
2
3 typedef struct data {
4 int dia ;
5 int mes ;
6 int ano ;
7 } tData ;
8
10
9 tData menorData ( tData data0 , tData data1 ){
11 if( data0 . ano < data1 . ano ){
12 return data0 ;
13 }
14
15 if( data1 . ano < data0 . ano ){
16 return data1 ;
17 }
18
19 if( data0 . mes < data1 . mes ){
20 return data0 ;
21 }
22
23 if( data1 . mes < data0 . mes ){
24 return data1 ;
25 }
26
27 if( data0 . dia < data1 . dia ){
28 return data0 ;
29 }
30
31 return data1 ;
32 }
DRAFT

4.4.
EXERCÍCIOS RESOLVIDOS 109
33
34 tData leituraData (){
35 tData d;
36
37 printf (" Entre com a data ");
38 scanf ("%d %d %d", &d.dia , &d.mes , &d. ano );
39
40 return d;
41 }
42
43 int main (){
44 tData data0 , data1 , menor ;
45
46 printf (" Primeira data :\n");
47
48 data0 = leituraData ();
49
50 printf ("\ nSegunda data :\n");
51
52 data1 = leituraData ();
53 menor = menorData ( data0 , data1 );
54
55 printf ("\nA menor data e: %d/ %d/ %d.\n", menor .dia , menor .mes , menor . ano );
56
57 return 0;
58 }
Exemplo 4.16: Programa que lê duas datas e retorna a menor data cronologicamente.
Exercício Resolvido 4.3 - TAD tPonto
Defina a estrutura de dados necessária para um TAD tPonto que representa os pontos no plano
cartesiano de duas dimensões.
Solução Possível:
Para representar um ponto, é criada uma estrutura com dois atributos, as coordenadas x e y.
Pseudocódigo 4.3 Definição de TAD tPonto.
Descrição: Definição do TAD tPonto.
Dados de Entrada: Nenhuma.
Saída do Programa: Nenhuma.
DRAFT
Tipo abstrato de dados " tPonto ":
Variável do tipo inteiro x.
Variável do tipo inteiro y.
FIM - Tipo abstrato de dados
1 typedef struct {
2 int x;
3 int y;
4 } tPonto ;
Exemplo 4.17: Programa que define a estrutura tPonto.
Exercício Resolvido 4.4 - Operação tPonto simetricoOrigem (tPonto ponto)
Implemente a operação tPonto simetricoOrigem (tPonto ponto), para determinar o ponto
simétrico de um ponto em relação à origem.

110
CAPÍTULO 4. TIPOS ABSTRATOS DE DADOS
Solução Possível:
A operação simetricoOrigem tem como retorno uma variável do tipo tPonto. Para obter um
ponto simétrico a outro em relação a origem, basta inverter as coordenadas do ponto dado.
Pseudocódigo 4.4 Operação que retorna o valor simétrico ao dado em relação a origem.
Descrição: Operação que retorna o valor simétrico ao dado em relação a origem.
Dados de Entrada: Valor ponto do tipo tPonto.
Saída do Programa: Simétrico de ponto.
Processo componente " simetricoOrigem ":
Atribuir para a variável x de ponto o seu oposto , ou seja , -x.
Atribuir para a variável y de ponto o seu oposto , ou seja , -y.
Retornar ponto .
FIM - Processo componente " simetricoOrigem "
1 tPonto simetricoOrigem ( tPonto ponto ){
2 ponto .x = -ponto .x;
3 ponto .y = -ponto .y;
4
5 return ponto ;
6 }
Exemplo 4.18: Programa que define a operação simetricoOrigem.
Exercício Resolvido 4.5 - Operação int qualQuadrante (tPonto ponto)
Implemente a operação int qualQuadrante (tPonto ponto) que determina a qual quadrante
pertence um ponto.
Solução Possível:
Dado um ponto, a operação qualQuadrante retorna a qual quadrante esse ponto pertence. A
função retorna 0 quando o ponto for parte do limite de quadrantes, 1 quando o ponto pertencer ao
DRAFT
1º quadrante, 2 quando pertencer ao 2º quadrante, 3 se pertencer ao 3º quadrante e 4 caso seja do 4º
quadrante. Para determinar a que quadrante o ponto pertence, é utilizado um conjunto de if e else
aninhados que verificam os sinais das coordenadas.
Pseudocódigo 4.5 Operação que determina a qual quadrante pertence um ponto.
Descrição: Operação que determina a qual quadrante pertence um ponto.
Dados de Entrada: Valor ponto do tipo tPonto.
Saída do Programa: Valor que representa o quadrante em que está ponto, que será um inteiro de 0 a 4, sendo
que 0 significa que ponto está sobre os eixos.
Processo componente " qualQuadrante ":
SE x de ponto é zero ou y de ponto é zero :
Retornar 0.
FIM -SE
SE x de ponto é maior que zero :
SE y de ponto é maior que zero :
Retornar 1.
SEN~AO
Retornar 4.
FIM -SE
FIM -SE
SE y de ponto é maior que zero :

4.4.
EXERCÍCIOS RESOLVIDOS 111
Retornar 2.
SEN~AO
Retornar 3.
FIM -SE
FIM - Processo componente " qualQuadrante "
1 int qualQuadrante ( tPonto ponto ){
2
3 if( ponto .x == 0 || ponto .y == 0){
4 return 0;
5 }
6
7 if( ponto .x > 0){
8 if( ponto .y > 0){
9 return 1;
10 } else {
11 return 4;
12 }
13 }
14
15 if( ponto .y > 0){
16 return 2;
17 } else {
18 return 3;
19 }
20 }
Exemplo 4.19: Programa que define a operação qualQuadrante.
Exercício Resolvido 4.6 - Operação float distanciaPontos (tPonto a, tPonto b)
Defina um programa que calcule a distância entre dois pontos utilizando a estrutura tPonto.
Solução Possível:
A função distanciaPontos calcula a distância entre dois pontos, dada pela raiz quadrada da
soma do quadrado da diferença entre as abscissas e entre as ordenadas.
DRAFT
Pseudocódigo 4.6 Operação que calcula a distância entre dois pontos.
Descrição: Operação que calcula a distância entre dois pontos.
Dados de Entrada: Dois valores, ponto1 e ponto2 do tipo tPonto.
Saída do Programa: Distância euclidiana entre os dois pontos dados.
Processo componente " distanciaPontos ":
Declarar tr^es variáveis do tipo ponto flutuante , chamadas deltaX , deltaY e dist
^ancia .
Atribuir a deltaX a soma da variável x de ponto1 com o negativo da variável x
de ponto2 .
Atribuir a deltaY a soma da variável y de ponto1 com o negativo da variável y
de ponto2 .
Atribuir a dist^ancia a soma dos quadrados de deltaX e deltaY .
Atribuir a dist^ancia sua própria raiz quadrada .
Retornar dist^ancia .
FIM - Processo componente " distanciaPontos "
1 # include
2
3 float distanciaPontos ( tPonto a, tPonto b){
4 float distancia , deltaX , deltaY ;

112
CAPÍTULO 4. TIPOS ABSTRATOS DE DADOS
5
6 deltaX = a.x - b.x;
7 deltaY = a.y - b.y;
8
10
9 distancia = sqrt ( pow ( deltaX ,2) + pow ( deltaY ,2) );
11 return distancia ;
12 }
Exemplo 4.20: Programa que calcula a distância entra dois pontos.
Exercício Resolvido 4.7 - Operações inicializacao() e finalizacao()
Defina um programa que implemente e use operações construtoras e destrutoras utilizando a estrutura
tPonto. Utilize também a operação distanciaPontos definida anteriormente.
Solução Possível:
Inicialmente, são definidas as funções inicializacao e finalizacao. A função inicializacao inicializa
o tPonto a partir de valores fornecidos pelo usuário e a função finalizacao zera as coodernadas
do ponto. A função principal utiliza os métodos declarados de forma a corresponder à funcionalidade
desejada.
Pseudocódigo 4.7 Operações de construção e destruição em TADs
Descrição: Programa que calcula a distância entra dois pontos.
Dados de Entrada: Dois valores ponto1 e ponto2 do tipo tPonto.
Saída do Programa: Distância euclidiana entre os dois pontos dados.
Funç~ao Principal :
Declarar duas variáveis do tipo tPonto chamadas a e b.
Declarar um variável do tipo ponto flutuante chamada dist^ancia .
Usar o Processo componente " inicializaç~ao", inicializando a.
Usar o Processo componente " inicializaç~ao", inicializando b.
Usar o processo componente " ditanciaPontos ", passando a e b como par^ametros e
atribuindo o resultado variável dist^ancia .
Apresentar o valor de dist^ancia na tela .
Usar o Processo componente " finalizaç~ao", finalizando a.
Usar o Processo componente " finalizaç~ao", finalizando b.
FIM - Funç~ao Principal
DRAFT
Processo componente " inicializaç~ao":
Declarar variável ponto do tipo tPonto .
Pedir ao usuário que entre com um valor inteiro .
Atribuir o valor dado a variável x de ponto .
Pedir ao usuário que entre com um valor inteiro .
Atribuir o valor dado a variável y de ponto .
Retornar ponto .
FIM - Processo componente " inicializaç~ao"
Processo componente " finalizaç~ao":
Declarar variável ponto do tipo tPonto .
Atribuir o valor zero a variável x de ponto .
Atribuir o valor zero a variável y de ponto .
Retornar ponto .
FIM - Processo componente " finalizaç~ao"
1 # include
2
3 \\ Operacao Construtora
4 tPonto inicializacao (){

4.5. RESUMO 113
5 tPonto ponto ;
6
7 printf (" Entre com as coordenadas \n");
8 printf ("X: ");
9 scanf ("%d", & ponto .x);
10 printf ("Y: ");
11 scanf ("%d", & ponto .y);
12
13 return ponto ;
14 }
15
16 \\ Operacao Destrutora
17 tPonto finalizacao (){
18 tPonto origem = {0 , 0};
19
20 return origem ;
21 }
22
23 int main (){
24 tPonto a, b;
25 float distancia ;
26
27 a = inicializacao ();
28 b = inicializacao ();
29
30 distancia = distanciaPontos (a, b);
31
32 printf (" Distancia entre pontos : %f\n", distancia );
33
34 a = finalizacao ();
35 b = finalizacao ();
36
37 return 0;
38 }
Exemplo 4.21: Programa que implementa as operações inicializacao e finalizacao.
4.5 Resumo
ˆ
ˆ
ˆ
Neste capítulo foram discutidas as seguintes técnicas de programação:
1. bottom-up: propõe considerar o programa como um conjunto de módulos correlacionados,
implementar cada um desses módulos e depois juntá-los por meio de uma estrutura global.
DRAFT
2. top-down: o programa é visto como uma descrição de um processo. Primeiramente definese
a estrutura global do programa. O processo é, então, dividido em subprocessos, os quais
são responsáveis por cumprir partes da funcionalidade geral do processo. Por sua vez, cada
subprocesso ainda pode ser dividido em novos subprocessos.
Uma estrutura serve para agrupar um conjunto de dados não similares, formando um novo tipo
de dados. Estruturas permitem a criação de tipos não definidos pela linguagem facilitando a
programação.
O uso de estruturas é considerado uma ótima prática de programação, visto que, além de permitirem
uma organização melhor, possibilitam realizar atribuições ou passagem de parâmetros
em uma única ação.
ˆ
ˆ
Uma estrutura pode ser manipulada de forma seletiva (acesso a um único atributo) ou de forma
integral (acesso a estrutura como um todo).
Os TADs são generalizações das estruturas. Nos TADs operações são associadas à estrutura.

114
CAPÍTULO 4. TIPOS ABSTRATOS DE DADOS
ˆ
As operações associadas a um TAD podem ser dos seguintes tipos: construtoras, analisadoras,
modificadoras, produtoras e destrutoras.
ˆ
Os TADs são definidos a partir de uma estrutura de dados e das operações sobre os dados.
ˆ
O uso de TADs possui diversas vantagens como: abstração, facilidade de alteração, reutilização,
ocultamento e integridade.
ˆ
Os Tipos Abstratos de Dados são classificados em TADs de Domínio e TADs Implementacionais.
TADs de domínio são aqueles que descrevem um tipo do problema, enquanto TADs Implementacionais
descrevem uma estrutura que irá ajudar a resolver o problema, mas não se refere ao
problema. Exemplos de TADs de domínio são os registros de alunos, funcionários, datas etc.
Exemplos de TADs implementacionais são as pilhas, listas etc.
4.6 Exercícios Propostos
1. Crie um TAD para modelar um cilindro. A entrada dos dados referentes ao cilindro deve ser
realizada via console (teclado). As possíveis operações sobre o tipo são:
ˆ
ˆ
ˆ
ˆ
ˆ
ˆ
ˆ
Inicializa Cilindro;
Leitura dos Dados;
Altera Altura;
Altera Raio;
Calcula Volume;
Apresenta Dimensões;
Apresenta Volume.
2. Modifique o TAD tData do Exemplo 4.8 incluindo operações que contenham a diferença em
dias entre duas datas. Em seguida, use o novo tData para fazer um programa que determine
à idade de uma pessoa, e quantos dias faltam para seu aniversário tendo como entradas a data
de nascimento e a data atual. Deve-se considerar anos bissextos e meses com o número de dias
conforme o calendário ocidental.
3. Implemente um TAD tPonto para representar um ponto no plano com as seguintes operações:
ˆ
ˆ
ˆ
ˆ
ˆ
ˆ
Leitura: leitura via console;
DRAFT
Deslocamento Horizontal: faz o ponto se deslocar horizontalmente no plano a uma distância
especificada na chamada da operação;
Deslocamento Vertical;
Atualização de Coordenadas: atribui novos valores às coordenadas de um ponto;
Distância: calcula a distância entre dois pontos;
Apresente: apresente as coordenadas do ponto.
4. Implemente um TAD tCirculo para representar um círculo (utilize o tipo tPonto definido no
Exercício 3 para representar o centro do tCirculo) com as seguintes operações:
ˆ
ˆ
ˆ
ˆ
ˆ
Leitura: leitura via console;
Atualização do raio: atribui um valor r ao raio do círculo;
Atualização do centro: atribui novo valor ao centro do círculo;
Área: calcula a área do círculo;
Interior: verifica se um dado ponto está dentro do círculo.

4.7. TRABALHOS SUGERIDOS 115
5. Implemente um TAD tTrapezio para representar um trapézio com as seguintes operações:
ˆ
ˆ
ˆ
ˆ
Leitura: leitura via console das bases e da altura do trapézio;
Atualização: atualização das bases e altura do trapézio
Área: calcula a área do trapézio;
Interior: verifica se um dado ponto está dentro do trapézio.
6. O sistema responsável pelo controle de entrada e saída de veículos de um estacionamento funciona
24h por dia. Um motorista ao entrar no estacionamento recebe um ticket indicando o horário e a
data de entrada, na saída do estacionamento o atendente realiza a cobrança pelo uso do serviço.
O preço do uso do estacionamento por hora é de R$1,00 nos dias úteis e R$2,00 aos sábados,
domingos e feriados.
O sistema deve ler do ticket do usuário o horário e a data de entrada, deve identificar o horário
atual e a respectiva data, calcular o tempo de uso do estacionamento e o valor a ser pago.
Caso o motorista permaneça no estacionamento por menos de 15 minutos ele não deverá pagar
pelo uso do estacionamento. Caso o motorista permaneça por mais de 15 minutos e menos de
uma hora ele deverá pagar pelo preço de uma hora completa.
Implemente esse sistema utilizando TADs para representar uma data, um horário e o estacionamento.
7. O gerente de uma agência bancária te contratou para fazer um programa em C que obtenha
algumas informações das contas dos correntistas de sua agência. Para tanto leia sucessivamente
os dados do número da conta (um valor inteiro positivo) e o valor das operações (um valor ponto
flutuante positivo para as operações de crédito e negativo para as operações de débito) realizadas
no último mês. Seu programa deve usar os dados da listagem para informar:
ˆ
ˆ
ˆ
As operações suspeitas, isto é, aquelas que movimentaram acima de 20.000 reais;
Os dois correntistas que produziram o maior saldo nas suas operações;
O saldo total das operações na agência.
Nos ítens 1, 2 e 3 também devem ser apresentados os números das contas dos correntistas.
Considere que os dados de cada conta são fornecidos contiguamente, isto é, são fornecidos todos os
dados das operações de uma conta, depois todos os dados de outra conta e assim sucessivamente.
O processamento deve ser encerrado quando for lido um número de conta igual a zero. Utilize
um TAD para representar as contas bancárias.
4.7 Trabalhos Sugeridos
DRAFT
1. A Jogos Matemáticos Ltda. é uma empresa que desenvolve jogos computacionais educativos para
apoio ao ensino de matemática. Ela te contratou para fazer um programa em C que implemente
um jogo de adivinhação. Este jogo ocorre da seguinte maneira: o jogador define um intervalo
de números naturais, por exemplo, entre 0 e 1000, e o computador escolhe aleatoriamente um
valor neste intervalo. O jogador tem, então, um número determinado de chances (dependente
do tamanho do intervalo) para acertar o valor escolhido pelo computador. A cada tentativa,
o computador responde se a tentativa foi bem sucedida (neste caso, o jogador acertou o valor
escolhido pelo computador), se a tentativa é baixa (neste caso o valor é inferior ao valor escolhido)
ou se a tentativa é alta (neste caso o valor é superior ao valor escolhido). Se o jogador consegue
acertar o valor escolhido antes de expirar seu número de chances, ele vence. Caso o número
de chances termine sem que ele acerte o valor escolhido, a vitória é do computador. Ao final
de cada jogo, o programa deve perguntar ao jogador se ele quer continuar ou parar de jogar.
Para gerar o valor a ser adivinhado, antes do início de cada rodada, o computador deve pedir ao
jogador que forneça um número inteiro no intervalo entre 1 e 10000. Este número, chamado de

116
CAPÍTULO 4. TIPOS ABSTRATOS DE DADOS
n, será usado para obter o n-ésimo termo primo da série de fibonacci, chamado de f. O valor
f deve ser então ajustado ao intervalo pré-definido pelo jogador, através de um procedimento
de normalização. Para tanto, o resto da divisão inteira do número f por 101, chamado de r, é
usado juntamente com o intervalo de escolha [min, max] para obter o valor a ser adivinhado,
chamado de x, através da seguinte fórmula:
x = arredondamento((r/100.00) ∗ (max–min) + min)
O número máximo de chances, chamado de mc, que o jogador tem para acertar o valor é dado
pela seguinte fórmula:
mc = parteinteira(log 2 (max–min + 1)) + 1
Seu programa deve tratar ainda as seguintes condições de entrada de dados:
(a) Se o valor inteiro n, fornecido para obtenção do valor a ser adivinhado, está no intervalo
entre 1 e 10000.
(b) Se os valores inteiros min e max fornecidos pelo jogador são números naturais, se min é
menor que max, e se max é um valor inferior ao valor máximo inteiro possível do intervalo
(considerar 1.000.000.000 como máximo valor possível).
(c) Se os valores das tentativas se encontram sempre no intervalo entre min e max, inclusive.
(d) Se a resposta à pergunta de continuação do jogo é o caractere ’s’ ou ’n’.
Sempre que alguma dessas condições não for satisfeita o jogador deve ser avisado do seu erro
e deve poder repetir a entrada de dados. Apresenta-se, a seguir, um exemplo de execução do
programa.
Jogo de Adivinhacao
Forneca um numero no intervalo entre 1 e 10000: 4
Forneca um intervalo de numeros naturais: 23 18
O primeiro numero do intervalo deve ser inferior ao segundo
Forneca um intervalo de numeros naturais: 0 10
Voce tem direito a 4 tentativas
Tentativa 1: 9
Alta
Tentativa 2: 7
Alta
Tentativa 3: 5
Alta
Tentativa 4: 3
Voce perdeu! O numero escolhido foi 1
Deseja continuar a jogar (s/n): n
Obrigado por jogar comigo. Ate a proxima.
DRAFT

Capítulo 5
Vetores
Objetivos:
ˆ
ˆ
ˆ
ˆ
Introduzir a estrutura de dados vetor e mostrar sua importância;
Apresentar suas operações básicas e demonstrar o seu uso;
Coautores:
Definir um TAD Implementacional lista vetorial de inteiros, TListaVetInt;
Apresentar aplicações para o TAD TListaVetInt.
Alan Floriano
André Boechat
Ebenézer Silva
Thiago Salviato
Este capítulo apresenta o conceito de vetor. Um vetor é usado para armazenar uma coleção de
objetos semelhantes. Se vetores não estivessem disponíveis para uso, quando o programador precisasse
lidar com uma grande quantidade de “objetos” semelhantes – por exemplo, os milhares de alunos em
uma escola –, seria necessário criar uma variável distinta (isto é, com um nome diferente) para cada
um desses objetos. Já com o uso de vetores, conjuntos de objetos semelhantes podem ser tratados de
uma forma simples e que não demanda a definição de múltiplas variáveis.
5.1 Vetores e sua importância
DRAFT
Imagine que se queira fazer um programa para manusear dados de um mesmo tipo - as idades das
pessoas de uma família, ou os salários dos funcionários de uma empresa, por exemplo. Uma alternativa
seria a utilização de muitas variáveis ou então a leitura de valores sempre que necessários. Mas será que
essas seriam as melhores soluções? E se o programa for grande e houver a necessidade de modularizálo?
Não seria incômodo quando fosse necessário passar todas essas variáveis como parâmetros? Ao
refletir sobre essas perguntas, outra idéia pode vir à tona: a utilização de um TAD. Dessa forma,
as variáveis podem ser encapsuladas em uma só estrutura e apenas ela poderia ser passada como
parâmetro. Para muitos casos isso poderia ser uma boa idéia.
Mas e se fossem 100 valores diferentes? E se quiséssemos ordenar 100 valores? Seriam necessárias
100 variáveis, uma para armazenar cada valor, o que implicaria em escrever mais e tornaria o código
pouco legível.
Mesmo que o programador considere abordagens que não usam muitas variáveis, não empregar
vetores pode decisivamente limitar a funcionalidade do programa desenvolvido. Para ilustrar a diferença
entre usar ou não vetores, apresentamos a seguir dois exemplos nos quais a ausência de vetores
torna o código menos legível e muito maior que o realmente necessário.
O Pseudocódigo 5.1 mostra um algoritmo para ordenar seis elementos sem a utilização de vetores.
117

118
CAPÍTULO 5. VETORES
Pseudocódigo 5.1 Programa para ordenar seis inteiros.
Descrição: Ordenar seis inteiros.
Dados de Entrada: Seis inteiros, x1, x2, x3, x4, x5, x6.
Saída do Programa: Exibe na tela os seis inteiros ordenados crescentemente.
Funç~ao Principal :
PARA um loop de 1 a 6
SE o retorno da chamada processo componente " Trocar " passando como
par^ametros x1 e x2 for igual a um
Trocar os valores de x1 e x2
FIM -SE
SE o retorno da chamada processo componente " Trocar " passando como
par^ametros x2 e x3 for igual a um
Trocar os valores de x2 e x3
FIM -SE
SE o retorno da chamada processo componente " Trocar " passando como
par^ametros x3 e x4 for igual a um
Trocar os valores de x3 e x4
FIM -SE
SE o retorno da chamada processo componente " Trocar " passando como
par^ametros x4 e x5 for igual a um
Trocar os valores de x4 e x5
FIM -SE
SE o retorno da chamada processo componente " Trocar " passando como
par^ametros x5 e x6 for igual a um
Trocar os valores de x5 e x6
FIM -SE
FIM - PARA
Apresentar x1 x2 x3 x4 x5 x6
FIM - Funç~ao Principal
Processo componente " Trocar "
SE o primeiro elemento passado como par^ametro for maior que o segundo elemento
passado como par^ametro
Retorna um
SEN~AO:
Retorna zero
FIM -SE
FIM - Processo componente " Trocar "
1 # include
2
3 int trocar ( int valor1 , int valor2 )
4 {
5 if( valor1 > valor2 ){
6 return 1;
7 } else {
8 return 0;
9 }
10 }
11
12 int main ()
13 {
DRAFT
14 int i, elem1 , elem2 , elem3 , elem4 , elem5 , elem6 , elemAux ;
15
16 printf (" Digite os valores dos 6 inteiros : ");
17 scanf ("%d%d%d%d%d%d", & elem1 , & elem2 , & elem3 , & elem4 , & elem5 , & elem6 );
18
19 for (i =0; i

5.1. VETORES E SUA IMPORTÂNCIA 119
22 elem1 = elem2 ;
23 elem2 = elemAux ;
24 }
25 if( trocar ( elem2 , elem3 ) == 1){
26 elemAux = elem2 ;
27 elem2 = elem3 ;
28 elem3 = elemAux ;
29 }
30 if( trocar ( elem3 , elem4 ) == 1){
31 elemAux = elem3 ;
32 elem3 = elem4 ;
33 elem4 = elemAux ;
34 }
35 if( trocar ( elem4 , elem5 ) == 1){
36 elemAux = elem4 ;
37 elem4 = elem5 ;
38 elem5 = elemAux ;
39 }
40 if( trocar ( elem5 , elem6 ) == 1){
41 elemAux = elem5 ;
42 elem5 = elem6 ;
43 elem6 = elemAux ;
44 }
45 }
46
47 printf ("%d %d %d %d %d %d\n", elem1 , elem2 , elem3 , elem4 , elem5 , elem6 );
48
49 return 0;
50 }
Exemplo 5.1: Ordenação de seis inteiros sem a utilização de vetores.
Como já se pode perceber, nem sempre os tipos básicos de dados (int, float, char) e as estruturas
são suficientes para expressar estruturas de dados em algoritmos.
Para ilustrar melhor o problema, considere que um professor tenha uma turma de 50 alunos e
deseja saber quantos deles tiveram nota acima da média da turma. Com as estruturas e conceitos
apresentados até o capítulo anterior, seria necessária a leitura das notas dos alunos por duas vezes (ou
a utilização de 50 variáveis - o que também seria um grande incômodo): uma para calcular a média
e outra para verificar quais alunos tiveram notas superiores a esse valor. O Exemplo 5.2 mostra uma
maneira de resolver o problema do professor utilizando a linguagem C e fazendo a dupla leitura.
1 # include
2
3 # define QTD_NOTAS 50
4
5 int main (){
6 int i, conta ;
7 float nota , soma , media ;
8
10
9 soma = 0.0;
11 for (i =0; i < QTD_NOTAS ; i ++) {
12 printf (" Digite uma nota : ");
13 scanf ("%f", & nota );
14 soma = soma + nota ;
15 }
16
17 media = soma / QTD_NOTAS ;
18
19 conta = 0;
20
21 for (i =0; i < QTD_ALUNOS ; i ++) {
22 printf (" Digite uma nota : ");
23 scanf ("%f", & nota );
DRAFT

120
CAPÍTULO 5. VETORES
24
25 if( nota > media ){
26 conta ++;
27 }
28 }
29
30 printf ("\n%d alunos obtiveram nota acima da media \n", conta );
31
32 return 0;
33 }
Exemplo 5.2: Resolução do problema do professor sem a utilização de vetores.
Todos os problemas citados até agora no capítulo poderiam ser resolvidos com a utilização de
vetores.
Em resumo, um vetor é uma estrutura de dados composta e homogênea; isto é, ele possui, em
geral, mais de um elemento – por isso, composto –, e estes elementos são sempre do mesmo tipo –
logo, homogêneo. O uso de vetores é necessário quando um conjunto de dados de um mesmo tipo deve
ser armazenado, a fim de ser utilizado durante a execução do programa. Se vetores fossem empregados
no Exemplo 5.2, as notas de todos os alunos poderiam ter sido armazenadas num único vetor durante
a primeira leitura dos dados, e assim elas estariam disponíveis para uso durante toda a execução
seguinte do programa; assim, após o cálculo da média, não seria necessário fazer novamente a entrada
de dados das notas para checar as que estão acima da média, já que todas as notas ainda estariam
armazenadas.
5.2 Representação
A Figura 5.1 mostra a maneira mais comum de se representar um vetor graficamente.
Figura 5.1: Representação de um vetor.
A Figura 5.1 representa um vetor de inteiros chamado vet com os nove primeiros números primos.
O terceiro elemento, de índice igual a 2, é o número 5 e o de índice 4 é o número 11. É importante
lembrar que o primeiro elemento de um vetor, na linguagem C, sempre corresponde ao índice zero.
Analisando a Figura 5.1, ficam evidentes outras importantes características dessa estrutura: a
sequencialização, a indexação de seus elementos e a sua dimensão.
Quando se executa um programa que contém um vetor, reserva-se um espaço de memória sequencial
com o tamanho necessário para que seja possível armazenar todos os elementos do vetor. Por exemplo,
para um vetor de inteiros com tamanho igual a oito, é reservado um espaço de memória necessário
para armazenar oito números inteiros. Se um inteiro ocupar 32 bits, então é reservado um espaço
sequencial de 256 bits na memória.
Essa propriedade facilita bastante o acesso do programa ao elemento desejado dentro do vetor,
pois, para que o dado seja recuperado, é necessário apenas o nome do vetor, que localiza o primeiro
elemento, e um índice, que indica ao programa a que distância do início está o dado desejado.
Discute-se nas próximas seções como essa estrutura pode ser utilizada na prática, abordando
assuntos como sua definição e as operações possíveis sobre ela.
DRAFT
5.3 Definição
Na linguagem C, o vetor é definido da seguinte maneira:

5.3.
DEFINIÇÃO 121
[];
onde tipoDosDados representa o tipo dos dados dos elementos que são armazenados no vetor, nome-
DoVetor é o nome pelo qual o vetor será referenciado e tamanhoDoVetor o número de elementos que
podem ser armazenados no vetor. O Exemplo 5.3 mostra alguns exemplos de declaração de vetores.
1 int vet [9];
2
3 char nome [9];
4
5 float nota [6];
6
7 float notasAlunos [50];
Exemplo 5.3: Algumas declarações de vetores.
No Exemplo 5.3, o primeiro vetor pode ser representado graficamente pela Figura 5.1 mostrada
na seção anterior, ou seja, seu nome é vet e ele pode armazenar até 9 elementos do tipo int. O
segundo e o terceiro são representados pela Figura 5.2. O vetor chamado nome armazena no máximo
9 elementos do tipo char, e o chamado nota, até 6 do tipo float. Já o último poderia ser utilizado no
problema do professor citado anteriormente, por exemplo. Nesse vetor, chamado notasAlunos, podem
ser armazenados 50 valores do tipo float, que poderiam representar as notas dos 50 alunos.
Figura 5.2: Vetores na memória do computador.
É possível definir vetores dentro de estruturas. Suponha que se queira fazer um programa para
cadastrar os alunos de uma turma de uma escola de ensino médio e fazer um acompanhamento de
suas notas. Considere que o aluno terá oito avaliações no ano. O Exemplo 5.4 mostra uma estrutura
que poderia ser utilizada para representar um aluno na linguagem C.
1 typedef struct aluno {
2 char nome [50];
3 int matricula ;
4 int idade ;
5 float notas [8];
6 } tAluno ;
DRAFT
Exemplo 5.4: Definição da estrutura tAluno.
A estrutura proposta no Exemplo 5.4 possui um vetor chamado nome, do tipo char e de tamanho
igual a 50 para armazenar o nome completo de um aluno; duas variáveis do tipo int chamadas matricula
e idade, para armazenar, respectivamente, a matrícula do aluno e sua idade; e um vetor do tipo float
de tamanho igual a 8 chamado notas, para armazenar as notas desse aluno.
Repare que o nome do aluno pode ocupar um espaço menor que o tamanho máximo do vetor.
Porém, não será possível armazenar um nome maior que o tamanho do vetor, o que pode ser um
problema. Para tais casos deve-se usar uma estrutura apropriada.
No caso de um vetor com menos elementos do que o tamanho definido, é necessário que esteja
disponível uma informação explícita acerca de quantos elementos “de fato” o vetor armazena – uma
quantidade que é menor ou igual ao seu tamanho máximo definido. Por exemplo, uma outra variável
(distinta do vetor) que indique quantos elementos o vetor armazena, ou, no caso de vetores de caracteres,
o uso de um caractere específico que indica que, a partir dele, todos os outros elementos do

122
CAPÍTULO 5. VETORES
vetor (isto é, os elementos com índice maior) não tem um valor válido definido. Vetores de caracteres,
chamados de strings, serão discutidos em detalhes na Seção 5.5.
É possível definir o tamanho do vetor durante a execução. Isso pode ser implementado substituindo
o número inteiro que é colocado entre colchetes na declaração do vetor por uma variável que só ganha
um valor durante a execução do programa. O Exemplo 5.5 mostra como isso pode ser feito na
linguagem C.
1 # include
2
3 int main (){
4 int num ;
5
6 printf (" Quantas notas deseja armazenar ?");
7 scanf ("%d", & num );
8
10
9 float notas [ num ];
11 return 0;
12 }
Exemplo 5.5: Definição de um vetor em tempo de execução.
Repare que declarando o vetor notas dessa forma, o desperdício de memória pode ser eliminado,
já que o vetor é utilizado por completo. Isso pode ser feito desde que o usuário tenha conhecimento
prévio do número de elementos que serão armazenados e que ele possa informá-lo à aplicação.
É importante ressalvar que essa forma dinâmica de definição de tamanho não funciona no caso de
vetores dentro de estruturas, como o vetor notas da estrutura tAluno do Exemplo 5.4, por exemplo.
No caso das estruturas o tamanho de cada atributo deve, necessariamente, ser conhecido no momento
da definição da estrutura.
O programador deve ficar atento ao momento da declaração dinâmica do vetor. Note que, no
Exemplo 5.5, o vetor notas só foi declarado depois de haver um valor válido na variável num. Um erro
lógico aconteceria se o vetor fosse declarado logo após a declaração da variável num, como mostrado
no Exemplo 5.6. Neste exemplo, o vetor notas não possui um tamanho válido, já que a variável num
não foi inicializada até o momento da declaração do vetor. Na execução do programa, o vetor notas
terá um tamanhjo qualquer e desconhecido, possivelmente inadequado para armazenar as notas.
1 # include
2
3 int main (){
4 int num ;
5 float notas [ num ];
6
7 printf (" Quantas notas deseja armazenar ?");
8 scanf ("%d", & num );
9
10 return 0;
11 }
DRAFT
Exemplo 5.6: Definição errônea de um vetor em tempo de execução.
5.4 Operações
Na linguagem C não existem operações pré-definidas para a manipulação de um vetor como um todo.
As operações só podem ser feitas para cada elemento do vetor, individualmente.
Como já mencionado na Seção 5.2, para acessar um elemento de um vetor, são necessários apenas
seu nome e o índice que informa sua localização. Na linguagem C, a sintaxe de acesso a um elemento
de um vetor é dada por:

5.4.
OPERAÇÕES 123
[]
no qual o índice pode ser tanto um número inteiro maior ou igual a zero quanto uma expressão inteira
composta por variáveis e números.
Um elemento acessado por um índice pode ser manipulado como uma variável qualquer e ser
utilizado em diversas operações, como atribuição, operações aritméticas etc. O Exemplo 5.7 mostra
algumas dessas operações em C.
1 # include < stdio .h>
2
3 int main (){
4 int i;
5 int medias [10];
6
7 printf (" Digite as notas dos alunos \n");
8
9 for (i =0;i

124
CAPÍTULO 5. VETORES
22 conta ++;
23 }
24 }
25
26 printf ("\n%d alunos obtiveram nota acima da media \n", conta );
27
28 return 0;
29 }
Exemplo 5.8: Resolução do exemplo do professor utilizando vetores.
Na solução do problema do professor apresentada no Exemplo 5.8, as notas são lidas do teclado
apenas uma vez; são, então, armazenados no vetor notas, e a soma total de notas é obtida, para,
em seguida, ser calculado o valor da média das notas da turma. Então, as notas com valor acima
da média podem ser obtidas, via acesso ao vetor notas; não é necessário ler novamente as notas do
teclado, como foi preciso no Exemplo 5.2.
Vetores podem ser usados como parâmetro de funções. Porém, é importante destacar que vetores
não podem ser usados como valores de retorno de funções, em C (ao contrário de estruturas, que
podem ser valores de retorno de funções).
O Exemplo 5.9 mostra uma nova solução para o exemplo do professor, já tratado nos Exemplos
5.2 e 5.8. Nesta nova solução, é utilizada modularização, e os sub-problemas do cálculo da média das
notas e do cálculo da quantidade de notas acima da média são tratados com uso de funções. Estas
funções recebem vetores como parâmetros. Também, a quantidade de notas (tamanho do vetor) não
é definida como uma contante, mas, sim, lida durante a execução do programa.
1 # include
2
3 float calculaMedia ( float vet [] , int tam ) {
4 int i;
5 float soma , media ;
6
7 soma = 0.0;
8 for (i =0; i < tam ; i ++) {
9 soma = soma + vet [i];
10 }
11
12 media = soma / tam ;
13
14 return media ;
15 }
16
17 int contaAcima ( float vet [] , int tam , float valor ) {
18 int i, conta ;
19
20 conta = 0;
21 for (i =0; i < tam ; i ++) {
22 if(vet [i] > valor ){
23 conta ++;
24 }
25 }
26
27 return conta ;
28 }
29
30 int main () {
31 int i, conta , qtd ;
32 float media ;
33
DRAFT
34 printf (" Informe a quantidade de notas que serao digitadas : ");
35 scanf ("%d", & qtd );
36
37 float notas [ qtd ];
38

5.5. STRINGS 125
39 for (i =0; i < qtd ; i ++) {
40 printf (" Digite uma nota : ");
41 scanf ("%f", & notas [i]);
42 }
43
44 media = calculaMedia ( notas , qtd );
45 conta = contaAcima ( notas , qtd , media );
46
47 printf ("%d notas estao acima da media .\n", conta );
48
49 return 0;
50 }
Exemplo 5.9: Resolução do exemplo do professor com utilização de vetores e funções.
No Exemplo 5.9, inicialmente, é lida a quantidade total de notas a serem informadas. Essa informação
é armazenada na variável qtd e usada na declaração do vetor notas. Após as notas serem
todas lidas a partir do teclado, a média dessas notas é calculada, com uso da função calculaMedia,
e o valor de retorno dessa função é armazenado na variável media. Em seguida, é verificada a quantidade
de alunos que obtiveram nota maior que a média, com uso da função contaAcima, e o valor de
retorno dessa função é armazenado na variável conta. Finalmente, é exibida a a quantidade de notas
que ficaram acima da média.
5.5 Strings
O vetor de elementos do tipo char do Exemplo 5.3, chamado nome, assim como todos os vetores
do tipo char, podem ser considerados de um novo tipo, o tipo string. Strings correspondem a uma
sequência de caracteres. Geralmente, são usadas para realizar a entrada e saída de dados em um
programa e para armazenar dados não numéricos.
É comum representar uma string como um vetor de caracteres (tipo char), dispondo das mesmas
operações comuns a essa estrutura de dados. A Figura 5.3 exemplifica a representação de uma string
como um vetor de caracteres.
DRAFT
Figura 5.3: Vetor de caracteres.
Toda string armazenada em um vetor é terminada por um caracter especial, conhecido como
caracter nulo ‘\0’. A principal função desse caracter é indicar o fim de uma string, evitando um acesso
indesejado a uma posição do vetor que se encontra “vazia”. O programa do Exemplo 5.10 demonstra
uma forma não usual de apresentar strings, mas aplica o conceito de caracter nulo.
1 void apresenta_string ( char palavra []) {
2 int i;
3
4 for (i =0; palavra [i ]!= ‘\0 ’; i ++) {
5 printf ("% c", palavra [i]);
6 }
7
8 printf ("\ n"); // quebra de linha .
9 }
Exemplo 5.10: Subprograma para apresentação de strings, utilizando diretamente o ‘\0’.
No Exemplo 5.10, a condição de parada do laço for é encontrar o caracter ‘\0’, e, durante cada
iteração, cada caracter do vetor é apresentado separadamente. A forma mais comum (e simples) de
apresentar uma string é a mostrada no Exemplo 5.11.

126
CAPÍTULO 5. VETORES
1 void apresenta_string ( char palavra []) {
2 printf ("%s\n", palavra );
3 }
Exemplo 5.11: Apresentação de uma string sem a utilização direta do caracter “barra-zero”.
O programa do Exemplo 5.11 produz o mesmo resultado do Exemplo 5.10, porém, no 5.11 o
caracter ‘\0’ é verificado implicitamente pela função printf.
A biblioteca padrão de C ainda oferece algumas funções muito úteis para a manipulação de strings,
como a strcpy (cópia), a strlen (tamanho) e a strcmp (comparação). O Exemplo 5.12 demonstra o
uso dessas funções.
1 # include
2 # include < string .h> // funcoes da biblioteca padrao para manipulacao de strings
3
4 int main (){
5 char vet1 [20] = " ola enfermeira ";
6 char vet2 [20];
7 char vet3 [20];
8
10
9 printf (" Tamanho da string : %d \n\n", strlen ( vet1 ));
11 strcpy (vet2 , vet1 );
12
13 printf ("%s \n %s \n\n", vet1 , vet2 );
14
15 strcpy (vet3 , " sim senhor ");
16
17 printf ("%s \n\n", vet3 );
18
19 if( strcmp (vet1 , vet2 ) == 0){
20 printf ("As strings sao iguais ");
21 } else {
22 printf ("As strings sao diferentes ");
23 }
24
25 if( strcmp (vet1 , vet3 ) == 0){
26 printf ("As strings sao iguais ");
27 } else {
28 printf ("As strings sao diferentes ");
29 }
30
31 return 0;
32 }
DRAFT
Exemplo 5.12: Programa demonstrativo de algumas funções da biblioteca padrão de C para
manipulação de strings.
A primeira linha dentro da função main mostra uma maneira de criar um vetor, no caso do exemplo
o vetor chamado vet1, e já preenchê-lo com valores (linha 5). Em seguida são declarados mais dois
vetores de caracteres: vet2 e vet3, ambos de tamanho igual a 20. Depois disso as funções da biblioteca
padrão string.h são utilizadas para, respectivamente: apresentar o tamanho da string em vet1, com
a função strlen (linha 9); copiar o conteúdo de vet1 em vet2, com a função strcpy e em seguida
apresentá-los na tela com a função printf da biblioteca stdio.h (linhas 11 e 13); copiar a string “sim
senhor” para dentro do vetor vet3 e em seguida apresentar seu conteúdo na tela (linhas 15 e 17); e,
finalmente, comparar o conteúdo das strings contidas em vet1 e vet2 (linhas 19 a 23), e vet1 e vet3
(linhas 25 a 29) com a função strcmp.
Para o uso da função strcpy, a ordem dos parâmetros é de suma importância; o primeiro parâmetro
é o vetor de destino da string que se deseja copiar, enquanto o segundo é o vetor de origem da string.
Em relação a função strcmp, ela retorna o valor zero se as strings armazenadas em ambos os vetores
forem iguais (letras maiúsculas são consideradas diferentes das minúsculas).

5.6. O TAD IMPLEMENTACIONAL LISTA VETORIAL DE INTEIROS 127
5.6 O TAD Implementacional Lista Vetorial de Inteiros
Como dito na seção 5.4, na linguagem C não existem operações básicas para a manipulação de vetores
como um todo. Porém a manipulação individual de todos os seus elementos pode ser muito trabalhosa
e muitas vezes operações comuns devem ser repetidas várias vezes ao longo do código do programa. Por
isso, as operações básicas sobre um vetor devem ser modularizadas pela utilização de subprogramas
e, para isso, a utilização de um TAD se mostra oportuna.
Nessa seção será apresentado na linguagem C o TAD Lista Vetorial de Inteiros, de natureza implementacional,
chamado tListaVetInt, que poderá ser usado em aplicações que necessitam manipular
vetores de inteiros.
5.6.1 Atributos
O Exemplo 5.13 mostra a representação da estrutura utilizada no TAD Implementacional tListaVetInt.
Ela contém um vetor e o número de elementos correntes do vetor.
1 # define TAM 100
2
3 typedef struct vetor {
4 int vet [ TAM ];
5 int n;
6 } tListaVetInt ;
Exemplo 5.13: Definição da Estrutura tListaVetInt.
O Exemplo 5.13 mostra a definição da estrutura tListaVetInt. Ela possui um vetor de inteiros
chamado vet, de tamanho definido por TAM e uma variável n do tipo int que representa o número
corrente de elementos em vet, ou seja, o número de elementos armazenados no vetor num determinado
momento da execução do programa. Esse valor deve ser zero quando o vetor estiver vazio e
deve ser incrementado ou decrementado sempre que se adicionar ou excluir um elemento do vetor,
respectivamente.
A primeira linha do código do Exemplo 5.13 indica que TAM é uma constante de valor 100. Esse
artifício é bastante utilizado quando se trabalha com vetores com tamanho máximo, já que permite
que uma alteração no valor de TAM no início do código modifique os tamanhos de todos os vetores
do código que utilizam TAM para definir seu tamanho.
A Figura 5.4 mostra uma maneira simples de representar graficamente a estrutura proposta no
Exemplo 5.13.
DRAFT
Figura 5.4: Representação gráfica da estrutura tListaVetInt.
A figura mostra duas estruturas do tipo tListaVetInt. Como pode ser observado, apesar de vet
possuir tamanho igual a 100, ele possui apenas 8 elementos na primeira estrutura e 5 na segunda,
valores representados pela variável n.

128
CAPÍTULO 5. VETORES
5.6.2 Operações
Agora serão ilustradas as funções que devem ser utilizadas como operações para manipular a estrutura
tListaVetInt. Tal como visto no capítulo anterior, essas operações se dividem em quatro categorias
diferentes: construtoras, analizadoras, produtoras e modificadoras.
Construtoras
As operações construturas do TAD tListaVetInt são usadas na criação de novas variáveis desse tipo.
Após definir uma nova variável do tipo tListaVetInt, é necessário que uma função construtura do
TAD seja chamada e então receba essa variável como parâmetro; isto é, é necessário usar uma função
construtura antes de se usar qualquer outra função do TAD. Serão apresentadas duas funções construtoras:
uma que inicializa uma variável tListaVetInt que não possui nenhum elemento armazenado,
e outra que inicializa uma variável tListaVetInt já com alguns elementos armazenados.
O Exemplo 5.14 apresenta a função construtora inicializacaoVaziaListaVetInt, que inicializa
uma variável do tipo tListaVetInt sem elementos armazenados.
1 tListaVetInt inicializacaoVaziaListaVetInt ( tListaVetInt v){
2 v.n = 0;
3
4 return v;
5 }
Exemplo 5.14: Inicialização de um tListaVetInt vazio.
Repare que a função tem como tipo de retorno uma estrutura do tipo tListaVetInt, ou seja, antes
desta função ser utilizada, uma variável deste tipo deve ser declarada no programa para receber o
retorno da função.
O Exemplo 5.15 mostra o código da função leituraListaVetInt que inicializa o TAD já com
alguns que devem ser inseridos pelo usuário, por meio do teclado.
1 tListaVetInt leituraListaVetInt ( tListaVetInt v, int num ){
2 int i;
3
4 for (i =0; i

5.6. O TAD IMPLEMENTACIONAL LISTA VETORIAL DE INTEIROS 129
O Exemplo 5.16 apresenta uma função analisadora simples: a partir do primeiro elemento, sequencialmente
e até o último elemento do vetor, a função compara esse elemento com o informado no
parâmetro de entrada; se o elemento for encontrado, a função encerra e retorna seu índice. Já se o
final do vetor for alcançado e o elemento não for encontrado, a função retorna “−1”.
1 int pesquisaSequencialListaVetInt ( tListaVetInt v, int elem ){
2 int i;
3
4 for (i =0; i

130
CAPÍTULO 5. VETORES
FIM -SE
FIM -SE
FIM - ENQUANTO
Retornar -1.
FIM - Processo componente " busca binária "
1 int pesquisaBinariaListaVetInt ( tListaVetInt v, int elem ){
2 int inicio ;
3 int fim ;
4 int meio ;
5
6 inicio = 0;
7
8 fim = v.n - 1;
9
10 while ( inicio v. vet [ meio ]){
17 inicio = meio + 1;
18 } else {
19 return meio ;
20 }
21 }
22 }
23
24 return -1;
25 }
Exemplo 5.17: Pesquisa binária.
A função pesquisaBinariaListaVetInt, do Exemplo 5.17, recebe como parâmetro de entrada a
estrutura do tipo tListaVetInt que possui o vetor que se deseja pesquisar e o elemento a ser encontrado.
São declaradas, então, três variáveis: inicio, fim e meio. A variável inicio recebe o valor do índice
do menor elemento do vetor, ou seja, zero, e fim recebe o valor do índice do maior elemento, ou
seja, v.n−1. Enquanto o valor de inicio for menor ou igual ao valor de fim, meio recebe o índice do
elemento central da região por eles delimitada. É exatamente esse elemento central que sempre será
comparado ao elemento procurado. Se aquele for maior que este, em virtude da ordenação do vetor,
todos os elementos posteriores ao central são também maiores que o elemento procurado. Logo, fim
deve receber o valor do índice anterior a meio. Caso contrário, todos os elementos anteriores ao central
são menores que o elemento procurado. Logo, inicio deve receber o valor do índice posterior a meio.
Se nenhuma das duas alternativa acontecerem, quer dizer que o elemento foi encontrado e seu índice
é igual a meio. Se em algum momento inicio passar a ser maior que fim, então o elemento não existe
no vetor e a busca é encerrada.
As Figuras 5.5 e 5.6 mostram o funcionamento do algoritmo do Exemplo 5.17 para duas pesquisas
diferentes.
A Figura 5.5 ilustra as etapas da busca do elemento 4 dentro do vetor vet da estrutura do tipo
tListaVetInt mostrada na figura. Primeiramente inicio e fim adquirem os valores 0 e 10, respectivamente.
Como inicio é menor que fim, meio recebe o índice 5, e o elemento apontado por ele, o valor
10, é comparado ao valor procurado. Como 10 é maior que 4, fim recebe o índice 4. Como inicio
continua menor que fim, meio recebe o índice 2. Dessa vez, o elemento apontado por meio é igual ao
elemento procurado. A função retorna, então, o valor de seu índice: 2.
A Figura 5.6 apresenta três etapas da busca pelo elemento 23 no mesmo vetor apresentado na
Figura 5.5. Inicialmente, inicio e fim adquirem os valores 0 e 10, respectivamente. Como inicio é
menor que fim, meio recebe o índice 5, e o elemento apontado por ele, de valor 10, é comparado
DRAFT

5.6. O TAD IMPLEMENTACIONAL LISTA VETORIAL DE INTEIROS 131
Figura 5.5: Etapas da pesquisa binária com o elemento procurado no início do vetor.
DRAFT
Figura 5.6: Etapas da pesquisa binária com o elemento procurado no final do vetor.
ao valor procurado. Então, já que 10 é menor que 23, inicio recebe o índice 6. Em seguida, como
inicio continua menor que fim, meio recebe o índice 8, e o elemento apontado por ele, o valor 19, é
comparado ao valor procurado. Novamente, 19 é menor que 23, e inicio recebe o índice 9. E como
inicio continua menor que fim, meio também recebe o índice 9. O elemento apontado por meio é
comparado ao elemento buscado, e, desta vez, os valores são iguais. Então, a função retorna o valor 9.
É importante destacar que, na busca apresentada na Figura 5.6, o algoritmo de pesquisa binária faz
apenas três comparações de valores; já o algoritmo de pesquisa sequencial realizaria dez comparações,
pois o elemento buscado ocupa a décima posição.
Produtoras
As funções produtoras geram novas informações que resultam de operações sobre vetores. Por exemplo,
a escrita, o tamanho da lista, o elemento presente em uma posição determinada, a adição de vetores
e o produto escalar entre vetores.
O Exemplo 5.18 apresenta uma função que retorna a quantidade atual de elementos armazenados.

132
CAPÍTULO 5. VETORES
1 int tamListaVetInt ( tListaVetInt v){
2 return v.n;
3 }
Exemplo 5.18: Obtenção do tamanho do vetor.
O Exemplo 5.19 apresenta uma função que retorna um elemento de uma determinada posição do
vetor.
1 int iesimoElemListaVetInt ( tListaVetInt v, int i) {
2 return v. vet [i];
3 }
Exemplo 5.19: Obtenção do i-esimo elemento do vetor.
O Exemplo 5.20 apresenta uma função que imprime todos os elementos armazenados.
1 void escritaListaVetInt ( tListaVetInt v) {
2 int i;
3
4 printf ("\n\ nOs elementos sao :\n");
5
6 for (i =0; i < v.n; i ++) {
7 printf ("%d ", v. vet [i]);
8 }
9
10 printf ("\n\n");
11 }
Exemplo 5.20: Escrita em tela.
O Exemplo 5.21 apresenta uma função que recebe duas variáveis do tipo tListaVetInt, as quais
devem ter a mesma quantidade de elementos; então, uma nova variável do tipo tListaVetInt é criada,
que armazenará, como seu elemento de índice i, o valor que é a soma dos valores na posição i em
cada uma das duas variáveis de entrada. Caso as duas variáveis de entrada possuam vetores de
tamanhos diferentes, uma mensagem de erro é exibida, e a variável retornada armazenará um vetor
sem elementos.
DRAFT
1 tListaVetInt adicaoListaVetInt ( tListaVetInt v1 , tListaVetInt v2) {
2 int i;
3 tListaVetInt soma ;
4
5 if (v1.n != v2.n) {
6 printf (" Vetores com tamanhos diferentes \n");
7 soma .n = 0;
8 } else {
9 soma .n = v1.n;
10 for (i =0; i < soma .n; i ++) {
11 soma . vet [i] = v1.vet [i] + v2.vet [i];
12 }
13 }
14
15 return soma ;
16 }
Exemplo 5.21: Adição de dois vetores.
O Exemplo 5.22 apresenta uma função que calcula o produto escalar entre dois vetores. Para isto,
os vetores devem possuir o mesmo número de elementos correntes; senão, uma mensagem de erro é
exibida, e o retorno terá valor “0”.

5.6. O TAD IMPLEMENTACIONAL LISTA VETORIAL DE INTEIROS 133
1 int prodEscalarListaVetInt ( tListaVetInt v1 , tListaVetInt v2) {
2 int i;
3 int prod ;
4
5 prod = 0;
6
7 if (v1.n != v2.n) {
8 printf (" Vetores com tamanhos diferentes \n");
9 } else {
10 for (i =0; i < v1.n; i ++) {
11 prod = prod + v1.vet [i] * v2.vet [i];
12 }
13 }
14
15 return prod ;
16 }
Modificadoras
Exemplo 5.22: Produto escalar entre dois vetores.
Operações modificadoras realizam alterações nos elementos da variável tListaVetInt à qual são aplicadas.
Nesta seção, serão apresentadas funções que inserem um elemento, que excluem um elemento,
e que ordenam os elementos armazenados no vetor.
A função apresentada no Exemplo 5.23 realiza a inserção de um elemento numa posição prédeterminada.
A função insereListaVetInt recebe como parâmetros de entrada uma variável do tipo
tListaVetInt (que será modificada), o valor do elemento a ser inserido e a posição na qual isso deve
ocorrer. No código da função, a validade da posição informada é avaliada; se esta for inválida – com
valor menor que 0 ou maior que o tamanho do vetor –, uma mensagem de erro é apresentada e o
elemento não é inserido. Em caso contrário, o tamanho do vetor é aumentado em 1, significando que
um elemento adicional foi inserido na posição de maior índice; então, cada elemento já armazenado
no vetor é movido uma posição à direita, até que se chegue à posição da inserção. O elemento a
ser inserido é copiado no elemento de índice desejado. Por fim, a variável tListaVetInt modificada é
retornada.
Pseudocódigo 5.3 Processo componente para inserção de um elemento numa posição pré-definida.
DRAFT
Descrição: Inserir um elemento em uma posição pré-definida.
Dados de Entrada: Estrutura do tipo lista vetorial de inteiros, elemento a ser inserir (elem), posição de
inserção (pos).
Saída do Programa: Estrutura do tipo lista vetorial atualizada.
Processo componente " insere no vetor ":
SE a posiç~ao onde será inserido for menor que zero OU a posiç~ao onde será
inserido for maior que o tamanho do vetor
Apresentar a mensagem : Entrada de Dados Incorreta .
SEN~AO
Incrementa a quantidade de elementos do vetor .
PARA um loop da quantidades de elementos do vetor menos 1 à posiç~ao onde
será inserido menos 1 FAÇA:
Posiç~ao posterior recebe o valor da posiç~ao anterior .
FIM - PARA
Atribui o elemento a ser inserido para a posiç~ao a ser inserido .
FIM -SE
FIM - Processo componente " insere no vetor "
1 tListaVetInt insereListaVetInt ( tListaVetInt v, int elem , int pos ) {
2 int i;

134
CAPÍTULO 5. VETORES
v.vet 1 2 3 4 5
elem 10 pos 3
v.n 5
v.vet 1 2 3 4 5
elem 10 pos 3
v.n 6
3
v.vet 1 2 3 4 5 5
v.n 6
v.vet 1 2 3 4 4 5
v.n 6
v.vet 1 2 3 10 4 5
v.n 6
elem 10 pos 3
elem 10 pos 3
elem 10 pos 3
Figura 5.7: Etapas da inserção de um elemento em uma posição especificada.
4 if (( pos < 0) || ( pos > v.n)) {
5 printf (" Entrada de Dados Incorreta ");
6 } else {
7 v.n ++;
8 for (i=v.n - 2; i > pos - 1; i - -) {
9 v. vet [i +1] = v. vet [i];
10 }
11 v. vet [i +1] = elem ;
12 }
13
14 return v;
15 }
DRAFT
Exemplo 5.23: Inserção em uma posição pré-determinada.
A função apresentada no Exemplo 5.24 realiza a exclusão de todos os elementos que possuem valor
igual ao valor informado como parâmetro. A função excluiListaVetInt verifica cada elemento do
vetor, do primeiro elemento ao último, e quando encontra um elemento com valor igual ao valor a ser
excluído, esse elemento é apagado; para isso, cada elemento à frente deste elemento a ser excluído é
movido uma posição à esquerda, e, em seguida, o tamanho do vetor é reduzido em um. Após realizar
a exclusão de um elemento, a função prossegue a busca no vetor, até verificar todos os elementos. Por
fim, a variável tListaVetInt modificada é retornada.
Pseudocódigo 5.4 Processo componente para excluir elementos de um vetor que possuem um valor
especificado.
Descrição: Exclui elementos de um vetor.
Dados de Entrada: Estrutura do tipo lista vetorial de inteiros, valor a ser excluido.
Saída do Programa: Estrutura do tipo lista vetorial atualizada.
Processo componente " excluir do vetor ":
Atraibuir 0 variável pos.

5.6. O TAD IMPLEMENTACIONAL LISTA VETORIAL DE INTEIROS 135
ENQUANTO variável pos for menor que o tamanho do vetor
SE valor na posiç~ao pos for igual ao elemento a ser excluido
PARA variável i variando da posiç~ao pos a penúltima posiç~ao do vetor FAÇA
:
Atribuir ao valor na posiç~ao i o valor da posiç~ao i + 1.
FIM - PARA
Tamanho do votor é subtraido de 1.
SEN~AO
Variável pos é acrescida de 1.
FIM -SE
FIM - ENQUANTO
FIM - Processo componente " excluir do vetor "
1 tListaVetInt excluiListaVetInt ( tListaVetInt v, int elem ) {
2 int i, pos ;
3
4 pos = 0;
5 while ( pos < v.n) {
6 if (v. vet [ pos ] == elem ) {
7 for (i= pos ; i < v.n - 1; i ++) {
8 v. vet [i] = v. vet [i +1];
9 }
10 v.n - -;
11 } else {
12 pos ++;
13 }
14 }
15
16 return v;
17 }
Exemplo 5.24: Exclusão de elementos com um valor especificado.
v.vet 1 2 3 10 4 5
v.n 6
v.vet 1 2 3 4 4 5
v.n 6
elem 10
elem 10
DRAFT
v.vet 1 2 3 4 5 5
v.n 6
v.vet 1 2 3 4 5
v.n 5
elem 10
elem 10
Figura 5.8: Etapas da exclusão de elementos com um valor especificado.
A função apresentada no Exemplo 5.25 realiza a ordenação dos elementos armazenados na variável
tListaVetInt.
Ambas colocam em ordem crescente os elementos de um vetor, mas utilizando métodos diferentes.
A função ordenaMenorListaVetInt utiliza uma estratégia denominada “método do menor elemento”.
Ela recebe uma variável do tipo tListaVetInt, cujo vetor será ordenado. Inicialmente, a função verifica

136
CAPÍTULO 5. VETORES
todos os elementos do vetor, e localiza a posição do elemento de menor valor; então, esse elemento é
trocado com o elemento na primeira posição do vetor. Assim, neste momento, o primeiro elemento do
vetor já contém o menor valor. Em seguida, a função busca a posição do segundo menor elemento do
vetor, e, quando este elemento é encontrado, ele é trocado com o segundo elemento do vetor. Assim,
neste momento, os dois primeiros elementos do vetor já estão corretamente ordenados. De forma
semelhante, são também ordenados o terceiro, o quarto, e assim sucessivamente, até o penúltimo
elemento do vetor. Por fim, a variável tListaVetInt modificada é retornada.
Pseudocódigo 5.5 Processo componente para ordenar um vetor de forma crescente.
Descrição: Ordena um vetor de forma crescente.
Dados de Entrada: Estrutura do tipo lista vetorial de inteiros.
Saída do Programa: Estrutura do tipo lista vetorial ordenada crescentemente.
Processo componente " ordena crescente ":
PARA variável pos variando de 0 até penúltima posiç~ao FAÇA:
Atribuir a variável menor o valor do elemento do vetor na posiç~ao pos.
Atribuir a variável indice menor valor da variável pos.
PARA variável i variando de pos + 1 até última posiç~ao FAÇA:
SE o elemento na posiç~ao i for menor que menor
Atribuir a variável menor o valor do elemento do vetor na posiç~ao i.
Atribuir a variável indice menor o valor da variável i.
SE - FIM
FIM - PARA
Atribuir ao elemento do vetor na posiç~ao indice menor o valor do elemento do
vetor na posiç~ao pos.
Atribuir ao elemento do vetor na posiç~ao pos o valor da variável menor.
FIM - PARA
FIM - Processo componente " ordena crescente "
1 tListaVetInt ordenaMenorListaVetInt ( tListaVetInt v) {
2 int pos , i, indice_menor , menor ;
3
4 for ( pos =0; pos < v.n - 1; pos ++) {
5 menor = v. vet [ pos ];
6 indice_menor = pos ;
7 for (i= pos +1; i < v.n; i ++) {
8 if (v. vet [i] < menor ) {
9 menor = v. vet [i];
10 indice_menor = i;
11 }
12 }
13
DRAFT
14 v. vet [ indice_menor ] = v. vet [ pos ];
15 v. vet [ pos ] = menor ;
16 }
17
18 return v;
19 }
Exemplo 5.25: Ordenação pelo método do menor elemento.
A Figura 5.9 ilustra o funcionamento do algoritmo de ordenação pelo método do menor elemento.
A função apresentada no Exemplo 5.26 também realiza a ordenação dos elementos do vetor, mas
utiliza uma estratégia diferente da do método do menor elemento; esta estratégia é denominada
método da bolha. A função ordenaBolhaListaVetInt recebe como parâmetro de entrada a variável
tListaVetInt cujo vetor será ordenado. Então, a função percorre o vetor por completo, do elemento
de maior índice para o elemento de menor índice, a cada etapa comparando o elemento de índice i
com o elemento de índice i − 1, e trocando-os se o elemento de maior índice possui valor menor do

5.6. O TAD IMPLEMENTACIONAL LISTA VETORIAL DE INTEIROS 137
Figura 5.9: Método do menor.
DRAFT
que o elemento de menor índice. Após percorrer uma vez o vetor, o elemento de menor valor fica
armazenado na primeira posição do vetor. Então, o algoritmo ignora esse primeiro elemento, e repete
o procedimento para todo o restante do vetor. Este procedimento é repetido uma quantidade de
vezes igual ao número total de elementos armazenados menos um. Por fim, a variável tListaVetInt
modificada é retornada.
Pseudocódigo 5.6 Processo componente método da bolha.
Descrição: Ordena um vetor de forma crescente usando o método da bolha.
Dados de Entrada: Estrutura do tipo lista vetorial de inteiros.
Saída do Programa: Estrutura do tipo lista vetorial ordenada crescentemente.
Processo componente "método da bolha ":
Atribuir verdadeiro à variável houve troca.
Atribuir à variável limite a quantidade de elementos da estrutura do tipo lista
vetorial de inteiros passada como entrada menos um.
ENQUANTO houve troca for verdadeiro FAÇA:
Atribuir falso a variável houve troca.
PARA variável i variando de 0 a limite FAÇA:
SE elemento do vetor na posiç~ao i for maior que o elemento do vetor na
posiç~ao i + 1

138
CAPÍTULO 5. VETORES
Troque o valor entre os elementos dos vetor nas posiç~oes i e i + 1.
Atribuir verdadeiro a variável houve troca.
Atribuir o valor de i -1 à variável limite
FIM -SE
FIM - PARA
FIM - ENQUANTO
FIM - Processo componente "método da bolha "
1 tListaVetInt ordenaBolhaListaVetInt ( tListaVetInt v) {
2 int i, temp , houve_troca , limite ;
3
4 limite = v.n -1;
5 houve_troca = 1;
6 while ( houve_troca == 1) {
7 houve_troca = 0;
8 for (i =0; i < limite ; i ++) {
9 if (v. vet [i] > v. vet [i +1]) {
10 temp = v. vet [i];
11 v. vet [i] = v. vet [i +1];
12 v. vet [i +1] = temp ;
13 houve_troca = 1;
14 limite = i -1;
15 }
16 }
17 }
18
19 return v;
20 }
Exemplo 5.26: Ordenação pelo método da bolha.
A Figura 5.10 ilustra o funcionamento do algoritmo de ordenação pelo método da bolha.
Exemplo de Utilização do TAD tListaVetInt
Será apresentado agora um exemplo de utilização do TAD tListaVetInt. Vale lembrar que o Exemplo
5.27 apresenta apenas o programa principal contendo a chamada das funções definidas até aqui.
Para seu funcionamento correto, todas as funções devem estar definidas anteriormente no arquivo do
programa.
1 int main (){
2 tListaVetInt vet1 ;
3 tListaVetInt vet2 ;
4 tListaVetInt vet3 ;
5 int elem ;
6 int pos ;
7 int prodEscalar ;
8 int enter ;
9
10 vet1 = leituraListaVetInt (vet1 ,10) ;
11 vet2 = leituraListaVetInt (vet2 ,10) ;
12 vet3 = inicializacaoVaziaListaVetInt ( vet3 );
13
14 printf (" Vet1 :");
15 exibeListaVetInt ( vet1 );
16
17 printf (" Vet2 :");
18 exibeListaVetInt ( vet2 );
19
DRAFT
20 printf ("\n\ nQual elemento deseja localizar utilizando a pesquisa sequencial ?\n\n")
;
21 scanf ("%d", & elem );

5.6. O TAD IMPLEMENTACIONAL LISTA VETORIAL DE INTEIROS 139
22
Figura 5.10: Método da bolha
23 pos = pesquisaSequencialListaVetInt (vet1 , elem );
24
25 if(pos >= 0){
DRAFT
26 printf ("\n\ nElemento encontrado na posicao %d\n\n", pos );
27 } else {
28 printf ("\n\ nElemento nao encontrado \n\n");
29 }
30
31 printf ("\n\ nQual elemento deseja localizar utilizando a pesquisa binaria ?\n\n");
32 scanf ("%d", & elem );
33
34 pos = pesquisaBinariaListaVetInt (vet1 , 3);
35
36 if(pos >= 0){
37 printf ("\n\ nElemento encontrado na posicao %d\n\n", pos );
38 } else {
39 printf ("\n\ nElemento nao encontrado \n\n");
40 }
41
42 vet3 = adicaoListaVetInt (vet1 , vet2 , vet3 );
43
44 printf (" Vet1 :");

140
CAPÍTULO 5. VETORES
45 exibeListaVetInt ( vet1 );
46
47 printf (" Vet2 :");
48 exibeListaVetInt ( vet2 );
49
50 printf (" Vet3 :");
51 exibeListaVetInt ( vet3 );
52 prodEscalar = prodEscalarListaVetInt (vet1 , vet2 );
53
54 printf ("\n\n");
55 printf (" Vet1 :");
56 exibeListaVetInt ( vet1 );
57
58 printf (" Vet2 :");
59 exibeListaVetInt ( vet2 );
60
61 printf ("\n\ nProduto escalar = %d\n\n", prodEscalar );
62
63 vet3 = leituraListaVetInt (vet3 , 0);
64 vet3 = insereListaVetInt (vet3 , 5, 0);
65
66 printf (" Vet3 :");
67 exibeListaVetInt ( vet3 );
68
69 vet3 = insereListaVetInt (vet3 , 3, 0);
70
71 printf (" Vet3 :");
72 exibeListaVetInt ( vet3 );
73
74 vet3 = insereListaVetInt (vet3 , 7, 1);
75
76 printf (" Vet3 :");
77 exibeListaVetInt ( vet3 );
78
79 vet3 = insereListaVetInt (vet3 , 10 , 3);
80
81 printf (" Vet3 :");
82 exibeListaVetInt ( vet3 );
83
84 vet3 = excluiListaVetInt (vet3 , 3);
85
86 printf (" Vet3 :");
87 exibeListaVetInt ( vet3 );
88
89 vet3 = excluiListaVetInt (vet3 , 7);
90
91 printf (" Vet3 :");
92 exibeListaVetInt ( vet3 );
93
94 vet3 = excluiListaVetInt (vet3 , 10) ;
95
96 printf (" Vet3 :");
97 exibeListaVetInt ( vet3 );
98
99 vet3 = excluiListaVetInt (vet3 , 5);
100
101 printf (" Vet3 :");
102 exibeListaVetInt ( vet3 );
103
104 vet1 = ordenaMenorListaVetInt ( vet1 );
105
106 printf (" Vet1 :");
107 exibeListaVetInt ( vet1 );
108
109 vet2 = ordenaBolhaListaVetInt ( vet2 );
110
DRAFT

5.7.
EXERCÍCIOS RESOLVIDOS 141
111 printf (" Vet2 :");
112 exibeListaVetInt ( vet2 );
113
114 return 0;
115 }
Exemplo 5.27: Exemplo de Utilização do TAD tListaVetInt.
5.7 Exercícios Resolvidos
Exercício Resolvido 5.1 - Soma de um vetor de 100 inteiros
Crie uma função do tipo lista vetorial de inteiros na linguagem C que some os elementos de um
vetor com ’n’ elementos inteiros.
Solução Possível:
É mostrada uma possível solução no Pseudocódigo 5.7 e no Exemplo 5.28:
Pseudocódigo 5.7 Passos a serem realizados pela função Soma de 100 elementos de um vetor
de inteiros.
Descrição: Calcular a soma dos 100 elementos de um vetor de inteiros.
Dados de Entrada: Elemento do tipo lista vetorial de inteiros e a quantidade n de elementos.
Saída do Programa: A soma dos elementos.
Processo componente " soma de n elementos de um vetor de inteiros "
Atribuir 0 a variável soma.
PARA variável i variando de 0 à n -1 FAÇA:
Somar a variável soma o valor do elemento do vetor na posiç~ao i.
FIM - PARA
Retornar o valor de soma.
FIM - Processo componente " soma de n elementos de um vetor de inteiros "
1 int somaElementosListaVetInt ( TListaVetInt v, int n){
2 int i, soma ;
3 soma = 0;
4 for (i =0; i

142
CAPÍTULO 5. VETORES
Pseudocódigo 5.8 Passos a serem realizados pela função apresenta os 100 primeiros números
primos.
Descrição: Apresentar os 100 primeiros números primos.
Dados de Entrada: Não existe.
Saída do Programa: Os 100 primeios números primos.
Processo componente " apresenta os 100 primeiros números primos "
Atribuir 2 à primeira posiç~ao do vetor primos .
Atribuir 1 a v a r i v e l contador .
Atribuir 3 a v a r i v e l numero .
ENQUANTO a variável contador for menor que 100 FAÇA:
Atribuir o valor da raiz quadrada da variável numero a variável limite .
Atribuir 1 a variável eh_primo .
PARA variável i variando de 0 até limite FAÇA:
SE o resto da divis~ao da variável numero pelo valor do vetor primos na
posiç~ao i for igual a 0
Atribuir 0 a variável eh_primo .
INTERROMPER o PARA .
FIM -SE
FIM - PARA
SE a variável eh_primo for igual a 1
Atribuir numero ao vetor primos na p o s i o contador .
Incrementar 1 a variável contador.
FIM -SE
Incrementar 2 a variável numero .
FIM - ENQUANTO
PARA variável i variando de 0 até 100 FAÇA:
Apresentar o valor do vetor primos na posiç~ao i.
FIM - PARA
FIM - Processo componente " apresenta os 100 primeiros números primos "
1 # include
2 # include
3
4 int main (){
5 int primos [100];
6 int contador , numero , i, eh_primo ;
7 float limite ;
8
9 primos [0] = 2;
10 contador = 1;
11 numero = 3;
12
13 while ( contador < 100) {
14 limite = sqrt ( numero );
15 eh_primo = 1;
16 for (i =0; primos [i]

5.7.
EXERCÍCIOS RESOLVIDOS 143
30 printf ("%d\n", primos [i]);
31 }
32
33 return 0;
34 }
Exemplo 5.29: Programa que apresenta os 100 primeiros números primos.
Exercício Resolvido 5.3 - Intercala dois vetores de inteiros previamente ordenados
Faça um programa em linguagem C que leia dois vetores ordenados em M e N elementos respectivamente
e os intercale gerando um novo vetor U, também ordenado. Considere o exemplo:
M: 5
N: 4
Primeiro vetor :
1 7 13 14 30
Segundo vetor :
2 3 7 16
Resultado :
1 2 3 7 7 13 14 16 30
Obs.: O terceiro vetor não pode ser gerado copiando-se primeiramente os dois vetores e fazendo a
ordenação posteriormente.
Solução Possível:
É mostrada uma possível solução no Pseudocódigo 5.9 e no Exemplo 5.30:
Pseudocódigo 5.9 Passos a serem realizados pela função intercala.
Descrição: Intercalar dois vetores de inteiros previamente ordenados.
Dados de Entrada: Três estruturas TListaVetInt, duas contendo os vetores ordenados e U.
Saída do Programa: Estrutura TListaVetInt contendo o vetor intercalado.
Processo componente " intercala "
Inicializar as v a r i v e i s i,j, e k com 0.
ENQUANTO a variável i for menor que o tamanho do vetor contido em A e j for menor
que o tamanho do vetor contido em B passados como argumento para a funç~ao
FAÇA:
SE o elemento da posiç~ao i do vetor contido em A for menor ou igual ao
elemento da posiç~ao j do vetor contido em B
Atribuir ao elemento da posiç~ao k do vetor contido em U o valor do
elemento da posiç~ao i do vetor contido em A.
Incrementar 1 a variável i.
SEN~AO
Atribuir ao elemento da posiç~ao k do vetor contido em U o valor do
elemento da posiç~ao j do vetor contido em B.
Incrementar 1 a variável j.
FIM -SE
Incrementar 1 a variável k.
FIM - ENQUANTO
PARA variável iAux variando de i até o tamanho do vetor contido em A FAÇA:
Atribuir ao elemento da posiç~ao k do vetor contido em U o valor do elemento
da posiç~ao iAux do vetor contido em A.
Incrementar 1 a variável k.
FIM - PARA
PARA variável iAux variando de j até o tamanho do vetor contido em B FAÇA:
Atribuir ao elemento da posiç~ao k do vetor contido em U o valor do elemento
da posiç~ao iAux do vetor contido em B.
Incrementar 1 a variável k.
FIM - PARA
Atribuir a variável n contida em U a soma dos tamanhos dos vetores contidos em A
e B.
Retornar o valor de U.
FIM - Processo componente " intercala "
DRAFT

144
CAPÍTULO 5. VETORES
1 # include < stdio .h>
2
3 # define TAM 100
4
5 TListaVetInt intercalaListaVetInt ( TListaVetInt U, TListaVetInt A, TListaVetInt B){
6
7 int i = 0, j = 0, k = 0, iAux ;
8
9 while (i

5.7.
EXERCÍCIOS RESOLVIDOS 145
Pseudocódigo 5.10 Passos a serem realizados pela função calcula fatuamento armazém.
Descrição: Calcular o faturamento do armazém.
Dados de Entrada: Dois vetores, um com as quantidades de produtos e um com os preços dos produtos.
Saída do Programa: Faturamento do armazém.
Processo componente " calcula faturamento armazém"
Utiliza funç~ao prodEscalarListaVetInt já definida para obter o faturamento .
FIM - Processo componente " calcula faturamento armazém"
1 float calculaFaturamentoArmazem ( TListaVetInt quantidade , TListaVetInt precos ){
2 return prodEscalarListaVetInt ( quantidade , precos );
3 }
Exemplo 5.31: Função que calcula o faturamento do armazém.
Exercício Resolvido 5.5 - Gerencia de Turmas e Cursos
Você foi contratado para fazer um programa em C para processar algumas informações a respeito
dos alunos do seu curso. Para tanto o coordenador do curso te forneceu uma listagem com as médias
finais obtidas em cada disciplina cursada pelos alunos do curso. Portanto, cada linha da listagem
contém o código da disciplina (um valor inteiro positivo), a matrícula do aluno (um valor inteiro
positivo) e a média final obtida pelo aluno (um valor ponto flutuante não negativo). Você deve:
ˆ
ˆ
ˆ
ˆ
ˆ
Definir as estruturas de dados que serão usadas no programa.
Criar uma função para a leitura dos dados da listagem.
Criar uma função para ordenar crescentemente a listagem por disciplina cursada e por matrícula
do aluno, isto é, os dados da listagem devem ficar ordenados crescentemente por código da
disciplina e, em uma mesma disciplina, ordenados crescentemente por matrícula.
Criar uma função que receba a matrícula de um aluno, um código de disciplina e os dados
ordenados da listagem (conforme item c), utilize uma pesquisa binária para encontrar a nota
obtida por esse aluno na disciplina e retorne essa nota ou o ponto flutuante -1.0, caso o aluno
não tenha cursado esta disciplina. Observe que só há registros na listagem da última vez que
os alunos cursaram a disciplina, isto é, não há registros repetidos de um mesmo aluno em uma
disciplina.
DRAFT
Criar um programa que leia os dados da listagem, ordene-os conforme item c, leia a matrícula
de um aluno e o código de uma disciplina e diga se ele cursou a disciplina e qual nota obteve, se
for o caso.
É um requisito do programa que a passagem de parâmetros para as funções seja realizada sem que haja
gasto de uma grande quantidade de memória. Note que os dados não estão ordenados na listagem.
Considere ainda que existem no máximo 30 disciplinas distintas no curso e que não existem mais de
100 alunos no curso. A leitura dos dados deve ser encerrada quando for lido um código de disciplina
igual a zero. Um exemplo de listagem é apresentado na tabela 5.11:
Solução Possível:
Para facilitar definiu-se as constantes mostradas em 5.32, que são os limites exigidos no exercício:
1 # define TAM_ALUNO 100
2 # define TAM_DISCIPLINAS 30
Exemplo 5.32: Constantes

146
CAPÍTULO 5. VETORES
Código da Disciplina Matrícula Média Final
121 1313 4.1
27 2222 9.3
121 2032 6.1
17 1313 4.2
121 4546 3.8
322 2222 8.0
0 0 0.0
Figura 5.11: Exemplo de listagem
A estrutura que foi definida para a resolução do problema é apresentada em 5.33:
1 typedef struct {
2 int codigo ;
3 int matricula ;
4 float media ;
5 } registro ;
Exemplo 5.33: Estruturas
Para fazer a leitura dos códigos das disciplinas, das matrículas e das notas, faz-se um loop que
percorre o arquivo de entrada e guarda-se o código da disciplina, a matrícula do aluno e a média em
um vetor de estruturas do tipo registro, que foi definida para esse exercício.
É mostrada uma possível implementação para a leitura no Pseudocódigo 5.11 e no Exemplo 5.34:
Pseudocódigo 5.11 Passos a serem realizados pela função leitura.
Descrição: Faz a leitura das disciplinas, matrículas e notas.
Dados de Entrada: Nome do arquivo de onde será lido, e vetor da estrutura disciplinas.
Saída do Programa: Quantidade de disciplinas.
Processo componente " leitura "
EQUANTO
Ler do arquivo de entrada o código da disciplina , a matrícula e a media do
aluno
SE código da disciplina for zero
PARAR EQUANTO
SEN~AO
Armazena na estrutura registro os valores lidos .
FIM -SE
Incrementa a quantidade de alunos nessa disciplina
FIM - ENQUANTO
FIM - Processo componente " leitura "
DRAFT
1 int leitura ( char entrada [] , registro reg []) {
2 int quant , cod , mat ;
3 float med ;
4 FILE *f;
5
6 f = fopen ( entrada ,"r");
7
8 if(f == NULL ){
9 printf (" Erro ao abrir o arquivo para leitura .\n");
10 exit (1) ;
11 }
12

5.7.
EXERCÍCIOS RESOLVIDOS 147
13 quant = 0;
14
15 while (1) {
16 fscanf (f,"%d%d%f" ,&cod ,& mat ,& med );
17 if(reg [ quant ]. codigo == 0){
18 break ;
19 }
20 else {
21 reg [ quant ]. codigo = cod ;
22 reg [ quant ]. matricula = mat ;
23 reg [ quant ]. media = med ;
24 }
25 quant ++;
26 }
27
28 return quant ;
29 }
Exemplo 5.34: Programa que faz a leitura das disciplinas, matrículas e notas.
A ordenação é feita usando-se um método da bolha mais simplificado do que aquele que foi apresentado
neste capítulo. Primeiro ordena-se de forma crescente de acordo com o código da disciplina.
Se as disciplinas forem de mesmo código ordena-se pela matrícula do aluno.
1 void ordena ( registro reg [] , int n){
2 registro regAux ;
3 int i,j;
4
5 for (i =0;i

148
CAPÍTULO 5. VETORES
10 if( inicio == fim ){
11 return -1;
12 }
13 else {
14 if(reg [ pivot ]. codigo < cod ){
15 return buscaBinariaDisciplina (cod , reg , pivot + 1, fim );
16 }
17 else {
18 return buscaBinariaDisciplina (cod , reg , inicio , pivot - 1);
19 }
20 }
21 }
Exemplo 5.36: Programa que usa busca binária para encontrar uma determinada disciplina.
1 float busca ( int cod , int mat , registro reg [] , int n){
2 int pos , i;
3
4 pos = buscaBinariaDisciplina (cod , reg , 0, n);
5
6 if(pos == -1){
7 return -1.0;
8 }
9
10 if(reg [ pos ]. matricula < mat ){
11 for (i = pos ; reg [i]. codigo == cod && i < n;i ++) {
12 if(reg [i]. matricula == mat ){
13 return reg [i]. media ;
14 }
15 }
16 }
17 else {
18 for (i= pos ; reg [i]. codigo == cod && i >= 0;i - -){
19 if(reg [ pos ]. matricula == mat ){
20 return reg [ pos ]. media ;
21 }
22 }
23 }
24
25 return -1.0;
26 }
DRAFT
Exemplo 5.37: Programa que usa busca binária para encontrar um determinado aluno.
Por fim temos o Exemplo 5.38 que une todas as funcionalidades mostradas e exibe a nota do aluno
em uma determinada matéria.
1 void sistemaDisciplina ( char entrada []) {
2 registro reg [ TAM_ALUNO * TAM_DISCIPLINAS ];
3 int n, mat , cod ;
4 float nota ;
5
6 n = leitura ( entrada , reg );
7 ordena (reg , n);
8
9 printf (" Digite a matricula do aluno : ");
10 scanf ("%d", & mat );
11
12 printf (" Digite o codigo da disciplina : ");
13 scanf ("%d", & cod );
14
15 nota = busca (cod , mat , reg , n);
16
17 if( nota == -1.0) {

5.8. RESUMO 149
18 printf (" Aluno ou disciplina inexistente .\n");
19 }
20 else {
21 printf ("A nota do aluno %d na disciplina %d foi : %f\n", mat , cod , nota );
22 }
23 }
5.8 Resumo
ˆ
ˆ
ˆ
ˆ
ˆ
ˆ
ˆ
ˆ
ˆ
ˆ
Exemplo 5.38: Programa final que usa todas as outras funções acima.
Um vetor é uma estrutura de dados composta e homogênea, isto é, ele possui, em geral, mais de
um elemento de um mesmo tipo.
São características importantes dos vetores a sequencialização, a indexação e a sua dimensão.
Deve-se tomar cuidado para não se acessar um vetor indevidamente, como por exemplo utilizando
um índice maior que seu tamanho.
A dimensão de um vetor pode ser definida, em C, tanto em tempo de compilação, quanto em
tempo de execução.
Na linguagem C não existem operações básicas para a manipulação de um vetor como um todo.
Seus elementos devem ser manipulado separadamente.
Quando acessado individualmente, cada elemento de um vetor pode ser encarado como uma
variável básica.
A utilização de expressões como índice no acesso a elementos de um vetor é uma ferramenta
poderosa.
A utilização de funções para a manipulação de vetores como um todo é importante para a
legibilidade e reusabilidade do programa e deve ser usada.
A utilização de TAD’s Implementacionais é um artifício para facilitar a manipulação de vetores
e aumentar a legibilidade e reusabilidade do programa.
O TAD Implementacional TListaVetInt, implementado aqui na linguagem C, pode ser utilizado,
sempre que necessário, para a manipulação de vetores de números inteiros.
5.9 Exercícios Propostos
DRAFT
1. Implemente uma operação do tipo lista vetorial de inteiros que inverta a sequência na qual se
encontram na lista. Use essa operação e as operações de leitura e escrita para fazer um programa
na linguagem C que leia 100 números inteiros e os apresente na ordem inversa em que foram
lidos.
2. Faça um programa em linguagem C que leia N (N < 1000) números de matrículas de alunos que
fazem Programação 1 e os coloque em ordem crescente num vetor à medida que vão sendo lidas
as matrículas. Posteriormente escreva uma função que identifique se um certo conjunto de M
alunos fazem Programação 1. Deve-se utilizar o algoritmo de pesquisa binária para fazer esta
verificação.
3. Faça um programa em linguagem C que:
(a) leia N números reais colocando-os num vetor de 100 elementos (considerar N < 1000);

150
CAPÍTULO 5. VETORES
(b) ordene crescentemente os elementos de índices ímpares utilizando o método da bolha para
tal (considerar apenas os N elementos);
(c) escreva os N números após o ajuste do ítem (b).
4. Crie um procedimento em linguagem C que cumpra a seguinte especificação:
(a) Dados de entrada:
i. um vetor de caracteres com um máximo de 100 elementos;
ii. o tamanho corrente do vetor (suponha que o vetor inicie na primeira posição);
iii. um caractere a ser inserido;
iv. a posição do vetor onde o caractere deve ser inserido.
(b) Dados de saída:
i. o vetor com o caractere inserido na posição;
ii. o vetor deve ser mantido inalterado se a posição onde deveria ser inserido o carctere
superior ao tamanho corrente do vetor ou se o vetor já estiver completo.
5. Baseado no tipo vetorial de inteiros crie um novo tipo e escreva um algoritmo em linguagem C
que:
(a) leia um conjunto A de 100 elementos reais;
(b) construa e apresente um outro conjunto B formado da seguinte maneira:
i. os elementos de ordem par são os correspondentes de A divididos por 2;
ii. os elementos de ordem ímpar são os correspondentes de A multiplicados por 3.
6. Dado um vetor contendo uma frase com 80 caracteres (incluindo espaços em branco), escreva
um algoritmo em linguagem C para:
(a) contar quantos brancos existem na frase;
(b) contar quantas vezes aparece a letra ’A’;
(c) contar quantas vezes aparece um mesmo par de letras na frase e quais são eles.
7. Faça um algoritmo em linguagem C para ler um vetor de comprimento N (para N

5.9.
EXERCÍCIOS PROPOSTOS 151
14. O Colegiado de seu curso mantém uma listagem com informações sobre o desempenho de cada
aluno do curso. Esta listagem contém as notas obtidas pelo aluno em cada uma das disciplinas
que ele cursou e é organizada da seguinte maneira (note que as notas de um aluno nas disciplinas
não estão necessariamente em sequência):
Matrícula do Aluno Código da Disciplina Carga Horária Nota
00018 0001 60 4.5
11111 3232 30 8.7
00234 0500 75 9.0
00018 0001 60 7.0
00234 0500 90 9.5
.
.
.
.
09999 0786 60 7.5
Figura 5.12: Exemplo de listagem
Para facilitar a consulta a esta listagem, o coordenador do colegiado precisa de um programa
que realize algumas operações sobre os dados da lista. Ele te pediu para que você elabore este
programa. Para isso, ele pede para que você faça:
(a) Um suprograma que leia os dados da lista.
(b) Um subprograma que imprima as notas obtidas por um aluno numa determinada disciplina.
Lembre-se que o aluno pode ter cursado mais de uma vez uma mesma disciplina por motivo
de reprovação.
(c) Um subprograma que exclua todos os dados de um aluno que foi jubilado.
(d) Um subprograma que calcule o coeficiente de rendimento (C.R.) de um aluno. Lembre-se
que o C.R. é calculado da seguinte maneira:
C.R. = ( ∑ (Carga Horária x Nota )) / ( ∑ (Carga Horária))
(e) Um programa interativo que permita ao usuário:
Ler os dados da listagem.
Imprimir as notas de um aluno numa disciplina.
Excluir um aluno jubilado.
Calcular o C.R. de um aluno.
DRAFT
Observações: Assuma que existem, no máximo, 1000 (mil) alunos no seu curso.
15. Uma grande empresa capixaba necessita fazer um estudo sobre os salários pagos aos seus funcionários.
Para tanto, ela dispões de uma listagem onde constam as matrículas e os salários de
cada um deles (tal como na Figura 5.13).
Funcionário Salário
00001 1500.00
12897 300.00
00032 734.00
09000 1886.00
00666 1201.00
.
.
12345 1113.00
Figura 5.13: Exemplo de listagem

152
CAPÍTULO 5. VETORES
Sabendo de tua grande competência como programador, a empresa te contratou para elaborar
um programa interativo que produza algumas informações para o estudo. A partir dos dados da
listagem, o programa deve:
(a) Ler os dados da lista.
(b) Calcular o salário médio da empresa.
Salário médio =( ∑ salários) / (total de funcionários)
(c) Calcular o percentual de funcionários que ganham abaixo do salário médio.
Perc. Abaixo =(número quad de func. abaixo x 100) / (total de funcionários)
(d) Calcular o percentual da despesa total em salários que é pago aos funcionários que ganham
o maior salário.
Perc. Maior = ( ∑ maiores salários x 100) / ( ∑ salários)
16. Considere uma seqüência de números inteiros não negativos armazenada em uma lista vetorial
de inteiros. Os elementos da seqüência estão em qualquer ordem e podem ocorrer subseqüências
de números repetidos. Por exemplo, na seqüência:
S1= 4, 4, 5, 9, 1023, 4, 4, 4, 4, 2, 7, 4, 6, 6, 7, 8, 8, 8, 8, 3
existem 4 subseqüências de elementos repetidos (duas de 4, uma de tamanho 2 e outra de
tamanho 4, a de 6 com 2, e a de 8 com 4). Escreva um subprograma que tenha como parâmetro
uma lista vetorial de inteiros v preenchida com uma sequência qualquer de números inteiros
não negativos, um número natural x especificando um possível componente da seqüência e um
tamanho t. O objetivo do subprograma é localizar em v, a menor subseqüência de elementos
iguais a x com tamanho mínimo igual a t. O retorno da função deve ser o índice do primeiro
elemento desta subseqüência. Para a seqüência S1 acima, se o argumento da busca (x) é 4 e o
tamanho (t) é 3 o resultado retornado deverá ser 5. Se não for encontrada uma seqüência que
satisfaça a condição, deve ser retornado -1.
17. O comitê organizador dos jogos pan-americanos de 2007, no Rio de Janeiro, deseja apresentar os
resultados da competição indicando o total de medalhas de ouro, prata e bronze de cada país.
Faça um programa em C para apresentar esses resultados. Os dados devem ser lidos da entrada
padrão de uma listagem organizada como no exemplo seguinte (cada linha da listagem apresenta
o resultado de uma competição).
12 23 43
17 12 34
· · ·
11 12 33
DRAFT
Assuma que o número máximo de países participantes dos jogos é 30. Considere ainda que a
classificação dos países é feita primeiramente pelo critério total de medalhas de ouro, depois
pelo critério total de medalhas de prata e, por fim, pelo critério total de medalhas de bronze.
Desconsidere a hipótese de haver empate nos três critérios: total de medalhas de ouro, prata e
bronze. Os resultados devem ser apresentados na saída padrão apresentando o código do país,
seguido do total de medalhas de ouro, prata e bronze obtidos, ordenados decrescentemente (ou
seja, primeiro devem ser mostrados os dados do país campeão dos jogos, em seguida, os dados
do vice-campeão e assim por diante). O exemplo seguinte mostra como deve ser organizada a
saída.
17 34 48 63
34 30 57 29
· · ·
22 0 0 1

5.10. TRABALHOS SUGERIDOS 153
18. Considere uma seqüência de números inteiros não negativos armazenada em uma lista vetorial
de inteiros. Nela podem ocorrer subseqüências de números consecutivos. Por exemplo, na
seqüência:
1, 4, 5, 9, 10, 13, 1, 2, 3, 4, 2, 7, 5, 6, 7, 7, 8, 9, 10, 8, 3
existem 5 subseqüências de números consecutivos (uma com 4 e 5, uma com 9 e 10, uma com
1, 2, 3 e 4, uma com 5, 6 e 7 e outra com 7, 8, 9 e 10). Escreva um subprograma que receba
como parâmetro uma lista vetorial de inteiros preenchida com uma sequência qualquer
de números inteiros não negativos e retorne o tamanho da maior subseqüência encontrada de
números consecutivos. No exemplo, acima, o subprograma deverá retornar o valor 4.
19. Escrever um programa que leia uma palavra do teclado e conte as ocorrências de todos pares
de letras nesta palavra. Por exemplo, na palavra Mississippi, as seguintes combinações de dois
caracteres ocorrem.
5.10 Trabalhos Sugeridos
1. Extrato Bancário
Mississippi
MI 1 VEZ
IS 2
SS 2
SI 2
IP 1
PP 1
PI 1
Figura 5.14: Exemplo de ocorrências
O gerente de uma agência bancária te contratou para fazer um programa em C para processar
algumas informações das contas dos correntistas de sua agência. Para tanto o gerente te forneceu
uma listagem contendo, em cada linha, os dados do número da conta (um valor inteiro positivo),
o código da operação (um valor inteiro positivo) e o valor da operação (um valor ponto flutuante
positivo para as operações de crédito e negativo para as operações de débito) realizadas no último
mês. Você deve:
DRAFT
(a) Ler os dados da listagem.
(b) Apresentar as operações realizadas por cada cliente ordenadas por número da conta. As
operações individuais de cada cliente devem estar ordenadas por código da operação.
(c) Apresentar os saldos totais das operações realizadas no mês pelos clientes que se encontram
no grupo dos 40% de clientes com maior saldo.
(d) Apresentar a movimentação financeira de cada tipo de operação realizada na agência. As
operações devem ser apresentadas ordenadas decrescentemente pelo valor da movimentação
financeira total no mês. Considere que tanto as operações de crédito quanto as de débito dos
clientes devem ser consideradas para determinar a movimentação financeira da operação,
isto é, o valor total da movimentação financeira de uma operação é a soma de todas as
operações de crédito com o valor absoluto de todas as operações de débito daquela operação.
Note que os dados de cada conta não estão ordenados na listagem. Considere ainda que existem
no máximo 100 clientes na agência e que no máximo ocorrem 100 operações na agência a cada
mês. O processamento deve ser encerrado quando for lido um número de conta igual a zero. Um
exemplo de listagem é apresentado na Figura 5.15:

154
CAPÍTULO 5. VETORES
Número de Conta Código da Operação Valor de Operação
1 17 123,02
7 32 -22,54
2 54 1000,01
1 28 22222,22
... ... ...
0 0 0,00
Figura 5.15: Exemplo de listagem
DRAFT

Capítulo 6
Matrizes
Objetivos:
ˆ
ˆ
ˆ
Coautores:
Clebson Oliveira
Julio Dalfior
Rafael Favoreto
Ramon Schiavo
Thales Carvalho
Thaylo de Freitas
Mostrar a importância de se utilizar a estrutura de dados matriz para resolver problemas;
Introduzir o conceito do tipo abstrato de dados matriz;
Mostrar como modelar um problema através do TAD Matriz de inteiros.
No capítulo anterior, foi discutida a estrutura de dados vetor, que é capaz de armazenar dados de
um mesmo tipo, poupando o programador de declarar uma grande quantidade de variáveis.
Neste, capítulo é apresentada a estrutura de dados matriz que, diferentemente do vetor, armazena
dados de forma multidimensional.
6.1 Matrizes e sua importância
Uma matriz é um tipo de dado composto em que os elementos são do mesmo tipo e organizados em
uma estrutura multidimensional. Uma matriz bidimensional, por exemplo, é formada pela combinação
de linhas e colunas. Com isso, cada elemento passa a ser associado a um indicador de linha e um
indicador de coluna, como em uma tabela. A Figura 6.1 mostra uma matriz 5 por 3. Note que a
matriz possui 5 linhas e 3 colunas. Embora matrizes possam ter mais que 2 dimensões, neste livro
enfatiza-se as matrizes bidimensionais. Uma matriz de m linhas e n colunas é chamada matriz m por
n.
DRAFT
Figura 6.1: Uma matriz 5 por 3 preenchida com zeros.
155

156
CAPÍTULO 6. MATRIZES
Para mostrar que matrizes bidimensionais são muito comuns no nosso dia-a-dia pode-se citar vários
exemplos: um cartão de bingo, uma agenda com a disponibilidade para marcar compromissos (ver
Figura 6.2) etc. É interessante que haja uma maneira de representar esse tipo de estrutura, para que
se possa utilizá-la na solução de problemas computacionais.
Figura 6.2: Agenda de disponibilidade e sua representação matricial.
Na Figura 6.2, as linhas representam os dias do mês e as colunas representam os meses do ano.
Dessa forma, cada posição (ou célula) da matriz representa a disponibilidade em um determinado dia
de um determinado mês.
Considerando que essa matriz será utilizada para representar se há ou não compromisso naquele
dia do mês, se tratará de uma matriz bidimensional, pois a cada célula dessa matriz estão associadas
duas informações, mês e dia. Por outro lado, se for necessário especificar as horas de um dia que estão
ou não ocupadas, ter-se-ia uma matriz tridimensional, porque cada célula da matriz estaria associada
a três informações (mês, dia e hora).
A forma de se visualizar uma matriz facilita o entendimento do conceito de dimensão. Por exemplo,
uma matriz bidimensional pode ser visualizada como um quadro e uma tridimensional pode ser
visualizada como um cubo formado por vários cubos menores. Apesar de ser difícil visualizar matrizes
com mais de três dimensões, vale ressaltar que elas existem e que é possível declará-las em C. Como
exemplo da utilização de matrizes com mais de três dimensões, pode-se utilizar a Figura 6.2 supondo
que, além de representar o horário, se queira também representar o ano. Nesse caso seria necessária
uma matriz de quatro dimensões (ano, mês, dia e hora).
6.2 Definição e Acesso
DRAFT
Para que um problema seja modelado através de uma matriz é necessário que se defina uma variável do
tipo matriz para representá-la. Assim será possível utilizar seus elementos para guardar informações
e, posteriormente, aplicar operações sobre essa estrutura.
6.2.1 Definição
A definição de uma variável do tipo matriz exige que se informe o tamanho de suas dimensões.
No entanto, existem duas maneiras de estabelecer o tamanho dessas dimensões: estaticamente e
dinamicamente. Este capítulo tem um foco maior na definição estática do tamanho das dimensões.
Para se definir uma matriz estaticamente é necessário estabelecer um tamanho para cada dimensão,
sendo que esse tamanho não poderá ser alterado durante a execução do programa. O código do
Exemplo 6.1 mostra como isso pode ser feito em C:
1 int matriz [5][10];
Exemplo 6.1: Definição estática.

6.2.
DEFINIÇÃO E ACESSO 157
O número entre o primeiro par de colchetes ([5]) define o tamanho da primeira dimensão (número
de linhas). O número entre o segundo par de colchetes ([10]) define o tamanho da segunda dimensão
(número de colunas), e assim por diante para matrizes com mais de duas dimensões. No Exemplo 6.1,
a variável matriz possui 5 linhas e 10 colunas.
Inicialização
Na declaração de matrizes mostrada anteriormente, os valores das células da matriz não foram inicializados
e, por isso, geram resultados inesperados, uma vez que não se sabe quais valores estavam
armazenados anteriormente nas áreas de memória utilizadas. Para evitar esse tipo de problema, é
necessário, como uma boa prática de programação, inicializar os elementos das matrizes antes de
qualquer acesso a seus valores, mesmo que posteriormente esses elementos sejam configurados com
novos valores. A forma mais simples de se fazer isso, em C, pode ser vista no Exemplo 6.2.
1 int main (){
2 int matriz [2][2] = {0};
3
4 return 0;
5 }
Exemplo 6.2: Inicialização de uma matriz.
Na linha 2 do Exemplo 6.2, há a inicialização de todos os elementos da matriz com o valor zero.
6.2.2 Acesso
Com a matriz já inicializada, para se utilizar os dados contidos nela será necessário fazer uma operação
de acesso, como no Exemplo 6.3:
1 # define NMESES 12
2 # define NDIAS 31
3 # define NHORAS 24
4
5 int main (){
6 int reservaSala [ NMESES ][ NDIAS ][ NHORAS ] = {0};
7 int resposta = 0;
8 .
9 .
10 .
11 resposta = reservaSala [4][0][9];
12
13 if ( resposta == 0){
14 reservaSala [4][0][9] = 1;
15 }
16
17 return 0;
18 }
DRAFT
Exemplo 6.3: Acesso e atualização de um elemento.
A variável resposta recebe 0 ou 1 indicando, respectivamente, se às 10 horas do dia 1 de maio a
sala está livre ou reservada. Note que, assim como em vetores, a primeira posição de cada dimensão
da matriz tem índice 0, por isso, os índices dos meses, dias e horas são subtraídos por 1, tornando
os índices iguais a 4, 0 e 9. Após acessar um elemento da matriz chamada reservaSala (linha 11) e
verificar que em uma determinada data e horário a sala está livre (linha 13), atualiza-se o estado da
sala de livre para ocupada (linha 14).

158
CAPÍTULO 6. MATRIZES
6.2.3 Definição dinâmica de uma matriz
Uma matriz pode ser definida dinamicamente. Nesse caso, o tamanho de suas dimensões só será
estabelecido durante a execução do programa, conforme é visto no Exemplo 6.4:
1 # include
2
3 int main (){
4 int m, n;
5
6 printf (‘‘ Forneca as dimensoes da matriz :’’);
7 scanf (‘‘%d %d’’, &m, &n);
8
10
9 int matriz [m][n];
11 return 0;
12 }
Exemplo 6.4: Definição dinâmica.
Nesse exemplo, a matriz só será definida após a execução da função scanf, em que o tamanho de
suas dimensões será lido do teclado.
6.3 O TAD Implementacional Matriz de Inteiros
Nesta seção será mostrada a implementação de um tipo abstrato de dados envolvendo o uso de matrizes,
o TAD Matriz de Inteiros. Primeiramente serão definidos os atributos do TAD, em seguida as operações
e por fim será mostrado um exemplo de uso. Doravante o TAD Matriz de Inteiros será referido como
tMatrizInt.
6.3.1 Atributos
O primeiro passo para definir o TAD tMatrizInt envolve escolher os seus atributos. Como a ideia
é modelar um problema por uma matriz, é necessário que um dos atributos seja a própria matriz
que armazenará os elementos. Além disso, é necessário guardar a quantidade de elementos de cada
dimensão.
Apesar de ser possível definir uma matriz com um número qualquer de dimensões e que armazene
um tipo qualquer de dados (int, float, char, etc), nesta seção serão utilizadas matrizes bidimensionais
de inteiros, por serem comumente utilizadas.
Portanto, os atributos de uma matriz bidimensional de inteiros são:
ˆ
ˆ
ˆ
DRAFT
Número de linhas (nLinhas): armazena a quantidade de elementos de cada coluna;
Número de colunas (nColunas): armazena a quantidade de elementos de cada linha;
Matriz (valores): armazena os dados da matriz propriamente ditos.
No Exemplo 6.5 é vista uma maneira de se definir o TAD tMatrizInt, de forma a representar
matrizes bidimensionais de inteiros.
1 # define MAX_DIM 5
2
3 typedef struct {
4 int valores [ MAX_DIM ][ MAX_DIM ];
5 int nLinhas ;
6 int nColunas ;
7 } tMatrizInt ;
Exemplo 6.5: Estrutura básica do tipo tMatrizInt.

6.3. O TAD IMPLEMENTACIONAL MATRIZ DE INTEIROS 159
No Exemplo 6.5, a matriz valores é declarada estaticamente, sendo seu tamanho máximo definido
pela constante MAX DIM.
Na Figura 6.3 pode-se visualizar a estrutura da matriz dados, do tipo tMatrizInt, inicializada
como no Exemplo 6.6:
1 tMatrizInt dados ;
2 int i,j;
3
4 dados . nLinhas = 3;
5 dados . nColunas = 3;
6
7 for (i = 0; i < dados . nLinhas ; i ++) {
8 for (j = 0; j < dados . nColunas ; j ++) {
9 dados . valores [i][j] = 0;
10 }
11 }
Exemplo 6.6: Inicialização de uma estrutura tMatrizInt.
Nas linhas 4 e 5, o tamanho da matriz é definido como 3 por 3. Na linha 7, o comando for percorre as
linhas da matriz de índice zero a nLinhas - 1. O segundo comando for percorre todas as colunas (para
cada laço do for anterior) de índice zero a nColunas - 1. Dessa forma percorre-se todos os elementos
da matriz valores, dentro das dimensões passadas, atribuindo a eles o valor zero.
Figura 6.3: Estrutura da matriz valores pertencente à variável dados (para MAX DIM igual a 5).
Apesar da matriz valores, pertencente à variável dados, ter 5 linhas e 5 colunas, somente os
elementos pertencentes às 3 primeiras linhas e colunas foram inicializados. Isso porque se definiu, nas
linhas 4 e 5, que a matriz deveria ter somente esse número de linhas e colunas. Dessa forma, em
todas as operações efetuadas sobre essa variável, somente os elementos pertencentes a essa submatriz
(formada pelos zeros na figura) devem ser considerados. Todos os outros (marcados com sinal ’-’)
possuem valores não determinados, por não terem sido inicializados, e devem ser ignorados.
6.3.2 Operações
DRAFT
Uma das vantagens de se implementar um tipo abstrato de dados é facilitar a solução de problemas
por meio do uso de operações que atuem sobre o tipo abstrato de dados definido. A seguir serão
implementadas as operações classificadas por seu tipo.
sobre tMatrizInt: inicialização, atualização de valor, acesso a valor, leitura, exibição,
soma dos elementos de uma linha, soma dos elementos de uma coluna, soma dos elementos
de uma diagonal e produto escalar.
Construtoras
Uma operação construtora essencial para se realizar sobre tMatrizInt é a inicialização. Ela deve ser
a primeira a ser realizada, caso contrário, as demais podem gerar resultados inesperados, como o
término do programa, por exemplo. Isso porque, durante a inicialização, preparam-se as estruturas

160
CAPÍTULO 6. MATRIZES
internas do TAD para se adequar ao caso desejado. No caso do tipo tMatrizInt proposto, a operação
de inicialização definirá as dimensões iniciais da matriz.
O código do Exemplo 6.7 mostra como isso pode ser implementado:
1 tMatrizInt inicializaMatrizInt ( int nLinhas , int nColunas ){
2 tMatrizInt resultado ;
3 int i,j;
4
5 resultado . nLinhas = nLinhas ;
6 resultado . nColunas = nColunas ;
7
8 for (i = 0; i < nLinhas ; i ++) {
9 for (j = 0; j < nColunas ; j ++) {
10 resultado . valores [i][j] = 0;
11 }
12 }
13
14 return resultado ;
15 }
Exemplo 6.7: Função de inicialização.
Na definição da função inicializaMatrizInt (linha 1), os argumentos nLinhas e nColunas servem
para definir a quantidade de linhas e colunas da matriz, respectivamente, e esses valores são atribuídos
à estrutura tMatrizInt nas linhas 5 e 6. Finalmente, na linha 14, a variável resultado, que contém a
estrutura inicializada, é retornada.
Modificadoras
Naturalmente, é necessário definir uma forma de atualizar os valores armazenados em uma matriz
individualmente. Isso pode ser feito, por meio, da operação de escrita atualizaMatrizInt definida
pela função do Exemplo 6.8.
1 tMatrizInt atualizaMatrizInt ( tMatrizInt matriz , int linha , int coluna , int valor ){
2 if ( ( linha >= 0 && linha < matriz . nLinhas ) &&
3 ( coluna >= 0 && coluna < matriz . nColunas ) ){
4 matriz . valores [ linha ][ coluna ] = valor ;
5 } else {
6 printf ("Os limites da matriz nao comportam o valor de linha e coluna
especificados ");
7 }
8
9 return matriz ;
10 }
DRAFT
Exemplo 6.8: Escrita em um elemento da matriz.
Na linha 2 é verificado se o elemento pertence à matriz, ou seja, se os índices de sua linha e de sua
coluna não ultrapassam os limites de linha e coluna da matriz. Se o elemento pertencer à matriz, o
valor passado como parâmetro é atribuído ao elemento desejado. Por fim, a função retorna a variável
matriz atualizada.
Em algumas aplicações pode ser importante ler um conjunto de valores inseridos pelo teclado e
armazena-los na matriz. O Exemplo 6.9 mostra uma implementação desta funcionalidade.
1 tMatrizInt leMatrizInt ( tMatrizInt matriz ){
2 int i = 0, j = 0;
3
4 printf (" Insira os %d elementos da matriz :\n", matriz . nLinhas * matriz . nColunas );
5
6 for (i = 0; i < matriz . nLinhas ; i ++) {
7 for (j = 0; j < matriz . nColunas ; j ++) {

6.3. O TAD IMPLEMENTACIONAL MATRIZ DE INTEIROS 161
8 scanf (" %d", &( matriz . valores [i][j]));
9 }
10 }
11
12 return matriz ;
13 }
Exemplo 6.9: Função de leitura dos dados da matriz.
No Exemplo 6.9 os elementos serão lidos linha a linha, ou seja, todas as colunas de uma linha
devem ser lidas e só depois se passa para a próxima linha. Cabe destacar que a função leMatrizInt só
desempenhará seu papel corretamente se a variável matriz, passada como parâmetro, for corretamente
inicializada, por meio da função inicializaMatrizInt.
Analizadoras
Tendo em vista a importância de utilizar o valor de um determinado item, é necessário construir uma
função para acessar os dados da matriz (Exemplo 6.10).
1 int acessaMatrizInt ( tMatrizInt matriz , int linha , int coluna ){
2 if ( ( linha >= 0 && linha < matriz . nLinhas ) &&
3 coluna >= 0 && coluna < matriz . nColunas ){
4 return matriz . valores [ linha ][ coluna ];
5 } else {
6 printf (‘‘ Indexador invalido \n’’);
7 return -1;
8 }
9 }
Exemplo 6.10: Função de acesso aos dados da matriz.
Na linha 2 é realizada a mesma verificação que no Exemplo 6.8. Se o elemento pertencer à matriz o
seu valor é retornado. Caso contrário, uma mensagem de erro é exibida na tela e o valor -1 é retornado.
Note que, em algumas aplicações, não será possível verificar a execução correta da função analisando
apenas o valor de retorno, pois o valor retornado (-1) pode fazer parte do universo de valores válidos
para a aplicação. Por isso, é emitida a mensagem de erro.
Para poder visualizar todos os elemetos de uma matriz de inteiros é necessário definir uma operação
de exibição da matriz na tela (Exemplo 6.11).
DRAFT
1 int exibeMatrizInt ( tMatrizInt matriz ){
2 int i = 0, j = 0;
3
4 for (i = 0; i < matriz . nLinhas ; i ++) {
5 for (j = 0; j < matriz . nColunas ; j ++) {
6 printf (" %5d", matriz . valores [i][j]);
7 }
8 printf ("\n");
9 }
10 }
Exemplo 6.11: Exibição da matriz na tela.
No Exemplo 6.11, tem-se na linha 4 um comando for para varrer as linhas da matriz, e para cada
linha tem-se outro comando for, na linha 5, para varrer os elementos dessa linha. Na linha 6, o trecho
“%5d” faz com que os números sejam exibidos sempre com 5 dígitos, o que faz com que a forma de
exibição seja regular, como pode ser visto na Figura 6.4.

162
CAPÍTULO 6. MATRIZES
Figura 6.4: Exemplo de saída da operação exibeMatrizInt.
Produtoras
Em muitas aplicações é necessário obter o valor da soma dos elementos de uma linha da matriz. Por
isso, no Exemplo 6.12 é definida uma operação para efetuar esse cálculo.
1 int somaLinhaMatrizInt ( tMatrizInt matriz , int linha ){
2 int i = 0, soma = 0;
3
4 for (i = 0; i < matriz . nColunas ; i ++) {
5 soma = soma + matriz . valores [ linha ][i];
6 }
7
8 return soma ;
9 }
Exemplo 6.12: Soma dos elementos de uma linha.
A variável soma é inicializada com o valor zero. O for percorre todos os elementos da linha da
matriz adicionando o valor da célula da matriz à variável soma. A variável soma funciona, então,
como um acumulador e, ao final das repetições, armazena o valor da soma dos elementos da linha.
Agora será definida, no Exemplo 6.13 uma operação para efetuar a soma dos elementos de uma
coluna.
1 int somaColunaMatrizInt ( tMatrizInt matriz , int coluna ){
2 int i = 0, soma = 0;
3
4 for (i = 0; i < matriz . nLinhas ; i ++) {
5 soma = soma + matriz . valores [i][ coluna ];
6 }
7
8 return soma ;
9 }
DRAFT
Exemplo 6.13: Soma dos elementos de uma coluna.
A operação é análoga à soma dos elementos de uma linha. Porém, recebe uma coluna e não uma
linha como parâmetro.
O Exemplo 6.14 é uma operação que soma os valores dos elementos pertencentes à diagonal principal
de uma matriz quadrada.
1 int somaDiagonalMatrizInt ( tMatrizInt matriz ){
2 int i;
3 int soma = 0;
4
5 if ( matriz . nLinhas != matriz . nColunas ){
6 printf ("A matriz precisa ser quadrada .\n");
7 return -1;
8 }
9
10 for (i = 0; i < matriz . nLinhas ; i ++) {
11 soma += matriz . valores [i][i];

6.3. O TAD IMPLEMENTACIONAL MATRIZ DE INTEIROS 163
12 }
13
14 return soma ;
15 }
Exemplo 6.14: Soma da Diagonal.
Assim como no Exemplo 6.10, é necessário ter cuidado, pois o valor -1 pode pertencer ao conjunto
de valores válidos para a soma. Nesse caso, um valor mais apropriado deve ser escolhido para indicar
erro.
Será definida uma operação de composição chamada produto escalar, que gera uma matriz M
cujos elementos são resultados de uma composição dos elementos de uma matriz A com uma matriz
B. Nesta operação os elementos m ij da matriz M são resultantes do somatório dos produtos entre os
elementos da linha i da primeira matriz com os elementos da coluna j da segunda matriz. Para que
esta operação seja executada é necessário que o número de colunas da matriz A seja igual ao número
de linhas da matriz B.
1 tMatrizInt produtoEscalarMatrizInt ( tMatrizInt matriz1 , tMatrizInt matriz2 ){
2 int i = 0, j = 0, k = 0;
3 tMatrizInt produto ;
4
5 if ( matriz1 . nColunas == matriz2 . nLinhas ){
6 for (i = 0; i < matriz1 . nLinhas ; i ++) {
7 for (j = 0; j < matriz2 . nColunas ; j ++) {
8 produto . valores [i][j] = 0;
9 for (k = 0; k < matriz1 . nColunas ; k ++) {
10 produto . valores [i][j] += matriz1 . valores [i][k] * matriz2 . valores [
k][j];
11 }
12 }
13 }
14
15 produto . nLinhas = matriz1 . nLinhas ;
16 produto . nColunas = matriz2 . nColunas ;
17 } else {
18 produto . nLinhas = produto . nColunas = 0;
19 }
20
21 return produto ;
22 }
DRAFT
Exemplo 6.15: Produto Escalar de 2 matrizes.
6.3.3 Exemplo de utilização do TAD tMatrizInt
A seguir, no Exemplo 6.16, é demonstrada a utilização das operações definidas sobre o TAD tMatrizInt,
no programa como um todo.
1 int main (){
2 tMatrizInt matrizA ;
3 tMatrizInt matrizB ;
4 tMatrizInt matrizProduto ;
5
6 matrizA = inicializaMatrizInt (4 ,4) ;
7 matrizB = inicializaMatrizInt (4 ,4) ;
8
9 matrizA = leMatrizInt ( matrizA ); // Usuario insere os valores da matriz A pelo
teclado .
10 matrizB = leMatrizInt ( matrizB ); // Usuario insere os valores da matriz B pelo
teclado .
11

164
CAPÍTULO 6. MATRIZES
12 // Os indices de posicao comecam em 0.
13 matrizA = atualizaMatrizInt ( matrizA , 2, 2, 10) ; // Atualiza a matriz A com o valor
10 na linha 2, coluna 2.
14 matrizB = atualizaMatrizInt ( matrizB , 3, 3, 20) ; // Atualiza a matriz B com o valor
20 na linha 3, coluna 3.
15
16 exibeMatrizInt ( matrizA ); // Exibe a matriz A atualizada na tela .
17 exibeMatrizInt ( matrizB ); // Exibe a matriz B atualizada na tela .
18
19 printf (" Soma da primeira linha da matriz A: %d.\n", somaLinhaMatrizInt ( matrizA , 0)
);
20 printf (" Soma da primeira coluna da matriz B: %d.\n", somaColunaMatrizInt ( matrizB ,
0));
21
22 printf (" Elemento da posicao (1 , 1) da matriz A: %d.\n" , acessaMatrizInt ( matrizA ,
1, 1));
23
24 printf (" Soma da diagonal da matrizA : %d.\n", somaDiagonalMatrizInt ( matrizA ));
25
26 matrizProduto = produtoEscalarMatrizInt ( matrizA , matrizB );
27 printf (" Produto escalar A X B:\n");
28 exibeMatrizInt ( matrizProduto );
29
30 return 0;
31 }
Exemplo 6.16: Uso do TAD tMatrizInt na função principal.
Vale lembrar que os atributos e operações do TAD devem estar definidos, fora da função principal,
no corpo do arquivo, para que o programa funcione corretamente.
6.4 Exercícios Resolvidos
Exercício Resolvido 6.1 - Operações em matrizes
Dada uma matriz bidimensional de inteiros, defina operações que realize a soma dos elementos da
submatriz triangular superior.
DRAFT
Solução Possível:
Como os elementos da submatriz triangular superior são os elementos que estão situados acima dos
elementos da diagonal principal, pode-se notar que, em cada linha, esses elementos estão situados nas
colunas à direita do elemento da diagonal principal. Dessa forma, percorre-se a submatriz triangular
superior por meio de um loop, na linha 5, que varre todas as linhas i da matriz, e para cada linha
tem-se outro laço (linha 6) para varrer as colunas de índice i+1 até nColunas, somando o valor de cada
elemento visitado. Para acessar os elementos das matrizes, será utilizada a função acessaMatrizInt
do Exemplo 6.10.
Pseudocódigo 6.1 Cálculo da soma dos elementos da submatriz triangular superior.
Descrição: Calcular a soma dos elementos da submatriz triangular superior.
Dados de Entrada: A estrutura da matriz (tMatrizInt).
Saída da Função: O valor da soma.
Processo componente " soma dos elementos da submatriz triangular superior ":
Criar a variável que receberá o resultado da soma da submatriz .
PARA todos os índices linha da matriz :
PARA cada índice coluna direita do índice linha atual da matriz :
Incrementar à soma , o elemento da posiç~ao atual acessado na matriz .
FIM - PARA .
FIM - PARA .

6.4.
EXERCÍCIOS RESOLVIDOS 165
FIM - Processo componente " soma dos elementos da submatriz triangular superior "
1 int somaTriangular ( tMatrizInt matriz ){
2 int soma = 0;
3 int i,j;
4
5 for (i = 0; i < matriz . nLinhas ; i ++) {
6 for (j = i + 1; j < nColunas ; j ++) {
7 soma = soma + acessaMatrizInt ( matriz , i, j);
8 }
9 }
10
11 return soma ;
12 }
Exemplo 6.17: Soma dos elementos da matriz triangular superior.
Exercício Resolvido 6.2 - Controle de reserva de sala
Deseja-se desenvolver um programa para controlar a reserva de uma sala ao longo de um ano. Ao
usuário devem ser fornecidas as seguintes operaçoes:
ˆ
ˆ
ˆ
ˆ
Reservar a sala;
Cancelar reserva;
Dado um mês, listar dias em que a sala está disponível;
Informar o índice de ocupação de cada mês.
Implemente o programa utilizando o TAD tMatrizInt.
Solução Possível:
Para armazenar as informações de reserva da sala será utilizada uma matriz com 31 linhas (representando
os dias) e 12 colunas (representado os meses). Dessa forma, para reservar a sala para o dia
1º de janeiro, atribui-se ao elemento da linha 0 e coluna 0, o valor 1.
Para resolver o problema, será criada uma função para cada operação. Além disso, serão utilizadas
as funções atualizaMatrizInt e acessaMatrizInt dos Exemplos 6.8 e 6.10, respectivamente, quando
necessário.
Reservar a sala
Pseudocódigo 6.2 Reserva de sala.
DRAFT
Descrição: Fazer a reserva de uma sala.
Dados de Entrada: Matriz de ocupação, dia e mês da reserva.
Saída da Função: Matriz de ocupação atualizada.
Processo componente " reserva sala ":
SE a data for válida :
SE estiver a data estiver disponível :
Exibir aviso de reserva concluída.
Retornar matriz de ocupaç~ao atualizada .
SEN~AO:
Exibir aviso de indisponibilidade .
Retornar matriz inalterada .
FIM -SE.
SEN~AO:
Exibir aviso de data inválida .
Retornar matriz inalterada .

166
CAPÍTULO 6. MATRIZES
FIM -SE.
FIM - Processo componente " reserva sala "
1 tMatrizInt reservaSala ( tMatrizInt mat , int dia , int mes ){
2 if ( (dia

6.4.
EXERCÍCIOS RESOLVIDOS 167
14 }
Exemplo 6.19: Cancelar reserva.
Listar dias livres do mês
Deve-se verificar, em um laço, todos os dias do mês escolhido e, para cada dia, verificar a reserva
da sala. Se ela estiver desocupada, então o dia será impresso na tela de modo a informar isso ao
usuário. Note que o número de dias de cada mês varia e, portanto, deve haver um controle de forma
que o laço termine com o número de dias correto para o mês escolhido.
Pseudocódigo 6.4 Listar dias livres do mês.
Descrição: Exibir os dias não reservados de uma sala em um determinado mês.
Dados de Entrada: Matriz de ocupação, mês da consulta.
Saída da Função: Exibe na tela os dias livres.
Processo componente " dias n~ao reservados ":
Exibir mensagem informando o m^es consultado .
PARA todos os dias do m^es da consulta :
Verificar se a sala está reservada no dia do m^es.
SE estiver desocupada :
Exibir na tela o dia .
FIM -SE
FIM - PARA
FIM - Processo componente " dias n~ao reservados "
1 void listaDiasLivres ( tMatrizInt mat , int mes ){
2 int dia ;
3 int numeroDiasMes [] = {31 ,28 ,31 ,30 ,31 ,30 ,31 ,31 ,30 ,31 ,30 ,31};
4
5 printf (" Dias livres para o mes %d\n", mes );
6
7 for ( dia = 0; dia < numeroDiasMes [mes -1]; dia ++) {
8 if ( acessaMatrizInt (mat , dia , mes ) == 0){
9 printf ("%d\n", dia + 1);
10 }
11 }
12 }
DRAFT
Exemplo 6.20: Listar dias livres do mês.
Obter o índice de ocupação de cada mês
O índice de ocupação de um mês nada mais é do que o número de dias com a sala reservada naquele
mês. Além disso, como a sala ocupada é representada pelo número 1 e a sala vazia pelo número 0,
somando-se a coluna que representa um determinado mês obtem-se o número de dias ocupados para
esse mês. Assim sendo, para resolver o problema, basta percorrer todas as colunas da matriz e, para
cada uma delas, efetuar a soma de seus elementos. Para computar o número de dias ocupados no mês,
será utilizada a função somaColunaMatrizInt do Exemplo 6.13
Pseudocódigo 6.5 Obter o índice de ocupação de cada mês.
Descrição: Exbir os números de dias ocupados em cada mês.
Dados de Entrada: Matriz de ocupação.
Saída da Função: Exibe na tela os números de dias ocupados no meses.
Processo componente " exibe números de dias ocupados ":
Exibir mensagem informando que será verificado o índice de ocupaç~ao de um
determinado m^es.

168
CAPÍTULO 6. MATRIZES
PARA todos os meses :
Computar o número de dias ocupados no m^es através de uma funç~ao auxiliar .
Exibir na tela o número de dias ocupados no m^es.
FIM - PARA
FIM - Processo componente " exibe números de dias ocupados "
1 void imprimeIndiceOcupacao ( tMatrizInt mat ){
2 int mes ;
3 int indice ;
4
5 printf (" Indice de ocupacao dos meses do ano \n");
6
7 for ( mes = 0; mes < 12; mes ++) {
8 indice = somaColunaMatrizInt (mat , mes );
9 printf (" Mes %d: %d dias ocupados \n", mes +1 , indice );
10 }
11 }
Exemplo 6.21:
Índice de ocupação de cada mês.
Uma vez definidas as funções que realizam as operações, falta então definir a função principal do
programa onde a interação com o usuário será feita, ou seja, onde as funções definidas ao longo deste
exercício serão chamadas.
O programa principal segue os passos descritos no Pseudocódigo 6.6.
Pseudocódigo 6.6 Sistema de controle de ocupação de sala.
Descrição: Programa com objetivo de agregar as funcionalidades relacionadas ao controle de ocupação de
uma sala.
Dados de Entrada: Variam com a funcionalidade escolhida.
Saída do Programa: Variam com a funcionalidade escolhida.
Funç~ao Principal
Cria matriz de ocupaç~ao.
FAÇA:
Exibir na tela mensagens informativas .
Ler opç~ao escolhida .
CASO a opç~ao SEJA :
1, ENT~AO exibir mensagem requerendo uma data .
Fazer a leitura da data .
Processo componente " reservaSala ".
DRAFT
2, ENT~AO exibir mensagem requerendo uma data .
Fazer a leitura da data .
Processo componente " cancelaReserva ".
3, ENT~AO exibir uma mensagem requerendo um m^es.
Fazer a leitura do m^es.
Processo componente " listaDiasLivres ".
4, ENT~AO Processo componente " imprimeIndiceOcupacao ".
5, ENT~AO Fazer nada .
OUTRO VALOR , ENT~AO Exibir mensagem avisando que a opç~ao inválida .
FIM - CASO
ENQUANTO a opç~ao for diferente de 5.
FIM - Funç~ao Principal

6.4.
EXERCÍCIOS RESOLVIDOS 169
1 int main (){
2 tMatrizInt reservas ;
3 int codigo , dia , mes ;
4
5 reservas = inicializaMatrizInt (31 , 12) ;
6
7 do{
8 printf ("\\n\\n\\n\\n\\n\\n\\n");
9 printf ("## Reserva de Salas ##\\ n\\ nEscolha uma operacao :\\ n");
10 printf (" 1- Reservar a sala \\n");
11 printf (" 2- Cancelar uma reserva \\n");
12 printf (" 3- Listar dias livres \\n");
13 printf (" 4- Exibir indice de ocupacao \\n");
14 printf (" 5- Sair \\n");
15 printf (" Digite o codigo da operacao escolhida : ");
16 scanf ("%d", & codigo );
17
18 switch ( codigo ){
19 case 1:
20 printf ("\\n\\ nDigite a data da reserva ( dia / mes ): ");
21 scanf ("%d/%d", &dia , & mes );
22 reservas = reservaSala ( reservas , dia , mes );
23 break ;
24
25 case 2:
26 printf ("\\n\\ nDigite a data da reserva a cancelar ( dia / mes ): ");
27 scanf ("%d/%d", &dia , & mes );
28 reservas = cancelaReserva ( reservas , dia , mes );
29 break ;
30
31 case 3:
32 printf ("\\n\\ nDigite o mes : ");
33 scanf ("%d", & mes );
34 listaDiasLivres ( reservas , mes );
35 break ;
36
37 case 4:
38 imprimeIndiceOcupacao ( reservas );
39 break ;
40
41 case 5:
42 break ;
43
44 default :
DRAFT
45 printf (" Codigo deve ter valor entre 1 e 5\n");
46 }
47 } while ( codigo != 5);
48
49 return 0;
50 }
Exercício Resolvido 6.3 - Uns isolados
Exemplo 6.22: Interação com usuário.
Dada uma matriz bidimensional com m linhas e n colunas, de “zeros” e “uns”, defina uma operação
para calcular o número de uns isolados dessa matriz. Considere que um número um está isolado se
nenhum dos elementos adjacentes a ele, são “uns”.
Solução Possível:
Implementa-se uma função auxiliar que verificará se uma posição a ij da matriz está isolada, ou
seja, não possui um 1 adjacente. Os dois laços de repetição aninhados (linhas 4 e 6) permitirão verificar
os quadrados adjacentes à posição indicada. As variáveis auxiliares k e l servirão como deslocadores

170
CAPÍTULO 6. MATRIZES
de posição, a fim de realizar os acessos. Note que só serão consideradas as posições acima, abaixo, à
direita e à esquerda. As diagonais não serão levadas em conta no critério implementado.
Em seguida implementa-se uma função que irá percorrer toda a matriz com dois laços de repetição
aninhados (linhas 22 e 23) verificando se o elemento acessado é 1, e se é uma posição isolada, em caso
afirmativo, um contador (no caso, a variável quantidade) é incrementado. Por fim, essa quantidade
é retornada. Para acessar os elementos da matriz, utiliza-se a função acessaMatrizInt do Exemplo
6.10.
Pseudocódigo 6.7 Processo para verificar se a posição a ij de uma matriz é isolada
Descrição: Verificar se a posição a ij de uma matriz é isolada.
Dados de Entrada: A estrutura da matriz (tMatrizInt) e os índices ’i’ e ’j’.
Saída do Programa: 1, se a posição a ij de uma matriz é isolada e 0, caso contrário.
Processo componente " verifica se a posiç~ao (i,j) de uma matriz é isolada ":
PARA a primeira à última linha adjacente ao elemento (i,j) da matriz :
PARA a primeira à última coluna adjacente ao elemento (i,j) da matriz :
SE a posiç~ao atual for igual à posiç~ao (i,j) ou a posiç~ao atual n~ao for
adjacente à posiç~ao (i,j):
Voltar à primeira instruç~ao do loop .
SE o valor do elemento da posiç~ao atual for igual a um:
Retornar falso .
FIM - PARA .
FIM - PARA .
Retornar verdadeiro .
FIM - Processo componente " verifica se a posiç~ao (i,j) de uma matriz é isolada "
Pseudocódigo 6.8 Número de uns isolados de uma matriz de zeros e uns.
Descrição: Calcular o número de uns isolados de uma matriz de zeros e uns.
Dados de Entrada: A estrutura da matriz (tMatrizInt).
Saída do Programa: A quantidade de uns isolados.
DRAFT
Processo componente "número de uns isolados ":
Criar a variável que receberá a quantidade de uns isolados .
PARA todos os índices linha da matriz :
PARA todos os índices coluna da matriz :
SE o elemento atual for igual a um e isolado :
Incrementar a quantidade de uns isolados .
FIM - PARA .
FIM - PARA .
FIM - Processo componente "número de uns isolados "
1 int isolado ( tMatrizInt matriz , int i, int j){
2 int k,l;
3
4 for (k = -1; k

6.5. RESUMO 171
15 return 1;
16 }
17
18 int unsIsolados ( tMatrizInt matriz ){
19 int i,j;
20 int quantidade = 0;
21
22 for (i = 0; i < matriz . nLinhas ; i ++) {
23 for (j = 0; j < matriz . nColunas ; j ++) {
24 if ( ( acessaMatrizInt ( matriz ,i,j) == 1) && isolado ( matriz ,i,j) ){
25 quantidade ++;
26 }
27 }
28 }
29
30 return quantidade ;
31 }
6.5 Resumo
ˆ
ˆ
ˆ
ˆ
ˆ
ˆ
Exemplo 6.23: Uns Isolados.
Uma matriz é um tipo de dados composto homogêneo no qual os elementos são organizados em
uma estrutura multidimensional.
A dimensão de uma matriz pode ser definida, em C, tanto em tempo de compilação, quanto em
tempo de execução.
Assim como os vetores, em C, os elementos de uma matriz devem ser manipulados separadamente.
Foi implementado o TAD Matriz de Inteiros, composto pelos seguintes atributos: número de
linhas da matriz, número de colunas da matriz e a matriz que armazenará os elementos.
Para manipular os dados do TAD Matriz de Inteiros foram criadas as operações: inicialização,
atualização de valor, acesso a valor, leitura, exibição, soma dos elementos de uma linha, soma
dos elementos de uma coluna, soma dos elementos de uma diagonal e produto escalar.
Deve-se tomar cuidado para não acessar uma matriz indevidamente, por exemplo utilizando
índice de linha ou coluna maior que o tamanho da linha ou coluna.
6.6 Exercícios Propostos
DRAFT
1. Escreva um subprograma que determine o maior valor em uma matriz de valores inteiros com
m linhas e n colunas (m e n são inteiros positivos).
2. Faça um subprograma que calcule a matriz resultante da soma de duas matrizes de dimensões
m linhas por n colunas, ambas preenchidas com valores inteiros.
3. Escreva um subprograma que calcule a transposta de uma dada matriz de m linhas e n colunas.
Considere como matriz transposta A t , a matriz cujos elementos A t [i,j] são iguais aos elementos
A[j][i].
4. Escreva um subprograma que verifique se uma matriz quadrada de dimensão n é simétrica. Uma
matriz A é simétrica se A[i,j] = A[j,i] para todo valor de i e j.
5. Faça um subprograma que calcule a soma dos termos que se situam na diagonal secundária ou
abaixo dela numa matriz quadrada com elementos inteiros. Assuma que o número máximo de
linhas e colunas é 100, mas que a matriz pode estar preenchida apenas parcialmente.

172
CAPÍTULO 6. MATRIZES
Observação: Antes de escrever o subprograma, você deve apresentar a declaração do tipo da
matriz que deve ser colocada nos programas que usarão este subprograma.
6. Uma matriz quadrada inteira é chamada de ‘’quadrado mágico” se a soma dos elementos de cada
linha, a soma dos elementos de cada coluna e a soma dos elementos das diagonais principal e
secundária são todos iguais.
Exemplo de um quadrado mágico:
8 0 7
4 5 6
3 10 2
Escreva uma função que verifique se uma matriz quadrada de dimensão n é um quadrado mágico.
7. Um quadrado latim de ordem n é preenchido com números de 1 até n de forma que nenhum
número é repetido na mesma linha ou coluna. Este quadrado pode ser usado, por exemplo, em
alguns torneios esportivos para assegurar que cada equipe joga com todas outras equipes uma
e somente uma vez. Escreva uma função que receba uma matriz quadrada e verifica se ela é
realmente um quadrado latim.
Exemplo de quadrado latim:
1 2 3 4
2 3 4 1
3 4 1 2
4 1 2 3
8. A matriz abaixo representa o triângulo de pascal de ordem 6:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
Os elementos extremos de cada linha são iguais a 1. Os outros elementos são obtidos somando-se
os dois elementos que aparecem imediatamente acima e à esquerda na linha anterior. Assim 10
= 4 + 6. Escreva um programa que, dado n, gere e exiba na tela o triângulo de Pascal de ordem
n. A exibição não deve conter zeros acima da diagonal principal.
DRAFT
9. Considere uma matriz de inteiros. Define-se como vizinhança de uma posição da matriz a soma
de todos os números que estejam em posições adjacentes. Escreva um programa que determine
a posição do elemento de maior vizinhança.
10. Considere 2 matrizes quadradas do tipo tMatrizInt. Faça um subprograma para cada item abaixo
(note que as matrizes devem obrigatoriamente ser passadas como parâmetros aos subprogramas):
(a) Determinar se as duas matrizes são idênticas;
(b) Determinar se a segunda matriz é uma rotação de 90 graus à direita sobre a primeira;
(c) Determinar se a segunda matriz é uma rotação de 180 graus à direita sobre a primeira;
(d) Determinar se a segunda matriz é a imagem espelhada vertical da primeira;
(e) Determinar se a segunda matriz é a imagem espelhada horizontal da primeira;
A Figura 6.5 ilustra cada tipo de matriz com um exemplo de dimensão 3 x 3:

6.7. TRABALHOS SUGERIDOS 173
Figura 6.5: Figura exemplo relativa ao exercício 11.
11. Escreva ainda um programa que leia 2 matrizes e determine as relações existentes entre elas
utilizando os subprogramas do exercício anterior.
12. Implemente os tipos tMatrizChar e tVetChar (para armazenar variáveis do tipo char ao inves
de int) e escreva uma função que receba uma matriz preenchida com caracteres maiúsculos do
tipo tMatrizChar e um vetor do tipo tVetChar contendo uma palavra em letras maiúsculas
e retorne o número de ocorrências da palavra na matriz. A palavra pode estar escrita na matriz
de cima para baixo, da esquerda para a direita ou nas diagonais paralelas à diagonal principal
ou na própria.
6.7 Trabalhos Sugeridos
1. Caça-Palavras
Considere o jogo caça-palavras que consiste em procurar uma palavra dada em uma matriz de
letras. Considera-se que a palavra foi encontrada se ela estiver inteiramente disposta em uma
linha, em uma coluna ou em uma diagonal da matriz. Define-se uma palavra como uma sequência
de letras maiúsculas (para facilitar não considere acentuação). As palavras estão escritas na
matriz sempre de cima para baixo, da esquerda para a direita ou nas diagonais paralelas à
diagonal principal ou na própria diagonal. Faça um programa que tenha como entrada um
conjunto de n palavras e a matriz de caracteres, ambas fornecidas pelo teclado. O programa
deve ser capaz de:
DRAFT
(a) Verificar quais palavras foram encontradas e computar o número de ocorrências de cada
uma delas na matriz.
(b) Exibir a lista das palavras encontradas e as listas das palavras não encontradas. As duas
listas devem estar em ordem alfabética.
(c) Exibir a lista das palavras encontradas na matriz, ordenadas pelo seu número de ocorrências
(considerar ordem decrescente). Informar também, nestes casos, a posição na matriz do
caractere inicial de cada ocorrência da palavra, além da direção que ela se encontra na
matriz. As direções são definidas como: diagonal, vertical, horizontal.
(d) Informe a direção na qual mais palavras foram encontradas exibindo a quantidade de palavras.
A saída deve seguir o formato apresentado no exemplo a seguir:
Exemplo:
Conjunto de palavras: CAPELA, LAPIS, FLORESTA, AULA, ALEGRIA, MANGA
Matriz:

174
CAPÍTULO 6. MATRIZES
Saída:
F L O R E S T A R S
H J V N O A C I W Z
C A P E L A P I S C
I K V D I P M B S F
T Y G C S A L U O P
Q L K Ç A D U O L Ç
A A S A R P R Y O A
N E N E F T E B A U
J K D D S H W L F L
I O T U G J J V A A
Lista de palavras encontradas em ordem alfabética:
AULA
CAPELA
FLORESTA
LAPIS
Lista de palavras não encontradas em ordem alfabética:
ALEGRIA
MANGA
Lista de palavras encontradas, ordenadas pelo número de ocorrências na matriz:
CAPELA 2 (2, 0) horizontal (4, 3) diagonal
AULA 1 (6,9) vertical
FLORESTA 1 (0, 0) horizontal
LAPIS 1 (2,4) horizontal
Direção em que mais palavras foram encontradas: horizontal
Número de palavras encontradas nesta direção: 3
DRAFT

Capítulo 7
Apontadores
Objetivos:
ˆ
ˆ
ˆ
ˆ
Definir o que são apontadores;
Coautores:
Alan Floriano
Douglas Almonfrey
Igor Vale
Ivan Nunes
Juan Souza
Mostrar a importância dos apontadores na passagem de parâmetros sem cópia, no retorno de
múltiplos valores nas funções e na alocação dinâmica de memória;
Apresentar os principais problemas no uso de apontadores;
Definir o TAD Lista Encadeada e suas principais operações;
Neste capítulo serão apresentados os conceitos relacionados aos apontadores. Estes conceitos estão
intimamente ligados à manipulação da memória do computador e são fundamentais para a criação de
estruturas de dados muito importantes como listas, pilhas e árvores. Por esta razão, o conhecimento
a cerca dos apontadores é fundamental para desenvolver programas em C.
7.1 Variáveis Apontadoras
Em um programa, cada variável possui seu endereço de memória - que representa o local, ou posição,
na memória onde o dado está de fato armazenado - e um conteúdo, que é a informação propriamente
dita. A Figura 7.1 exibe cinco endereços de memória e seus respectivos conteúdos.
DRAFT
Figura 7.1: Formato abstrato da memória.
Os apontadores são um tipo especial de variável, cujo conteúdo não é um simples valor, e sim um
endereço de memória. Na Figura 7.2, pode ser observado que o conteúdo de uma variável apontador
175

176
CAPÍTULO 7. APONTADORES
corresponde a um endereço de uma variável não apontador. Nota-se que os conteúdos das variáveis à
esquerda (apontadores) indicam os endereços das variáveis à direita (não apontadores).
Figura 7.2: Apontadores e não apontadores.
Neste capítulo, serão estudados os apontadores, também chamados de ponteiros. Como os apontadores
são variáveis que guardam endereços, trata-se de um conceito de baixo nível muito ligado à
arquitetura de computadores. Apontadores são ferramentas poderosas na linguagem de programação
C. Dentre diversas funções, apontadores permitem passagem de parâmetros sem cópia de muitos dados,
retorno de múltiplos valores em funções, alocação dinâmica de memória e construção de listas
encadeadas.
No decorrer do capítulo, serão utilizados modelos de figuras ilustrativas para auxiliar na explicação.
Na Figura 7.3, tem-se o modelo para representar uma variável e seu endereço.
Figura 7.3: Formato abstrado de uma variável.
Como pode ser observado na Figura 7.3, um quadrado será usado como formato abstrato de
variável de memória. Dentro deste quadrado estará representado o conteúdo da variável. Além disso,
um círculo negro no seu vértice superior esquerdo representará de forma abstrata seu endereço.
Já para representar a ligação entre um apontador e a variável que está sendo apontada por ele,
será utilizado o modelo da Figura 7.4. Tal ligação é ilustrada por meio de uma seta, que sai da variável
apontador, e aponta o círculo negro (endereço) da variável não apontador.
DRAFT
Figura 7.4: Abstração de uma variável apontador.
Existe ainda um valor especial para apontadores conhecido como valor nulo ou simplesmente NULL.
O valor NULL indica que um apontador, intencionalmente, não aponta para nenhuma variável. Vale

7.2. A SINTAXE DOS APONTADORES 177
lembrar que um apontador, quando não inicializado, não necessariamente aponta para NULL. A aplicabilidade
do valor NULL ficará mais clara no decorrer do capítulo. Doravante o valor NULL será
representado pelo símbolo da Figura 7.5.
7.2 A Sintaxe dos Apontadores
Figura 7.5: Representação gráfica do valor NULL.
Na linguagem C, o operador asterisco * é que especifica se uma variável guarda um endereço, ou seja,
se é um apontador. A declaração de um apontador segue o seguinte formato:
*
No lugar do tipo do apontador, devem-se utilizar alguns dos tipos padrões da linguagem C, como
char, int e float, ou até mesmo novos tipos definidos pelo programador, por meio de structs. No
Exemplo 7.1 são declarados apontadores dos tipos char, int, float e tAluno.
1 typedef struct {
2 char nome [30];
3 int matricula ;
4 } tAluno ;
5
6 int main (){
7 char *c;
8 int *p;
9 float *f;
10 tAluno *x;
11
12 return 0;
13 }
DRAFT
Exemplo 7.1: Declaração de apontadores.
Assim, no código do Exemplo 7.1, c pode apontar para uma área de memória que guarda uma
variável do tipo caractere, enquanto p, f e x dos tipos inteiro, ponto flutuante e tAluno, respectivamente.
Dois outros operadores também estão associados à sintaxe de apontadores: o operador endereço
de memória e o operador seta. Eles serão discutidos nas duas próximas subseções.
7.2.1 Operador Endereço de Memória
Em C, o operador unário &, quando aplicado a uma variável, retorna o endereço dela. Portanto,
quando um apontador é declarado, pode-se inicializá-lo usando o operador &, que faz o apontador
receber um endereço de uma variável já existente.
O Exemplo 7.2 mostra o uso do operador & para inicializar uma variável apontador. A variável p
recebe o endereço da variável d. Note que a variável apontador p é do mesmo tipo da variável d, pois
é fundamental que o apontador aponte para uma variável de tipo compatível com a declaração dele.
1 # include
2

178
CAPÍTULO 7. APONTADORES
3 int main (){
4 int *p;
5 int d = 10;
6 p = &d;
7
8 printf ("%p\n%p\n", &d, p);
9
10 return 0;
11 }
Exemplo 7.2: Inicialização de um apontador usando o operador endereço de memória.
No Exemplo 7.2, serão apresentados o endereço de d, e logo após, o valor do apontador p, que é o
endereço de d. Portanto, dois valores iguais serão apresentados na tela. O %p, utilizado no Exemplo
7.2, é usado pela função printf para identificar o tipo de valor que será apresentado, neste caso %p
informa que o valor de um apontador será apresentado, ou seja, o endereço de uma variável.
7.2.2 Acesso a Variável por Meio de Apontadores
O operador unario * tem outra função além das já conhecidas que estão relacionadas a multiplicação
e definição de apontadores. Esse operador também pode ser usado junto a um apontador para que se
possa retornar o valor da variável apontada. Por esse motivo, apontadores podem ser usados para
atribuir valores a outras variáveis. Observe o Exemplo 7.3.
1 int *p;
2 int c = 10;
3 int d;
4 p = &c;
5 d = *p;
Exemplo 7.3: Acesso ao conteúdo de variáveis por meio de apontadores.
No Exemplo 7.3, p recebe o endereço de c. Através de p portanto, pode-se agora acessar o valor
de c. Com esse recurso, na quinta linha do Exemplo 7.3, d recebe o valor de c por meio de p.
Uma variável pode ser atribuída por meio do uso de apontadores. No Exemplo 7.4, a variável c
tem seu valor alterado através de uma atribuição feita a p.
1 float *p;
2 float c = 15;
3 p = &c;
4 *p = *p + 1;
5 printf ("%f", c);
DRAFT
Exemplo 7.4: Alterando valor de variáveis por meio de apontadores.
Pode ser observado no Exemplo 7.4, que p aponta para c. Assim, a expressão na linha 4 incrementa
o conteúdo da variável apontada por p em uma unidade, ou seja, c passa a ter o valor 16, o qual é
apresentado na tela.
Uma variável pode receber o valor de outra por meio de apontadores. Na linha 7 do Exemplo 7.5,
a variável i apontada por v tem seu valor alterado para o de d, pois d está apontado por j.
1 float *v;
2 float *j;
3 float d = 15.0;
4 float i = 17.0;
5 j = &d;
6 v = &i;
7 *v = *j;
8 v = j;
Exemplo 7.5: Alterando valor de variáveis através de apontadores.

7.2. A SINTAXE DOS APONTADORES 179
Figura 7.6: Atribuição dos conteúdos de apontadores.
Figura 7.7: Atribuição dos endereços de apontadores.
Um apontador também pode ser atribuído a outro apontador. No Exemplo 7.5, linha 8, v passa a
apontar para o mesmo endereço que j aponta.
Por fim, esse acesso a variáveis através de apontadores é muito importante, pois é por meio deste
recurso que as variáveis passadas como parâmetros de uma função são alteradas definitivamente, dentro
da própria função.
7.2.3 O Operador Seta
Outro operador associado a apontadores é a seta (->). Quando um apontador indica uma variável do
tipo estrutura, para que se acesse os atributos desta variável, ao invés do ponto (.), utiliza-se (->).
Observe o Exemplo 7.6.
1 # include
2
3 typedef struct {
4 char nome [30];
5 int matricula ;
6 } tAluno ;
7
8 int main (){
9 tAluno *x;
10 tAluno y;
11
12 x = &y;
13 x-> matricula = 2031;
14
15 printf ("%d\n", y. matricula );
16
17 return 0;
18 }
DRAFT
Exemplo 7.6: Acesso ao atributo de uma estrutura por meio do operador seta.
Note que no Exemplo 7.6, x é um apontador para uma estrutura tAluno e y uma variável tAluno.
Após fazer x apontar para o endereço de y, para acessar a matrícula de y através de x, deve ser

180
CAPÍTULO 7. APONTADORES
utilizado o operador ->. Já para exibir o atual valor da matrícula de y, que passou a ser 2031, basta
utilizar o ponto.
O operador seta é uma sintaxe alternativa muito utilizada por sua simplicidade. Seria possível
também utilizar o acesso ao conteúdo seguido do ponto. Na linha 13 do Exemplo 7.6 a sintaxe
equivalente seria:
1 (*x). matricula = 2031;
Exemplo 7.7: Acesso ao atributo de uma estrutura por meio do operador asterisco seguido de ponto.
7.3 Uso de Apontadores nas Passagens de Parâmetros
O conceito de função em C, conforme já discutido em capítulos precedentes, é fundamental. Uma das
principais vantagens de apontadores, no que diz respeito à função, é a passagem de valores sem cópia.
Na passagem por cópia, as variáveis que são passadas como argumentos da função tem seus valores
copiados para uma região de memória criada especificamente para a execução da função. São essas
cópias que a função utiliza no decorrer da sua execução. Assim, qualquer alteração dos valores das
cópias não implicará em mudança nas variáveis originais.
Por meio de apontadores, é possível alterar os valores das variáveis passadas como argumentos
para uma função. Ao declarar que um parâmetro de uma função é um apontador, deve-se passar o
endereço de uma variável como argumento correspondente. Nesse tipo de passagem, não é copiado o
valor da variável argumento, mas com o endereço dela, pode-se acessar o conteúdo e modificá-lo no
decorrer da execução da função. O Exemplo 7.8 mostra a passagem por cópia e por apontadores.
1 void adicionaX1 ( int x, int b){
2 b = b + x;
3 }
4
5 void adicionaX2 ( int x, int *b){
6 *b = *b + x;
7 }
8
9 int main (){
10 int a = 0;
11
12 adicionaX1 (10 , a);
13 printf ("a = %d\n", a);
14 adicionaX2 (10 , &a);
15 printf ("a = %d\n", a);
16
17 return 0;
18 }
DRAFT
Exemplo 7.8: Passagem de valor por cópia e através de apontadores.
Em adicionaX1 , no Exemplo 7.8, uma cópia do valor de a é passada com argumento da função,
ou seja, b recebe uma cópia do valor 0 de a. Dentro da função, o valor de b muda para 10, mas o de
a continua o mesmo. Assim, o primeiro valor impresso é 0. Já em adicionaX2 , o endereço de a é
passado para o apontador b e, na execução da função, é adicionado x ao conteúdo da variável apontada
por b, o que faz a ter seu valor modificado para 10. Portanto, o que é apresentado no segundo printf é
a = 10. A Figura 7.8 ilustra as passagens de parâmetro de a para b, em adicionaX1 e adicionaX2 .

7.4.
ALOCAÇÃO DINÂMICA DE MEMÓRIA 181
Figura 7.8: Passagem de valor por cópia e por apontadores.
Na Figura 7.8, repare que na passagem por cópia, o valor de a é copiado para o conteúdo de b,
enquanto que na passagem por apontador, b passa a apontar para o endereço de a.
Uma aplicação da passagem de valor por apontadores é proporcionar que uma função retorne
múltiplas variáveis. O Exemplo 7.9 mostra como isso é feito.
1 void troca ( int *x, int *y){
2 int aux ;
3
4 aux = *x;
5 *x = *y;
6 *y = aux ;
7 }
8
9 int main (){
10 int a, b;
11 a = 10;
12 b = 20;
13
14 troca (&a, &b);
15 printf ("a = %d, b = %d\n", a, b);
16
17 return 0;
18 }
DRAFT
Exemplo 7.9: Retorno de múltiplas variáveis por uma função.
No Exemplo 7.9, desejava-se uma função para trocar o conteúdo de a e b. Contudo, uma função
pode retornar apenas um valor no return. Assim, por meio dos apontadores, os dois conteúdos são
alterados e permanecem assim após o fim da execução da função, pois a e b são passados sem cópia,
ou seja, são passados seus endereços como parâmetros da função troca.
7.4 Alocação Dinâmica de Memória
Apontadores também são fundamentais no que diz respeito à alocação dinâmica, economia de memória
e tempo de execução.
Apontadores permitem alocação de memória em tempo de execução (alocação dinâmica). Para
tanto, uma variável ponteiro aponta para uma área de memória livre definida durante a execução do
programa. As Figuras 7.9 e 7.10 ilustram o processo de alocação dinâmica.
A Figura 7.9 mostra as áreas livres da memória. Em um determinado momento, um endereço, que

182
CAPÍTULO 7. APONTADORES
Figura 7.9: Áreas de memória livres.
indicava uma região de memória livre, passa a ser apontado por uma variável apontador, dessa forma
a região de memória passa a poder ser utilizada, o que é ilustrado na Figura 7.10.
Figura 7.10: Área de memória alocada dinamicamente.
Em C, a função malloc (abreviatura de memory allocation), da biblioteca padrão stdlib, aloca um
bloco de bytes consecutivos na memória do computador e devolve o endereço desse bloco. O Exemplo
7.10 mostra seu uso.
1 int *p
2 p = ( int *) malloc (4 * ( sizeof ( int )));
DRAFT
Exemplo 7.10: Alocação dinâmica de quatro inteiros.
No Exemplo 7.10, a expressão sizeof retorna o número de bytes de um tipo passado como
parâmetro, no caso int. Além disso, como a função malloc retorna um apontador do tipo void *
para um bloco de bytes consecutivos, esse apontador deve ser convertido em apontador para o tipo
desejado, nesse caso, por meio do operador de conversão de tipo (int *), uma vez que a variável p é
do tipo int. Deste modo fica garantida a consistência de tipos. A Figura 7.11 ilustra um espaço de 4
inteiros, alocados dinamicamente pelo Exemplo 7.10.
Vale ressaltar que a função malloc, antes de alocar a região de memória especificada, deve buscar
na memória do computador um espaço correspondente ao desejado no programa. Esse processo de
busca pode comprometer a velocidade de execução do programa, embora para a maioria das aplicações
esse tempo de busca seja desprezível.

7.4.
ALOCAÇÃO DINÂMICA DE MEMÓRIA 183
Figura 7.11: Vetor de inteiros alocados dinamicamente.
Um espaço de memória deve ser desalocado quando não é mais necessário. Isto significa que a área
de memória que foi apontada por um apontador agora passa a ser novamente livre. Somente variáveis
alocadas dinamicamente podem ser desalocadas em tempo de execução.
O processo de desalocação de memória, em C, está ilustrado no Exemplo 7.11.
1 int *p;
2 p = ( int *) malloc (4 * sizeof ( int ));
3 free (p);
Exemplo 7.11: Utilização da função free para liberar memória.
No Exemplo 7.11, a função free, que assim como malloc, está na biblioteca stdlib tem o papel de
desalocar uma área de memória. Note que a função free deve receber como parâmetro uma variável
apontador. Assim, a área de memória apontada por ele será então liberada. A Figura 7.12 ilustra a
desalocação de memória.
DRAFT
Figura 7.12: Desalocação dinâmica de memória.
Na Figura 7.12, pode-se observar que no decorrer da execução do programa, a variável apontador
deixa de apontar para área de memória, que por sua vez volta para o grupo de endereços livres.
O processo de alocação dinâmica pode ser usado para ler linhas de um documento de texto. Sem o
uso de alocação dinâmica, seria necessário definir previamente um tamanho fixo n x m de uma matriz
limitando o tamanho do texto e da linha que podem ser lidos. Para se conseguir ler todas as linhas,
define-se o tamanho m da matriz como o tamanho da maior linha que será lida e n um número grande
suficiente para armazenar todas as linhas. Entretanto, esse procedimento acarreta perda de memória
com linhas pequenas, que não utilizam todo o espaço alocado para elas, e tratando-se de textos com

184
CAPÍTULO 7. APONTADORES
grandes quantidades de linhas essa perda torna-se considerável.
Considere a Figura 7.13, que ilustra como seria o processo de alocação dinâmica de uma matriz
para ler um pequeno texto de caracteres. Percebe-se facilmente que, para a quarta linha da matriz, 9
espaços seriam perdidos.
Figura 7.13: Matriz que armazena um texto.
Para contornar o problema de perda de memória com espaços não utilizados, faz-se uso da alocação
dinâmica. A cada necessidade de se ler uma linha com certo número de caracteres, aloca-se o exato
tamanho da linha, ou seja, a quantidade de caracteres da string que será lida.
O Exemplo 7.12 mostra a implementação em linguagem C de uma matriz de caracteres dinamicamente
alocada. Esta matriz possui 4 linhas de tamanhos alocados de acordo com o tamanho da string
armazenada, e cada linha da matriz recebe uma linha do texto da Figura 7.13. A matriz declarada no
Exemplo 7.12 é simplesmente um vetor de apontadores para strings e os elementos do vetor g contém
os endereços dos primeiros elementos de cada string. Na Figura 7.14 está ilustrado o vetor de strings
correspondente ao texto.
1 # include
2 # include < stdlib .h>
3
4 int main (){
5 char *g [4];
6 g [0] = ( char *) malloc ( ( strlen (" Joao ama Maria ") + 1) * sizeof ( char ));
7 strcpy (g[0] , " Joao ama Maria ");
8 g [1] = ( char *) malloc ( ( strlen (" Maria ama pedro ") + 1 ) * sizeof ( char ));
9 strcpy (g[1] , " Maria ama pedro ");
10 g [2] = ( char *) malloc ( ( strlen (" Ana ama quem ama Maria ") + 1) * sizeof ( char ));
11 strcpy (g[2] , " Ana ama quem ama Maria ");
12 g [3] = ( char *) malloc ( ( strlen (" Quem Ana ama ?") + 1) * sizeof ( char ));
13 strcpy (g[3] , " Quem Ana ama ?");
14
15 return 0;
16 }
DRAFT
Exemplo 7.12: Definição de uma matriz de caracteres dinâmica
Figura 7.14: Vetor de strings.
Para determinar o tamanho alocado dinamicamente é calculado o tamanho da string usando a
função strlen e soma-se 1 que é a posição ocupada pelo caracter \0, sinalizador de fim de string.

7.5. PROBLEMAS GERADOS POR APONTADORES 185
Pode-se acessar um elemento da matriz utilizando a notação g[i][j] no Exemplo 7.12, onde i e j são
os indices da matriz. Alternativamente, é possível acessar o primeiro elemento da matriz por meio do
operador asterisco com a sintaxe: **g.
7.5 Problemas Gerados por Apontadores
Apesar de serem muito importantes, quando usados inapropriadamente, apontadores são fontes de
erros difíceis de serem encontrados. Apontadores não inicializados, objetos pendentes, referência
pendente, e programação macarrônica são alguns desses erros.
7.5.1 Apontadores Não Inicializados
Quando se trata de apontadores, um erro muito comum é utilizá-los antes de fazê-los apontar para
algum endereço válido, ou seja, sem inicializá-los. O Exemplo 7.13 mostra como isso pode ocorrer. O
valor da variável apontada por p recebe o valor de h, mas p não foi inicializado ainda, ou seja, não
apontava para nenhum espaço de memória válido.
1 float *p, h = 15.0;
2 *p = h;
Exemplo 7.13: Apontador não inicializado.
As consequências da utilização de um apontador não inicializado são imprevisíveis, podendo provocar
uma paralisação do programa.
7.5.2 Objetos Pendentes
Objetos pendentes ocorrem quando uma área de memória alocada fica inacessível. Veja o Exemplo
7.14. A área de memória apontada por p fica inacessível, pois p passa a apontar para o mesmo endereço
de q. Durante o restante da execução do programa este espaço de memória permanece reservado,
impedindo sua reutilização e comprometendo a economia de memória. A Figura 7.15 ilustra como
ocorrem objetos pendentes.
DRAFT
Figura 7.15: Objetos pendentes.
1 int *p = ( int *) malloc ( sizeof ( int ));
2 int *q = ( int *) malloc ( sizeof ( int ));
3 p = q;
Exemplo 7.14: Objetos pendentes.

186
CAPÍTULO 7. APONTADORES
7.5.3 Referência Pendente
Quando é liberado um endereço de memória que é apontado por mais de uma variável apontador ocorre
a referência pendente. Assim, algumas variáveis ficam referenciando um endereço que foi desalocado.
Veja o Exemplo 7.15 que mostra um caso de referência pendente. O endereço da variável h é liberado,
portanto p aponta para um espaço de memória liberado. A Figura 7.16 ilustra o problema de referência
pendente. Um espaço de memória livre pode ser alocado a qualquer momento por outras variáveis do
sistema. Ao se utilizar variáveis que tiveram seu espaço de memória liberado, pode-se estar acessando
áreas importantes do sistema, que alocou o espaço de memória que acabara de ser liberado, e isto
pode provocar uma paralisação do programa.
Figura 7.16: Referência pendente.
DRAFT

7.6. TAD IMPLEMENTACIONAL LISTA ENCADEADA DE INTEIROS 187
1 int *p;
2 int *h;
3 h = ( int *) malloc ( sizeof ( int ));
4 p = h;
5 free (h);
Exemplo 7.15: Referência pendente.
7.5.4 Programação Macarrônica
Um mesmo endereço de memória pode ser apontado por vários apontadores. Isso pode tornar confuso
o entendimento do programa e a identificação de erros. O Exemplo 7.16 mostra um trecho de código
difícil de entender devido ao uso indiscriminado de apontadores.
1 typedef struct {
2 int numeroSala ;
3 int numeroAlunos ;
4 } tSala ;
5
6 void acresentaAluno ( tSala *g){
7 g-> numeroAlunos = g-> numeroAlunos + 1;
8 }
9
10 int main (){
11 int p;
12 tSala sala ;
13 sala . numeroSala = 1;
14 sala . numeroAlunos = 0;
15 tSala *x;
16 tSala *y;
17
18 y = & sala ;
19 x = y;
20 acrescentaAluno (x);
21 acrescentaAluno (y);
22
23 return 0;
24 }
Exemplo 7.16: Programação macarrônica causada pelo uso indiscriminado de apontadores.
No Exemplo 7.16, o número de alunos da variável sala é alterado duas vezes, uma pelo apontador
x, outra por meio do apontador y. Portanto, quando apontadores são usados de uma maneira
indiscriminada, pode-se diminuir a legibilidade do código.
DRAFT
7.6 TAD Implementacional Lista Encadeada de Inteiros
Uma lista encadeada é uma estrutura cujos elementos são acessados sequencialmente por meio de
apontadores. Nessa estrutura estão armazenados os apontadores para o começo e o fim de uma
sequência de blocos, conhecidos como “nós”, além de uma variável inteira que indica a quantidade
atual de elementos na lista. Cada nó, por sua vez, possui informações armazenadas, um apontador
para o próximo nó. Na Figura 7.17, tem-se um esquema de uma lista simplesmente encadeada, com
três nós e com apontadores para o primeiro e o último elemento.
Note que cada um dos nós possui um apontador para o próximo, com exceção do último, no qual
há um apontador para NULL, pois não há próximo. Repare também que a estrutura da lista possui
apontadores para o início e o fim da lista, além de armazenar seu tamanho corrente, no caso, três
elementos.
Pode-se perceber que incluir elementos em uma lista encadeada torna-se um processo simples.
Se um novo dado necessita ser incluído, basta alocar um espaço de memória para o nó, atualizar os

188
CAPÍTULO 7. APONTADORES
Figura 7.17: Esquema de uma lista simplesmente encadeada.
apontadores da sequência de nós e a quantidade deles na lista. Excluir um dado da lista é um processo
semelhante, com a diferença de que, ao invés de se alocar, desaloca-se uma área da memória.
Vale destacar que as estruturas da lista e de cada um dos dados armazenados em um nó são exemplos
do uso de abstração, pois se encapsulam informações, seleciona-se o que deve ser apresentado de
uma função à outra e possibilita-se o trabalho em níveis de implementação e uso, prática fundamental
na modularização de um código. Conforme visto no capítulo 4, pode-se dizer que o tipo de abstração
utilizada na lista encadeada é uma abstração de dados implementacional, por meio do uso de Tipos
Abstratos de Dados, TADs.
Anteriormente foi visto que TADs são conjuntos de valores com comportamento uniforme definido
por operações, que são tipicamente os componentes responsáveis pela interface entre os diferentes
níveis e módulos de implementação. Essa interface é responsável por encapsular e proteger os dados.
A implementação do TAD lista encadeada tLista será apresentada a seguir. Também serão detalhadas
várias operações fundamentais sobre a lista. Inicialmente, será definido o tipo tNo, o qual é
um componente importante de tLista.
7.6.1 Definição do Tipo tNo
De acordo com o que foi dito até agora, cada nó deve ser responsável por armazenar um dado, além de
conter um apontador para o próximo nó, no caso de uma lista simplesmente encadeada. O Exemplo
7.17 mostra como pode ser a estrutura tNo:
1 typedef int tInfo ;
2
3 void imprimetInfo ( tInfo info ){
4 printf (" Elemento : %d\n",info );
5 }
6
7 typedef struct no{
8 tInfo info ;
9 struct no * proximo ;
10 } tNo ;
DRAFT
Exemplo 7.17: Estrutura tNo.
Há necessidade de se incluir o termo no após o primeiro struct porque, ao se incluir o atributo
proximo, ocorre uma definição recursiva do tipo no, ou seja, a estrutura no possui um campo do
mesmo tipo que ela. Assim, caso fosse retirado o primeiro termo no, não se saberia qual o tipo de
proximo. Também é importante dizer que a variável inteira info poderia ser substituída por qualquer
outro tipo, tais como char, float e, até mesmo, estruturas compostas por uma variedade de tipos.
Para isso, bastaria alterar o termo int na definição do tipo tInfo.
A partir de agora, devido ao uso do typedef, sempre que for utilizado o termo tNo antes de um
identificador, significa que está sendo declarada uma estrutura como a do Exemplo 7.17.
Como frequentemente será necessário incluir novos nós, torna-se importante criar uma função que
aloque dinamicamente um espaço de memória para um nó. O Exemplo 7.18 mostra uma forma de

7.6. TAD IMPLEMENTACIONAL LISTA ENCADEADA DE INTEIROS 189
implementar tal função.
1 tNo * criaNo ( tInfo elem ){
2 tNo *no = ( tNo *) malloc ( sizeof ( tNo ));
3 no -> proximo = NULL ;
4 no -> info = elem ;
5
6 return no;
7 }
Exemplo 7.18: Implementação da operação criaNo.
Após a alocação do espaço de memória, o apontador proximo é inicializado como NULL. Em
seguida, o campo info do nó criado é associado ao valor do elemento passado como argumento. Por
fim, é retornado um apontador para a área de memória inicializada na função.
7.6.2 Atributos de tLista
A estrutura tLista a ser definida tem apontadores para o primeiro e último nó. Essa estrututa é
chamada cabeçalho da lista. Cabe ressalvar que existem diferentes formas de implementar listas
encadeadas. A mostrada no Exemplo 7.19 é apenas uma delas.
1 typedef struct {
2 tNo * primeiro ;
3 tNo * marcador ;
4 tNo * ultimo ;
5 int tam ;
6 } tLista ;
Exemplo 7.19: Estrutura tLista.
Repare que três atributos de tLista são apontadores para o tipo tNo, o qual foi definido na
seção anterior. Dois deles, primeiro e ultimo, apontam para o começo e para o fim da lista, enquanto
marcador aponta para qualquer posição. A variável inteira tam é a responsável por guardar o tamanho
atual, ou número de nós, da lista.
O apontador marcador é responsável por apontar o nó corrente num processo de busca sequencial.
Por exemplo, na operação de imprimir a lista, que será explicada mais adiante, a informação é extraída
do nó apontado por marcador, o qual é posicionado desde o primeiro nó até o último.
7.6.3 Operações de tLista
DRAFT
Como já se têm definidos os tipos de dados, tNo e tLista, necessita-se criar as operações que serão
responsáveis por trabalhar com valores do tipo tLista, concluindo assim, a implementação do TAD
lista encadeada.
Operações Construtoras
As operações construtoras são responsáveis por garantir a alocação da estrutura tLista, além de
inicializá-la com os valores desejados, geralmente com os apontadores apontando para NULL e as
variáveis numéricas com valor zero. O Exemplo 7.20 mostra a função de inicialização de uma lista.
1 void inicia ( tLista * lista ){
2 lista -> primeiro = NULL ;
3 lista -> marcador = NULL ;
4 lista -> ultimo = NULL ;
5 lista -> tam = 0;
6 }
Exemplo 7.20: Inicialização de uma lista.

190
CAPÍTULO 7. APONTADORES
Na função inicia os apontadores primeiro, marcador e ultimo são inicializados com NULL, pois
não há nós na lista e, garante-se assim, que estes não apontem para uma área de memória indevida.
Em seguida, o tamanho da lista é zerado uma vez que o atual tamanho da lista é nulo.
Operações Analisadoras
Em algumas situações é importante analisar a posição atual do marcador, se ele está no fim da lista,
se a lista está vazia etc. Por exemplo, ao se percorrer a lista, uma condição de parada importante
é quando o final da lista for alcançado e, ao se incluir ou excluir um elemento da lista, é necessário
saber se a lista está vazia.
Essas análises são importantes para que não se cometa acessos indevidos com os apontadores, um
dos problemas explicados anteriormente.
O Exemplo 7.21 mostra a implementação da função analisadora de fim da lista.
1 int final ( tLista * lista ){
2 return ( lista -> marcador == NULL );
3 }
Exemplo 7.21: Verificação de fim da lista.
Essa função simplesmente retorna o resultado da comparação do marcador da lista com NULL.
Isso porque o último nó da lista tem como próximo este valor, bem como a lista vazia, que tem seus
apontadores iniciais todos apontando para NULL. Na Figura 7.18, o marcador não está apontando
para NULL, assim não é o fim da lista e, portanto, a função final retorna 0.
Figura 7.18: Marcador Apontando para uma posição da lista.
Já na Figura 7.19 o marcador aponta para NULL, ou seja para o fim da lista. Assim, o retorno da
função é 1.
DRAFT
Figura 7.19: Marcador Apontando para o fim da lista.
O Exemplo 7.22 mostra a implementação da função analisadora de lista vazia.
1 int vazia ( tLista * lista ){
2 return ( lista -> tam == 0);

7.6. TAD IMPLEMENTACIONAL LISTA ENCADEADA DE INTEIROS 191
3 }
Exemplo 7.22: Verificação se a lista está vazia.
Assim como na análise do fim da lista, vazia retorna o resultado de uma comparação. Nesse caso,
porém, se o tamanho da lista é igual zero. Como o tamanho da lista é inicializado com este valor
e, sempre que um novo nó for adicionado, ou removido, este tamanho deve ser atualizado, a única
possibilidade de ele ser zero é quando a lista estiver realmente vazia.
Um exemplo de utilização da função vazia é quando se deseja incluir, ou excluir um nó da lista.
É necessário um tratamento especial na primeira inclusão, pois o primeiro e ultimo elemento são os
mesmos, e na exclusão, uma vez que seria um erro tentar remover elementos de uma lista vazia.
Operações Modificadoras
Uma das características interessantes da lista encadeada é a facilidade de se incluir e excluir elementos,
em tempo de execução, com praticidade, uma vez que é necessário somente alocar e desalocar nós,
respectivamente. É importante, então, conhecer as funções de inserção e exclusão, tratadas como
operações modificadoras, pois alteram a composição corrente da lista. No Exemplo 7.23, o novo
elemento e a lista no qual ele será inserido são passados como argumentos. A passagem do cabeçalho
lista é feita por apontador, pois assim, qualquer modificação em seus elementos é feita diretamente
na função, sem necessidade de passar toda lista por cópia e retorná-la ao fim da execução da função.
O elemento será incluído no fim da lista, mas diferentes implementações, nas quais ele é inserido no
começo, ou numa dada posição, também são possíveis.
1 void incluirFim ( tLista * lista , tInfo elem ){
2 tNo *no;
3
4 no = criaNo ( elem );
5
6 if( vazia ( lista )){
7 lista -> primeiro = no;
8 } else {
9 lista -> ultimo -> proximo = no;
10 }
11
12 lista -> ultimo = lista -> marcador = no;
13 lista -> tam ++;
14 }
DRAFT
Exemplo 7.23: Função de inclusão de um novo nó na lista.
Como pode ser visto no exemplo acima, inicialmente o novo nó deve ser criado para armazenar o
elemento a ser incluído. Para isso é utilizada a função inicializadora criaNo, que aloca um espaço
de memória do tamanho de tNo, faz o campo info ser igual ao elemento passado como argumento
e retorna um apontador para o espaço alocado. A Figura 7.20 mostra o estado da lista, antes da
inclusão, e o novo nó a ser incluído.
Agora que já se tem o novo nó, é necessário incluí-lo na lista, ou seja, atualizar o valor de tam e
os apontadores. Como a lista tem mais um nó, seu tamanho deve ser incrementado em uma unidade.
Quanto à atualização dos apontadores, os apontadores ultimo e marcador devem apontar para o nó
incluído, respectivamente, porque ele é incluído no fim da lista e no último nó acessado. Antes, porém,
é importante verificar se a lista está vazia, pois caso esteja, quem também vai apontar para nó a ser
incluído, será o apontador primeiro da lista, caso contrário, será apontador proximo do ultimo nó da
lista. Vale destacar que a análise se a lista está vazia é um exemplo de uso da função vazia, que foi
explicada anteriormente. A Figura 7.21 exibe a lista após a inclusão do novo nó.

192
CAPÍTULO 7. APONTADORES
Figura 7.20: Lista antes da inclusão.
Figura 7.21: Lista após a inclusão.
O Exemplo 7.24 mostra a implementação de uma operação de exclusão.
1 void excluir ( tLista * lista , int pos ){
2 tNo *auxA , * auxB ;
3 int i;
4
5 if(pos < 0 || pos >= lista -> tam ){
6 return ;
7 }
8
10
9 auxA = lista -> primeiro ;
11 for (i =0;i proximo ;
14 }
15
16 if( auxA != lista -> primeiro ){
17 auxB -> proximo = auxA -> proximo ;
18 if( auxA == lista -> ultimo ){
19 lista -> ultimo = auxB ;
20 }
21 } else {
22 lista -> primeiro = auxA -> proximo ;
23 if(lista -> ultimo == auxA ){
24 lista -> ultimo = auxA -> proximo ;
25 }
26 }
27
28 lista -> marcador = NULL ;
29 lista ->tam - -;
DRAFT

7.6. TAD IMPLEMENTACIONAL LISTA ENCADEADA DE INTEIROS 193
30 free ( auxA );
31 }
Exemplo 7.24: Função de exclusão de um nó da lista.
Na função de exclusão, são passadas como parâmetros a lista e a posição do nó a ser excluído.
Considera-se que a primeira posição é zero. Assim, é importante saber, inicialmente, se o valor de pos
é válido e, caso não seja, a função é encerrada.
São criados dois apontadores auxiliares do tipo tNo: auxA e auxB. Para buscar o nó da posição pos,
auxA aponta para o primeiro nó da lista e inicia-se um laço for, até que o valor de i, que inicialmente
é zero, seja pos. A cada iteração desse laço, auxB vai apontar para o último nó apontado por auxA e
este, por sua vez, aponta para o próximo nó da lista. Portanto, quando auxA estiver apontando para o
nó a ser excluído, o anterior a ele é apontado por auxB, o que é importante na hora de se atualizarem
os apontadores, conforme será explicado.
Após ter encontrado o nó da posição pos, tem que se analisar quatro situações possíveis: 1) esse
nó a ser excluído não ser nem o primeiro e nem o último nó da lista; 2) ser o último; 3) ser o primeiro;
4) e ser o único nó. No caso 1, basta fazer o apontador proximo do nó apontado por auxB apontar
para o nó apontado pelo proximo do nó apontado por auxA. No caso 2, também se deve fazer o último
nó da lista ser auxB. Vale lembrar que, no caso de auxA ser o último, ao se fazer o proximo de auxB
ser o proximo de auxA, está se fazendo simplesmente auxB ter como próximo o valor NULL. Já no
caso 3, coloca-se o próximo de auxA como o nó inicial e, no caso 4, faz-se também o apontador ultimo
da lista apontar para o próximo de auxA. Nesse último caso, está se redirecionando os apontadores,
primeiro e ultimo da lista, para NULL.
Agora que já se tem os apontadores atualizados e retirado o nó da seqüência de nós, coloca-se o
marcador da lista como NULL, pois será perdido o último nó acessado. Então, diminui-se o tamanho
da lista e, finalmente, libera-se o espaço de memória apontado por auxA. A Figura 7.22 ilustra a lista
da Figura 7.19 após a exclusão do nó 2.
DRAFT
Figura 7.22: Lista após a exclusão do nó 2.
Outro importante tipo de operação modificadora é a que permite posicionar o marcador em um
nó. Elas são úteis para acessar informações em um nó determinado previamente.
O Exemplo 7.25 é a implementação da função que posiciona o marcador no primeiro nó da lista.
1 void primeiro ( tLista * lista ){
2 lista -> marcador = lista -> primeiro ;
3 }
Exemplo 7.25: Posicionado o marcador no começo da lista.
Para fazer o marcador de uma lista apontar para o primeiro elemento dela, basta igualar o marcador
ao apontador primeiro. O objetivo da função primeiro é posicionar o marcador no início da lista,
para permitir que seja feita uma busca nos elementos da lista a partir do seu início.
A função proximo é mostrada no Exemplo 7.26.
1 void proximo ( tLista * lista ){
2 if(lista -> marcador != NULL ){
3 lista -> marcador = lista -> marcador -> proximo ;
4 }

194
CAPÍTULO 7. APONTADORES
5 }
Exemplo 7.26: Posicionado o marcador no proximo nó da lista.
A função proximo é para posicionar o marcador, fazendo-o apontar para o próximo elemento da
lista. A verificação se o marcador atual é diferente de NULL evita o acesso indevido à memória.
A utilidade das operações de posicionamento de marcador será ilustrada a seguir na seção Operações
Produtoras.
Operações Produtoras
Uma vez armazenados os dados na lista é fundamental permitir o acesso e a recuperação destas
informações. As funções produtoras possibilitam extrair alguma informação da lista.
O Exemplo 7.27 mostra a operação responsável por retornar a informação do nó apontado pelo
marcador da lista.
1 int obterInfo ( tLista * lista , tInfo * info ){
2 if(lista -> marcador == NULL ){
3 return 0;
4 }
5 * info = lista -> marcador -> info ;
6 return 1;
7 }
Exemplo 7.27: Função para recuperar a informação de um nó.
A função obterInfo tem por objetivo atribuir o conteúdo do nó, apontado pelo marcador, à
variável info, passada como parâmetro. A função retorna o valor 1 se houve sucesso na obtenção do
conteúdo do nó e retorna o valor 0 caso contrário. Assim, impede-se o acesso a um local indevido da
memória.
O Exemplo 7.28 ilustra o uso dessas informações por meio do uso de uma função que imprime todos
os dados de uma lista. Para a função é passada a lista cujos elementos serão impressos. Inicialmente
a função primeiro é utilizada para posicionar o marcador no início da lista e, em seguida, começa
um laço while, que varre a lista até queo final dela seja alcançado. A verificação se o final da lista foi
alcançado é feita pela função final, conforme descrito anteriormente.
1 void imprimir ( tLista * lista ){
2 tInfo x;
3 int erro = 0;
4
5 primeiro ( lista );
6
7 while (! final ( lista )){
8 erro = obterInfo ( lista , &x);
9 if( erro ){
10 imprimetInfo (x);
11 }
12 proximo ( lista );
13 }
14 }
DRAFT
Exemplo 7.28: Impressão de todos elementos de uma lista.
Para cada posição do marcador, obterInfo retorna o valor de info do nó apontado pelo marcador
da lista. Esse valor é impresso caso tenha ocorrido sucesso na obtenção da informação, ou seja, a
variável erro ter o valor 1. A operação proximo posiciona o marcador no próximo nó da lista e,
somente quando este marcador for NULL, o laço while será encerrado.
Pode ser necessário em algum momento da execução obter o tamanho total da lista. Para isso,
pode ser usada a função obterTam mostrada no Exemplo 7.29.

7.6. TAD IMPLEMENTACIONAL LISTA ENCADEADA DE INTEIROS 195
1 int obterTam ( tLista * lista ){
2 return lista -> tam ;
3 }
Exemplo 7.29: Função para obter o tamanho da lista.
Operação Destrutora
Quando a lista não é mais necessária, é importante desalocar o espaço de memória ocupado por seus
nós. A função responsável por desalocar a lista e seus elementos é conhecida como destrutora. Repare,
no Exemplo 7.30, que a desalocação de memória é feita nó por nó. Note que ao final da operação,
os valores dos atributos de lista são modificados para apontarem para NULL para evitar que fiquem
referenciando áreas já desalocadas.
1 void destroi ( tLista * lista ){
2 tNo * aux ;
3
4 primeiro ( lista );
5
6 while (! final ( lista )){
7 aux = lista -> marcador ;
8 proximo ( lista );
9 free ( aux );
10 }
11
12 lista -> primeiro = NULL ;
13 lista -> marcador = NULL ;
14 lista -> ultimo = NULL ;
15 lista -> tam = 0;
16 }
Exemplo 7.30: Desalocação das áreas de memória ocupados pelos nós da lista.
Semelhantemente a função de imprimir, a função primeiro é utilizada para posicionar o marcador
no inicio da lista e, em seguida, inicia-se um laço enquanto o final dela não é alcançado.
A cada iteração, um nó auxiliar aux guarda o endereço de memória apontado pelo marcador da
lista. Em seguida, posiciona-se o marcador no próximo nó da lista e a região apontada por aux é
liberada com o uso da função free.
Quando se chega ao final da lista, o laço while é encerrado e os atributos da lista voltam ao seu
estado inicial, assim, seus apontadores apontam para NULL e o tamanho é zerado.
7.6.4 Uso
DRAFT
A fim de ilustrar a utilização do TAD Implementacional Lista Encadeada, será utilizado um cadastro
simples de alunos na universidade. Veja o Pseudocódigo 7.1.
Pseudocódigo 7.1 Uso de uma lista simplesmente encadeada.
Descrição: Cadastrar alunos.
Dados de Entrada: Nomes e as respectivas matrículas.
Saída do Programa: Lista impressa.
Inicializar lista .
Ler primeiro nome .
Ler primeira matrícula .
ENQUANTO matrícula for maior que zero :
Incluir nome e matrícula na lista .
Ler nome .

196
CAPÍTULO 7. APONTADORES
Ler matrícula .
FIM - ENQUANTO .
ENQUANTO posiç~ao for maior ou igual a zero :
Ler posiç~ao a ser excluída.
Validar posiç~ao a ser excluída.
SE a posiç~ao contiver algum nó:
Excluir o nó.
FIM -SE.
FIM - ENQUANTO .
Exibir lista .
Destruir lista .
O Pseudocódigo 7.1 descreve os passos para o programa de cadastro simples, no qual apenas
pode-se ler e armazenar algumas entradas. Após a leitura, alguns dados podem ser excluídos e as
informações restantes exibidas.
No cadastro, haverá apenas o nome e o número de matrícula do aluno, mas vale lembrar que, para
um registro de informações mais detalhado, basta acrescentar mais atributos no exemplo de estrutura
tInfo do exemplo apresentado.
Observe o Exemplo 7.31, no qual se tem a transcrição do Pseudocódigo 7.1. Foram utilizadas todas
as funções estudadas nesta seção, porém com algumas modificações, uma vez que o campo info, da
estrutura do nó, não é mais um inteiro, e sim, uma outra estrutura. Só estão mostradas as estruturas
e as operações anteriores que sofreram modificação.
1 typedef struct {
2 int matricula ;
3 char nome [30];
4 } tInfo ;
5
6 void imprimirtInfo ( tInfo info ){
7 printf (" Nome : %s.\n", info . nome );
8 printf (" Matricula : %d.\n", info . matricula );
9 }
10
11 int main (){
12 tLista * lista ;
13 tInfo dados ;
14 int pos ;
15
16 inicia ( lista );
17
18 printf (" Entre com o nome do aluno : ");
19 scanf ("%s", & dados . nome );
20 printf (" Entre com a matricula do aluno : ");
21 scanf ("%d", & dados . matricula );
22
23 while ( dados . matricula > 0){
24 incluirFim ( lista , dados );
25
26 printf (" Entre com o nome do aluno : ");
27 scanf ("%s", & dados . nome );
28 printf (" Entre com a matricula do aluno : ");
29 scanf ("%d", & dados . matricula );
30 }
31
DRAFT
32 printf (" Digite a posicao do elemento a ser excluido : ");
33 scanf ("%d", & pos );
34
35 while ( pos >= 0){
36 excluir ( lista , pos );
37 printf (" Digite a posicao do elemento a ser excluido : ");
38 scanf ("%d", & pos );
39 }
40

7.7.
EXERCÍCIOS RESOLVIDOS 197
41 imprimir ( lista );
42 destroi ( lista );
43
44 return 0;
45 }
Exemplo 7.31: Cadastro de alunos na universidade.
O programa implementado no Exemplo 7.31 apenas lê as informações do teclado enquanto não se
digita um valor inválido, no caso matricula menor ou igual a 0. Se for digitado algum desses valores
para matricula o laço while é interrompido. Cada nome e matrícula são armazenados na lista e, após o
término de leitura de dados, os elementos da lista são exibidos na tela. Pode-se apagar as informações
fornecendo a posição na lista, do dado a ser apagado. Por fim, antes de se encerrar o programa, a lista
é destruída.
7.7 Exercícios Resolvidos
Exercício Resolvido 7.1 - Acesso ao Conteúdo de Variáveis por Apontadores
Para o trecho de código do Exemplo 7.32, ilustre os estados das variáveis apontadoras e nãoapontadoras.
Utilize para a ilustração os padrões adotados na Figura 7.3 e Figura 7.4 para representar
uma variável não apontador e apontador respectivamente.
1 int *p;
2 int *q;
3 int a;
4 int b;
5 int c;
6
7 b = 10;
8 c = 15;
9 a = c;
10 p = &b;
11 q = &c;
12 *p = *q;
Exemplo 7.32: Código para o exercício resolvido 7.1.
Solução Possível:
Inicialmente são criados dois apontadores para inteiro, p e q, e três variáveis inteiras: a b e c. Em
seguida, b passa a armazenar o valor 10, enquanto c, 15. Já a rebece o valor de c, ou seja, 15. Isso é
ilustrado nas três primeiras cenas da Figura 7.23.
Por fim, p e q passam a apontar b e c, repectivamente. Assim, na última linha, o conteúdo da
variável apontada por p recebe o valor de c, pois este é a variável apontada por q, o que faz b receber
o valor 15. Vejas os três últimos passos da Figura 7.23.
DRAFT

198
CAPÍTULO 7. APONTADORES
Figura 7.23: Solução do exercício resolvido 7.1.
Exercício Resolvido 7.2 - Múltiplo Retorno em uma Função
A função calculaPot, do Exemplo 7.33, calcula o quadrado de um inteiro. Modifique esta função
para que ela passe a retornar também o cubo deste número. Faça as devidas alterações na main.
1 int calculaPot ( int valor ){
2 int potQuadrada ;
3
4 potQuadrada = valor * valor ;
5
6 return potQuadrada ;
7 }
8
9 int main (){
10 int x;
11 int quadrado ;
12
DRAFT
13 scanf ("%d", &x);
14 quadrado = calculaPot (x);
15 printf (" Quadrado de %d = %d\n", x, quadrado );
16
17 return 0;
18 }
Exemplo 7.33: Função calculaPot.
Solução Possível:
O dado de entrada do programa é um número inteiro, e as saídas devem ser o quadrado e cubo
deste número, calculadas pela função apresentada no Exemplo 7.33, com suas devidas alterações. O
Pseudocódigo 7.2 exibe as etapas para a solução.

7.7.
EXERCÍCIOS RESOLVIDOS 199
Pseudocódigo 7.2 Cálculo das potências quadradas e cúbicas de um número inteiro.
Descrição: Retornar as potências quadrada e cúbica de um número inteiro, calculadas por uma função apenas.
Dados de Entrada: Um número inteiro.
Saída do Programa: Potências quadrada e cúbica do valor de entrada.
Ler o número inteiro ;
Passar os par^ametros para a funç~ao calculaPot ;
Calcular as pot^encias pela funç~ao calculaPot .
A função calculaPot deve ser alterada para também calcular e retornar o cubo do valor. Contudo,
o retorno dessa função já é o quadrado do parâmetro de entrada. Nesse sentido, a passagem por
apontadores é a ferramenta para múltiplos retornos numa função.
As modificações no Exemplo 7.33 podem ser observadas no Exemplo 7.34.
1 int calculaPot ( int valor , int * potCubica ){
2 int potQuadrada ;
3
4 potQuadrada = valor * valor ;
5 * potCubica = potQuadrada * valor ;
6
7 return potQuadrada ;
8 }
9
10 int main (){
11 int x;
12 int quadrado ;
13 int cubo ;
14
15 scanf ("%d", &x);
16 quadrado = calculaPot (x, & cubo );
17 printf (" Quadrado de %d = %d\ nCubo de %d = %d\n", x, quadrado , x, cubo );
18
19 return 0;
20 }
Exemplo 7.34: Múltiplo retorno em calculaPot.
DRAFT
Como pode ser observado, calculaPot passa a ter um parâmetro que irá receber o endereço da
variável cubo, declarada na main. Dessa forma, ao término da execução de calculaPot, a variável
cubo irá conter a potência cúbica do valor.
Exercício Resolvido 7.3 - Inserção no Início de Lista Simplesmente Encadeada
Foi visto anteriormente como inserir um elemento no final da lista. Agora, pretende-se criar uma
função que insere no começo de uma lista simplesmente encadeada.
Solução Possível:
São apresentados os passos a serem seguidos pela função no Pseudocódigo 7.3, onde também se
pode observar os dados de entrada e o retorno da função.
Pseudocódigo 7.3 Inserção no começo de uma lista simplesmente encadeada.
Descrição: Inserir um nó no começo de uma lista simplesmente encadeada.
Dados de Entrada: A lista e o elemento a ser inserido.
Saída da Função: A lista após a inserção.

200
CAPÍTULO 7. APONTADORES
Criar um nó para armazenar o novo elemento .
Verificar se a lista está vazia :
SE estiver vazia :
Incluir novo nó como último da lista .
SEN~AO
Inserir o novo nó tendo como seu próximo o antigo primeiro .
FIM -SE.
Posicionar o atributo primeiro no nó criado .
Posicionar o atributo marcador no nó incluído.
Incrementar o tamanho da lista .
O Exemplo 7.35 mostra a implementação em C do Pseudocódigo 7.3. Para tal função, a passagem
da lista será feita por apontador, pois assim, qualquer modificação em seus elementos será feita diretamente
na função e, por consegüinte, o retorno é void. A lista poderia ser passada por cópia, mas
assim a lista modificada deveria estar em um comando return.
1 void incluirInicio ( tLista * lista , tInfo elem ){
2 tNo *no;
3
4 no = criaNo ( elem );
5
6 if( vazia ( lista )){
7 lista -> ultimo = no;
8 } else {
9 no -> proximo = lista -> primeiro ;
10 }
11
12 lista -> primeiro = lista -> marcador = no;
13 lista -> tam ++;
14 }
Exemplo 7.35: Função de inclusão de um novo nó no começo da lista.
No Exemplo 7.35, um novo nó é criado com a utilização da função criaNo. Ao incluí-lo no inicío,
os apontadores primeiro e marcador devem apontar para o nó ser incluído, respectivamente porque
ele é incluído no começo da lista e é o último nó acessado.
Contudo, antes de atualizar o apontador primeiro é fundamental verificar se a lista está vazia, pois
caso não esteja, o novo nó deve guardar, como seu próximo, o antigo primeiro da lista. Já se a lista
estiver vazia, basta fazer o apontador ultimo também apontar para o novo nó. Por fim, o tamanho da
lista deve ser incrementado em uma unidade.
A Figura 7.24 mostra a Figura 7.20, após a inclusão do novo nó no começo da lista.
DRAFT
Figura 7.24: Lista da Figura 7.20, após a inclusão do nó no começo.

7.7.
EXERCÍCIOS RESOLVIDOS 201
Exercício Resolvido 7.4 - Media de valores de uma Lista Simplesmente Encadeada
Considere uma lista na qual são armazenados o nome e o salário de funcionários de uma empresa.
Exibir na tela todos os funcionários cujos salários estão acima da média.
Solução Possível:
O programa principal segue os passos descritos no Pseudocódigo 7.4.
Pseudocódigo 7.4 Média dos valores de uma lista simplesmente encadeada.
Descrição: Imprimir os funcionários cujos salários estão acima da média.
Dados de Entrada: Nomes e os respectivos salários.
Saída do Programa: Lista de nomes que tem o salário acima da média.
Inicializar a lista .
FAZER :
Ler nome .
Ler salário .
SE o salário n~ao for menor que zero :
Incluir no fim da lista .
FIM -SE.
ENQUANTO salário for maior ou igual o zero .
Processo componente " Verificar quem está acima da média ".
Destruir lista .
O passo Verificar quem está acima da média pode ser descrito como o Pseudocódigo 7.6. O
Pseudocódigo 7.5 mostra os passos para calcular a média, basta somar todos os salários e dividir pelo
total de nós da lista. Obtida a média, o Pseudocódigo 7.6 procura na lista quem tem o salário maior
que ela.
Pseudocódigo 7.5 Processo para encontrar a média dos salários.
Descrição: Calcular a média dos salários dos funcionários.
Dados de Entrada: Lista com os nomes e os respectivos salários.
Saída do Programa: Valor da média dos salários.
DRAFT
Processo componente " Obter média ":
Ir para o começo da lista .
Inicializar soma dos salários igual a zero .
ENQUANTO n~ao chegar no fim da lista :
Somar o salário atual à soma acumulada dos salários .
Ir para o próximo da lista .
FIM - ENQUANTO
Achar média ( Divide -se o total somado pelo tamanho da lista ).
Fim Processo componente " Obter média ".
Pseudocódigo 7.6 Processo para ver quem está com salário acima da média.
Descrição: Verificar os funcionários com salário acima da média
Dados de Entrada: Lista com os nomes e os respectivos salários.
Saída do Programa: Exibição na tela dos funcionários com salário acima da média.
Processo componente " Verificar quem está acima da média ":
Ir para o começo da lista .
Processo componente " Obter média ".

202
CAPÍTULO 7. APONTADORES
ENQUANTO n~ao chegar no fim da lista :
SE existir um nó com o salário maior que a média :
Exibir as informaç~oes do funcionário .
FIM -SE.
Ir para o próximo da lista .
FIM - ENQUANTO .
FIM Processo componente " Verificar quem está acima da média "
No exemplo 7.36 é mostrada a implementação em C do exercício.
1 typedef struct {
2 char nome [30];
3 float salario ;
4 } tInfo ;
5
6 float acharMedia ( tLista * lista ){
7 tInfo elem ;
8 int tam ;
9 int ok = 0;
10 float total , media ;
11
12 total = 0;
13 tam = obterTam ( lista );
14
15 primeiro ( lista );
16
17 while (! final ( lista )){
18 ok = obterInfo ( lista , & elem );
19
20 if(ok)
21 {
22 total += elem . salario ;
23 }
24
25 proximo ( lista );
26 }
27
28 media = total / tam ;
29
30 return media ;
31 }
32 float acimaMedia ( tLista * lista ){
33
34 tInfo elem ;
35 int tam ,ok;
36 float media ;
37
38 media = obterMedia ( lista );
39 primeiro ( lista );
40
41 while (! final ( lista )){
42 ok = obterInfo ( lista , & elem );
43
44 if(ok){
45 if( elem . salario > media ){
46
47 printf (" Nome : %s\n", elem . nome );
48 printf (" Salario : %f\n\n", elem . salario );
49 }
50 }
51
52 proximo ( lista );
53 }
54 }
55
DRAFT

7.8. RESUMO 203
56 int main (){
57 tLista lista ;
58 tInfo dados ;
59 int pos ;
60
61 inicia ( lista );
62
63 do{
64 printf (" Entre com o nome : ");
65 scanf ("%s", & dados . nome );
66 printf (" Entre com o salario : ");
67 scanf ("%f", & dados . salario );
68
69 if ( dados . salario >= 0)
70 incluirFim (& lista , dados );
71 } while ( dados . salario >= 0);
72
73 acimaMedia (& lista );
74 destroi ( lista );
75
76 return 0;
77 }
Exemplo 7.36: Cadastro de nomes e salários.
Na função acimaMedia, a variável total é inicializada como 0 e, a partir do primeiro elemento da
lista, esse total é incrementado com o salário de cada funcionário. Quando o final da lista é alcançado,
a média de salários é computada como sendo o total obtido dividido pelo tamanho da lista, ou seja, o
número de funcionários.
Com a média calculada, inicia-se um nova busca na lista, desde o primeiro elemento até o final
da lista, a fim de que se encontre os salários acima da média. Caso algum funcionário contenha um
salário maior que a média, os dados do funcionário são impressos na tela.
7.8 Resumo
ˆ
ˆ
ˆ
Apontadores são um tipo de variável que guarda o endereço de outras variáveis. Trata-se de um
conceito de baixo nível, ligado essencialmente à arquitetura de computadores.
Em C, a declaração de uma variável apontador segue o formato:
DRAFT
*
No lugar do tipo do apontador, podem ser utilizados os tipos padrões da linguagem C e também
os tipos definidos pelo programador.
O operador & retorna o endereço de memória de uma variável. Já o operador seta (− >) é
utilizado para acessar, por meio de apontadores, os atributos de uma estrutura.
ˆ Os apontadores podem alterar o conteúdo da variável apontada por ele. Por meio de apontadores
também é possível a passagem de parâmetros sem cópia. A passagem de parâmetros
por apontadores permite múltiplos retornos em uma função, evita a cópia de muitos dados e
possibilita a alteração das variáveis do programa no decorrer da execução da função.
ˆ
ˆ
Dentre os principais problemas com o uso de apontadores estão: apontadores não inicializados,
objetos pendentes, referências pendentes e programação macarrônica.
A alocação dinâmica é uma forma de reservar espaços de memória no decorrer da execução do
programa, o que evita o desperdício de recursos da máquina. Em C, as funções malloc e free
são responsáveis por alocar e desalocar áreas de memória, respectivamente.

204
CAPÍTULO 7. APONTADORES
ˆ
O TAD Implementacional Lista Encadeada é uma forma eficiente de armazenar dados num
programa, pois aloca-se e desaloca-se os espaços para os dados dinâmicamente, o que torna
muito simples as operações de incluir e excluir elementos.
7.9 Exercícios Propostos
1. Cite três vantagens e três desvantagens de se utilizar apontadores.
2. Explique quais as funcionalidades dos operadores * e &.
3. Liste as diferenças entre variáveis apontadoras e não apontadoras. Faça um código em C, que
realize a soma de duas variáveis float a e b, usando dois apontadores g e h, que apontem para
a e b respectivamente. Quais são os tipos dos apontadores g e h?
4. No Exemplo 7.37, escrito na linguagem C, encontre os erros de sintaxe na utilização de apontadores.
Justifique cada erro encontrado.
1 int main (){
2 int p;
3 int *d;
4 int q = 10;
5 float *j;
6 float t = 15.0;
7
8 j = &t;
9 p = &q;
10 d = j;
11
12 return 0;
13 }
Exemplo 7.37: Código do Exercício Proposto 4.
5. No Exemplo 7.38, escrito na linguagem C, encontre os problemas causados pela utilização indevida
de apontadores. Justifique cada problema encontrado.
1 int main (){
DRAFT
2 int *p = ( int *) malloc ( sizeof ( int ));
3 int *q = ( int *) malloc ( sizeof ( int ));
4 int *j;
5 int *h;
6 int *v;
7 int d = 20;
8 int e = 30;
9
10 *q = e;
11 *j = d;
12 p = &d;
13 h = &e;
14 v = q;
15 free (q);
16
17 return 0;
18 }
Exemplo 7.38: Código do Exercício Proposto 5.

7.10. TRABALHOS SUGERIDOS 205
6. Ilustre as atribuições e referenciamentos feitos no trecho de código do Exemplo 7.5. Utilize para
a ilustração os padrões adotados na Figura 7.3 e na Figura 7.4 para representar uma variável
não apontador e apontador respectivamente.
7. Implemente, na linguagem C, uma matriz de caracteres para armazenar strings nas suas linhas,
alocada estaticamente e uma alocada dinamicamente. Explique um caso em que a alocação
dinâmica é importante para economia de memória.
8. Explique o que é alocação e desalocação de memória em tempo de execução e quais funções
em C executam essas funcionalidades. Cite uma vantagem de se desalocar memória não mais
utilizada.
9. Crie uma funcão que insere um novo elemento em uma lista encadeada numa dada posição.
Considere que os argumentos da função são:
- Um apontador para a lista no qual o elemento será inserido.
- Um elemento de um tipo tInfo previamente definido.
- Um inteiro que indica a posição na qual ocorrerá a inserção.
Sugestão: verifique se a posição fornecida à função é válida.
10. Considere duas listas simplesmente encadeadas ”A”e ”B”contendo inteiros ordenados crescentemente.
Assim, pede-se para implementar uma função que retorne uma lista encadeada ordenada
formada pela intercalação ordenada dos elementos de ”A”e ”B”garantindo que a lista resultante
não possua valores repetidos. Considere que ”A”e ”B”também não possuem valores repetidos.
11. Implemente uma lista encadeada que armazene as informações sobre os DVDs de uma locadora.
Tais informações são o título do filme, o nome do diretor, os principais atores e o número de
cópias disponíveis na locadora. Apresente um menu e crie funções que atendam as seguintes
opções:
- Inserir um título na lista.
- Dado um título de filme, verificar se locadora possui em seu acervo.
- Dado um título de filme, verificar se há alguma cópia disponível.
- Dado um diretor, imprimir as informações sobre os filmes dirigidos por ele.
DRAFT
- Dado um ator, imprimir as informações sobre os filmes nos quais ele foi um dos atores
principais.
- Remover um título da lista.
12. Sabe-se que um texto é uma sequência de caracteres contendo apenas letras, espaços em branco
e sinais de pontuação. Uma palavra é definida como um segmento do texto que consiste apenas
de letras. Escreva uma função que recebe um texto do teclado e imprime uma relação de todas
as palavras que ocorrem no texto juntamente com o número de ocorrências de cada palavra.
7.10 Trabalhos Sugeridos
1. Notas de Alunos
O Colegiado de um curso de uma instituição de ensino mantém uma listagem com informações
sobre o desempenho de cada aluno do curso. Esta listagem contém as notas obtidas pelo aluno
em cada uma das disciplinas que ele cursou e é organizada da seguinte maneira:

206
CAPÍTULO 7. APONTADORES
Matrícula do Aluno Código da Disciplina Carga Horária Nota
00018 0001 60 4.5
11111 3232 30 8.7
00234 0500 75 9.0
00018 0001 60 7.0
... ... ... ...
09999 0786 60 7.5
Para facilitar a consulta a esta listagem, o coordenador do colegiado precisa de um programa
em C que realize algumas operações sobre os dados da lista. Ele te pediu para elaborar um
programa interativo que permita ao usuário:
(a) Ler os dados da listagem e colocá-los em quatro listas. O usuário deve poder incluir tantos
dados quanto quiser. A indicação de fim de entrada de dados é feita através de um aluno
de Matrícula 0 (zero).
(b) Mostrar as notas de um aluno numa disciplina. Lembre-se que o aluno pode ter cursado
mais de uma vez uma mesma disciplina por motivo de reprovação.
(c) Incluir uma nota de um aluno em uma disciplina.
(d) Retificar uma nota de um aluno em uma disciplina.
(e) Excluir uma nota de um aluno em uma disciplina.
(f) Excluir todos os dados de um aluno jubilado.
(g) Calcular o o coeficiente de rendimento (C.R.) de um aluno. O C.R. é calculado da seguinte
maneira:
(h) Identificar o aluno de melhor CR.
C.R. = (Σ (Carga Horária x Nota)) / (Σ (Carga Horária))
(i) Identificar os alunos com CR abaixo de 5.0.
Exemplo de Programa
Escolha Operação:
0 - Sair
1 - Ler dados
2 - Mostrar Notas
3 - Incluir Nota
4 - Corrigir Nota
5 - Excluir Nota
6 - Excluir Aluno
7 - CR de Aluno
8 - Melhor Aluno
9 - Maus Alunos
DRAFT
Opção: 1
Dados do aluno: 18 1 60 4.5
Dados do aluno: 1111 3232 30 8.7
Dados do aluno: 234 500 75 9.0
Dados do aluno: 18 1 60 7.0
... ... ...
Dados do aluno: 0 0 0 0.0
Opção: 2
Matrícula: 18

7.10. TRABALHOS SUGERIDOS 207
Disciplina: 1
Notas: 4.5 7.0
Opção: 3
Matrícula: 1111 Disciplina: 316
Carga Horária: 60
Nota: 7.0
Opção: 4
Matrícula: 1111 Disciplina: 316
Carga Horária: 60
Nota: 7.0
Nova Nota: 8.5
Opção: 5
Matrícula: 1111 Disciplina: 316
Nota: 7.0
Opção: 6
Matrícula: 234
Opção: 7
Matrícula: 1111
CR: 7.2
Opção: 8
Matrícula: 234
Opção: 9
Matrículas: 194
Opção: 10
Matrícula: 1111
Não cumpriu carga horária mínima.
... ... ...
Opção: 0
Até a próxima!
DRAFT
2. Controlador de Tráfego Aéreo
Descrição
Controle de Tráfego Aéreo é um serviço prestado por controladores, em terra, que guiam aeronaves
(geralmente aviões) no ar e no solo, para garantir um fluxo de tráfego seguro e ordenado.
Os controladores de tráfego áereo fornencem indicações e autorizações de vôo, de acordo com as
características operacionais das aeronaves e as condições de tráfego em determinado momento.
Estas autorizações podem incidir sobre a rota, altitude e/ou velocidade propostas pelo operador

208
CAPÍTULO 7. APONTADORES
da aeronave para determinado voo, devendo os pilotos cumprir as instruções recebidas.
Espaço Aéreo
Em muitos países, os serviços de tráfego aéreo são prestados em toda a extensão do espaço aéreo
e estes serviços são utilizados por todos os usuários (aeronaves privadas, militares e comerciais).
Os espaços aéreos onde o controlador é responsável por prover separação entre as aeronaves são
chamados de espaços áereos controlados em oposição aos espaços áereos não controlados
nos quais pilotos das aeronaves são responsáveis por manter a separação entre a sua aeronave e
outras. Dependendo do tipo de voo e de classe do espaço aéreo, o controlador de tráfego aéreo
pode emitir instruções que os pilotos devem seguir ou apenas informações de vôo para ajudar os
pilotos operando no espaço aéreo. Em todos os casos, entretanto, o piloto tem a responsabilidade
final pela segurança da aeronave, e pode não cumprir as instruções numa emergência.
Os serviços de controle de tráfego aéreo incluem o controle de rotas das aeronaves que estão no
espaço áereo do aeroporto, o controle da autorização de pousos e decolagens e o controle das
pistas de táxi-aéreo e pátios.
O Trabalho
O trabalho consiste em implementar um programa que faça o controle dos pousos em um aeroporto
que apresente três portões de embarque e desembarque (A,B,C). O trabalho deve ser feito
em dois módulos: controle de espaços aéreos e controle de pista, e a estrutura para armazenamento
dos dados deve ser uma lista encadeada dinâmica.
ˆ
ˆ
Controle de espaço aéreo
Como o controle da torre consiste em controlar as aeronaves enquanto elas estiverem no
espaço aéreo do aeroporto, pode-se dividir essa tarefa em duas subtarefas:
Controle de rotas
A partir do momento em que as aeronaves entram no espaço aéreo do aeroporto, o controle
das suas rotas deverá ser realizado pelo seu programa. Para isso considere que a função
básica do seu programa é impedir que ocorram colisões, e para isso uma das aeronaves
em risco deverá ser redirecionada para a rota mais próxima a uma das rotas envolvidas.
Existem duas ocoasiões em que ocorrerão colisões: se duas aeronaves estiverem utilizando
a mesma rota ou se duas aeronaves estiverem utilizando rotas que apresentem intersecção.
Considere que duas rotas apresentam intersecção se uma delas é múltipla da outra.
DRAFT
Controle de aproximação
Dado que o controle de rotas já foi realizado será necessário definir qual será a ordem das
aeronaves a pousar. Para isso deverá ser considerada a sequência de prioridades abaixo:
CLASSE > ALTITUDE > VELOCIDADE
Assim, define-se que existem apenas duas classes (militar e comercial) e que duas altitudes
são consideradas iguais se a diferença entre elas for menor que 2000 pés. Além disso, a
classe militar tem prioridade frente a classe comercial; quanto menor a altitude de uma
aeronave maior será a sua prioridade e quanto maior a velocidade de uma aeronave maior
será a sua prioridade. Considere que cada operação de pouso dura 5 minutos.
Controle de pista
Após o pouso de uma aeronave é necessário que o tráfego em solo também seja controlado.
Com isso, a segunda parte do trabalho consistirá em controlar o momento em que cada

7.10. TRABALHOS SUGERIDOS 209
aeronave deverá encostar em uma plataforma que está livre. Caso todas as três plataformas
estejam ocupadas no momento em que uma aeronave pouse, esta deverá esperar no pátio
de espera até que alguma das plataformas seja desocupada. Considere que cada operação
de desembarque dure 30 minutos.
Especificação
Módulo 1
Essa primeira parte do trabalho consiste em determinar a fila de aeronaves que irão pousar e
as novas rotas das aeronaves que precisam mudar de rota. Para isso, considere que quando
duas aeronaves apresentarem chance de colisão a aeronave que apresentar número de rota maior
deverá ser redirecionada para uma rota com número igual ao primeiro número primo maior que
a rota de maior número.
Módulo 2
A segunda parte consiste em determinar a que horas a operação de desembarque de cada aeronave
foi realizada.
Entrada
As informações referente às aeronaves serão fornecidas através do teclado. As informações serão
as seguites: identificação da aeronave (0103, 0407, 1114,...); número inteiro que servirá para
indentificar qual rota que a aeronave está percorrendo (1, 2, 4, 6,...); classe da aeronave (”comercial”ou
”militar”); altitude na qual a aeronave se encontra no momento em que entra no
espaço aéreo do aeroporto (7700, 9060, 1120, ...); velocidade com qual a aeronave está (650, 680,
810, ...) e a hora de entrada da aeronave no espaço áereo do aeroporto (14:30, 14:29, 14:31, ...).
Considere que a hora apresentará o caracter ”:”para separar hora de minuto.
Obs.: As horas de entrada no espaço aéreo do aeroporto são muito próximas, com
diferença entre o menor e o maior horário de no máximo 5 minutos. Cada nova
aeronave deve ser adicionada na lista já na ordem de prioridade de pouso, do mais
para o menos prioritário. Assim, após todas as inserções, as colisões devem ser
verificadas, aeronave por aeronave, na sequência de pouso obtida.
Exemplo:
0103
2
militar
7100
670
14:30
DRAFT
0307
10
comercial
8200
770
14:29

210
CAPÍTULO 7. APONTADORES
0200
13
militar
1000
710
14:30
0708
10
comercial
8600
640
14:29
1102
4
militar
9100
700
14:30
Saída
Os dados de saída do programa devem ser exibidos no console. O formato da saída deve seguir
o exemplo abaixo.
Exemplo:
0200
13
15:00
0103
2
15:05
1102
17
15:10
0307
19
15:30
0708
23
15:35
DRAFT

Capítulo 8
Arquivos
Objetivos:
ˆ
ˆ
ˆ
ˆ
ˆ
Definir o conceito de arquivos;
Definir e diferenciar variáveis transientes e variáveis persistentes;
Definir e diferenciar arquivos de texto e arquivos binários;
Mostrar algumas operações que podem ser feitas com arquivos;
Mostrar outras funções e exemplos de programas que usam arquivos;
Coautores:
Ebenézer Nogueira
Estefhan Wandekokem
Marcos Couto
Este capítulo tem por objetivo apresentar o conceito de arquivos. Os arquivos são a forma fundamental
de armazenamento de informação na memória não volátil do computador. Ou seja, dados
armazenados em arquivos persistem salvos no computador mesmo que o programa do qual se originaram
seja finalizado ou, até mesmo, que o computador seja desligado. Aqui serão estudados os tipos
de arquivos e as operações que podem ser realizadas sobre eles.
8.1 Variáveis Transientes X Variáveis Persistentes
Quando os programas são executados, eles lidam com variáveis. Elas são a forma abstrata pela qual os
programadores enxergam os dados que seus programas manipulam. Internamente, variáveis indicam
células de memória.
A memória principal de um computador (muitas vezes chamada de memória RAM) é o local onde
os programas em execução e as variáveis que eles utilizam são armazenados. As variáveis armazenadas
na memória principal são chamadas de variáveis transientes porque seu tempo de existência é limitado
pelo tempo que o programa está em funcionamento. Assim que o usuário ou o sistema operacional
decidir que o programa deve ser finalizado, todas as variáveis deixarão de existir.
Os computadores teriam sua utilidade muito reduzida se a informação só pudesse ser armazenada
enquanto os programas estivessem na memória principal (e a máquina, ligada). Para resolver esse
problema, existem as variáveis persistentes, as quais têm seu conteúdo armazenado, e possível de
ser acessado, independentemente do programa que as criou estar na memória principal. Variáveis
persistentes devem ser armazenadas em algum dispositivo de memória secundária, como discos rígidos,
CDs, memória flash e DVDs, os quais tem a capacidade de manter por um longo tempo o valor da
informação neles contida, independente do conteúdo da memória principal do computador, ou mesmo
de ele estar ligado. Deve-se ressaltar que o tempo de acesso e de gravação das variáveis armazenadas
em meio secundário é muito maior que o das variáveis armazenadas na memória principal, por isso
essa última é tão importante.
DRAFT
211

212
CAPÍTULO 8. ARQUIVOS
O conceito por trás das variáveis persistentes é o de arquivo, e esse será o tema desse capítulo.
Por meio de arquivos, essas variáveis podem ser armazenadas e as informações que elas guardam,
acessadas e processadas no futuro, tanto pelo programa que as criou quanto por outros programas.
8.2 Tipos de Arquivos
Os arquivos podem ser classificados em dois tipos: arquivos texto e arquivos binários. Ambos têm a
mesma finalidade: armazenar variáveis persistentes. Quando o programador cria um arquivo em seu
programa, ele deve indicar a qual tipo ele pertencerá. Essa escolha determinará como o arquivo deve
ser tratado, quais funções usar e como os dados devem ser interpretados por elas durante a leitura ou
a escrita.
8.2.1 Tipos de Arquivos - Arquivos Texto
Um arquivo texto é uma sequência de caracteres. Se um arquivo texto for aberto num editor de texto
convencional, o usuário poderá ler seu conteúdo (ou ao menos ver os caracteres lá contidos), e poderá
até mesmo modificá-lo de uma forma que faça sentido.
Por exemplo, na linguagem C, tome uma variável int que guarde o numero 43. Uma forma de
escrever essa variável num arquivo texto seria gravar “43”, mas note que, com isso, dois caracteres
foram gravados: o ‘4’ seguido do ‘3’. Isso poderia significar, por exemplo, para um arquivo numa
arquitetura que salve caracteres como variáveis de 1 byte, que dois bytes foram gravados no arquivo,
o primeiro armazenando o caractere ‘4’ e o segundo armazenando o caractere ‘3’. A Figura 8.1 mostra
um exemplo de arquivo texto.
Figura 8.1: Exemplo de um arquivo texto.
DRAFT
8.2.2 Tipos de Arquivos - Arquivos Binários
Por meio de um arquivo binário, as variáveis armazenadas na memória principal podem ter seus bytes
armazenados num arquivo físico, sem tradução para caracteres e com correspondência de um para
um. Isso significa que, usando-se arquivos binários, torna-se possível criar um “espelho” da memória
principal na memória secundária.
A fim de exemplificar esse conceito na linguagem C, será citada a gravação de uma struct. Essa é
uma das razões pela qual arquivos binários são tão úteis nessa linguagem. Já foi estudado que uma
struct é um tipo especial de variável que armazena outras variáveis. No Exemplo 8.1 define-se uma
struct com informações básicas de uma pessoa.
1 struct pessoa {
2 char nome [50];
3 int idade ;
4 float salario ;
5 }
Exemplo 8.1: Exemplo de struct.

8.3.
DEFINIÇÃO DE ARQUIVOS 213
Como guardar essa informação em um arquivo? Pode-se guardá-la num arquivo texto, escrevendose
o nome da pessoa, então sua idade e finalmente seu salário. Sabendo o formato como essa informação
foi escrita, o programador pode criar um programa que a lê.
De modo alternativo, pode-se armazená-la num arquivo binário. A struct será tratada como uma
única variável e uma cópia dela será armazenada no arquivo ou lida do arquivo para a memória,
dependendo da operação desejada. Isso é possível, pois se sabe o formato como essa struct foi armazenada
no arquivo binário. Esse formato poderia ser, para uma arquitetura de 32 bits de palavra, na
linguagem C, de 50 bytes que armazenam cada uma das variáveis char, mais 32 bits (4 bytes) que
armazenam uma variável int, e mais 32 bits (4 bytes) que armazenam uma variável float.
Observe que, se não houver bons motivos para usar arquivos texto é mais interessante usar arquivos
binários. Se optar pela utilização de arquivos texto o programador deverá trabalhar apenas uma das
variáveis de cada vez. Outro problema a ser tratado, como no exemplo de armazenar a variável inteira
de valor 43, o valor deverá ser traduzido em uma string para ser armazenado e traduzido de volta
para o tipo desejado após ser lido. O armazenamento binário simplifica o processo permitindo que
você leia toda uma struct de uma vez com os tipos das variáveis originais. A Figura 8.2 mostra um
exemplo de arquivo binário.
8.3 Definição de arquivos
Figura 8.2: Exemplo de um arquivo binário.
Para serem utilizados nos programas, os arquivos são tratados como variáveis. Então, como todas as
outras variáveis, eles devem ser declarados. Dessa forma, também podem ser usados como argumentos
para funções.
Para lidar com arquivos, existem funções responsáveis por realizar todas as operações necessárias.
Por exemplo, criar um novo arquivo em branco, excluir um já existente, gravar informação ou ler as
já contidas num arquivo, dentre outras.
Na linguagem C, o tipo FILE, definido na biblioteca stdio.h, é usado para se tratar arquivos. Um
apontador para FILE deve ser declarado sempre que uma variável arquivo for utilizada no programa.
Por exemplo, o comando do Exemplo 8.2 declara uma variável do tipo apontador para arquivo denominada
arq:
1 FILE * arq ;
DRAFT
Exemplo 8.2: Declaração de um apontador para FILE.
Os apontadores para FILE não fazem referência ao arquivo físico em si, mas a uma região de
memória principal que possui as informações necessárias para leitura e escrita no arquivo. Isso implica
que não é possível manipular o arquivo diretamente, por exemplo, abrir um arquivo e tentar armazenar
o conteúdo do apontador FILE* em outro arquivo. Para copiar um arquivo deve-se ler seu conteúdo e
depois armazená-lo em outro arquivo como será visto mais adiante. De qualquer forma, o programador
deve abstrair esses conceitos e usar a variável FILE* declarada. Ele associará um arquivo físico a ela,
e então a usará como argumento para as funções que operam sobre arquivos.

214
CAPÍTULO 8. ARQUIVOS
8.4 Operações sobre arquivos
Arquivos demandam algumas operações como abertura e fechamento. Os valores já armazenados nos
arquivos devem poder ser lidos, e novos valores devem poder ser escritos, para que tenham utilidade.
As operações que realizam essas tarefas são fornecidas pela linguagem de programação em vários
formatos.
8.4.1 Abertura
Após a declaração de uma variável do tipo arquivo, essa deve ser associada a um nome de arquivo, o
qual identifica um arquivo de fato, com correspondência na memória secundária.
Se o arquivo com o nome especificado já existir, então o programador terá acesso a seu conteúdo,
e poderá lê-lo e alterá-lo. Mas um nome de arquivo que ainda não existe também pode ser utilizado.
Nesse caso, um novo arquivo, “em branco”, com o nome especificado, será criado. Esses detalhes são
resolvidos passando-se as informações corretas à função responsável por abrir o arquivo.
Na linguagem C, essa função é a fopen. Seu protótipo é mostrado no Exemplo 8.3.
1 FILE * fopen ( const char * nomearq , const char * modo );
Exemplo 8.3: Protótipo da função para abertura de arquivos.
A função retorna um apontador para FILE, que deverá ser recebido pela variável usada para manipular
o arquivo. O primeiro argumento de fopen, nomearq, é uma string, e refere-se ao nome do
arquivo que será aberto. O segundo argumento, modo, também uma string, é um código passado a
fopen, responsável por indicar que tipo de arquivo e operação será realizada sobre esse arquivo. Os
códigos são descritos na Tabela 8.1:
Parâmetro
Efeito
r
Abre um arquivo-texto para leitura
w
Cria um arquivo-texto para escrita
a
Abre um arquivo-texto para gravar ao fim dele
r+ Abre um arquivo-texto para leitura/escrita
w+ Cria um arquivo-texto para leitura/escrita
a+ Abre ou cria (se não existir) um arquivo-texto para ler dele ou gravar ao fim dele
rb
Abre um arquivo binário para leitura
wb
Cria um arquivo binário para escrita
ab
Abre um arquivo binário para gravar ao fim dele
r+b
Abre um arquivo binário para leitura/escrita
w+b
Cria um arquivo binário para leitura/escrita
a+b
Abre ou cria um arquivo binário para gravar ao fim dele
DRAFT
No Exemplo 8.4 serão criados dois arquivos: o arquivo texto somente escrita.txt, que não existia
antes da execução de fopen, e que será usado somente para gravação de informação (no caso, caracteres);
e leio e escrevo.meu, binário, no qual as informações poderão ser lidas e escritas. Note como
as variáveis FILE* são declaradas, inicialmente, e depois recebem o retorno da função fopen.
1 FILE * arq_ex1 , * arq_ex2 ;
2
3 arq_ex1 = fopen (" somente_escrita . txt ", "w");
4 arq_ex2 = fopen (" leio_e_escrevo . meu ", "a+b");
Exemplo 8.4: Abertura de arquivo
Um ponto importante a ser ressaltado sobre a função fopen é a avaliação de seu valor de retorno.
Muitas vezes ocorrem erros na abertura de um arquivo, como, por exemplo, passar para fopen o

8.4.
OPERAÇÕES SOBRE ARQUIVOS 215
código “r”e o arquivo com o nome especificado não existir no disco. Esses erros podem ser detectados
porque a função fopen retornará NULL para indicar que houve falha na abertura de um arquivo.
No Exemplo 8.5, é declarada uma variável do tipo arquivo. Em seguida, é chamada fopen para
realizar a abertura de arquivo. Imediatamente depois, é verificado se ele foi aberto corretamente.
Se não foi, o usuário será notificado e o programa encerrado. Esse encerramento é feito com o uso
da função exit (definida na biblioteca stdlib.h), a qual finaliza o programa e retorna para o sistema
operacional o código numérico passado como argumento.
1 FILE * arq_ex3 ;
2
3 arq_ex3 = fopen (" alunos . txt ", "r");
4
5 if( arq_ex3 == NULL ){
6 printf (" Erro com a abertura de arquivo ! O programa sera finalizado ... ");
7 exit (1) ;
8 }
Exemplo 8.5: Abertura de arquivo com verificação de sucesso
Todas as vezes que fopen for usada deve-se verificar imediatamente se a abertura de arquivo
ocorreu sem problemas. Essa abordagem evitará muitos problemas posteriores.
Quando um arquivo é aberto, passa a estar associado a ele um indicador de posição, responsável
por indicar em qual ponto do arquivo novas informações são lidas ou gravadas. Esse indicador pode
ser imaginado como o cursor em um texto sendo editado em um editor de texto. De modo geral, no
momento em que um arquivo é aberto, esse indicador estará no começo do arquivo. Sempre que um
dado do arquivo é lido ou gravado, o indicador de posição se movimenta, ficando sempre à frente do
último dado lido ou gravado.
8.4.2 Fechamento
Quando um arquivo aberto não for mais utilizado em um programa, ele deve ser fechado. Esse
fechamento desassocia o arquivo físico, em disco (por exemplo), da variável do tipo arquivo usada
para abrí-lo. Um arquivo aberto pode ser fechado usando-se uma função que execute essa tarefa e que
o receba como argumento.
Na linguagem C, a função fclose é usada para fechar um arquivo. Seu protótipo é mostrado no
Exemplo 8.6.
1 int fclose ( FILE *fp);
DRAFT
Exemplo 8.6: Protótipo da função para fechamento de arquivos.
Ela retorna 0 se a operação de fechamento foi bem sucedida, e um número diferente de 0, caso
contrário. Ela recebe como parâmetro um apontador para FILE, o qual é o arquivo a ser fechado.
Caso se queira utilizar um arquivo depois que ele foi fechado, deve-se reabrí-lo novamente por meio
da função fopen.
Sempre que não houver mais utilidade em um arquivo, ele deve ser fechado. Como já dito, o
que está armazenado na variável FILE* é apenas informação sobre o arquivo. Quando é feita alguma
operação de leitura ou armazenamento, os dados necessários são armazenados em um buffer e o sistema
operacional se encarrega do resto, o que não necessáriamente ocorrerá no momento em que se faz a
requisição da operação. Quando fclose é chamada, qualquer informação que ainda esteja no buffer
será gravada no arquivo. Somente após isso o arquivo físico é finalmente desassociado da variável
FILE* usada. Ou seja, não fechar o arquivo corretamente pode corrompê-lo.

216
CAPÍTULO 8. ARQUIVOS
8.5 Operações sobre arquivos texto
Um arquivo texto armazena caracteres. Dessa forma, somente caracteres são lidos e gravados em um
arquivo-texto; algumas funções especiais existem, contudo, para que strings e números possam ser
lidos e gravados.
8.5.1 Leitura
A linguagem C fornece uma série de funções para leitura de informações em arquivos de texto. Serão
mostradas a seguir duas delas: fscanf e fgets.
fscanf()
A função fscanf funciona de forma semelhante à scanf, já estudada em capítulos anteriores. A diferença
está no fato de que fscanf trabalha com arquivos, e não com a entrada padrão (normalmente o teclado),
como é o caso de scanf. Seu protótipo é mostrado no Exemplo 8.7
1 int fscanf ( FILE *fp , const char * format , ... );
Exemplo 8.7: Protótipo da função para leitura em arquivos de texto.
A passagem de argumentos é semelhante à de scanf, com o acréscimo de que deve ser colocado como
primeiro argumento o apontador para FILE representando o arquivo do qual serão lidas as variáveis.
No formato comum de uso, fscanf, assim como scanf, encerra a leitura de uma string (ou seja,
argumento de código “%s”) assim que um caractere de espaço em branco, tabulação ou quebra de
linha é encontrado. Dessa forma, fscanf não é recomendada para a leitura de strings. C oferece outra
função para esse fim, que será estudada em seguida: fgets.
O Exemplo 8.8 mostra como a função fscanf pode ser usada para ler um inteiro, uma string (não
formada por espaços ou quebras de linha) e um float de um arquivo-texto. Note que é necessário o
uso de & antes da variável int e float, já que se deve passar o endereço delas a fscanf, e que isso não
é necessário com a variável string, como ocorre com no uso de scanf).
1 # include
2 # define NOME_ARQUIVO " meu_texto . txt "
3 # define TAM_STR 50
4
5 int main (){
6 int inteiro ;
7 float real ;
8 char str [ TAM_STR ];
9 FILE * arq ;
10
DRAFT
11 if (!( arq = fopen ( NOME_ARQUIVO , "r"))){
12 printf (" Erro na abertura de arquivo ! Abortando o programa ... ");
13 exit (1) ;
14 }
15
16 fscanf (arq , "%d\n%s\n%f", & inteiro , str , & real );
17
18 fclose ( arq );
19
20 return 0;
21 }
Exemplo 8.8: Uso de fscanf.
1 1145
2 segunda_linha
3 45.99

8.5.
OPERAÇÕES SOBRE ARQUIVOS TEXTO 217
Exemplo 8.9: Exemplo de arquivo de texto.
Dessa forma, um arquivo texto como o do Exemplo 8.9 caso lido com o código do Exemplo 8.8,
resultaria o valor 1145 na variável inteiro, “segunda linha” em str e 45.99 na variável real.
fgets()
Outra função de C utilizada para ler informações de um arquivo texto é fgets, que permite ler strings
completas. O Exemplo 8.10 mostra seu protótipo.
1 char * fgets ( char *str , int length , FILE *fp);
Exemplo 8.10: Protótipo da função para leitura em arquivos de texto.
Essa função lê os caracteres do arquivo fp, passado como argumento, e armazena-os na string str,
também passada como argumento, até que os length - 1 caracteres sejam lidos ou um caractere de
nova linha ’\n’ seja lido. Se um caractere de nova linha for lido, ele será armazenado em str. Já
quando a leitura de caracteres do arquivo finaliza, fgets encerrará a string str armazenando ‘\0’ no
próximo caractere (ou seja, finalizando a string).
1 primeira linha
2 segunda linha
Exemplo 8.11: Exemplo de arquivo de texto.
Dessa forma, um arquivo texto que contenha os seguintes caracteres: “primeira linha\nsegunda
linha”, tal como mostrado no Exemplo 8.11, pode ser lido usando-se duas chamadas a funções fgets.
Duas strings serão lidas e gravadas nas variáveis string: str1 conterá “primeira linha\n”, e str2 conterá
“segunda linha”. O Exemplo 8.12 mostra como isso pode ser feito.
1 char str1 [50];
2 char str2 [40];
3 FILE * arquivo ;
4
5 if (!( arquivo = fopen ( NOME_ARQUIVO , "r"))){
6 printf (" Erro na abertura de arquivo ! Abortando o programa ... ");
7 exit (1) ;
8 }
9
10 fgets (str1 , 50 , arquivo );
11 fgets (str2 , 40 , arquivo );
DRAFT
Exemplo 8.12: Uso de fgets.
Note que o tamanho máximo passado a fgets corresponde ao tamanho das strings definidas.
8.5.2 Escrita
A linguagem C oferece a função fprintf que pode ser usada para gravar em arquivos de texto.
fprintf()
A função fprintf é semelhante a printf. Seu protótipo pode ser visto no Exemplo 8.13.
1 int fprintf ( FILE *fp , const char * format , ... );
Exemplo 8.13: Protótipo da função para escrita em arquivos de texto.

218
CAPÍTULO 8. ARQUIVOS
A passagem de parâmetros é semelhante a de printf, com o acréscimo do primeiro argumento, o
apontador para FILE representando o arquivo no qual serão gravadas as informações.
O Exemplo 8.14 mostra o uso dessa função. Nesse programa, três variáveis, uma float, uma de
caracteres e uma string, são criadas e têm valores associados; então, o arquivo é aberto e elas são
gravadas.
1 # include
2 # include < stdlib .h>
3 # define NOME_ARQUIVO " meu_texto . txt "
4 # define TAM_STR 50
5
6 int main (){
7 float real = 547.32;
8 char carac = ‘T’;
9 char str [ TAM_STR ] = " teste para string ";
10 FILE * arq ;
11
12 if (!( arq = fopen ( NOME_ARQUIVO , "w"))){
13 printf (" Erro na abertura de arquivo ! Abortando o programa ...") ;
14 exit (1) ;
15 }
16
17 fprintf (arq , "%f\ nIsso e uma string constante \n%s\n%c\n", real , str , carac );
18
19 return 0;
20 }
1 547.32
Exemplo 8.14: Uso de fprintf.
A execução desse programa resultará num arquivo texto como o do Exemplo 8.15.
2 Isso e uma string constante
3 teste para string
4 T
Exemplo 8.15: Exemplo de arquivo de texto.
8.6 Operações sobre arquivos binários
Como já explicado, arquivos binários armazenam bytes que correspondem diretamente aos valores das
variáveis na memória principal (as variáveis transientes), e não somente armazenam caracteres, como
os arquivos de texto.
São muito úteis principalmente por serem usados para ler e escrever diretamente tipos definidos
pelo programador, como estruturas.
8.6.1 Leitura
DRAFT
A linguagem C possui a função fread que pode ser usada para ler um arquivo binário. O protótipo
da função fread é mostrado no Exemplo 8.16.
1 size_t fread ( void * buffer , size_t num_bytes , size_t count , FILE *fp);
Exemplo 8.16: Protótipo da função para leitura em arquivos binários.
O parâmetro buffer é um apontador para uma região de memória que receberá as variáveis lidas
do arquivo. O número de bytes a serem lidos é especificado por num bytes. O parâmetro count indica
quantas variáveis do tamanho num bytes deverão ser lidas com essa chamada da função fread. E fp
é um apontador para o arquivo de onde serão lidos os valores.

8.6.
OPERAÇÕES SOBRE ARQUIVOS BINÁRIOS 219
O tipo de retorno, size t, da função é definido no arquivo stdio.h. Esse retorno pode ser avaliado
para verificar se ocorreu algum erro, pois fread retornará a quantidade de itens lidos. Esse valor deve
ser igual a count; se não for, então o arquivo chegou ao final antes de ler a quantidade solicitada ou
ocorreu um erro.
O Exemplo 8.17 mostra a leitura de um inteiro, de um ponto flutuante e de um caractere de um
arquivo binário. Considere que o arquivo arq1 já foi aberto nesse trecho de código.
1 int inteiro ;
2 float real ;
3 char carac ;
4 /* ... */
5 fread (& inteiro , sizeof ( int ), 1, arq1 );
6 fread (& real , sizeof ( float ), 1, arq1 );
7 fread (& carac , sizeof ( char ), 1, arq1 );
Exemplo 8.17: Uso de fread.
Note que as três variáveis devem estar gravadas em seqüência no arquivo. Note também que buffer
é um apontador para as variáveis que armazenarão valores lidos do arquivo.
8.6.2 Escrita
Para se realizar a escrita de variáveis persistentes num arquivo binário, a linguagem C oferece a função
fwrite. O Exemplo 8.18 mostra o protótipo da função fwrite.
1 size_t fwrite ( void * buffer , size_t num_bytes , size_t count , FILE *fp);
Exemplo 8.18: Protótipo da função para escrita em arquivos binários.
Essa função se assemelha muito com fread. O parâmetro buffer é um apontador para a variável
que será escrita no arquivo. Já num bytes é usado para informar à função quantos bytes contém o tipo
da variável a ser escrita. count indica quantas variáveis (do tamanho de num bytes) serão escritas.
E, finalmente, fp é o apontador para FILE que indica em qual arquivo devem ser escritas as variáveis.
O Exemplo 8.19 mostra um programa completo que gera uma struct, a grava em um arquivo e
depois o fecha. Então, esse arquivo é reaberto e essa struct é lida (somente para exemplo, pois os
valores da struct ainda estavam corretos). Depois, esses dados lidos serão gravados em um arquivo
texto.
1 # include
2 # include < stdlib .h>
3
4 typedef struct {
5 char nome [50];
6 int idade ;
7 char sexo ;
8 } tPessoa ;
9
10 int main (){
11 FILE * arq ;
12 tPessoa p;
13
14 p. nome = " Marcia Maia ";
15 p. idade = 46;
16 p. sexo = ‘F’;
17
DRAFT
18 if (!( arq = fopen (" arquivo_bin . teste ", "wb "))){
19 printf (" Erro na abertura de arquivo ! Finalizando o programa ...") ;
20 exit (1) ;
21 }
22

220
CAPÍTULO 8. ARQUIVOS
23 fwrite (&p, sizeof ( tPessoa ), 1, arq );
24 fclose ( arq );
25
26 if (!( arq = fopen (" arquivo_bin . teste ", "rb "))){
27 printf (" Erro na abertura de arquivo ! Finalizando o programa ...") ;
28 exit (1) ;
29 }
30
31 fread (&p, sizeof ( tPessoa ), 1, arq );
32 fclose ( arq );
33
34 if (!( arq = fopen (" arquivo_texto . txt ", "w"))){
35 printf (" Erro na abertura de arquivo ! Finalizando o programa ...") ;
36 exit (1) ;
37 }
38
39 fprintf (arq , "%s\n%d\n%c\n", p.nome , p. idade , p. sexo );
40
41 fclose ( arq );
42
43 return 0;
44 }
Exemplo 8.19: Gravação e leitura de struct em arquivos.
Pode-se ver que, ao final da execução do programa, arquivo texto.txt conterá os dados da pessoa.
Estes dados poderão ser lidos assim que o arquivo for aberto por um editor de texto qualquer (fato
que não ocorre com o arquivo binário).
8.7 Outras funções úteis para arquivos
As seções anteriores mostraram as funções básicas para se trabalhar com arquivos em C. Porém, essas
funções não são suficientes para realizar todas as tarefas que arquivos permitem.
Serão apresentadas duas funções nessa seção: feof, usada para verificar se o indicador de posição
chegou ao final de um arquivo; e fseek, usada para posicionar o indicador de posição num local
específico do arquivo.
Os exemplos apresentados nessa seção serão de programas completos e mais complexos dos que os
anteriormente mostrados.
8.7.1 feof
DRAFT
Uma função essencial usada para trabalhar com arquivos é feof. Seu protótipo é visto no Exemplo
8.20.
1 int feof ( FILE *fp);
Exemplo 8.20: Protótipo da função feof.
Essa função retornará 0 se o arquivo fp passado como argumento ainda não chegou ao final. A
verificação se dá pelo indicador de posição no arquivo. Assim, a função feof é utilizada para verificar
quando um arquivo, tanto de texto quando binário, termina.
No Exemplo 8.21, considere que existe um arquivo previamente criado, binário, que armazena
muitas variáveis struct do tipo tFuncionario. O programa abre esse arquivo, lê todas as variáveis lá
presentes (uma quantia inicialmente desconhecida), e vai gravando-as num arquivo texto.
Note que esse programa usa o tipo tFuncionario como um TAD: existem funções para ler e escrever
os dados, eliminando a necessidade de se operar sobre as variáveis internas ao TAD.
Outra observação importante é sobre a passagem de um apontador para tFuncionario como
parâmetro da função leFuncionario. Isso serve para que se possa armazenar o dado de forma

8.7. OUTRAS FUNÇÕES ÚTEIS PARA ARQUIVOS 221
que ele não se perca ao final da execução da função. Com isso, o valor de retorno fica reservado para
tratamento de erros.
1 # include
2 # define ARQUIVO_LEITURA " binario "
3 # define ARQUIVO_ESCRITA " texto . txt "
4
5 typedef struct {
6 char nome [50];
7 char sexo ;
8 int idade ;
9 int matricula ;
10 float salario ;
11 } tFuncionario ;
12
13 int leFuncionario ( tFuncionario *func , FILE * arqbin );
14 void gravaFuncionario ( tFuncionario f, FILE * arqtex );
15
16 int main (){
17 FILE * arqbin , * arqtex ;
18 tFuncionario f;
19 int i;
20
21 /* Bloco de codigo r e s p o n s v e l pela correta abertura dos arquivos */
22 if (!( arqbin = fopen ( ARQUIVO_LEITURA , "rb")) ||
23 !( arqtex = fopen ( ARQUIVO_ESCRITA , "rb"))){
24 printf (" Erro na abertura de arquivos ! Abortando ...\ n");
25 exit (1) ;
26 }
27
28 /* Bloco de codigo que contem o loop while , que usa a f u n o feof para
29 ler o arquivo */
30 while (! feof ( arqbin )){
31 if( leFuncionario (&f, arqbin ) < 0){
32 printf (" Erro na leitura de funcionarios . Abortando ...\ n");
33 exit (1) ;
34 } else {
35 gravaFuncionario (f, arqtex );
36 }
37 }
38
39 return 0;
40 }
41
DRAFT
42 int leFuncionario ( tFuncionario *func , FILE * arqbin )
43 {
44 if (( fread (func , sizeof ( tFuncionario ), 1, arqbin )) != 1){
45 return -1;
46 }
47
48 return 0;
49 }
50
51 void gravaFuncionario ( tFuncionario f, FILE * arqtex )
52 {
53 fprintf ( arqtex , " Nome : %s\ nSexo : %c\ nIdade : %d\ nMatricula : %d\n
54 Salario : %f\n\n", f.nome , f.sexo , f. idade , f. matricula , f. salario );
55 }
Exemplo 8.21: Uso de feof e outras funções no TAD tFuncionario

222
CAPÍTULO 8. ARQUIVOS
8.7.2 fseek
Muitas vezes, deseja-se ter controle sobre o indicador de posição num arquivo. Ao se saber, por
exemplo, qual o índice de uma estrutura específica já gravada, do total de todas as estruturas que
fazem parte de um arquivo binário, pode-se buscar essa estrutura desejada sem ter de carregar para
a memória todas as outras. Isso pode ser feito posicionando-se o indicador de posição no arquivo e
lendo somente a próxima estrutura.
A função em C que permite fazer isso é fseek. Veja seu protótipo no Exemplo 8.22.
1 int fseek ( FILE *fp , long numbytes , int origin );
Exemplo 8.22: Protótipo da função fseek.
A função retornará 0 se for bem-sucedida; caso contrário, retornará um int diferente de 0. Seus
argumentos são: fp, um apontador para arquivo já aberto por fopen; numbytes, um número que
indica quantos bytes a partir do parâmetro origin estará o indicador de posição; e, finalmente, origin
será uma das três macros mostradas abaixo (que estão definidas no arquivo stdio.h):
Posição
Início do arquivo
Posição atual
Final do arquivo
Parâmetro
SEEK SET
SEEK CUR
SEEK END
O Exemplo 8.23 mostra como posicionar o indicador de posição duas variáveis int à frente da
posição inicial do arquivo arq, ou seja, pronto para ler a terceira variável int armazenada).
1 fseek (arq , 2 * sizeof ( int ), SEEK_SET );
Exemplo 8.23: Exemplo de utilização da função fseek.
O Exemplo 8.24 mostra a função obtemFuncionarioPosicao. Essa função é usada para ler
structs tFuncionario, contidas no arquivo binário definido, passando-se o índice do funcionário que se
deseja ler. Ela recebe um apontador para o arquivo binário de leitura, já aberto com fopen, de onde
tentará ler a struct de índice i, um parâmetro inteiro passado. Assim, se i=1, o retorno da função
será a primeira struct; se i=3, será a terceira; etc.
1 int obtemFuncionarioPosicao ( tFuncionario *func , int i, FILE * arqbin )
2 {
DRAFT
3 if( fseek ( arqbin , (i -1) * sizeof ( tFuncionario ), SEEK_SET )){
4 return -1;
5 }
6 if (( fread (func , sizeof ( tFuncionario ), 1, arqbin )) != 1){
7 return -1;
8 }
9
10 return 0;
11 }
Exemplo 8.24: Uso de fseek para posicionamento num arquivo binário
8.8 Exercícios Resolvidos
Exercício Resolvido 8.1 - Cópia de arquivos texto

8.8.
EXERCÍCIOS RESOLVIDOS 223
Escreva um programa em C que solicite ao usuário a digitação do nome de um arquivo texto já
existente, e que então gere um outro arquivo, que será uma cópia do primeiro.
Solução Possível:
A menor quantidade de memória que se pode alocar em C é um byte, portanto essa unidade
será usada no problema para que o arquivo copiado sempre seja dividido em um número inteiro de
segmentos.
O tipo de dados a ser utilizado para representar um byte é o char, observe que o tamanho do char
não está definido no padrão do C, mas nas implementações de compiladores mais comuns é esse o
tamanho adotado.
Uma das possíveis soluções é descrita pelo Pseudocódigo 8.1 e sua implementação pode ser vista
no Exemplo 8.25.
Pseudocódigo 8.1 Cópia de arquivo texto.
Descrição: Cópia de arquivo escolhido pelo usuário.
Dados de Entrada: Nome do arquivo fonte e nome do arquivo cópia.
Saída do Programa: Cópia do arquivo fonte com o nome desejado.
Funç~ao principal :
Pedir ao usuário que digite o nome do arquivo fonte .
Pedir ao usuário que digite o nome do arquivo cópia .
Abrir o arquivo fonte para leitura .
Abrir o arquivo cópia para escrita .
ENQUANTO n~ao for fim do arquivo fonte :
Ler caractere do arquivo fonte .
Gravar caractere no arquivo cópia .
FIM - ENQUANTO
Fechar arquivo fonte .
Fechar arquivo cópia .
FIM - Funç~ao principal
Ao inicio os arquivos são abertos com as permissões necessárias utilizando a função fopen. Para a
leitura e escrita foram utilizadas, respectivamente, as funções getchar e putchar que são capazes de
ler um char do arquivo. O funcionamento é bem simples: cada caractere, assim que lido do arquivo
fonte, deve ser armazenado no arquivo cópia mantendo a organização do arquivo original.
1 int main (){
2 char fonte [64] , copia [64];
3 FILE *fon , * cop ;
4
5 printf (" Digite o nome do arquivo fonte : ");
6 scanf ("%s", fonte );
7 printf (" Digite o nome do arquivo fonte : ");
8 scanf ("%s", copia );
9
DRAFT
10 if (!( fon = fopen ( fonte , "r"))) {
11 printf (" Impossivel abrir o arquivo . Finalizando ...\ n");
12 exit (1) ;
13 }
14
15 if (!( cop = fopen ( copia , "w"))) {
16 printf (" Impossivel abrir o arquivo . Finalizando ...\ n");
17 exit (1) ;
18 }
19
20 while (! feof ( fon )){
21 char c = getc ( fon );
22 putc (c, cop );
23 }

224
CAPÍTULO 8. ARQUIVOS
24
25 fclose ( fon );
26 fclose ( cop );
27 return 0;
28 }
Exemplo 8.25: Programa capaz de fazer uma cópia de um arquivo.
Exercício Resolvido 8.2 - Leitura e manipulação de dados em arquivo texto
Considere um arquivo texto que armazene números em ponto flutuante em cada uma de suas linhas.
Ou seja, o arquivo inicia com uma quantidade de um ou mais caracteres representando números
inteiros, então segue um caracter de ponto ’.’ e mais alguns inteiros; em seguida, uma quebra de linha;
na próxima linha esse formato prossegue, até que, no fim da última linha, não ocorre quebra de linha.
Escreva um programa em C que determine o valor mínimo, o valor máximo e a média desses valores
armazenados no arquivo. Imprima esses valores na tela.
Solução Possível:
Como no Exercício resolvido 8.1, este problema exige que os dados lidos sejam analisados assim que
lidos. A solução escolhida é descrita pelo Pseudocódigo 8.2 e sua implementação é vista no Exemplo
8.26.
Pseudocódigo 8.2 Leitura e manipulação de valores em ponto flutuante de um arquivo texto.
Descrição: Leitura de valores em ponto flutuante e calculo do mínimo, do máximo e da média deles.
Dados de Entrada: Arquivo texto com valores em ponto flutuante.
Saída do Programa: Valores mínimo, máximo e media dos valores.
Funç~ao principal :
Abrir arquivo texto .
Ler primeiro valor .
Atribuir o valor lido às variáveis mínimo , máximo e soma .
Atribuir o valor 1 a quantidade de valores lidos .
ENQUANTO n~ao for fim do arquivo :
Ler novo valor do arquivo .
Verificar se o valor é mínimo ou máximo :
SE o novo valor é maior que o máximo :
Atibuir novo valor a variável máximo .
FIM -SE
SE o novo valor for menor que o mínimo :
Atribuir novo valor à variável mínimo .
FIM -SE
Somar o novo valor à variável soma .
Incrementar a quantidade de valores lidos .
FIM - ENQUANTO
Fechar arquivo texto .
Calcular média a partir da variável soma e da quantidade de valores lidos .
FIM - Funç~ao principal
DRAFT
Neste problema a formatação do texto faz toda a diferença na hora da leitura do arquivo, por isso
foi utilizada a função fscanf que permite leitura formatada.
Observe que a primeira leitura é feita fora do loop principal e serve para inicializar as variáveis de
forma consistente para que o resto do código funcione corretamente.
Assim que um valor é lido, são feitos testes e cada variável é atualiazada conforme necessário.
1 # define ARQUIVO " arquivo . txt "

8.8.
EXERCÍCIOS RESOLVIDOS 225
2
3 int main (){
4 float val , min , max , soma ;
5 int n;
6 FILE * arq ;
7
8 if (!( arq = fopen ( ARQUIVO , "r"))) {
9 printf (" Impossivel abrir o arquivo . Finalizando ...\ n");
10 exit (1) ;
11 }
12
13 fscanf (arq , "%f", & val );
14 min = max = soma ;
15 n =1;
16
17 while (! feof (fp)){
18 fscanf (arq , "%f", & val );
19 if(val > max ){
20 max = val ;
21 }
22 else if(val < min ){
23 min = val ;
24 }
25 soma += val ;
26 n ++;
27 }
28
29 fclose ( arq );
30
31 printf (" Minimo : %f\ nMaximo : %f\ nMedia : %f\n", min , max , soma /n);
32 return 0;
33 }
Exemplo 8.26: Mínimo, máximo e média dos valores de um arquivo.
Exercício Resolvido 8.3 - Leitura e manipulação de dados em arquivo texto II
DRAFT
Escreva um programa que leia um arquivo texto contendo linhas de dados. Em cada linha do
arquivo há o nome de um aluno e duas notas. Esses dados estão separados por ponto e vírgula. Existe
um ponto e vírgula no final de cada linha. O programa deve ler esses dados e imprimir os valores
lidos, a média das duas notas, e se o aluno foi aprovado ou não (com nota maior ou igual a 5).
Solução Possível:
Com algumas semelhanças para os exercícios resolvidos anteriores, este problema exige que os
dados sejam tratados assim que lidos e ainda utiliza leitura formatada um pouco mais complexa.
O Pseudocódigo 8.3 esquematiza uma possível solução que é implementada no Exemplo 8.27.
Pseudocódigo 8.3 Leitura dos dados de alunos, cálculo da média de cada um e sua situação.
Descrição: Leitura de uma lista de alunos com suas notas, calculo da média das notas de cada um e sua
situação (aprovado ou reprovado).
Dados de Entrada: Arquivo texto formatado contendo a lista de alunos com suas notas.
Saída do Programa: Lista contendo cada aluno, suas notas, a média delas e a situação do aluno.
Funç~ao principal :
Abrir arquivo texto .
ENQUANTO n~ao for fim de arquivo :
Ler nome e duas notas do arquivo .

226
CAPÍTULO 8. ARQUIVOS
Calcular média das notas .
Apresentar na tela o nome , as duas notas e a média .
Testar se o aluno foi aprovado :
SE a média é maior ou igual a 5.0:
Apresentar na tela que o aluno foi aprovado .
SEN~AO:
Apresentar na tela que o aluno foi reprovado .
FIM - SE
FIM - ENQUANTO
Fechar arquivo .
FIM - Funç~ao principal
Como no Exercício resolvido 8.2, foi utilizada a função printf . Porém desta vez demonstrando
toda a versatilidade que esta função, tão importante, pode oferecer.
Não se pode esquecer que, para utilizar leitura ou escrita de arquivos, alguns passos devem ser
seguidos a risca: a declaração do apontador do tipo FILE, a abertura do arquivo com as permissões
corretas, a leitura ou escrita desejada e por último, muito importante mas muitas vezes esquecido, o
fechamento do arquivo.
1 # define ARQUIVO " arquivo . txt "
2
3 int main (){
4 char nome [64];
5 float nota1 , nota2 ;
6 FILE * arq ;
7
8 if (!( arq = fopen ( ARQUIVO , "r"))) {
9 printf (" Impossivel abrir o arquivo . Finalizando ...\ n");
10 exit (1) ;
11 }
12
13 while (! feof ( arq )){
14 fscanf (arq , "%s ,%f ,%f", nome , & nota1 , & nota2 );
15 media = ( nota1 + nota2 ) /2;
16 printf ("%s, %f, %f, %f, ", nome , nota1 , nota2 , media );
17 if( media >= 5.0) {
18 printf (" aprovado .\n");
19 } else {
20 printf (" reprovado .\n");
21 }
22 }
23
24 fclose ( arq );
25 return 0;
26 }
DRAFT
Exemplo 8.27: Leitura de dados de alunos de arquivo, calculo da média e verificação da situação de
cada um.
Exercício Resolvido 8.4 - Armazenamento de dados em arquivo binário
Escreva um programa em C que solicita ao usuário a digitação de um nome de arquivo. Esse arquivo
será criado e o usuário informará números em ponto flutuante, que serão gravados no arquivo. O
arquivo será um arquivo binário. O usuário pode encerrar a entrada de novos valores com a digitação
de um número negativo.
Solução Possível:

8.8.
EXERCÍCIOS RESOLVIDOS 227
Esse exercício resolvido difere dos outros pois são utilizados arquivos binários e não arquivos texto.
A idéia, que pode ser vista no Pseudocódigo 8.4 é que cada valor que o usuário utiliza como entrada
seja gravado no arquivo binário até que o programa encontre uma entrada negativa.
Veja a implementação no Exemplo 8.28.
Pseudocódigo 8.4 Armazenamento de dados em arquivo binário.
Descrição: Armazenamento de dados em ponto flutuante para arquivo binário.
Dados de Entrada: Nome do arquivo e valores em ponto flutuante.
Saída do Programa: Arquivo binário onde estão armazenados os valores escolhidos.
Funç~ao principal :
Pedir ao usuário que digite o nome do arquivo .
Abrir o arquivo binário com permiss~ao de escrita .
FAZER
Pedir ao usuário que digite um valor .
Testar se o usuário deseja encerrar a entrada :
SE o valor inserido é maior ou igual a zero :
Armazenar esse valor no arquivo .
FIM - SE
ENQUANTO o valor inserido é maior ou igual a zero .
Fechar arquivo binário .
FIM - Funç~ao principal
As principais diferenças do que foi mostrado nos exercícios resolvidos anteriores é o uso da função
fwrite, que serve para armazenar dados em binário.
1 int main (){
2 char nome [64];
3 float val ;
4 FILE * arq ;
5
6 if (!( arq = fopen ( ARQUIVO , "w"))) {
7 printf (" Impossivel abrir o arquivo . Finalizando ...\ n");
8 exit (1) ;
10
9 }
11 do{
12 printf (" Digite um valor : ");
13 scanf ("%f", & val );
14 if(val >= 0){
15 if( fwrite (& val , sizeof ( float ), 1, arq ) == 0){
16 printf (" I m p o s s v e l gravar no arquivo . Finalizando ...\ n");
17 exit (1) ;
18 }
19 }
20 } while ( val >= 0);
21
22 fclose ( arq );
23 return 0;
24 }
DRAFT
Exemplo 8.28: Armazenamento de dados em ponto flutuante em arquivo binário.
Exercício Resolvido 8.5 - Armazenamento dos dados de um TAD em arquivo binário
Escreva um programa em C que receba via teclado o nome de um arquivo binário. Esse arquivo
armazenará nome, idade e sexo de pessoas, como no TAD tPessoa. O programa deve solicitar ao

228
CAPÍTULO 8. ARQUIVOS
usuário a digitação desses dados e armazená-los no arquivo depois. O programa termina quando o
usuário digitar enter na entrada do nome, ou seja, informar um nome vazio.
Solução Possível:
Este exercício resolvido demonstra a utilização de escrita em arquivos binários para armazenamento
de dados mais complexos. Observe no Pseudocódigo 8.5 que os dados são encapsulados em um TAD
em seguida armazenados no arquivo. Isso pode ser feito facilmente, veja a implementação no Exemplo
8.29.
Pseudocódigo 8.5 Leitura e armazenamento de dados de pessoas em arquivo binário.
Descrição: Receber dados do usuário, inseri-los em um TAD e armazená-los em arquivo binário.
Dados de Entrada: O nome, idade e sexo de cada pessoa que se deseja inserir.
Saída do Programa: Arquivo binário com os dados armazenados.
Funç~ao principal :
Abrir o arquivo para escrita .
FAZER
Pedir ao usuário que digite um nome .
Testar se o usuário deseja encerrar a entrada :
SE o tamanho do nome for maior que zero :
Pedir ao usuário que digite a idade .
Pedir ao usuário que digite o sexo .
Encapsular dados em um TAD .
Armazenar dados no arquivo binário .
FIM -SE.
ENQUANTO o tamanho do nome for maior que zero .
Fechar o arquivo binário .
FIM - Funç~ao principal
Observe que, como no Exercício Resolvido 8.4, é utilizada a função fwrite sem grandes modificações.
mais uma vez, um exemplo que exibe a versatilidade das funções responsáveis pela entrada
e saída de dados da linguagem C.
Neste caso, há ainda um ponto que vale mencionar: ao se utilizar o scanf , esta função deixa
na stdin um caractere de salto de linha que não é lido. Esse caractere pode prejudicar a leitura do
próximo scanf , por isso o uso da função getchar nesse caso, ela é responsável por eliminar esse
caractere indesejado.
1 typedef struct {
2 char nome [64];
3 int idade ;
4 char sexo ; // M ou F
5 } tPessoa ;
6
7 int main (){
8 char arquivo [64];
9 tPessoa pessoa ;
10 int tam ;
11 FILE * arq ;
12
DRAFT
13 printf (" Digite o nome de um arquivo para escrita : ");
14 scanf ("%s", arquivo );
15 getchar ();
16
17 if (!( arq = fopen ( arquivo , "w"))) {
18 printf (" Impossivel abrir o arquivo . Finalizando ...\ n");
19 exit (1) ;
20 }
21
22 do{

8.9. RESUMO 229
23 printf (" Digite um nome : ");
24 scanf (" %[^\ n]", pessoa . nome );
25 getchar ();
26
27 tam = strlen ( pessoa . nome );
28 if(tam > 0){
29 printf (" Digite a idade : ");
30 scanf ("%d", & pessoa . idade );
31 getchar ();
32 printf (" Digite o sexo : ");
33 scanf ("%c", & pessoa . sexo );
34 getchar ();
35
36 if( fwrite (& pessoa , sizeof ( tPessoa ), 1, arq ) == 0){
37 printf (" I m p o s s v e l gravar no arquivo . Finalizando ...\ n");
38 exit (1) ;
39 }
40 }
41 } while ( tam > 0);
42
43 fclose ( arq );
44 return 0;
45 }
Exemplo 8.29: Leitura, encapsulamento e armazenamento em arquivo binário de dados do usuário.
8.9 Resumo
ˆ
ˆ
ˆ
ˆ
ˆ
Variáveis transientes são armazenadas na memória principal. Tem tempo de acesso rápido, mas
duração limitada. Só existem enquanto o programa que as está utilizando estiver na memória.
Variáveis persistentes não perdem suas informações quando o programa que as criou não está
mais em memória, pois estão armazenadas em meio secundário, tais como, disco rígido, memória
flash, CD.
Arquivos texto só armazenam caracteres, e são compreensíveis ao serem lidos em um editor de
texto. Já arquivos binários armazenam variáveis no formato em que elas são armazenadas em
memória;
Um arquivo deve ser aberto para poder ser utilizado, e após essa utilização, deve ser fechado;
As variáveis persistentes podem ser escritas e lidas dos arquivos. Existem funções específicas
para essas tarefas, algumas designadas para arquivos binários e outras para arquivos texto;
DRAFT
A linguagem C oferece uma série de funções para lidar com arquivos, e esse capítulo apresentou
algumas, como fopen, usada para abrir arquivos, e fread, usada para ler variáveis persistentes
de arquivos binários.
8.10 Exercícios Propostos
1. Escreva um programa em C que abra um arquivo texto e conte a quantidade de caracteres
armazenados nele. Imprima o número na tela. O programa deve solicitar ao usuário que digite
o nome do arquivo.
2. Considere o programa escrito para a questão anterior. Exiba na tela, agora, o valor n correspondente
à quantidade de números reais contidos no arquivo e o valor máximo, mínimo e a
média calculados anteriormente, porém agora divididos por n. Depois, gere um novo arquivo
que contenha cada um dos números reais do arquivo divididos por n, um por linha. Procure
reutilizar, nessa questão, o maior número possível das funções que você tenha construído para a
questão anterior.

230
CAPÍTULO 8. ARQUIVOS
3. Considere um arquivo texto que armazene caracteres variados, ou seja, um texto digitado. Escreva
um programa que o leia e gere um novo arquivo que contenha somente as letras do arquivo
original, na ordem em que lá aparecem (ou seja, caracteres de A-Z ou a-z).
4. Para um arquivo do mesmo tipo da Questão 3 (que armazene caracteres variados), escreva
um programa em C que determine a média dos comprimentos de todas as palavras que se
encontram nele. Entende-se por palavra um conjunto de caracteres de letras que está separado
de outros conjuntos de caracteres no arquivo por um (ou mais) caracteres de espaço em branco
( ’ ’, tabulações ou quebra de linha); e seu comprimento será a quantidade de caracteres que o
formam.
5. Considere um arquivo texto como o usado na Questão 3. Faça um programa que o leia e que
permita ao usuário consultar uma das linhas do arquivo, solicitando a ele que informe o índice
n dessa linha. O programa deve imprimir a linha especificada ou a mensagem de que ela não
existe.
6. Escreva um programa em C que receba via teclado o nome de um arquivo texto e uma palavra.
O programa deve apresentar todas as linhas que possuem essa palavra.
7. Escreva um programa em C que receba via teclado o nome de um arquivo texto. O programa
deve solicitar ao usuário que digite o índice da linha inicial e da linha final, e o programa deve
apresenta-las e todas as linhas entre elas. Se o índice superior de linhas não existe, esse erro
deve ser informado ao usuário (mas as linhas existentes devem, ainda, ser impressas).
8. Escreva um programa em C que receba o nome de um arquivo binário, o qual armazena números
em ponto flutuante, no mesmo formato que na questão anterior. O programa deve ler todos
esses valores e gravá-los na memória; então, ordená-los, e regravá-los num arquivo texto, com
um número por linha.
9. Escreva um programa em C que receba via teclado o nome do arquivo binário da questão anterior.
Então, ele deve abrir o arquivo. Deve existir um menu que ofereça ao usuário a possibilidade de
poder: 1) imprimir (na tela) todos os registros lá contidos; 2) acessar os dados de uma pessoa
passando o índice dela no arquivo (1 para a primeira pessoa no arquivo, 5 para a quinta pessoa no
arquivo...); 3) o programa deve informar a quantidade total de homens e mulheres armazenadas
no arquivo; 4) O programa deve permitir ao usuário digitar novas pessoas. Esses novos dados
digitados devem ser gravados no arquivo (e posteriormente descarregados da memória) somente
quando o usuário escolher, no menu, a opção para sair do programa.
8.11 Trabalhos Sugeridos
DRAFT
1. Registro de alunos e turmas dos cursos de uma Universidade
Faça um programa capaz de gerenciar os dados do catálogo de curso, turma e aluno de uma
universidade. O catálogo deve ser lido de um arquivo texto, no qual cada entrada representará
um curso, turma ou aluno da universidade. O formato de cada entrada é descrito abaixo e logo
em seguida um exemplo de catálogo.
Para um curso:
CURSO
Para uma turma:

8.11. TRABALHOS SUGERIDOS 231
TURMA
Para um aluno:
ALUNO
Exemplo:
CURSO
1256
Engenharia de computaç~ao
CURSO
9756
Medicina
TURMA
111
1256
2009
1
2
ALUNO
25
Ubirajara
111
9.56
DRAFT
Observe que cada aluno é vinculado a uma turma e cada turma é vinculada a um curso. Dessa
forma, uma turma não pode ser inscrita antes do curso ao qual ela é vinculada e um aluno não
pode ser inscrito antes que a turma a qual ele é vinculado seja inscrita.
Implemente seu programa usando listas ligadas. Ele deve ser capaz de exibir ao usuário um
menu que permita executar as seguintes operações:
(a) Apresentar dados de um curso dada sua identificação;
(b) Apresentar dados de uma turma dada sua identificação;
(c) Apresentar dados de um aluno dada sua identificação;
(d) Apresentar lista de alunos de um curso em ordem crescente de CRA;
(e) Apresentar lista de alunos de uma turma em ordem alfabética;
(f) Apresentar CRA médio de um curso;
(g) Apresentar CRA médio de uma turma;
(h) Apresentar lista de cursos em ordem decrescente de CRA médio;

232
CAPÍTULO 8. ARQUIVOS
(i) Inserção, exclusão e modificação dos dados de um curso, turma ou aluno;
(j) Ler o catálogo de um arquivo binário;
(k) Gravar o catálogo em um arquivo binário;
DRAFT

Referências Bibliográficas
[1] PAUL STRATHERN. Turing e o Computador em 90 Minutos. first edition, 2000.
[2] ANDREW S TANENBAUM and JAMES R GOODMAN. Structured Computer Organization.
fourth edition, 1999.
[3] BRIAN KERNIGHAN and DENNIS RITCHIE. The C Programming Language. second edition,
1988.
DRAFT
233