Introdução à Programação C

Introdução a Programação
"Apostila Principal"
Programação 2
Sônia Virginia Alves França
Recife, 2009
Universidade Federal Rural de Pernambuco
Reitor: Prof. Valmar Corrêa de Andrade

Vice-Reitor: Prof. Reginaldo Barros
Pró-Reitor de Administração: Prof. Francisco Fernando Ramos Carvalho
Pró-Reitor de Extensão: Prof. Paulo Donizeti Siepierski
Pró-Reitor de Pesquisa e Pós-Graduação: Prof. Fernando José Freire
Pró-Reitor de Planejamento: Prof. Rinaldo Luiz Caraciolo Ferreira
Pró-Reitora de Ensino de Graduação: Profª. Maria José de Sena
Coordenação Geral de Ensino a Distância: Profª Marizete Silva Santos
Produção Gráfica e Editorial

Capa e Editoração: Allyson Vila Nova, Rafael Lira, Italo Amorim e Glaydson da Silva
Revisão Ortográfica: Ivanda Martins
Ilustrações: Diego Almeida
Coordenação de Produção: Marizete Silva Santos
Sumário
Plano da Disciplina................................................................................5
Apresentação.........................................................................................9
Conhecendo o Volume 01...................................................................10
Capítulo 1 – Introdução ao C..............................................................13
1.1. Programas e Programação de Computadores...........................13
1.2. Linguagens de Programação......................................................15
1.3. Breve Histórico da Linguagem de Programação C....................18
1.4. Criação, Compilação e Execução de um Programa...................19
Capítulo 2 – Conceitos Preliminares para Programar em C............24
2.1. Estrutura de um Programa Básico em C....................................25
2.2. Palavras Reservadas do C.........................................................28
2.3 Uso de Comentários....................................................................29
2.4. Os Fundamentos do Ambiente C................................................31
2.5. Conhecendo o Dev-cpp..............................................................34
Capítulo 3 – Tipos de Dados, Variáveis e Constantes......................40
3.1. Tipos de dados...........................................................................40
3.2. Variáveis e Constantes...............................................................42
3.3. Operador de Atribuição (=).........................................................49

Capítulo 4 – Comandos de Entrada e Saída de Dados.....................54
4.1. Entrada de Dados.......................................................................54
4.2. Saída de Dados..........................................................................59
4.3. Erros Frequentes no Uso dos Comandos de Entrada e Saída..65
4.4. Primeiros programas em C.........................................................66
Capítulo 5 – Operadores, Expressões e Funções Matemáticas......75
5.1. Operadores Básicos...................................................................75
5.2. Operadores Aritméticos de Atribuição .......................................87
5.3. Operadores ++ e --.....................................................................87
5.4. Conversão de tipo.......................................................................88
5.5. Funções Matemáticas (biblioteca math.h)..................................90

Plano da Disciplina
Carga horária: 60h
Ementa da Disciplina
Introdução à linguagem de programação C. Tipos de dados, variáveis, operadores

aritméticos, relacionais e lógicos. Comandos de entrada e saída. Estruturas de
seleção e repetição. Modularização. Vetores e registros. Ponteiros. Arquivos.
Manipulação de caracteres. Comandos de tela. Comandos de manipulação de
data e hora.
Objetivos
Objetivo Geral
• Apresentar técnicas de programação estruturada utilizando como ferramenta a

linguagem de programação C
Objetivos Epecíficos
• Desenvolver a capacidade de solução de problemas de programação, com o uso

da linguagem C.
• Introduzir métodos de otimização para garantir eficiência e segurança aos

programas.
• Desenvolver o auto-aprendizado.
Conteúdo Programático
Módulo 1 - Introdução à Linguagem de Programação C
Carga Horária do Módulo 01: 15 h
Objetivo do Módulo 01: Introdução ao C e seus comandos básicos, para

possibilitar a construção dos primeiros programas nesta linguagem.
Conteúdo Programático do Módulo 1
• Introdução ao C
○ Conceito de programa e linguagem de programação
○ Introdução ao C: Um breve histórico
○ Etapas de desenvolvimento de um programa
• Comandos Básicos do C
○ Estrutura de um programa C
○ Diretivas de compilação
○ Uso de comentário
○ Tipos de dados
○ Variáveis, constantes, identificadores e atribuição
○ Comandos de entrada e saída
○ Operadores aritméticos, relacionais e lógicos
○ Modificadores de tipos de dados
○ Funções matemáticas
Módulo 2 – Estruturas de Controle de Fluxo e Modularização
Objetivo do Módulo 2: Possibilitar o conhecimento das estruturas de controle

(seleção e repetição) do C e métodos para modularização dos programas (criação
de procedimentos e funções).
Conteúdo Programático do Módulo 2:
• Estruturas de Controle de Fluxo
○ Sequência
○ Estrutura de seleção: If e Switch
○ Estrutura de repetição: for, do/while e while
○ Comando break
• Modularização
○ Construção de módulos: funções e procedimentos
○ Passagem de parâmetros e escopo de variáveis
○ Comando return
Módulo 3 – Armazenamento de Dados em Vetores, Registros e Arquivos
Carga horária do Módulo 03: 15 h
Objetivo do Módulo 03: Apresentar as formas de armazenamento de dados

homogêneos (vetores) e heterogêneos (registros), além dos comandos para
manipulação de arquivos.
• Tipos de Dados Homogêneos e Heterogêneos
○ Vetores
○ Registros
○ Vetor de registro
• Arquivos
○ Ponteiros
○ Comandos para manipulação de arquivo
Módulo 4 – Comandos Avançados
Objetivo do Módulo 4: Apresentar comandos mais avançados da linguagem

C, tais como: manipulação de caracteres, comandos de tela (para melhorias na
interface dos programas) e manipulação de data e hora.
• Comandos para Manipulação de Caracteres e Strings
○ Comandos da biblioteca ctype e string
○ Validação de campos
• Comandos de Tela – Interface
○ Comandos da biblioteca conio
• Comandos para Manipulação de data e hora
○ Comandos da biblioteca time
Avaliação
• Avaliação prática em laboratório correspondendo a 60% da nota.

• Resolução de listas de exercícios, que serão enviadas através do ambiente virtual
(30%).
• Avaliação referente à participação do aluno nas aulas presenciais e ambiente

virtual: fóruns de discussão, chats, etc (10%).
Bibliografia
Básica:
SCHILDT, Herbert. C Completo e Total. São Paulo: Makron, 1996.
DEITEL, H, M e DEITEL, P. J. Como Programar em C. Rio de Janeiro: LTC,

1999.
Complementar:
ASCENIO, Ana Fernanda Gomes e CAMPOS, Edilene Aparecida Veneruchi.

Fundamentos de Programação de Computadores. São Paulo: Prentice Hall,
2002.
Apresentação
Caro(a) aluno(a),
Seja bem-vindo (a) ao primeiro módulo da disciplina Programação II. Nesta disciplina,
você irá aprender a programar na linguagem de programação C, uma das mais utilizadas
mundialmente. Desenvolver programas e garantir que estes sejam confiáveis, eficientes
e agradáveis de usar requer conhecimento técnico e muito treinamento.
Este livro foi escrito pensando em você, que está iniciando neste mundo da
programação de computadores e que precisa ser apresentado, com tranquilidade, a um
conjunto de novos conceitos. Os assuntos serão transmitidos gradativamente, de forma
que você os absorva com naturalidade.
Este livro contém muitos exemplos de questões resolvidas, comentadas em

detalhes, para que você não encontre dificuldades para aprender cada assunto. Além
de apresentar dicas para que você desenvolva seus programas de forma eficiente e
não cometa os principais erros de programação que ocorrem com quem está iniciando
a programar. Ao final de cada capítulo, você poderá testar o seu aprendizado e assimilar
melhor o que foi estudado, através da resolução de exercícios. Isto é muito importante!
Não deixe de resolvê-los.
De antemão, informamos que programar é muito bom, você vai gostar! Nada melhor
do que ver um programa rodando e saber que foi você quem o criou. Mas, não desanime
se encontrar alguma dificuldade durante esta caminhada. Às vezes o programa dá
um erro e não sabemos onde está o problema. Seja persistente! Ao longo do tempo,
a experiência vai te dar mais segurança e você conseguirá encontrar tais erros com
facilidade.
O objetivo deste primeiro módulo é fazer uma introdução à linguagem C, conhecer

um pouco da sua história e iniciar o estudo da sintaxe da linguagem, que possibilitará
a construção de programas básicos. Ao final deste primeiro módulo, você já estará
desenvolvendo seus primeiros programas em C. O que você está esperando? Vamos
começar?
Bons estudos!
Professora Sônia Virginia Alves França

Programação 2
Conhecendo o Volume 01
Neste primeiro volume, você irá encontrar o módulo 01 da disciplina:

Programação II. Este volume está estruturado em cinco capítulos, que
serão estudados ao longo de 15h/aula. Para facilitar seus estudos,
veja a organização deste primeiro volume.
Capítulo 1: Introdução ao C
Carga Horária do Capítulo 1: 2 h/aula
Objetivos do Capítulo 1: Introduzir os conceitos básicos da

área de programação e apresentar um breve histórico sobre a
linguagem C.
Conteúdo Programático do Capítulo 1
• Conceito de programas e programação de computadores;
• Linguagens de programação;
• Breve histórico da linguagem de programação C;
• Etapas do desenvolvimento de um programa.
Capítulo 2: Conceitos Preliminares para Programar em C
Objetivos do Capítulo 2: Apresentar detalhes mais específicos

da linguagem, necessários para dar início à programação
em C. Neste capítulo, também será apresentado o ambiente
de programação que utilizaremos no desenvolvimento dos
programas.
• Estrutura de um programa básico C;
• Palavras reservadas do C;
• Uso de comentários;
• Fundamentos do ambiente C;
• Conhecendo o Dev-cpp.
10
Programação 2
Capítulo 3: Tipos de Dados, Variáveis e Constantes
Objetivos do Capítulo 3: Apresentar os tipos de dados

suportados pelo C e introduzir o conceito de variáveis e
constantes
• Tipos de dados;
• Variáveis e constantes;
• Operador de atribuição;
Capítulo 4: Comandos de Entrada e Saída de Dados
Objetivos do Capítulo 4: Apresentar os comandos de entrada

e saída de dados do C. Neste capítulo, você terá acumulado
conhecimento suficiente para desenvolver os primeiros
programas em C.
• Entrada de dados;
• Saída de dados;
• Desenvolvimento dos primeiros programas C.
Capítulo 5: Operadores, Expressões e Funções Matemáticas
Objetivos do Capítulo 5: Apresentar os operadores

básicos (aritméticos, relacionais e lógicos), além de funções
complementares para o desenvolvimento de programas que
executem expressões mais complexas.
• Operadores aritméticos, lógicos e relacionais;
• Operadores aritméticos de atribuição;
• Operadores ++ e --;
11
Programação 2
• Conversão de tipos;
• Funções matemáticas.
Ao final de cada capítulo você encontrará:
• A seção “Atividades e Orientações de Estudo”: que contém

exercícios para a fixação do assunto estudado, além de
indicação de fóruns de discussão.
• A seção “Conheça Mais”: que contém dicas de sites e livros

que devem ser lidos para ampliar os seus conhecimentos.
• A seção “Vamos Revisar?”: que apresenta um resumo dos

principais tópicos abordados no capítulo.
12
Programação 2
Capítulo 1 – Introdução ao C
Vamos conversar sobre o assunto?
Neste primeiro capítulo, será feita uma apresentação do que é

programação e quais as principais linguagens de programação do
mercado, dando ênfase à linguagem C. Este capítulo é importante,
porque conheceremos um pouco da história da linguagem de
programação que iremos aprender nesta disciplina. Sempre que
conhecemos uma pessoa nova, queremos saber alguns detalhes
da sua vida, não é mesmo? Quantos anos ela tem, onde nasceu,
quem são seus pais, etc. Neste capítulo, também, serão introduzidos
conceitos utilizados na área de programação, visando a nossa
preparação para nos lançarmos nesse mundo intrigante da criação de Saiba Mais
programas computacionais. Então, prontos (as) para o desafio? 1

Além dos
software
aplicativo e
1.1. Programas e Programação de software de
sistema, ainda é
Computadores possivel utilizar
a categoria
software
Um programa de computador é um conjunto de instruções que embutido ou
embarcado,
descrevem uma tarefa que será executada por um computador. destinado a
Um programa de computador também é conhecido como software, funcionar dentro
de uma máquina
software aplicativo, software de sistema ou simplesmente programa. que não é um
computador.
O termo software é mais utilizado quando é feita uma referência à Normalmente,
parte não física do sistema computacional, juntamente com o termo estes software
têm um
hardware, que faz referência ao conjunto de componentes eletrônicos propósito muito
específico, como,
que constituem um computador. por exemplo:
controlar a
Os programas que permitem ao usuário fazer uma ou mais tarefas injeção eletrônica
de um carro
específicas, como as planilhas eletrônicas, editores de texto e jogos ou gerenciar
o cozimento
são chamados de software aplicativo ou aplicação. Já os programas dos alimentos
que dão suporte funcional aos computadores, como os sistemas no forno de
microndas. Mais
operacionais e drivers de dispositivos, são chamados de software de recentemente,
surgiu também
sistema1. o software como
serviço, que é
O ato de desenvolver programas é chamado de programação um software que
roda diretamente
de computadores. A programação é o processo de escrita, teste na internet, não
e manutenção de um programa (ASCENIO e CAMPOS, 2002). sendo necessário
instalar nada no
O desenvolvimento de programas baseado em metodologias ou computador do
usuário.
processos formalizados é conhecido por engenharia de software.
13
Programação 2
Os programas são escritos em uma linguagem de programação.

Assim como o Português, o Inglês e o Espanhol, as linguagens
de programação têm as suas regras e devemos seguí-las para
escrever nossos programas corretamente. Portanto, a programação
de computadores é uma ciência e, por isso, devemos seguir uma
metodologia para termos como resultado: programas seguros e
eficientes.
Em uma disciplina anterior, vocês aprenderam a desenvolver

algoritmos, que são uma sequência de passos para realizar uma
tarefa ou resolver um problema. Utilizamos algoritmos no nosso
cotidiano para realizar atividades corriqueiras, definindo a sequência
de passos que deve ser executada para atingirmos um objetivo, como,
por exemplo, os passos que executamos para tomar banho, calibrar
um pneu ou fazer um bolo.
Figura 1.1: Exemplos de algoritmos
Para efetuarmos estas atividades, seguimos uma sequência

lógica de passos. Se esses passos não tiverem uma lógica, podemos
não conseguir atingir o nosso objetivo. Se vocês observarem, para
fazer um bolo, existe uma ordem em que os ingredientes devem ser
adicionados à receita, caso não sigamos esta ordem, o bolo não ficará
bom. Na programação irá ocorrer a mesma coisa, devemos passar as
instruções ao computador, utilizando uma linguagem de programação,
seguindo uma lógica – a lógica computacional.
Na próxima seção vamos abordar as linguagens de programação,

de uma forma mais abrangente, tratando os principais conceitos que
envolvem este assunto. Vamos seguir em frente?
14
Programação 2
1.2. Linguagens de Programação
É através das linguagens de programação que poderemos criar

nossos programas. Uma linguagem de programação é um conjunto de
regras sintáticas e semânticas usadas para definir um programa. O
conjunto de códigos (palavras e símbolos), compostos de acordo com
essas regras, constituem o código fonte do nosso programa. Para
ser executado pelo processador, o código fonte precisa ser traduzido
para código de máquina.
Aprender uma linguagem de programação é um pouco similar

a aprender um novo idioma. Temos que saber o significado das
palavras, as regras da estruturação das frases, etc., para podermos
nos comunicar corretamente no novo idioma.
Figura 1.2: Aprenda a dar ordens ao seu computador
Existem várias linguagens de programação. Vocês sabiam que

cada linguagem de programação possui o seu conjunto de regras e
um modo de funcionamento próprio? A escolha de uma linguagem
de programação para o desenvolvimento de um programa deve estar
atrelada ao tipo de problema que deseja resolver. Existem linguagens
15
Programação 2
que são melhores para resolver um certo tipo de questão do que

outras.
De acordo com Sebesta (2003), as linguagens de programação

vêm sendo classificadas de várias formas: por geração, de acordo com
o paradigma de programação, quanto ao grau de abstração, de acordo
com a estrutura de tipos, dentre outras. Uma das classificações mais
utilizadas é quanto ao grau de abstração. Segundo esta classificação,
as linguagens de programação são divididas em três grupos:
linguagens de máquina, linguagens de baixo nível e linguagens
de alto nível.
A linguagem de máquina é a linguagem natural dos computadores.

Estas linguagens são ininteligíveis para o ser humano não treinado.
As linguagens de máquina são representadas por sequências de
bits (zeros e uns). Estas sequências representam instruções que
serão executadas pelo processador do computador. As instruções
correspondem a sequências muito simples de operações, tais como:
transferir um dado em memória para a CPU ou somar dois valores. As
linguagens de máquina são dependentes do processador, isto é, uma
determinada linguagem de máquina só poderá usada por um tipo de
computador.
As linguagens de baixo nível são próximas da linguagem de

Saiba Mais máquina. No entanto, os zeros e uns que formam uma instrução
foram substituídos por palavras que representam tais instruções,
2
No contexto da
informática, a tornando-as um pouco mais legíveis. Estas linguagens são mais
portabilidade de
um programa é a
voltadas para a máquina, isto é, são escritas usando as instruções
sua capacidade do microprocessador do computador. São chamadas de linguagens
de ser compilado
ou executado Assembly (que significa montagem). Estas linguagens apresentam
em diferentes
arquiteturas (seja
as seguintes vantagens: os programas são executados com maior
de hardware ou velocidade de processamento (já que são executadas diretamente
de software).
pela máquina) e ocupam menos espaço na memória. No entanto, de
Esse termo modo geral, os programas em Assembly têm pouca portabilidade2 (um
também vem
sendo utilizado código gerado para um tipo de processador não serve para outro) e
pelas empresas não são estruturados, tornando a programação mais difícil.
de telefonia
móvel, quando
se referem à As linguagens de alto nível são mais próximas à linguagem
portabilidade
humana (do Inglês, por exemplo) e mais distantes das linguagens
de número, ou
seja, você muda de máquina. Por isso, são linguagens mais simples de entender, já
de operadora,
mas nao muda que, em geral, utilizam uma sintaxe estruturada, tornando seu código
o número do
mais legível. Necessitam de compiladores ou interpretadores
celular.
para gerar instruções do microprocessador. Interpretadores fazem
16
Programação 2
a interpretação de cada instrução do programa fonte executando-a

dentro de um ambiente de programação, Basic e Java são exemplos de
linguagens interpretadas. Os compiladores fazem a tradução de todas
as instruções do programa fonte gerando um programa executável.
Estes programas executáveis (*.exe) podem ser executados fora dos
ambientes de programação. A linguagem C e Pascal são exemplos de
linguagens compiladas.
As linguagens de alto nível ainda podem ser divididas de acordo com

a sua aplicação: genéricas (como C, Java e Pascal, que servem para
o desenvolvimento de programas de propósito geral) ou específicas
(como Fortran - utilizada para execução de cálculos matemáticos,
LISP - desenvolvimento de aplicações na área de inteligência artificial
e CLIPPER – utilizada para aplicações que manipulam bancos de
dados). As vantagens das linguagens de alto nível são: portabilidade
(por serem compiladas ou interpretadas podem ser executadas em
várias plataformas com pouquíssimas modificações) e facilidade de
desenvolvimento de programas. No entanto, as rotinas geradas são
mais genéricas (e mais complexas) e por isso são mais lentas e
ocupam mais memória.
A figura 1.3, a seguir, apresenta um trecho de código escrito em

linguagem de máquina, linguagem de baixo nível e linguagem de alto
nível, respectivamente.
Linguagem de Linguagem de Linguagem de Alto Nível

Máquina Baixo Nível
10110101 LOAD BASE

11100110 ADD BONUS Salario = Base + Bonus
11000100 STORE SALARIO
Figura 1.3: Trecho de código em diferentes linguagens
Notem como o código em linguagem de máquina é incompreensível.

Difícil entender essas seqüências de zeros e uns, não é mesmo?
O código na linguagem de baixo nível é mais legível e passamos
a entender as instruções. Na linguagem de alto nível, o código fica
menor e muito mais simples. Em qual tipo de linguagem vocês querem
programar? Nem precisamos parar para pensar, não é mesmo?
17
Programação 2
Figura 1.4: Linguagens de baixo nível x linguagens de alto nível
1.3. Breve Histórico da Linguagem de

Programação C
Vamos conhecer um pouco sobre a história do C? A linguagem

de programação C nasceu em 1972 nos laboratórios Bell, Estados
Unidos. Seus criadores são Brian Kernighan e Dennis M. Ritchie. A
Saiba Mais
linguagem C foi criada a partir da linguagem B (sugestivo, não é?),
3
Uma linguagem
que havia sido desenvolvida no final dos anos 60 por Ken Thompson.
é considerada
estruturada O C é uma linguagem de alto nível, compilada e estruturada3.
quando
permite que o No entanto, o C possui instruções de baixo nível, bem próximas à
programador linguagem de máquina, que só o Assembler possui. O objetivo dos
pegue trechos
de maior uso do seus criadores era usar o C para desenvolver o sistema operacional
seu programa e
transforme-os UNIX, que originalmente foi escrito em Assembly (linguagem de baixo
em pequenos nível). Desde então, espalhou-se por muitos outros sistemas e tornou-
módulos
(procedimentos se uma das linguagens de programação mais usadas, e influenciando
e funções) que
serão reutilizados o desenvolvimento de muitas outras linguagens como C++ e Java.
sempre que
necessário. Com a linguagem C podemos construir programas organizados
e concisos (características dos programas das linguagens de alto
18
Programação 2
nível), ocupando pouco espaço de memória e com alta velocidade

de execução (como o Assembler). Infelizmente, dada toda a
flexibilidade da linguagem, também poderemos escrever programas
desorganizados e difíceis de serem compreendidos. Portanto, cabe
ao programador de C utilizar boas práticas de programação, para ter
programas legíveis e de fácil manutenção.
Existem inúmeras razões para que o C seja uma das linguagens

mais preferidas dos programadores. As características da linguagem
C mostram o porquê de sua ampla aceitação. Vejamos algumas
características da linguagem C.
• Portabilidade entre máquinas e sistemas operacionais;
• Dados compostos em forma estruturada;
• Programas estruturados;
• Total interação com o sistema operacional;
• Código compacto e rápido, quando comparado ao código de

outras linguagens de alto nível.
Agora que já conhecemos um pouco mais da linguagem C, vamos

entender o processo de desenvolvimento de um programa. Quais são
os passos que devemos seguir para termos um programa pronto?
Vamos começar a falar sobre isto agora mesmo. Continuem firmes na
leitura!
1.4. Criação, Compilação e Execução de um

Programa
Nesta seção vamos estudar as etapas de desenvolvimento de um

programa em C. O desenvolvimento de um programa é dividido em
três etapas, como mostra a figura 1.5.
Figura 1.5: Estados do desenvolvimento de um programa em C
A primeira etapa para o desenvolvimento de um programa em C é
19
Programação 2
a criação do programa fonte, que consiste no “texto” formado pelo

conjunto de comandos que nós desejamos que o computador execute.
O programa fonte deve ser escrito respeitando as regras da linguagem.
De modo geral, os programas fontes são digitados em editores de
texto genéricos ou específicos dos ambientes de programação. No
próximo capítulo deste volume, vamos conhecer detalhadamente o
ambiente de programação que será utilizado para o desenvolvimento
dos nossos programas em C.
Com o programa fonte pronto, passamos para a etapa de

compilação. O compilador é um programa que verifica se o
programa fonte não apresenta nenhum erro de sintaxe e gera o
programa executável. Quando o programa fonte apresenta algum
problema, dizemos que ocorreu um “erro de compilação”. Assim, o
programador deverá avaliar o programa fonte, para a retirada tais
erros. Normalmente, os compiladores indicam os prováveis erros de
sintaxe cometidos pelo programador. Se o programa não tiver erros
de sintaxe, o compilador irá gerar o programa executável.
A etapa final consiste na execução do programa executável.

Neste momento, o programador deverá testar se o programa
Saiba Mais
está produzindo os resultados esperados. Quando o programa
4
Bug é um erro apresenta algum erro nesta fase, como, por exemplo, mostrar um
no funcionamento resultado incorreto, dizemos que ocorreu um “erro de lógica” ou
de um programa.
É também “erro de execução”. Isso ocorre porque, apesar do programa não
chamado de
erro de lógica, ter apresentado erros de sintaxe, o que tornou possível a geração
e pode causar do programa executável, a sequência de comandos não foi definida
discrepâncias
no objetivo ou de forma correta. Quando ocorre um erro de lógica, o programador
impossibilidade
de utilização de deverá revisar o seu programa fonte e passá-lo novamente pela fase
um programa de de compilação, para que um novo executável, sem erros, seja gerado.
computador.
O uso do Como o compilador não nos avisa onde estão os erros de lógica, estes
termo bug
para descrever são mais difíceis de serem corrigidos.
defeitos
inexplicáveis foi Após ter certeza que o programa executável está correto, sem
parte do jargão da
engenharia por erros de lógica, o programador poderá entregá-lo ao seu cliente. É
várias décadas. importante fazermos vários testes nos nossos programas. Testar com
Acredita-se que o
termo foi criado vários valores e verificar se está realmente tudo como esperado. Não
por Thomas
Edison quando fica bem nosso cliente ficar ligando, dizendo que o programa está com
um inseto (bug, BUG!4 Lembrem-se sempre, o computador só executa as instruções
em Inglês) causou
problemas de que nós mandarmos. Se houver erros, a responsabilidade será nossa
leitura em seu
fonógrafo em que não fizemos o programa corretamente! Vocês não vão querer
1878. passar por uma situação como essa? Vão?
20
Programação 2
Nesta fase de execução do programa executável, nós também

devemos verificar a usabilidade do programa, ou seja, se o programa
ficou fácil de ser utilizado pelo seu usuário. Quando o programa é de
difícil utilização ou confunde o usuário, induzindo-o ao erro, ele perde
o interesse em utilizá-lo ou comprá-lo. Também devemos verificar se
nosso programa tem um bom desempenho, ou seja, se ele processa
rapidamente as operações. Usuário não gosta de programa lento, não
é mesmo?
Atividades e Orientações de Estudo
Agora é o momento de analisarmos se os assuntos abordados

neste capítulo foram bem absorvidos. Foram vistos muitos conceitos
novos, não é mesmo? Vamos responder as questões a seguir. Caso
sintam necessidade, releiam alguma seção que não foi muito bem
assimilada ou complementem as respostas com a leitura dos sites
indicados na próxima seção. Vocês estão preparados(as)?
1. Para que serve uma linguagem de programação?
2. Quais as desvantagens das linguagens de baixo nível?
3. Por que desejamos programas portáveis?
4. O que motivou a criação da linguagem C?
5. A linguagem C é de baixo ou alto nível?
6. A linguagem C é compilada ou interpretada?
7. Por que os erros de lógica são mais difíceis de serem

corrigidos?
8. Por que devemos nos preocupar com a usabilidade dos nossos

programas?
Conheça Mais
Para ampliar os seus conhecimentos sobre os assuntos

tratados neste capítulo, visite o site da OReilly. Neste endereço,
21
Programação 2
http://oreilly.com/pub/a/oreilly/news/languageposter_0504.html,
foi disponibilizado um pôster, muitíssimo interessante, como uma
“árvore genealógica” das principais linguagens de programação dos
últimos 50 anos. Vale a pena dar uma olhada.
É muito importante que vocês se cadastrem em algum fórum de

discussão sobre a linguagem C. Assim, vocês poderão conversar e
trocar idéias com programadores de C mais experientes. Exemplos
de fóruns de C: DevMedia e Linha de código.
Vamos revisar?
Vamos dar uma reforçada em nosso aprendizado com esta

pequena revisão dos principais conceitos apresentados neste capítulo.
Observem o resumo a seguir:
• Programa: é um conjunto de instruções que descrevem uma tarefa

que será executada por um computador.
• Programação de Computadores: é o processo de escrita, teste e

manutenção de um programa.
• Algoritmo: sequência de passos para realizar uma tarefa ou

resolver um problema.
• Linguagem de Programação: é um conjunto de regras sintáticas e

semânticas usadas para definir um programa.
• Linguagem de máquina: é a linguagem natural dos computadores.

As instruções são formadas por zeros e uns. Estas linguagens não
são legíveis para um programador sem experiência.
• Linguagens de baixo nível: são linguagens escritas usando as

instruções do microprocessador do computador. Estas linguagens
são mais difíceis de entender e criar programas.
• Linguagens de alto nível: são linguagens mais próximas à

linguagem humana e mais distantes das linguagens de máquina.
São linguagens mais simples de entender, já que, em geral,
utilizam uma sintaxe estruturada, tornando seu código mais legível.
• Compiladores: são programas que fazem a tradução de todas as

instruções do programa fonte gerando um programa executável.
22
Programação 2
• Interpretadores: são programas que interpretam cada instrução

do programa fonte executando-a dentro de um ambiente de
programação.
• Compilação: é o processo, executado pelo compilador, que verifica

se existem erros de sintaxe no código fonte e gera um programa
executável.
• Erro de sintaxe: ocorre durante o processo de compilação do

programa, quando o programador, ao editar o seu programa
fonte, não respeita alguma regra de sintaxe da linguagem de
programação.
• Erro de lógica: ocorre durante a execução de um programa, devido

um erro na lógica dos comandos.
23
Programação 2
Capítulo 2 – Conceitos
Preliminares para Programar
em C
Neste capítulo, serão abordados conceitos preliminares que

irão nos preparar para programar em C. Estes conceitos estão
relacionados à estrutura de um programa básico em C. Aqui, também,
será apresentado o ambiente de programação que utilizaremos
Saiba Mais
para o desenvolvimento dos nossos programas – o Dev-cpp. Este
5
O Dev-cpp é ambiente apresenta uma interface amigável, que facilitará o processo
uma ferramenta
gratuita e pode
de programação. Vocês devem baixar e instalar o Dev-Cpp5, o
ser baixada quanto antes, no computador que será utilizado para a prática desta
acessando o site:
www.bloodshed. linguagem.
net/devcpp.html
É importante que vocês tenham paciência neste início de
aprendizado, já que precisamos, inicialmente, acumular o conhecimento
necessário para a construção de um programa completo em C.
Visando facilitar o aprendizado, em alguns momentos, será feito um
Saiba Mais
paralelo entre a sintaxe do C e do Portugol do VisuAlg6 (linguagem
6
Conheça
utilizada para escrever algoritmos).
mais o VisuAlg
pesquisando no
site: http://www.
apoioinformatica.
inf.br/visualg/
linguagem.htm
24
Programação 2
Figura 2.1: Qualidades de um programador: atenção, paciência e persistência
Vale lembrar que qualquer linguagem de programação é assimilada

através da resolução de exercícios. É importantíssimo que a prática
de programar faça parte da rotina de vocês. Assim, separem sempre
um tempo para resolver as questões propostas neste material. Vocês
vão perceber o quanto é bom ver um programa rodando! Que venha
o C!
2.1. Estrutura de um Programa Básico em C
Nesta seção, vamos estudar a estrutura de um programa básico

em C. Visando facilitar o entendimento e não sobrecarregar vocês
com muitos detalhes, alguns elementos da estrutura do programa
serão omitidos. Mas, no momento certo, abordaremos tais elementos,
certo? Assim, a estrutura do programa que será apresentada nesta
seção, é a estrutura mínima de um programa em C.
Nas linguagens de programação em geral, existe uma estrutura que

indica a ordem em que deve ser disposto cada elemento do programa.
Esta ordem deve ser respeitada para que nossos programas fiquem
corretos. Como será a estrutura de um programa em C?
A estrutura básica de um programa C deve seguir a seguinte

ordem:
1. Inclusão de bibliotecas (quando necessário);
2. Declaração das constantes (quando necessário);
3. Programa principal;
25
Programação 2
• Declaração de variáveis (quando necessário);
• Seqüência de comandos.
Para entendermos melhor a estrutura básica de um programa C,

vamos analisar o programa de exemplo 2.1, abaixo. Este programa
calcula o cubo de um número inteiro fornecido pelo usuário. Na
sequência, temos este programa resolvido utilizando o portugol, que é
do conhecimento de vocês. Assim, fica fácil compararmos a estrutura
do programa em C, com a estrutura do algoritmo. Não se preocupem
em entender cada comando do exemplo abaixo, estamos apenas
começando a estudar o C, certo?
Exemplo 2.1: Programa C – Cálculo do cubo de um número
1 #include <stdio.h>
2 main()
3 {
4 int num,c;
5 printf(“Cubo de um numero\n\n”);
6 printf(“Digite o numero: “);
7 scanf(“%d”,&num);
8 c = num*num*num;
9 printf(“\nCubo de %d = %d”,num,c);
10 getche();
11 }
Segue abaixo o algoritmo, escrito no VisuAlg, que calcula o cubo

de um número.
26
Programação 2
Exemplo 2.2: Algoritmo – Calculo do cubo de um número
1 algoritmo “Cubo”
2 var
3 num, c: inteiro
4 inicio
5 escreval(“Cubo de um numero”)
6 escreva(“Digite o numero: “)
7 leia(num)
8 c <- num*num*num
9 escreval(“Cubo de “, num, “ = “, c)
10 fimalgoritmo
Um programa em C inicia com a inclusão de bibliotecas. Uma

biblioteca é um arquivo que contém comandos complementares,
que são utilizados pelo nosso programa. Para a inclusão de uma
biblioteca devemos usar um comando que é chamado de diretiva de
compilação. Este comando informa ao compilador quais bibliotecas
devem ser anexadas ao programa executável. Assim, o comando para
a inclusão de uma biblioteca tem a seguinte sintaxe:
Sintaxe
#include <nome_do_arquivo_da_ biblioteca>
De acordo com a sintaxe, para incluir uma biblioteca ao nosso

programa devemos colocar a diretiva de compilação #include e, entre
os símbolos < e >, colocamos o nome do arquivo da biblioteca. De
maneira geral, os arquivos de biblioteca têm a terminação .h (esse h
vem de header, ou seja, este é um arquivo de cabeçalho). Para cada
biblioteca, que será incluída no nosso programa, devemos colocar
um comando #include. No exemplo 2.1, na linha 1, é feita a inclusão
de uma biblioteca: stdio.h. Na medida em que formos aprendendo
os comandos, serão indicadas quais bibliotecas devem ser incluídas
no programa. A quantidade de bibliotecas e quais bibliotecas serão
27
Programação 2
incluídas, depende dos comandos que serão utilizados no programa.

Pode ser que em um programa, não seja necessário incluir nenhuma
Saiba Mais biblioteca.
7
Do Inglês, O segundo item da estrutura de um programa C é a declaração
main significa
principal. Todo
das constantes, esse item é opcional, só constará no nosso programa,
programa C caso seja necessário. Veremos a declaração de constantes, em
começa a sua
execução a partir detalhes, no próximo capítulo. No exemplo 2.1 não foi necessário o
do programa
principal. Assim,
uso de constantes.
o programa
principal é uma O terceiro item da estrutura do programa C é o programa principal.
parte obrigatória
na estrutura de É no programa principal que colocaremos a sequência de comandos
um programa C. que deve ser executada para a solução do problema que desejamos
resolver. Nós devemos informar onde começa e termina o programa
principal. O programa principal inicia com: main()7, como mostra a linha
2, do exemplo 2.1. A sequência de comandos do programa principal é
delimitada por um par de chaves: { (abre chaves) e } (fecha chaves).
Saiba Mais As chaves que delimitam o corpo do programa principal8 aparecem
nas linhas 3 e 11, do exemplo 2.1. Fazendo uma comparação com
8
Chamamos o algoritmo do exemplo 2.2, as chaves fazem o papel do “inicio” e
de corpo do
programa “fimalgoritmo”, das linhas 4 e 10.
principal toda
a sequência Logo no início do programa principal, devem ser declaradas as
de comandos
que faz parte variáveis (que serão abordadas no próximo capítulo). A declaração
do programa
de variáveis é um item opcional, pode acontecer de não precisarmos
principal. Ou seja,
a seqüência de declarar variáveis no nosso programa. No exemplo 2.1, a declaração
comando que
aparece entre de variáveis é feita na linha 4. Foram declaradas duas variáveis do
as chaves de
tipo inteiro: num e c. No algoritmo, exemplo 2.2, as variáveis são
abertura e término
do programa declaradas fora do programa principal, na seção de declaração de
principal.
variáveis (linhas 2 e 3).
Após a declaração das variáveis, colocamos a sequência de

comandos que o programa deverá executar. O programa termina com
o fecha chaves que delimita o programa principal.
Agora que já sabemos como é a estrutura de um programa básico

em C, vamos começar a aprender a sintaxe dos comandos para
darmos início ao desenvolvimento dos nossos programas.
2.2. Palavras Reservadas do C
Como mencionado no capítulo anterior, as linguagens de

programação são formadas por um conjunto de regras de sintaxe e
28
Programação 2
semântica que ditam como o programa deve ser escrito. Com isso,
dentro dessas regras, existe um conjunto de palavras que tem um
significado para a linguagem de programação – são as palavras
reservadas. Uma palavra reservada é, essencialmente, um comando
e, na maioria das vezes, as palavras reservadas de uma linguagem
definem o que pode ser feito e como pode ser feito.
As palavras reservadas são de uso exclusivo da gramática da

linguagem, por isso, não podem ser utilizadas, pelo programador, para
dar nome a alguma variável, constante ou função do seu programa.
Assim, um programador não pode ter uma variável chamada “int” no
seu programa C, já que “int” é uma palavra reservada que indica um
tipo de dado.
Saiba Mais
Na linguagem C temos 32 palavras reservadas. Todas as palavras
9
A sigla ANSI
reservadas do C são escritas em minúsculo. A tabela abaixo mostra significa:
as palavras reservadas, conforme definido pelo padrão ANSI9, para a American
National
linguagem C. Standards
Institute (Instituto
Nacional
auto default float unsigned Americano de
Padronização). É
break do for return uma organização
case double goto short que tem por
objetivo facilitar a
char else union signed padronização dos
const typedef if sizeof trabalhos de seus
membros.
switch while int static
volatile enum long struct
continue extern register void
No Dev-cpp, ambiente de programação que será utilizado, sempre

que digitarmos uma palavra reservada no nosso programa, esta Saiba Mais
aparecerá em negrito. Isto facilita no momento da programação, pois
não precisaremos decorar esta lista de palavras reservadas. Que
10
Ao desenvolver
nossos
alívio! Assim que uma palavra ficar em negrito no nosso programa, programas
utilizando boas
poderemos verificar se estamos utilizando-a de forma correta. práticas de
programação,
teremos como
resultado um
2.3 Uso de Comentários código fonte
mais legível e
um progama
Os comentários são utilizados para documentar um programa. A executável mais
seguro e eficiente.
colocação de comentários em um programa é uma das boas práticas Ao longo deste
de programação10. Os comentários irão facilitar o entendimento material serão
ensinadas boas
e manutenção de programas. Por exemplo, um programador é práticas de
programação.
responsável por desenvolver o sistema de controle de vendas
29
Programação 2
da sua empresa. Como o sistema é grande, após um tempo, ele

não lembrará mais o porquê de ter colocado uma sequência de
comandos no seu programa. Se o programa estiver bem comentado,
o programador poderá, rapidamente, ter esta resposta. Além disso,
quando desenvolvemos programas em grupo, é importante que os
demais membros do grupo entendam o raciocínio do nosso programa
e isso pode ser explicado através dos comentários.
Os comentários podem ser colocados em qualquer parte do

programa. Quando o compilador identifica um comentário, ele os
ignora, já que os comentários são apenas informações para o
programador. A linguagem C fornece dois tipos de comentários: de
linha e de bloco. Vamos detalhar como funciona cada um deles.
Os comentários de linha são mais utilizados quando desejamos

comentar uma única linha do nosso programa. Um comentário de
linha possui a sintaxe a seguir:
Sintaxe
// texto do comentário
Um comentário de linha inicia com duas barras “//” e, na sequência,

vem o texto do comentário. O exemplo 2.3, a seguir, apresenta um
programa comentado. Na linha 7 temos o exemplo de um comentário
Saiba Mais de linha. Este comentário serviu para informar para que serve a
variável C. Assim que o compilador encontra “//”, ele ignora todo texto
11
No Dev- que vem após as duas barras11. Este tipo de comentário age apenas
cpp, quando
colocamos um na linha que ele é inserido.
comentário, as
letras do texto O segundo tipo de comentário disponível na linguagem C é o
comentado ficam
cinza comentário de bloco. Os comentários de bloco são utilizados quando
queremos fazer um comentário maior, que compreenda mais de uma
linha de comentário. A sintaxe do comentário de bloco é a seguinte:
Sintaxe
/* texto do comentário
texto do comentário
texto do comentário */
Um comentário de bloco inicia com barra-asterisco “/*” e termina

por asterisco-barra “*/”. O compilador irá ignorar tudo o que encontrar
30
Programação 2
entre estes dois símbolos. Veja no exemplo 2.3, que nas linhas 2, 3,
e 4 aparece um comentário de bloco. Este tipo de comentário do
exemplo é utilizado para identificar quem é o programador quando
o programa foi feito e o que o programa faz. Devemos Adotar este
tipo de comentário no início dos nossos programas. Assim, ao abrir
um programa, rapidamente, saberemos para que ele serve. Devemos
tomar cuidado para não esquecer o “*/” que fecha o comentário de
bloco.
Exemplo 2.3: Programa C Comentado – Calculo do cubo de um número
2 /* Programador: Sônia França
3 Data: 09/03/2009
4 Programa calcular o cubo de um número */
5 main()
6 {
7 int Num, C; // C guarda o cubo do numero
8 printf(“Cubo de um numero\n\n”);
9 printf(“Digite o numero: “);
10 scanf(“%d”,&Num);
11 C = Num*Num*Num;
12 printf(“\nCubo de %d = %d”,Num,C);
13 getche();
14 }
2.4. Os Fundamentos do Ambiente C
Na seção 1.5, do capítulo anterior, foram abordados os processos

de criação, compilação e execução de um programa. Nesta seção,
vamos detalhar um pouco mais estes processos, entendendo os
31
Programação 2
fundamentos do ambiente C. A figura 2.2 apresenta um ambiente

C, com as seis fases pelas quais passa um programa, desde a sua
edição, até a sua execução.
Figura 2.2: Ambiente C
A fase 1 compreende a edição do nosso programa. O programa

é criado com a utilização de um editor e é armazenado no disco do
computador (HD - Hard Disk). O arquivo que contém o nosso programa
tem a terminação .c, e este é chamado de programa fonte ou código
fonte.
Ao terminar a edição do programa, o programador solicita que

o seu código fonte seja compilado. O compilador traduz o código
fonte para o código em linguagem de máquina (também chamado
de código objeto). Vocês se lembram das diretivas de compilação?
Antes da tradução, temos a fase 2, em que o pré-processador
32
Programação 2
analisa o código fonte, executando as diretivas de compilação. O

pré-processador também é responsável por eliminar os comentários
que o programador colocou no seu código fonte. O pré-processador é
ativado automaticamente pelo compilador. Na fase 3, é que ocorre o
processo de compilação, após o código fonte ter sido pré-processado.
Para que o processo de compilação seja concluído, o programa não
pode apresentar erros de sintaxe.
Na fase 4, ocorre o processo de linking, que consiste na ligação do

código objeto, gerado pelo compilador, com o código das funções que
estão disponíveis nas bibliotecas que incluímos no nosso programa.
Ou seja, no exemplo 2.1, em que foi incluída uma biblioteca, o linker
deverá localizar o arquivo da biblioteca e fazer a ligação com o código
objeto. Esta fase termina com a geração do programa executável,
armazenando-o no disco do computador. No Dev-cpp, o programa
executável é armazenado no mesmo diretório que tiver armazenado
o código fonte. Na Figura 2.3, temos um diretório contendo o arquivo
do código objeto (.c – C source file) e o programa executável (.exe –
application). O arquivo do programa executável não pode ser editado,
o que nós podemos editar é o arquivo do código fonte.
Figura 2.3: Diretório contendo código objeto e o programa executável Saiba Mais
12
CPU é a sigla
As fases 5 e 6 consistem na execução do programa executável. para Central
Para dar início a execução de um programa, é necessário que o mesmo Processing
Unit, em Inglês,
esteja na memória principal do computador. Isto é feito na fase 5, pelo ou Unidade
Central de
carregador do programa. O carregador pega o programa executável Processamento.
que está armazenado no disco e o transfere para memória principal. A CPU é a parte
do computador
Assim que o programa está na memória principal do computador, ele que processa
as instruções
está pronto para ser executado. A execução de um programa é feita contidas em um
pela CPU12, que executa as instruções do programa, uma após a programa.
outra, até o seu término.
33
Programação 2
Na próxima seção, vamos conhecer o Dev-Cpp, que possibilitará a

criação, compilação e execução dos nossos programas. Com o Dev-
cpp poderemos observar as fases aqui descritas.
2.5. Conhecendo o Dev-cpp
Saiba Mais O Dev-Cpp é um ambiente de programação que edita, compila

e executa programas C e C++13. Sabem porque iremos usar o Dev-
13
C++ é uma cpp para desenvolver nossos programas? O Dev-cpp é gratuito
linguagem de
programação que (muito importante!) e possui uma interface bastante amigável (mais
surgiu a partir
do C.
importante ainda!). A Figura 2.4 apresenta a tela principal do Dev-
cpp.
Figura 2.4: Tela principal do Dev-cpp
Como mencionado no início deste capítulo, vocês deverão baixar

o Dev-cpp e instalar no seu computador, para que possamos fazer
os nossos programas. O processo de instalação não apresenta
dificuldades. Vocês só devem ficar atentos no momento que for
questionado sobre qual idioma deseja utilizar, para que faça a escolha
do idioma correto (Português), certo? Assim, a interface do Dev-cpp
ficará toda em Português, facilitando os seus estudos.
Vamos analisar a tela principal do Dev-cpp, apresentada na figura

2.4. Na parte 1 temos o menu principal do Dev-cpp, que disponibiliza
34
Programação 2
as seguintes opções:
• Arquivo: o menu arquivo disponibiliza, basicamente, as opções

para criar, salvar, imprimir e fechar arquivos.
• Editar: neste menu encontraremos as opções: copiar, colar,

selecionar, refazer e desfazer.
• Localizar: as opções deste menu nos possibilita localizar alguma

palavra no programa fonte, além de permitir substituições de
uma palavra por outra.
• Exibir: neste menu temos as opções que nos permite exibir ou

esconder itens da interface do ambiente, como por exemplo:
barra de ferramenta e barra de status.
• Projeto: permite a adição ou remoção de arquivos em um

projeto.
• Executar: é através deste menu que iremos chamar as opções

para a compilação e execução do nosso programa.
Saiba Mais
• Debug: o debugador auxilia o programador a encontrar erros
no programa, tornando possível acompanhar passo a passo a 14
O CVS, ou
execução dos comandos do programa. Neste menu teremos as Concurrent
Version System
opções para utilização do debugador. (Sistema
de Versões
• Ferramentas: no menu ferramentas temos as opções para Concorrentes)
é um sistema
configurar o ambiente (mudar cores, tipo de letra, dentre outros) de controle de
versões que
e também a opção para atualização do Dev-cpp. permite que
se trabalhe
• CVS14: este menu é utilizado por quem faz o controle de com diversas
versões do
versões dos programas. Apesar de ser uma função bastante mesmo arquivo.
interessante, é mais utilizado quando trabalhamos em grupo ou Este sistema
mantém as
com programas grandes. versões antigas
do seu arquivo
• Janela: neste menu estão disponíveis as opções que nos e os logs de
quem e quando
permitem escolher qual janela de edição deve ficar visível manipulou os
arquivos.
no momento. Utilizamos esta opção quando temos vários
programas abertos ao mesmo tempo. É especialmente
útil para se
• Ajuda: neste menu encontramos o help do Dev-cpp. controlar versões
de um software
durante seu
Na parte 2, da Figura 2.4, temos os ícones de atalhos para as desenvolvimento,
opções mais utilizadas no Dev-Cpp. Se vocês deixarem o mouse ou para
composição
sobre o ícone, aparecerá um texto, que informa o que ele faz. Na parte colaborativa de
um documento.
3 temos a área de edição do programa. Para a área de edição ficar
35
Programação 2
disponível, vocês deverão escolher a opção Arquivo/Novo/Arquivo

Fonte. É nesta área que digitaremos os nosso programas (código
fonte). A parte 4 fica visível quando nosso programa apresenta algum
erro de compilação. O compilador indicará em qual linha foi encontrado
um erro, e fornece uma dica do que pode ser o erro. Mesmo que
vocês tenham instalado o Dev-cpp em Português, as mensagens de
erro são apresentadas em Inglês. Por isso, é importante que vocês
comecem a se familiarizar com estas mensagens, para que consigam
tirar mais rapidamente os erros dos programas.
Segue abaixo um roteiro do que vocês precisam fazer para editar,

compilar e executar seus programas no Dev-cpp:
1. Crie um arquivo fonte novo na opção: Arquivo/Novo/Arquivo

Fonte;
2. Digite o programa fonte na área de edição. Ao terminar de editá-

lo, salve o arquivo;
Saiba Mais 3. Compile o programa na opção: Executar/Compilar;
15
O erro de 4. Se der algum erro no programa, vejam as indicações de
compilação pode erro fornecidas pelo compilador15. Conserte os erros, salve o
não estar na linha
que o complilador arquivo e compile novamente. Isto deve ser feito até que seja
está indicando. O
erro poderá estar: apresentada uma mensagem indicando que o programa não
na linha que ele tem erros de compilação.
está indicando,
na linha
imediatamente 5. Se vocês acessarem o diretório que o arquivo do código fonte
acima, ou ainda,
foi armazenado, notarão que foi criado um arquivo com a
em linhas mais
acima (menos extensão .exe (com o mesmo nome do arquivo do código fonte).
comum de
acontecer). Este é programa executável. Para executá-lo, escolha a opção
Executar/Executar no Dev-cpp. Imediatamente, aparecerá a
janela de execução do programa, como mostra a Figura 2.5.
Figura 2.5: Janela do programa em execução
É nesta janela que o programa será executado. Aqui o usuário
36
Programação 2
deverá fornecer os dados solicitados pelo programa, neste caso o

programa está solicitando que seja digitado um número. Além disso,
também receberá os resultados fornecidos pelo programa. Quando
a execução de um programa é finalizada, esta janela será fechada
automaticamente.
Agora que já conhecemos o ambiente de desenvolvimento de

programa C, precisamos aprender os comandos para fazer um
programa completo. Nos próximos capítulos iremos ver tais comandos,
para podermos começar a programar. Não fiquem ansiosos(as), a
nossa hora de programar está chegando!
Vamos resolver mais uma lista de exercícios? Note que estamos

conhecendo, ao poucos, os detalhes que envolve a programação de
computadores. A resolução das atividades propostas fará com que
estes conceitos sejam assimilados de forma mais natural. É sempre
importante complementar o nosso conhecimento com a leitura de
livros e materiais disponíveis na Internet, indicados na seção “Conheça
Mais”. Será que vocês estão lembrados (as) das respostas para as
questões abaixo?
1. Quando é que precisamos incluir uma biblioteca em um

programa C?
2. O que é diretiva de compilação?
3. O que deve ter no corpo do programa principal?
4. O que é uma palavra reservada?
5. Porque devemos comentar nossos programas?
6. Qual a função do pré-processador no momento da compilação

de um programa?
7. Qual o papel do linker no processo de compilação?
8. Qual elemento do computador é responsável pela execução do

programa?
37
Programação 2
Conheça Mais
Vocês poderão aprender mais sobre boas práticas de programação

nos sites:
http://www.ibm.com/developerworks/aix/library/au-hook_
duttaC.html
http://www2.eletronica.org/artigos/eletronica-digital/
programando-em-c-boas-praticas
Para conhecer mais detalhes do ambiente de programação que

iremos utilizar, acessem os sites:
http://www.bloodshed.net/dev/index.html
http://www.uniqueness-template.com/devcpp/
Vamos revisar?
Nesta seção iremos revisar os principais tópicos vistos neste

capítulo. Vale a pena dar uma lida para verificar como está o nosso
aprendizado. Observem o resumo a seguir:
• A estrutura básica de um programa C deve seguir a seguinte ordem:

inclusão de bibliotecas, declaração das constantes e programa
principal. No corpo de programa principal temos: declaração de
variáveis e seqüência de comandos.
• Uma biblioteca é um arquivo que contém comandos

complementares, que são utilizados pelo programa. Para a inclusão
de uma biblioteca devemos usar um comando que é chamado de
diretiva de compilação.
• As palavras reservadas de uma linguagem definem o que pode ser

feito e como pode ser feito. O programador não pode utilizar uma
palavra reservada da linguagem para dar nome as suas variáveis,
constantes e funções.
• O uso de comentário nos programas é uma boa prática de

programação, e facilita o entendimento do código fonte.
38
Programação 2
• Passos para o desenvolvimento de um programa: edição, pré-

processamento, compilação, ligação (linking), carregamento e
execução.
• O compilador traduz o código fonte para o código em linguagem

de máquina. O pré-processador analisa o código fonte, executando
as diretivas de compilação.
• O linker faz a ligação do código objeto, gerado pelo compilador,

com o código das funções que estão disponíveis nas bibliotecas
que incluímos no programa.
• Ao ser executado, um programa deve ser carregado na memória.

O carregador, também conhecido por loader, e responsável por
acessar o programa armazenado no disco e carregá-lo para a
memória principal do computador.
• Os programas são executados passo a passo pelo processador

do computador.
39
Programação 2
Capítulo 3 – Tipos de Dados,

Variáveis e Constantes
Saiba Mais Vamos conversar sobre o assunto?
16
A linguagem Programas são feitos para manipular dados. Armazenar notas,
C não possui
o tipo lógico,
calcular médias, alterar um endereço, etc. Os dados são a essência
que armazena de um programa. Dados precisam ser armazenados e modificados
verdadeiro ou
falso. ao longo da execução do programa. Neste capítulo, iremos conhecer
os tipos de dados suportados pela linguagem C e aprender a definir
constantes e variáveis.
Saiba Mais Inicialmente, os comandos serão apresentados em separado. Mas,

logo em seguida, veremos o ponto em que cada comando deve ser
17
Bit é uma colocado na estrutura do programa, certo? Tenham paciência! Vocês
abreviatura de
“Binary Digit” irão notar que muito dos conceitos estudados nos capítulos anteriores
(dígito binário).
Este termo foi
serão referenciados neste capítulo. Mas isto não é problema, não é
criado pelo mesmo? Vamos continuar os nossos estudos, conhecendo mais um
engenheiro belga
Claude Shannon pouco da linguagem C.
que em 1949
para simbolizar
uma unidade de
informação. Tudo 3.1. Tipos de dados
na informática é
medido em bits,
desde o tamanho Nesta seção, vamos aprender um conceito importante em
de um número
até a velocidade programação, que é: tipo de dados. De maneira geral, os programas
de transferência
de dados em uma
manipulam dados, armazenando-os e, muitas vezes, modificando seus
rede. Por ser uma valores. Primeiramente, vamos conhecer quais os tipos de dados são
unidade binária,
pode ter apenas manipulados na linguagem C. Basicamente, a linguagem C, manipula
dois valores, zero
ou um.
quatro tipos de dados: inteiro, real, caractere e void16. Para cada tipo
de dado, é necessária uma quantidade de bits17 para armazená-lo.
A partir do bit, Além disso, cada tipo de dado possui um conjunto de operações
surgiu o byte, que
nada mais é do que pode ser executada sobre ele. Nas subseções seguintes, vamos
que um conjunto
de 8 bits. detalhar cada tipo de dado separadamente.
Existem diversos
múltiplos dos
bytes: um kilobyte 3.1.1. Inteiro
(KB), equivalente
a 1.024 bytes; Os dados do tipo inteiro são toda e qualquer informação numérica
um megabyte
(MB), equivalente que pertença ao conjunto dos números inteiros relativos (negativo,
a 1.024 KB; e
um gigabyte, nulo ou positivo). Os números inteiros, em C, se dividem em três tipos,
equivalente a como mostra a tabela a seguir.
1.024 MB.
40
Programação 2
Tipo Tamanho Intervalo Suportado
Short 16 bits -32.768 a +32.767
Int 32 bits -2.147.483.648 a + 2.147.483.647
-9.223.372.036.854.775.808
Long 64 bits a
+9.223.372.036.854.775.807
Atenção
Qual a diferença entre cada um deles? A diferença entre os tipos
short, int e long é a quantidade de memória18 que é reservada para 18
A memória
é a parte do
armazená-los. Veja como é simples: à medida que se utiliza mais computador que
memória, aumenta o intervalo do valor que pode ser armazenado. Por tem como função
o armazenamento
exemplo, para armazenar um dado do tipo short, são reservados 16 de dados. Quando
um dado vai ser
bits de memória. Com isso, o tipo short pode suportar um número armazenado,
inteiro no intervalo de -32.768 a +32.767, como apresentado na precisamos
reservar uma
tabela. Portanto, dependendo do valor que será armazenado, deve quantidade de
memória para
ser escolhido um tipo (short, int ou long) que comporte tal valor. Por isto.
exemplo, para armazenar a idade de um funcionário, o tipo short
é o mais adequado (já que a idade de uma pessoa é um valor que
raramente ultrapassa 100). No entanto, para armazenar a quantidade
de eleitores de uma cidade, deve-se usar o tipo int (note que em
muitas cidades, a quantidade de eleitores ultrapassará o maior valor
suportado pelo tipo short: 32.767). Para facilitar nosso estudo, neste
material, sempre será usado o tipo int para armazenar os dados
inteiros.
3.1.2. Real
Os dados do tipo real são toda e qualquer informação numérica

que pertença ao conjunto de números reais (negativo, positivo ou
nulo). Os números reais, em C, podem ser de dois tipos, como mostra
a tabela abaixo:
Tipo Tamanho Intervalo Suportado
float 32 bits 3.4E-38 a 3.4E+38
double 64 bits 1.7E-308 a 1.7E+308
Para o tipo float são reservados 32 bits de memória, o que

possibilita armazenar um valor no intervalo 3.4–38 a 3.438. Como o tipo
float suporta valores bem altos, neste material, sempre será usado o
tipo float para armazenar os dados reais.
41
Programação 2
3.1.3. Caractere
Na linguagem C, os caracteres são do tipo char, representados

por toda e qualquer informação composta por um único caractere
alfa numérico (a, b, c,...z, A, B, C,...Z, 0...9) ou especial (como por
exemplo: ; # ? @ ! < ?). O tipo char armazena um único caractere.
Quando se deseja armazenar vários caracteres, é necessário definir
um vetor de caractere (mais detalhes na seção 3.2.2). Por exemplo,
o nome de um aluno é formado por uma cadeia de caracteres,
assim, será necessário usar um vetor de caracteres. Cada caractere
armazenado ocupa o espaço de 8 bits de memória. Um caractere
deve ser representado entre apóstrofo, por exemplo: ‘a’. Mas, quando
temos uma cadeia de caracteres, esta deve ser representada entre
aspas dupla, por exemplo: “Pedro Goncalves”.
3.1.4. Void
Em Inglês, void quer dizer vazio e é isto mesmo que o void é. Void
é um tipo que não armazena nada (um tanto esquisito, não é?). Este
tipo serve para indicar que um resultado não tem um tipo definido. Ele
é utilizado quando estamos definindo funções nos nossos programas.
Permiti-nos desenvolver funções que não retornam nada e funções
que não têm parâmetros. Voltaremos a falar do tipo void no Volume 2,
no capítulo que aborda modularização.
3.2. Variáveis e Constantes
Agora que já sabemos os tipos de dados manipulados pela

linguagem C, vamos aprender como reservar espaços de memória
para o armazenamento dos nossos dados.
Qualquer dado que seja manipulado pelo programa deve ficar

armazenado na memória principal do computador. Para que o
armazenamento seja possível, precisaremos reservar espaços na
memória principal do computador. As variáveis e constantes são
unidades básicas de armazenamento dos dados em programação.
Elas são um espaço de memória reservado para armazenar um certo
tipo de dado e possuem um identificador (nome) para referenciar o
seu conteúdo. Dessa forma, nossos dados ficam armazenados em
constantes ou variáveis.
Uma variável pode conter, a cada instante, valores diferentes. No
42
Programação 2
entanto, as constantes referem-se a valores fixos que não podem

ser alterados durante a execução do programa. O modo como cada
constante é representada depende do seu tipo (este assunto será
detalhado um pouco mais a frente).
Para entender o conceito de variáveis e constantes, vamos fazer

a seguinte analogia: um armário cheio de gavetas de tamanhos
diferentes. Acompanhem o raciocínio: Pedro tem um armário e
decide que em cada gaveta será guardado um tipo de roupa: camisa,
bermuda, calça, etc.
Figura 3.1: Armário cheio de gavetas
Em uma dada gaveta, só podem ser armazenadas camisas. Não

será permitido o armazenamento de calças nesta gaveta. Para facilitar
a identificação, Pedro coloca uma etiqueta informando o que cada
gaveta guarda. Com isso, Pedro poderá identificar, rapidamente, em
qual a gaveta estão guardadas suas camisas.
Agora vamos associar a ideia das gavetas com a ideia de variáveis,

constantes e tipo. As gavetas que guardam as roupas são como os
espaços de memória que armazenam nossos dados. Assim como uma
gaveta só pode armazenar um tipo de roupa, os espaços de memória
são especificados para armazenar um tipo de dado. Dependendo do
tipo de roupa, a gaveta precisa ser maior ou menor. Da mesma forma,
dependendo do tipo de dado, é feito uma reserva de mais ou menos
memória para armazená-lo (de acordo com as tabelas da seção 3.1).
As etiquetas das gavetas são os identificadores dos nossos
43
Programação 2
espaços de memória. Assim, iremos encontrar, facilmente, um dado

armazenado nos nossos espaços de memória. Quando temos uma
variável, o conteúdo da nossa gaveta pode mudar ao longo do
tempo. Mas, no caso de uma constante, seu conteúdo será sempre o
mesmo.
Nas próximas seções, vamos aprender as regras para dar nomes

às nossas variáveis e constantes e como criar as nossas gavetas –
espaços de memória (variáveis e constantes).
3.2.1. Identificadores
Para que o compilador saiba quais dados estamos querendo

manipular, eles precisam ter um nome. É como nós, todos temos um
nome. Sabemos quando alguém está nos chamando quando falam
o nosso nome. Vai acontecer a mesma coisa com os espaços de
memória dos nossos programas, precisamos identificá-los, de alguma
forma. Os identificadores são os nomes que damos as nossas
variáveis, constantes, funções e procedimentos usados no programa.
Para criar um identificador é necessário respeitar as regras a seguir:
• O primeiro caractere deve ser uma letra ou _ (underscore);
• O restante do nome deve ser formado por caracteres

pertencentes ao seguinte conjunto: a,b,c,..z, A,B,C,...Z,
0,1,2,...,9, _ (ou seja: letras, números e underscore);
• Não deve haver espaço em branco (ou seja, não existe

identificadores compostos, formados por dois ou mais nomes);
• Não utilizar acentos, nem cedilha;
• Os identificadores podem ter até 32 caracteres;
• Não deve haver identificadores repetidos (Se dermos o mesmo

nome para duas variáveis do nosso programa, o compilador
não vai saber qual delas será chamada, e isso não pode
acontecer).
A linguagem C faz distinção de maiúsculas e minúsculas. Assim,

os identificadores: Media, MEDIA, MediA e media, são diferentes.
O fato de termos uma única letra de forma diferente (maiúscula ou
minúscula), já faz com que os identificadores se diferenciem. Esta
propriedade é chamada de case sensibility (sensibilidade a letras
maiúsculas e minúsculas).
44
Programação 2
DICA: Boa Prática de Programação
Escolham bem os nomes das variáveis e constantes do

programa. Os identificadores escolhidos devem ser claros, a fim
de explicitar o conteúdo que será armazenado, mas também
não devem ser extensos para não dificultar a escrita.
A seguir, vamos verificar exemplos de identificadores corretos e

incorretos:
• Identificadores corretos: a, x2, Nome_Aluno, Media,

SalarioFuncionario. Note que, quando queremos usar
identificadores com mais de uma palavra, que foi o caso de
Nome_Aluno, usamos o _ para ligar uma palavra a outra. Ou
usamos as palavras juntas, como o exemplo SalarioFuncionario.
Lembrando que não podemos usar espaço em branco.
• Identificadores incorretos: 2m (começou com número),

media* (caractere * não é permitido), Nome disciplina (não pode
haver espaço em branco), funcionário (não pode acentuar).
Até este momento, vimos os conceitos de tipos de dados, variáveis,

constantes e identificadores. Na próxima seção, estes conceitos
serão utilizados em conjunto, para que possamos declarar as nossas
variáveis, ou seja, criar espaços de memória para armazenar os dados
manipulados pelo nosso programa. Continuemos a nossa leitura.
3.2.2. Declaração de Variáveis
Para que se possa usar uma variável em um programa,

primeiramente, é necessário fazer a declaração dela. A declaração
de uma variável informa ao processador duas coisas: o identificador
(nome) da variável e o seu tipo de dado. As variáveis precisam de
um nome para que o processador saiba onde desejamos armazenar
o nosso dado. Além disso, toda variável precisa ser associada a um
tipo de dado, para que o processador reserve o espaço de memória
necessário para o seu armazenamento. Como visto na seção 3.1, cada
tipo de variável, ocupa uma quantidade de bits diferente. Resumindo,
toda variável possui um nome, um tipo e um conteúdo (ou valor que é
armazenado na variável).
45
Programação 2
A declaração de variáveis deve obedecer a seguinte sintaxe:
Sintaxe
tipo [variavel_1, variavel_2, ...];
Onde tipo é o tipo de dado (int, float, char) e variavel_1 é o nome

da variável a ser declarada. O nome da variável deve seguir a regra
dos identificadores (mencionadas na seção 3.2.1). Se houver mais de
uma variável do mesmo tipo, seus nomes são separados por vírgulas.
Notem que, no final do comando, aparece um ponto e virgula (;),
indicando ao compilador que o comando terminou.
Exemplo 3.1: Declaração de Variáveis
1 int idade, matricula;
2 float media, total;
3 char letra, nome_aluno[20];
As variáveis idade e matricula são espaços de memória que

armazenam números inteiros. As variáveis media e total armazenam
números reais. Note que na linha 3, temos as variáveis letra e
nome_aluno. Quando uma variável caractere tem apenas um único
caractere, na sua declaração, é necessário apenas dar um nome a
esta variável.
Quando houver necessidade de armazenar vários caracteres,

temos o que é chamado de cadeia de caracteres, vetor de caracteres
ou string. Uma cadeia de caracteres forma uma palavra ou frases. Para
declarar uma variável capaz de armazenar uma cadeia de caracteres,
devemos colocar ao lado do nome da variável, entre colchetes, um
valor inteiro, que significa quantos caracteres podem ser armazenados
nesta cadeia. Assim, a variável nome_aluno, declarada na linha 3, tem
capacidade de armazenar uma palavra/frase com até 20 caracteres.
A figura 3.2 representa a memória do computador, após a declaração

das variáveis do exemplo. Cada caixa representa uma variável. E,
cada variável possui o seu identificador. Assim, esta declaração de
variáveis resultou na reserva de seis espaços na memória. Toda vez
que precisarmos acessar ou armazenar o conteúdo de uma variável,
utilizaremos o seu identificador.
46
Programação 2
Figura 3.2: Representação da memória do computador

após a declaração de um conjunto de variáveis
Atenção
Como dito anteriormente, o C difere as letras minúsculas

das maiúsculas. Assim, os tipos de dados e comandos que
iremos aprender ao longo da disciplina, DEVEM ser escritos em
minúsculo. Se vocês fizerem a seguinte declaração : Int x,y; Vai
ocorrer um erro no momento da compilação do seu programa,
já que o C não conhece o tipo Int com “I” maiúsculo. Fiquem
atentos, pois esse é um erro comum para quem está começando
a programar em C.
De acordo com o que foi visto, quando estudamos a estrutura

da um programa C, as variáveis devem ser declaradas logo quando
inicia o corpo do programa principal. Vamos estudar, a seguir, como
fazemos para declarar as nossas constantes.
3.2.3. Declaração de Constantes
Diferente das variáveis, as constantes mantêm seu valor ao

longo do programa. Para indicar ao compilador que se trata de uma
constante, a diretiva de compilação #define é utilizada. Segue a
sintaxe da declaração de uma constante.
Sintaxe
#define <identificador> <valor>
47
Programação 2
Não é necessário colocar o ponto e vírgula no final da linha e

também não precisa informar o tipo de dado da constante. O valor
de uma constante não pode ser modificado, de maneira alguma, ao
longo da execução do programa.
O modo como cada constante é representada depende do seu

tipo. Constantes do tipo inteiro são representadas por números sem
o componente fracionário, por exemplo, 123 e 2009. Constantes reais
precisam do uso de ponto decimal seguido do componente fracionário
do número, por exemplo, 302.54. Constantes caractere são colocadas
entre apóstrofos, por exemplo, ‘a’. Constantes cadeia de caractere
são colocadas entre aspas duplas, por exemplo, “Casa” e “Maria”. A
seguir são apresentadas as declarações de quatro constantes:
Exemplo 3.2: Declaração de Constantes
1 #define DIAS 7
2 #define PI 3.1416
3 #define RESPOSTA ‘s’
4 #define DISCIPLINA “Matemática”
De acordo com o exemplo, a constante DIAS irá armazenar sempre

7. Como o valor que esta constante recebeu foi um valor inteiro, o
compilador entende, automaticamente, que esta é uma constante
inteira. Da mesma forma, como a constante PI recebeu 3.1416 (um
número real), o compilador saberá que se trata de uma constante do
tipo real. A constante RESPOSTA armazena um char e DISCIPLINA
uma cadeia de caracteres.
É interessante declarar uma constante quando sabemos que um

valor não será modificado ao longo da execução do programa. Por
questões de padronização, declare as suas constantes com todas as
letras em maiúsculo, como apresentado nos exemplos. Assim você
estará diferenciando-as das variáveis.
De acordo com a estrutura de um programa C, as nossas

constantes são declaradas no início do programa, logo após incluirmos
as bibliotecas que serão utilizadas. Estão lembrados(as) disso? Se
não estão, deem uma revisada na seção 2.1, certo?
Ao serem criadas, as constantes já recebem o valor que elas vão

armazenar ao longo do programa. Isto não acontece com as variáveis.
48
Programação 2
Mas como fazemos para armazenar um valor em uma variável? Esta

resposta vocês encontrarão na próxima seção.
3.3. Operador de Atribuição (=)
Esse operador é utilizado para armazenar um valor em uma dada

variável. Assim, o operador de atribuição nos possibilita armazenar
um dado em um espaço de memória, que foi previamente declarado.
É importante que o dado que será armazenado seja compatível com
o tipo da variável que receberá a atribuição. Por exemplo, as variáveis
reais podem receber valores reais e inteiros. No entanto, uma variável
inteira, não pode receber um valor real. Segue a sintaxe do operador
de atribuição.
Sintaxe
Variavel = Valor;
Variavel_1 = Variavel_2;
Variavel = Expressão Aritmética;
Variavel = função;
Variavel_1 = variavel_2 = variavel_3 = valor;
O operador de atribuição é representado pelo símbolo =. No lado

esquerdo do operador da atribuição, temos a variável que vai receber
o valor. No lado direito do operador, temos o valor que será atribuído
à variável. Ao final da linha de atribuição deve ter um ponto e vírgula.
Notem que o operador de atribuição permite várias possibilidades.

Para um melhor entendimento, o exemplo 3.3 apresenta cada uma
das possibilidades do operador de atribuição.
49
Programação 2
Exemplo 3.3: Comando de atribuição
1 float Media, X, Y, Z;
2 int J, L, M, K, A, B;
3 char Letra;
4 Media = 7.5;
5 Letra = ’D’;
6 X = Y;
7 K = A + B;
8 Z = sqrt(4);
9 J = L = M = 10;
Nas linhas 1, 2 e 3, temos a declaração das variáveis. Lembrem

que só podemos armazenar algum valor, caso tenhamos declarado
as variáveis. Uma vez que é necessário ter reservado espaços de
memória para nossos dados, entendido?
Saiba Mais Na linha 4, a variável Media recebeu 7.5 (para números reais,
devemos utilizar ponto ao invés de virgula, para separar a parte inteira
19
Onde aparece o da parte fracionária do número)19.
= do comando de
atribuição, nos
lemos: “recebe”. Na linha 5, temos uma atribuição para uma variável char com um
Assim, o
comando da linha
único caractere. Note que, neste caso, o valor que a variável receberá
4 do exemplo 3.3, vem entre apóstrofo. Assim, a variável Letra está recebendo D.
seria lido: “Media
recebe 7.5”.
Atenção
O operador de atribuição não é usado para variáveis do tipo

char com vários caracteres. Este tipo de atribuição será visto no
capítulo “Comandos de Manipulação de Caracteres”, do Volume
4.
Na linha 6, a variável X receberá o valor que está armazenado

na variável Y. Na linha 7, a variável K irá receber o resultado da
50
Programação 2
expressão A + B, ou seja, será obtido o valor armazenado na variável

A, depois o valor da variável B, os valores são somados e o resultado é
atribuído a variável K. Uma variável sempre recebe um valor. Quando
a atribuição tem uma expressão matemática, a expressão é resolvida
e o resultado é atribuído a variável.
Na linha 8, a variável Z receberá o resultado da chamada da função

sqrt (que faz o cálculo da raiz quadrada de um número). Veremos
mais detalhes sobre estas funções no capítulo 5.
Na linha 9, aparece o que chamamos de atribuição em cadeia.

Quando várias variáveis vão receber o mesmo valor, ao invés de
ser feita uma atribuição de cada vez, podemos dizer: variavel1 =
variavel2 = variavel3 = valor. Nós podemos atribuir o mesmo valor a
quantas variáveis quisermos. Coloquei um exemplo com três, certo?
No exemplo da linha 9, as variáveis K, L e M vão receber 10. Mas
tem um detalhe, nós só podemos usar a atribuição em cadeia quando
todas as variáveis que irão receber o valor são do mesmo tipo. Assim,
nesta atribuição do exemplo, as três variáveis K, L e M são do mesmo
tipo: int.
Temos agora mais uma lista de exercícios para consolidar o nosso

entendimento do assunto visto neste capítulo. Vocês perceberam
quantas coisas novas nós já aprendemos até aqui? Como uma
linguagem de programação envolve vários detalhes, são os exercícios
que vão nos ajudar a não esquecer deles. Prontos (as) para acertar
todas as questões?
1. Identifique os tipos dos valores abaixo (int, float, char de um

caractere ou char de vários caracteres):
1) 1000 2) “09” 3) – 1.56 4) “VERDADE”
5) – 456 6) 34 7) ‘C’ 8) 45.8976
9) “BRASIL” 10) ‘l’ 11) - 5.6 12) 300
2. Abaixo, temos exemplos de identificadores. Assinale os

identificadores válidos e descreva o erro dos operadores
inválidos.
51
Programação 2
1) endereco 2) 21brasil 3) fone$com 4) nome_usuario
5) usuario6 6) nome*usuario 7) end*a-6 8) #media
9) nome aluno 10) média 11) _pais 12) Media_da_Turma
3. De acordo com as declarações abaixo, assinale os comando de

atribuição inválidos e descreva o erro.
int NUM, X, SOMA;
float MEDIA, K, L;
( ) SOMA = NUM + 2;
( ) MEDIA = SOMA;
( ) NUM = K + L;
( ) X = X + 1
( ) L = SOMA - K;
( ) SOMA + 2 = NUM + 10;
( ) S = SOMA;
( ) X = SOMA - NUM;
Conheça Mais
Comece a aprofundar mais seus conhecimentos com a leituras dos

livros clássicos da linguagem C:
• O mais autêntico de todos, tem como autores os criadores

desta linguagem: C - A Linguagem de Programação, de B.
W. Kernighan e D. M. Ritchie, editora Campus. Este é um livro
relativamente difícil de ler, mas é a “Bíblia” da linguagem.
Dois textos mais didáticos são:
• C Completo e Total, de Herbert Schildt, pela editora MAKRON

Books.
• Como programar em C, de H. M. Deitel e P. J. Deitel, pela

editora LTC.
52
Programação 2
A vantagem de ver vários livros é que um autor acaba

complementado o que o outro escreveu. Além disso, um autor pode
explicar um certo assunto de forma mais clara que o outro. Por isso é
bom sempre dar uma olhada em livros novos e material disponível na
Internet.
Vamos revisar?
Vamos fazer uma revisão do assunto que foi visto neste capítulo,
fazendo a leitura do resumo a seguir:
• Os tipos de dados manipulados pelo C são: inteiro, real, caractere

e void.
• O tipo inteiro se divide em: int, short ou long. A diferença entre os

três tipos é a quantidade de memória reservada para armazená-
los.
• O tipo real se divide em: float e double.
• O tipo char armazena um caractere. Quando desejamos armazenar

vários caracteres, para formar um nome ou frase, precisamos
declarar uma cadeia de caracteres.
• As variáveis são espaços de memória onde armazenamos nossos

dados. Uma variável possui um nome, um tipo e um valor.
• Para que um variável passe a existir, precisamos fazer a sua

declaração. Ao declarar uma variável, damos a ela um nome, e
dizemos que tipo de dado pode ser armazenado na variável.
• Os nomes da variáveis são os identificadores. Para dar um

nome a uma variável, precisamos seguir a regra de criação de
identificadores.
• As constantes são espaços de memória onde armazenamos um

valor que não será alterado durante a execução do programa.
• O comando de atribuição é utilizado quando desejamos armazenar

um valor em uma variável.
• A atribuição de um valor a uma variável só poderá ser executada

se o tipo de dado que a variável armazena for compatível com o
valor que será atribuído.
53
Programação 2
Capítulo 4 – Comandos de
Entrada e Saída de Dados
Um programa que não fornece resultados, nem recebe valores

para serem processados, não tem muita utilidade. De um modo
geral, o objetivo pelo qual escrevemos programas é a obtenção de
resultados (Saídas) depois da realização de cálculos ou pesquisas
(Processamento) através do fornecimento de um conjunto de dados
(Entradas). Neste capítulo, iremos a estudar os comandos de entrada
e saída de dados. Assim, com o comando de entrada poderemos
fornecer dados para que sejam processados pelo programa.
Com o comando de saída poderemos receber os resultados do
processamento dos nossos dados. Uma boa notícia é que, a partir
Saiba Mais
deste capítulo, teremos adquirido conhecimento suficiente para
20
Voce sabe construir um programa completo em C! Ficaram felizes? Então não
quem inventou o
mouse? Embora
vamos perder mais tempo, vamos logo aprender os comandos de
tenha sido entrada e saída de dados.
inventado por Bill
Enghlish, a sua
patente pertence
a Douglas
Engelbart. Ele
4.1. Entrada de Dados
apresentou este
periférico pela
O comando de entrada de dados é utilizado quando desejamos
primeira vez em
1968 e o chamou fornecer um valor para um nosso programa. A entrada de dados é
de “XY Position
Indicator For A feita através de um dispositivo de entrada de dados. Os dispositivos
Display System”.
mais comuns são: teclado, mouse20, tela sensível ao toque, scanner,
O primeiro
mouse era feito dentre outros. A figura 4.1 apresenta alguns destes dispositivos.
de madeira,
com apenas um
botão. O invento
de Engelbart
ficou sem
muita utilização
devido a falta de
necessidade de
tal dispositivo, já
que a maioria dos
computadores
utilizavam
apenas textos
sem cursores
na tela. Vocês
se imaginam
sem um mouse
em seus
computadores?
Figura 4.1: Dispositivos de Entrada de Dados
54
Programação 2
Nesta seção, iremos aprender como executar a entrada de um

dado (ou a leitura de um dado, como também é chamada) através do
teclado. A execução do comando de leitura pressupõe que os dados
serão fornecidos do meio externo (teclado), e serão armazenados na
memória (variáveis).
O comando que faz a leitura de um dado fornecido via teclado e

o armazena em uma variável do programa é o scanf. Fazendo um
paralelo com o Portugol, o scanf é o comando leia. Vamos ver a sua
sintaxe.
Sintaxe
scanf(“string de controle”, &variavel);
O comando scanf tem um certo nível de detalhes, para entendê-lo,

vamos por partes. Na primeira parte do scanf, entre as aspas, aparece
a string de controle. O que vem a ser a string de controle? A string de
controle indicará que tipo de dado será lido neste momento. A string
de controle deve assumir um dos valores abaixo:
String de Controle Significado
%d leitura de números inteiros
%f leitura de números reais
%c leitura de um caractere
Saiba Mais
%s leitura de cadeia de caracteres
Nós acessamos
21
Assim, quando formos ler um dado que vai ser armazenado em uma variável
através do seu
uma variável do tipo inteiro, a string de controle deve ser “%d”. Se nome. No entanto,
o processador
o valor a ser lido, for um número real, a string de controle será “%f”. acessa uma
Quando o dado a ser lido for um único caractere, a string de controle variável utilizando
o endereço de
é “%c” e para ler uma cadeia de caracteres, é utilizado “%s”. Com a memória dela.
Cada variável
resolução de exercícios, vocês não esquecerão o significado de cada criada no nosso
string de controle, certo? programa possui
um endereço de
memória. Nós
Na segunda parte do scanf, colocamos o nome da variável que não precisamos
vai armazenar o valor que será fornecido via teclado, entendido? conhecer o
endereço de
Notem que antes do nome da variável, aparece um & (e-comercial). memória de uma
variável, certo?
O & faz parte da sintaxe do scanf e não pode ser esquecido. NUNCA! Só precisamos
Na linguagem C, o & significa: “Endereço de memória”21. Assim, saber o nome
dela.
o comando scanf indica que o dado será lido via teclado e será
55
Programação 2
armazenado no endereço de memória da variável. O comando scanf

também termina com ponto e vírgula.
Vamos analisar o exemplo 4.1, que apresenta o uso do scanf.
Exemplo 4.1: Comando de Entrada - scanf
1 int idade;
2 float salario;
3 char letra, nome[20];
4 scanf(“%d”, &idade);
5 scanf(“%f”, &salario);
6 scanf(“%c”, &letra);
Nas linhas 1 a 3, temos as declarações das nossas variáveis. No

scanf da linha 4, temos a leitura da variável idade. Como esta variável
é do tipo int, a string de controle é “%d”. Na linha 5, temos a leitura
da variável salário, que é do tipo float. Assim, a string de controle é
“%f”. Por fim, na linha 6, temos a leitura da variável letra, que é do
tipo char, contendo apenas um caractere. Por conta disso, a string de
controle foi “%c”. A string de controle vem sempre entre aspas duplas,
certo? Note que também foi declarada uma variável chamada nome,
que é uma cadeia de 20 caracteres. No entanto, o comando scanf não
funciona corretamente nas leituras de cadeias de caractere. Portanto,
quando for necessário fazer a leitura de variáveis deste tipo, teremos
que usar um outro comando, que será visto na próxima seção.
4.1.1. Entrada de Cadeia de Caracteres
Como mencionado, o comando scanf não funciona de maneira

correta ao ler uma cadeia de caracteres. O problema é que, se nesta
cadeia de caractere tiver um espaço em branco, separando uma
palavra da outra, ao encontrar o espaço em branco, o processador
entende que a leitura terminou, desprezando parte do nosso dado.
Então já viu, não dá para ficar com o dado pela metade, não é
mesmo?
A solução é usar outro comando de leitura, específico para a leitura

de cadeias de caracteres. Este comando é o gets. A sintaxe do gets
é a seguinte:
56
Programação 2
Sintaxe
fflush(stdin);
gets(variável);
Para a execução de um gets, precisamos informar apenas a

variável que irá receber o valor lido. Note também que antes do gets,
temos o comando fflush. É assim mesmo. Sempre que tivermos um
gets, antes temos que executar um fflush. Não esqueça disso, certo?
O comando fflush é um comando que limpa o buffer de entrada de

dados (stdin). Estão querendo saber o que é o buffer de entrada? O
buffer é um espaço de memória que armazena, temporariamente, os
nossos dados. É assim, suponha que o programa está solicitando que
seja digitado o nome do usuário. O usuário vai teclando cada letra que
forma seu nome. Ao terminar de digitar, ele tecla enter. O enter indica
ao processador, que o usuário encerrou aquela entrada de dados.
Enquanto não for teclado o enter, o processador vai armazenado cada
tecla que está sendo pressionada, no buffer de entrada. Após o enter
ser pressionado, o processador pega o nome completo do usuário,
que está no buffer de entrada, e transfere para a variável.
Pode parecer complexo, mas não é. A questão é que, enquanto não

terminamos de digitar o dado, ele está sendo formado. Só depois de
finalizada a entrada, é que ele é pode ser transferido para a variável.
A Figura 4.2 ilustra o esquema da entrada de dados.
4.2: Esquema da entrada de dados
A execução do fflush nos assegura que o buffer de entrada está

limpo, sem o conteúdo de algum dado que foi teclado anteriormente.
57
Programação 2
No caso de entradas de dados usando o scanf, não é necessário

limpar o buffer de entrada.
Atenção
O gets e o fflush são comandos que se encontram em

uma biblioteca chamada stdio.h. Portanto, se você for
utilizar estes comandos, esta biblioteca deverá ser incluída
na seção de inclusão de bibliotecas do programa. A inclusão
é feita com a diretiva de compilação #include e fica assim:
#include <stdio.h>.
Vamos agora analisar o exemplo 4.2, que apresenta o uso do

comando gets.
Exemplo 4.2: Comando de Entrada - fgets
1 char nome_aluno[20], endereco[50];
2 fflush(stdin);
3 gets(nome_aluno);
4 fflush(stdin);
5 gets(endereco);
Na linha 1, temos as declarações das variáveis nome_aluno e

endereco. A variável nome_aluno armazena até 20 caracteres e a
variável endereco armazena até 50 caracteres. Antes de executar o
gets da linha 3, responsável por ler o nome_aluno, temos, na linha
2, o fflush, responsável por limpar o buffer de entrada. Na sequência,
temos a leitura da variável endereco. Assim, é necessária a execução
de um novo fflush antes do gets da linha 5. Notem que na leitura de uma
variável cadeia de caractere, só usamos o nome dela, desprezamos o
colchetes e o número que indica quantos caracteres ela armazena.
Agora que sabemos como fazer a entrada de dados via teclado,

vamos aprender a apresentar os dados na tela. Só falta este comando
para darmos início a criação dos nossos programas. Estamos bem
perto! Vamos em frente!
58
Programação 2
4.2. Saída de Dados
O comando de saída de dados é utilizado quando desejamos ver

o resultado do processamento do nosso programa. Este comando
também é utilizado para passar mensagens na tela, solicitando que
o usuário faça algo, como por exemplo, digitar a idade dele. Os
dispositivos de saídas de dados mais comuns são: monitor, impressora
e caixas de som. A figura 4.3 apresenta tais dispositivos.
Figura 4.3: Dispositivos de saída de dados
Vamos agora aprender o comando que fornece a saída de dados

para o dispositivo de saída padrão que é a tela do computador. Este
comando é o printf. Fazendo um paralelo com o Portugol, o printf é o
comando escreva. Vamos ver a sua sintaxe.
Sintaxe
printf(“string de controle”);
printf(“string de controle”, lista de argumentos);
Existem duas sintaxes para o printf. Na primeira, só temos a string

de controle, entre as aspas dupla. Usamos esta sintaxe quando
queremos escrever apenas texto na tela. Na segunda, além da string
de controle, temos a lista de argumentos. Esta sintaxe é aplicada
quando iremos escrever texto e valores armazenados nas variáveis.
Apesar de aparecer aqui uma string de controle, ela não é similar a
do scanf, certo? No printf, a string de controle é uma “máscara” que
especifica (formata) o que será impresso e de que maneira será
impresso. Na string de controle pode conter: texto, códigos especiais
e especificadores de formatos. Calma! Vamos detalhar mais.
Primeiramente, vamos ver quais são os códigos especiais que

podem aparecer na string de controle do printf. Os códigos especiais
são formados por uma barra invertida (\), seguida de uma letra. O
código especial, indica uma ação que deve ser executada pelo printf.
59
Programação 2
A tabela a seguir apresenta os códigos especiais e o seu significado.
Código Especial Ação
\n Muda o cursor para o início da linha seguinte.
\t tabulação (tab)
\” Escreve uma aspas dupla na tela
\\ Escreve uma barra invertida na tela
\a Dá um alerta sonoro
Vamos analisar exemplos bem simples de printf, que escrevem,

apenas um texto na tela.
Exemplo 4.3: Comando de Saída – printf – Escrevendo textos apenas
1 printf(“Ola Mundo!”);
2 printf(“\nBom Dia...”);
3 printf(“\n\nIsso eh um teste.\a”);
4 printf(“\n\nAte \nmais... \ntchau”);
A execução desta sequência de printf do exemplo 4.3, resulta na

seguinte tela (Figura 4.4).
Saiba Mais
22
A tela tem
as seguintes Figura 4.4: Tela de execução de um programa: uso do printf
dimensões: 80
colunas x 25
linha. Assim,
conseguimos
Vamos entender cada printf do exemplo 4.3. Um detalhe essencial
escrever em uma que devemos saber: o printf escreve um texto na tela, no ponto em que
linha de tela, 80
caracteres. E o cursor se encontra no momento. Quando um programa é executado,
conseguimos ter
uma tela com até
o cursor se encontra na primeira coluna, da primeira linha da tela22. No
25 linhas. primeiro printf do exemplo, a string de controle tem apenas o texto que
60
Programação 2
queremos colocar na tela: “Ola Mundo!”23. Após terminar este printf, o

cursor estará posicionado após a exclamação.
Saiba Mais
Na sequência, na linha 2, temos um printf cuja string de controle é:
“\nBom Dia...”. O \n serviu para fazer com que o cursor mudasse para 23
Atenção: Não
use acentos nos
o início da linha seguinte e logo em seguida, o texto “Bom dia..” foi textos que serão
escritos na tela.
impresso, e o cursor ficou no final desta linha. No volume 4,
aprenderemos
No printf da linha 3, temos a string de controle: “\n\nIsso eh um como acentuar
nossos textos.
teste.\a”. A string de controle começa com dois “\n”. Isso faz com que
o cursor mude de linha duas vezes. Assim, teremos uma linha em
branco na tela. Além disso, na string de controle, também temos um
“\a”, que faz com que seja disparado um beep(sinal sonoro) quando
este printf for executado. É interessante usar o sinal sonoro quando
quisermos chamar a atenção do usuário.
Finalmente, na linha 4, temos o printf com a string de controle:

“\n\nAte \nmais... \ntchau”. Como a string de controle começa com
dois “\n”, o cursor muda de linha duas vezes, e escreve “Ate”. Na
sequência, temos outro “/n”, o que fez o cursor mudar novamente
de linha e escrever “mais...”. Por fim, temos outro “\n”, o cursor vai
mudar de linha e escreve “tchau”. Notem que um único printf, pode
resultar em um texto em várias linhas da tela. Isso não é possível no
Portugol.
Vamos ver agora, como escrevemos textos e valores, armazenados

nas nossas variáveis, na tela do computador. Para isto, temos que
saber mais um detalhe que vai aparecer na string de controle, que
são os especificadores de formato. Um especificador de formato
marca o lugar e o formato de impressão das variáveis, contidas na
lista argumentos (vejam a segunda sintaxe do printf). Deve haver um
especificador de formato para cada variável a ser impressa. Todos os
especificadores de formato começam com um %. Os especificadores
de formato são apresentados na tabela a seguir.
Especificador de Formato Uso
%d Escrever um valor do tipo inteiro
%f Escrever um valor do tipo real
%c Escrever um caractere
%s Escrever uma cadeia de caracteres
%% Escrever o caractere ‘%’
61
Programação 2
Neste caso de impressão na tela, quando temos textos e valores,

na string de controle, devemos colocar um especificador de formato,
no ponto onde queremos que um valor seja impresso. O especificador
deve ser relativo ao tipo de dado que será impresso. Após a string
de controle, coloca-se uma vírgula, e na sequência vem a lista de
variáveis que será impressa. Assim, nós primeiro montamos a frase
(string de controle), informando em que ponto entrarão os valores
(usando os especificadores de formato) e depois, informamos quais
variáveis serão utilizadas. Vamos ver alguns exemplos.
Exemplo 4.4: Comando de Saída – printf – Escrevendo textos e valores
1 int X, Y, mat, idade;
2 float A;
3 X = 1;
4 Y = 3;
5 A = 7.5;
6 mat = 123;
7 idade = 25;
8 printf(“O valor de A = %f”, A);
9 printf(“\n\nO aluno de matricula %d tem %d anos”,

mat, idade);
10 printf(“\n\nResultado da soma: %d”, X+Y);
A sequência do exemplo 4.4 é iniciada com a declaração das

variáveis e com a atribuição de valores, para que possamos entender
melhor a montagem dos printf. No primeiro printf, da linha 8, queremos
que seja apresentado o valor da variável float A. Assim, montamos a
string de controle, informando o ponto da frase onde deve ser colocado
o valor da variável A, utilizando o especificador de formato de valores
reais, o “%f”. Veja na Figura 4.5, a tela resultante da execução desta
sequência de comandos.
62
Programação 2
Figura 4.5: Tela de execução de um programa usando printf com textos e valores
Quando pedimos para que um número real seja apresentado na tela,

este é mostrado com uma precisão de seis casa decimais. Por isso, o
valor da variável A, aparece como 7.500000. Podemos decidir quantas
casas decimais devem ser apresentadas, nem sempre queremos
trabalhar com tantas casas decimais, bem como, poderemos precisar
trabalhar com um número com mais casas decimais. Aprenderemos
daqui a pouco como informar quantas casas decimais devem ser
apresentadas, quando um número real for impresso na tela. Por
enquanto, vamos continuar a análise do exemplo 4.4, certo?
No segundo printf, na linha 9, queremos que seja apresentado o

número de matrícula do aluno e a sua idade. Aqui temos um printf que
irá apresentar mais de um valor. O raciocínio é o mesmo. Montamos a
string de controle, informando onde vai aparecer o valor das variáveis,
utilizando o especificador de formato. O que muda é depois da string
de controle. Após a vírgula, devemos colocar as variáveis que serão
impressas, na ordem que elas devem aparecer na frase. Ou seja, se
na ordem da frase, vem primeiro a matrícula do aluno, então, coloca-
se primeiro a variável mat. Quando temos mais de uma variável,
elas são separadas por vírgula. Notem que continuamos usando os
códigos especiais na string de controle, neste caso foi colocado o “/n”,
para mudar o cursor de linha.
Na linha 10, temos um printf que irá apresentar o resultado de um

expressão matemática. Isto também é possível. Assim, na parte do
printf que indicamos a variável que será impressa, nós colocamos a
expressão matemática. A expressão é resolvida e o seu resultado é
apresentado na tela.
Vamos ver agora como fazer para que nossos números reais sejam
apresentados com a quantidade de casa decimais que quisermos. O
que vai mudar é o especificador de formato dos números reais, o “%f”.
Agora ele deve ser assim: entre o “%” e o “f”, colocaremos um ponto,
seguido de um número, que representa quantas casas decimais nós
63
Programação 2
queremos que sejam apresentadas. Vejam os printf do exemplo 4.5.
Exemplo 4.5: Comando de Saída – printf – formatando números reais
1 float A, B,C;
2 A = 3.4;
3 B = 1.12345;
4 C = 7.56789;
5 printf(“A = %.1f”, A);
6 printf(“\n\nB = %.2f”, B);
7 printf(“\n\nC = %.2f”, C);
Primeiro, temos as declarações e atribuições para três variáveis

reais. Na linha 5, temos o printf que imprime o valor da variável A,
vejam como ficou o especificador de formato: “%.1f”. Neste caso,
queremos que seja apresentada apenas uma casa decimal deste
número. Vejam a Figura 4.6, que apresenta a tela resultante da
execução desta sequência de comandos.
Figura 4.6: Tela de execução de programa: formatação de números reais
Nas linhas 6 e 7, temos os printf que imprimem os valores das

variáveis B e C. Neste caso, queremos que sejam apresentadas duas
casas decimais, por isso, o especificador de formato ficou: “%.2f”.
Só vamos ver mais um detalhe. Notem que, quando pedimos para
que um número seja apresentado com poucas casas decimais, o
printf apresenta um valor arredondado. Como assim? Veja o valor
que foi atribuído a variável C, na linha 4 do exemplo: 7.56789. Veja
agora o valor que foi apresentado na tela de execução do programa:
64
Programação 2
7.57. Funciona assim: se queremos que sejam apresentadas apenas

duas decimais, o printf vai verificar qual valor tem na terceira casa
decimal, se tiver um valor maior ou igual a cinco, ele arredonda o valor
apresentado. Se for um número menor que 5, ele não arredonda.
Observe o valor da variável B.
Terminamos aqui os comandos de entrada e saída. Como estes

comandos tem muitos detalhes, ficamos sujeitos a cometer vários
erros quando os utilizamos: esquecer uma vírgula, uma aspa, dentre
outros. Na próxima seção, iremos ver uma lista dos erros mais comuns
que ocorrem com o uso destes comandos. Com esta lista, poderemos
encontrar os erros dos nossos programas mais rapidamente, certo?
4.3. Erros Frequentes no Uso dos Comandos

de Entrada e Saída
Nesta seção, será apresentada uma lista com os erros que são
mais frequentemente cometidos por quem está iniciando a programar,
e que precisa ficar atento a tantos detalhes da sintaxe dos comandos.
Vamos ver, na tabela abaixo, os erros que podemos cometer no uso
do scanf, gets e printf.
Comando Erros Consequência
Scanf Esquecer o & antes do O programa compila, como se

nome da variável. não tivesse erro, mas durante a
execução ele trava.
Trocar a string de controle. O programa compila, mas a

Por exemplo, no lugar de variável receberá um valor
um %d, usar um %f. esquisito (normalmente, um valor
bem grande)
Esquecer o ; no final do O compilador avisa que tem erro.

comando.
Esquecer as aspas da O compilador avisa que tem erro.

string de controle.
Esquecer a vírgula entre O compilador avisa que tem erro.

a string de controle e a
variável.
Fazer a leitura de uma O compilador avisa que tem erro.

variável que não foi
declarada.
65
Programação 2
Gets Esquecer de colocar o O programa compila, como se

comando fflush antes do não tivesse erro, mas durante a
gets. execução, o processador pula a
execução do comando gets.
Esquecer de incluir a O compilador avisa que tem erro.

biblioteca stdio.h.
printf Não fechar a string de O compilador avisa que tem erro.

controle.
Esquecer a vírgula entre O compilador avisa que tem erro.

as variáveis que serão
impressas.
Usar um especificador O programa compila, mas será

de formato incompatível impresso um valor esquisito.
com o valor que será
impresso.
Esquecer de colocar um O programa compila, mas não

especificador de formato. imprime o valor da variável.
Notem na coluna “consequência”, que mesmo que sejam cometidos

alguns tipos de erros, o programa vai compilar e só durante a execução
é que notaremos algo estranho. Atenção: podem ocorrer outros erros
que não foram mencionados nesta lista, estes são apenas os mais
comuns.
Pronto, enfim poderemos começar a fazer os nossos primeiros

programas! Já sabemos, declarar variáveis, atribuir valores a elas,
ler valores via teclado e apresentar resultados na tela. Com esses
comandos, já podemos fazer uns programas simples em C. Para
começar, vocês já tem devem ter instalado o Dev-cpp nos seus
computadores. Na próxima seção, veremos dois programas completos
comentados. Agora é de verdade, vamos programar!
4.4. Primeiros programas em C
É isso, vamos começar com o nosso primeiro programa em C.

Ele será simples, mas com o tempo iremos aumentado o nível de
complexidade dos nossos programas. Antes de tudo, vamos a alguns
detalhes (Mais detalhes?). Primeiro, vocês devem executar o Dev-
cpp e escolher a opção: Arquivo/Novo/Arquivo Fonte. NÃO devemos
trabalhar com projetos, certo? Em seguida, comecem a digitar o
programa.
66
Programação 2
Atenção
Por padrão, o Dev-cpp salva os nossos programas no formato

do c++ (ou seja, .cpp). Sempre que forem salvar os programas,
lembrem de informar que vocês querem que este seja salvo no
formato .c. Fiquem atentos a isso!
A Figura 4.7 mostra a tela de como devemos salvar nossos

programas. No momento que solicitamos que o programa seja salvo,
é aberta uma janela para escolha do diretório que o programa será
salvo, o nome dele e podemos também escolher o formato, na opção:
“Save as Type”. Nesta opção, você deve escolher: “C source files
(*.c)”. Só isso. Se você salvar seu programa como .cpp, ele ficará
dando erros.
Figura 4.7: Tela do Dev-cpp: salvando um programa c.
O nosso primeiro programa em C irá ler dois números inteiros e

apresenta a soma destes dois números. Segue abaixo o programa
completo. Em seguida, vamos comentar cada linha.
67
Programação 2
Programa Completo 4.1: Ler dois números inteiros e calcula a soma
1 //Ler dois numeros e calcula a soma
2 main()
3 {
4 int n1, n2, soma;
5 printf(“Calcular a soma de dois numeros\

n\n”);
6 printf(“Primeiro valor: “);
7 scanf(“%d”, &n1);
8 printf(“Segundo valor: “);
9 scanf(“%d”, &n2);
10 soma = n1 + n2;
11 printf(“\n\nA soma dos dois numeros = %d\n\

n”,soma);
12 system(“pause”);
13 }
Comentários sobre cada linha do Programa completo 4.1
• Linha 1: De acordo com a estrutura de um programa C,

Saiba Mais este inicia com inclusão das bibliotecas, quando necessário.
Neste exemplo, não utilizamos nenhum comando que se fez
24
Ao ler um necessária a inclusão de biblioteca. Assim, na linha 1 temos um
enunciado de
uma questão comentário, indicando o que o programa faz. Sempre coloquem
procure
identificar as
esse tipo de comentário no programa. Assim, ele ficará bem
variáveis de documentado.
entrada, ou seja,
quais valores
serão fornecidos • Linha 2: início do programa principal, que é definido pelo:
pelo usuário e “main()”.
qual resultado o
programa precisa
processar. E • Linha 3: temos um abre chaves, que irá delimitar o corpo do
assim, faça a programa principal.
declaração das
suas variáveis.
• Linha 4: temos as declarações das três variáveis do programa24:
68
Programação 2
n1 e n2 (para armazenar os números que serão fornecidos pelo

usuário) e soma (que armazena a soma dos dois números).
Saiba Mais
• Linha 5: um printf que serve para colocar, no início da tela,
o título do que o programa faz. Isso é importante para que o 25
Importante:
sempre que
usuário saiba para que serve o programa. temos que fazer
uma leitura de
• Linha 625: colocamos este printf para que o usuário saiba que dados (com
scanf ou gets),
precisa fornecer o primeiro valor. devemos colocar
uma mensagem
• Linha 7: scanf que lê o primeiro valor e armazena na variável para que o
usuário saiba
n1. o que ele deve
digitar. Assim,
todo scanf (ou
• Linha 8: printf para que o usuário saiba que precisa fornecer o
gets), deve ter
segundo valor. um printf antes,
informado o
que o usuário
• Linha 9: scanf que lê o segundo valor e armazena na variável tem que fazer. O
n2. programa precisa
se comunicar com
um usuário.
• Linha 10: agora que já temos os dois valores armazenados
nas variáveis n1 e n2, podemos executar a soma. Nesta linha,
temos o comando que atribui a soma das variáveis n1 e n2 para
a variável soma.
• Linha 11: printf que apresenta o resultado, que está armazenado

na variável soma.
• Linha 12: nesta linha, temos um comando novo. É o seguinte,

assim que é terminada a execução do nosso programa, o
processador fecha, automaticamente, a janela onde o programa
estava sendo executado. Por conta disso, acabamos sem
ver algum resultado que tenha sido impresso na tela. Para
fazer com que a janela não feche ao término da execução, foi
colocado o comando system(“pause”). Este comando dá uma
Saiba Mais
pausa na execução do programa e fica aguardando que o
usuário pressione alguma tecla26. Com esta pausa, poderemos 26
O comando
ver os resultados apresentados. Assim que pressionamos algo system(“pause”)
escreve na tela
no teclado, a janela irá fechar. Portanto, no final dos nossos de execução
do programa
programas, teremos que colocar o system(“pause”), certo? a seguinte
Um outro comando que faz a mesma coisa é o getche(), no mensagem:
“Press any key
próximo exemplo, usaremos o getche(), para que vocês possam to continue...”
ou “Pressione
conhecê-lo. qualquer tecla
para continuar...”
• Linha 13: fecha chaves, indicando o final do programa
principal.
69
Programação 2
Vocês devem digitar, compilar e executar este programa utilizando

o Dev-cpp. Comecem a se familiarizar com a sintaxe do C. Também
procurem se familiarizar com o ambiente de programação. Em breve,
vocês não estarão mais tendo que consultar as sintaxes dos comandos
com tanta frequência. Vamos logo fazer outro programa!
Nosso segundo programa irá ler o nome do usuário e o ano em

que ele nasceu e como resultado imprime uma mensagem dizendo
quanto anos o usuário tem.
Programa Completo 4.2: Ler o nome e a idade do usuário

e informar a sua idade.
2 //Ler o nome e a idade do usuário e informar a

sua idade.
3 main()
4 {
5 char nome[20];
6 int ano, idade;
7 printf(“Calcular a idade o usuario\n\n”);
8 printf(“Seu nome: “);
9 fflush(stdin);
10 gets(nome);
11 printf(“Ano que voce nasceu: “);
12 scanf(“%d”, &ano);
13 idade = 2009 - ano;
14 printf(“\n\n%s, voce esta com %d anos.”,

nome, idade);
15 getche();
16 }
70
Programação 2
Programa Completo 4.2: Ler o nome e a idade do usuário e

informar a sua idade.
Vamos ver o que está sendo feito em cada linha do programa

completo 4.2.
• Linha 1: Neste programa nós teremos que ler uma variável

que é uma cadeia de caractere: o nome do usuário. Assim,
precisaremos usar o gets e o fflush. Estes comandos ficam na
biblioteca stdio.h. Na linha 1, temos a inclusão desta biblioteca.
• Linha 2: Comentário indicando o que o programa faz.
• Linha 3: início do programa principal, que é definido pelo:

main().
• Linha 4: temos um abre chaves, que irá delimitar o corpo do

programa principal.
• Linha 5: declaração da variável do tipo char, que armazena o

nome do usuário.
• Linha 6: declaração das variáveis inteiras: ano (que armazena

o ano de nascimento do usuário) e idade (que armazenará a
idade do usuário, que será calculada pelo programa).
• Linha 7: printf que indica o que o programa faz, no início da Saiba Mais
tela de execução.
27
Importante:
• Linha 827: printf que solicita que seja digitado o nome do sempre que
temos que fazer
usuário. uma leitura de
dados (com
• Linha 9: temos o comando fflush, que DEVE sempre vir antes scanf ou gets),
devemos colocar
do comando gets. uma mensagem
para que o
• Linha 10: gets que efetuará a leitura do nome do usuário. usuário saiba
o que ele deve
digitar. Assim,
• Linha 11: printf para que o usuário saiba que precisa fornecer o todo scanf (ou
ano de nascimento. gets), deve ter
um printf antes,
informado o
• Linha 12: scanf que lê o ano de nascimento do usuário. que o usuário
tem que fazer. O
• Linha 13: atribuição que descobre quantos anos o usuários programa precisa
se comunicar com
tem. Para isso, subtraímos o ano atual (2009), do ano que o um usuário.
usuário nasceu. O resultado é atribuído para a variável idade.
• Linha 14: printf que apresenta o resultado. Notem que o nome

do usuário vai aparecer na frase. A string de controle começa no
dois “\n”, solicitando que o cursor mude de linha e logo temos
71
Programação 2
um “%s”, isto é porque queremos que a resposta seja iniciada

com o nome do usuário. Um exemplo de frase de resposta é:
“Carolina, você esta com 10 anos”.
• Linha 15: temos o comando getche(), similar ao system(“pause”),

faz com que a tela de execução não feche ao final do programa.
A vantagem do getche() é que ele não escreve nada na tela.
Lembram que o system(“pause”) coloca uma frase na tela?

principal.
A seguir, temos as telas de execução dos programas completos

4.1 e 4.2.
Tela de execução do Programa Tela de execução do Programa

completo 4.1 completo 4.2
Figura 4.8: Telas de execução dos programas completos 4.1 e 4.2
Com esses dois programa completamente comentados, já dá para

vocês começarem a treinar sozinhos. Não queiram acertar tudo de
primeira, vão com calma e sejam persistentes. Vejam que a sintaxe da
linguagem C é cheia de detalhes que precisamos ter muita atenção.
Na próxima seção, vocês encontrarão sugestões de exercícios.
Como vocês já devem ter notado, uma linguagem de programação

envolve muitos detalhes. Vocês só irão aprender realmente, se fizerem
muitos exercícios. É a prática que fará com que esta gama de detalhes
seja assimilada. Portanto, aqui vai mais uma lista de exercícios. Esta
é para ser resolvida no computador, certo? Podem começar a ligar
seus computadores!
72
Programação 2
1. Faça um programa que leia dois números reais A e B e os

imprima na tela. O valor da variável A deve ser apresentado
com duas casa decimais e o valor da variável B com três casas
decimais.
2. Faça um programa que leia o nome do usuário e escreva uma

frase de saudação, desejando um bom dia de trabalho para
o mesmo. A resposta deve ter o formato deste exemplo: “Ola
Joao, tenha um otimo dia de trabalho!”. Faca o programa soar
um sinal sonoro(beep) ao escrever esta frase.
4. Faça um programa que leia dois números inteiros A e B e

imprima o resultado da subtração de A por B. A resposta deve
ter o seguinte formato: “6 – 2 = 4”.
3. Faca um programa que leia o nome do usuário e a sua idade e

imprima quantos anos ele terá em 2020. A resposta deve ter o
formato deste exemplo: “Carlos, em 2020 voce estara com 45
anos”.
5. Faça um programa que leia o nome do usuário, a idade do

usuário, o nome da mãe do usuário e a idade da mãe do
usuário. O programa devera imprimir na tela quantos anos a
mãe do usuário tinha quando ele nasceu. A resposta deve ter
o formato deste exemplo: “Carlos, quando voce nasceu, Dona
Cecilia tinha 27 anos”.
Conheça Mais
Aumente os seus conhecimentos sobre comandos de entrada

e saída de dados acessando site especializados na linguagem C.
Muitos professores e instituições disponibilizam materiais na rede e o
principal, vocês podem encontrar muitos enunciados de exercícios.
Vocês já se inscreveram em um fórum de discussão da linguagem

de programação C? Nessa fase em que estamos iniciando a programar,
ter auxílio de programadores experientes é muito importante. Não
deixem de se inscrever, certo?
73
Programação 2
Vamos revisar?
Para dar uma revisada nos tópicos tratados neste capítulo,

observem o resumo a seguir:
• Dispositivos de entrada: são utilizados para passar informações

para o computador. São exemplos de tais dispositivos: teclado e
mouse.
• Dispositivos de saída: são utilizados para apresentar informações

processadas pelo computador.
• scanf: um dos comandos de leitura do C. Esta comando não é

adequado para a leitura de cadeia de caracteres.
• gets: comando específico para a leitura de cadeia de caracteres.

Para utilizá-lo, é necessário incluir no programa a biblioteca
stdio.h.
• fflush: comando que faz a limpeza do buffer de entrada de dados.

Sempre que fizermos uma leitura de cadeia de caracteres, devemos
colocar o comando fflush.
• printf: comando de saída de dados. O printf pode ser usado para

imprimir textos, valores de variáveis e resultados de expressões
aritméticas.
• getche() e system(“pause”): comandos para provocar uma parada

na tela de execução, fazendo com que o usuário possa conferir o
resultado processado pelo programa.
74
Programação 2
Capítulo 5 – Operadores,
Expressões e Funções
Matemáticas
Gostaram de ter feito os primeiros programas em C? Foram

programas simples, que utilizavam o assunto visto até o momento.
Vamos continuar avançando no estudo da linguagem C e aumentando,
gradativamente, o nível de complexidade dos nossos programas.
Neste capítulo, iremos aprender quais operadores estão disponíveis
na linguagem C e como utilizá-los, através da montagem de
expressões aritméticas, relacionais e lógicas. Também iremos abordar
as principais funções da biblioteca matemática. Com o assunto deste
capítulo, teremos habilidades para resolver questões que requerem
a construção de expressões, seja aritmética, relacional ou lógica.
Vamos em frente!
5.1. Operadores Básicos
Em toda linguagem de programação, existem operadores que

nos permitem armazenar, modificar, comparar e avaliar dados no
computador. Aqui veremos três tipos de operadores: aritméticos,
relacionais e lógicos. Nas próximas seções, será feito o detalhamento
de cada um dos tipos de operadores.
5.1.1 Operadores Aritméticos
Usamos os operadores aritméticos quando precisamos executar

operações aritméticas (matemáticas) sobre os nossos dados
(variáveis). A tabela abaixo apresenta os operadores aritméticos do C.
Notem que o operador da multiplicação é um asterisco.
Operador Descrição
+ Adição
- Subtração
* Multiplicação
75
Programação 2
/ Divisão
% Retorna o resto da divisão

inteira de a por b
() Parênteses
Vamos dar uma atenção especial aos operadores da divisão(/)

e resto(%). O resultado de uma divisão, em C, depende dos tipos
dos dados que estão sendo divididos. A tabela abaixo apresenta o
resultado da operação de divisão, de acordo com os tipos de dados
do numerador e do denominador.
numerador / denominador resultado
inteiro / inteiro inteiro
inteiro/ real real
real / inteiro real
real/real real
Quando dois números inteiros são divididos, o resultado é a parte

inteira do quociente da divisão. Quando pelo menos um dos elementos
(numerador e/ou denominador) é real, o resultado é um número real.
Vamos analisar a sequência de comandos a seguir:
Exemplo 5.1: Uso de Operadores Aritméticos
1 int X, Y, Z, W;
2 float K, L, M;
3 X = 19;
4 Y = 3;
5 Z = X/Y;
6 W = X % Y;
7 K = 19;
8 L = 3;
9 M = K/L;
76
Programação 2
Nas linhas 1 e 2, temos as declarações das variáveis: quatro

inteiras (X, Y, Z e W) e três reais (K, L, e M). Nas linhas 3 e 4 são
atribuídos valores nas variáveis X e Y, que passam a armazenar
tais valores. Na linha 5, temos um comando de atribuição, em que
a variável Z receberá o resultado da divisão entre a variável X (19)
e a variável Y (3). Como as variáveis X e Y são inteiras, o resultado
será a parte inteira do quociente da divisão. Assim, se temos: 19/3 =
6.333333, será considerado apenas a parte inteira do resultado, ou
seja, 6. Portanto, nesta atribuição da linha 5, a variável Z vai receber
6.
Na linha 6, a variável W vai receber o resto da divisão de X por

Y, ou seja, o resto da divisão de 19 por 3. A figura 5.1 ilustra como a
operação do resto é feita.
Figura 5.1: Resto de uma divisão
A operação do resto funciona da seguinte forma: os dois números

vão sendo divididos, neste caso: 19 é dividido por 3 (primeiro quadro
da figura 5.1). Assim, 19 por 3 dá 6 e sobra 1. Como o 1 não dá pra
ser dividido por 3, a conta para e pega o resto da divisão que é 1.
Portanto, o resultado da operação X%Y (neste caso, 19%3) é 1. Este
resultado será atribuído a variável W.
Atenção
O operador do resto (%) só pode ser usado quando as

variáveis envolvidas são do tipo inteiro. Não poderemos usar tal
operador para obter resto de divisão de números reais. Outra
coisa: o operador % não tem nada haver com percentagem,
certo?
Nas linhas 7 e 8 são atribuídos valores nas variáveis K e L, que

passam a armazenar tais valores. Na linha 9, temos um comando
77
Programação 2
de atribuição, em que a variável M receberá o resultado da divisão

entre a variável K (19) e a variável L (3). As variáveis K e L são reais
(float). Dessa forma, teremos 19/3 = 6.333333. O resultado completo
será atribuído a variável M, ou seja 6.33333, sem desprezar a parte
fracionária do resultado.
A figura 5.2 apresenta o valor que ficou armazenado em cada uma

das variáveis, após a execução da sequência de comandos. Note que,
nas variáveis reais, mesmo que seja atribuído um valor inteiro, como
por exemplo, na linha 7, que foi atribuído 19 à variável K, no momento
que o valor é armazenado, ele passa a ter a parte fracionária do
número. Por isso, a variável K aparece com 19.000000 de conteúdo
(lembrem-se que o ponto deste número, está representando uma
virgula, certo?).
Figura 5.2: Resultado final das variáveis
5.1.1.1 Prioridade dos Operadores
Uma questão que devemos tomar bastante cuidado ao montar

uma expressão aritmética é a prioridade dos operadores. A prioridade
que o operador aritmético tem sob o outro é que vai determinar como
a expressão será resolvida. Na matemática, quando montamos uma
expressão, usamos parênteses, colchetes e chaves. Nas linguagens
de programação, nós só temos os parênteses.
Os parênteses têm um papel importante nas expressões e

possibilitam que a ordem das operações seja alterada. Expressões
entre parênteses são calculadas primeiro, portanto eles fornecem
o maior grau de prioridade às expressões que envolvem. Podemos
ter pares de parênteses envolvendo outros pares. Dizemos que os
parênteses estão aninhados. Neste caso, as expressões dentro dos
parênteses mais internos são avaliadas primeiro.
78
Programação 2
A tabela abaixo apresenta a prioridade de resolução dos operadores

aritméticos:
Prioridade Operador
1º Operações embutidas em parênteses “mais internos”
2º % (resto) e/ou * (multiplicação) e/ou / (divisão)
3º + (adição) e/ou – (subtração)
De acordo com a tabela, as expressões entre parênteses tem maior

prioridade, portanto, são resolvidas primeiro. Na sequência, resolve
os operadores resto e/ou multiplicação e/ou divisão, e, finalmente,
resolve os operadores de adição e/ou subtração. Quando aparecem
operadores de mesma prioridade em uma expressão, o operador mais
à esquerda será avaliado primeiro.
Vamos analisar o exemplo 5.2, a seguir, e verificar qual o valor

final das variáveis A, B, C e D.
Exemplo 5.2: Prioridade de Operadores
1 int X, Y, Z, W, A, B, C, D;
2 X = 19;
3 Y = 3;
4 Z = 4;
5 W = 2;
6 A = X + Y * Z;
7 B = (X + Y) * Z;
8 C = X – Y * Z / W;
9 D = (X-Y) * (Z/W);
Na linha 1, temos as declarações das variáveis que serão usadas

(todas elas são do tipo int). Nas linhas 2 a 5, são atribuídos valores
às variáveis X, Y, Z e W. Vamos acompanhar a resolução de cada
expressão das linhas 6 a 9 na figura 5.3. A parte da expressão que
79
Programação 2
aparece circulada, é a que tem prioridade de resolução.
Figura 5.3: Acompanhamento da resolução das expressões aritméticas
No primeiro quadro (atribuição para a variável A), aparecem

na expressão os operadores da adição e multiplicação. Como a
multiplicação tem prioridade, esta é resolvida primeiro. Posteriormente,
o operador da adição é resolvido e assim o resultado que será
atribuído à variável A.
No segundo quadro (atribuição para a variável B), a expressão

também é composta por operadores de adição e multiplicação. No
entanto, a adição aparece entre parênteses. Sabe-se que a operação
dentro dos parênteses terá prioridade. Assim, a adição é resolvida e,
posteriormente, a multiplicação.
No terceiro quadro (atribuição para a variável C), aparecem na

expressão os operadores de subtração, multiplicação e divisão.
O operador de subtração é o de menor prioridade. No entanto, os
operadores de multiplicação e divisão tem a mesma prioridade. Dessa
forma, o operador da multiplicação será resolvido primeiro, já que ele
aparece mais a esquerda da expressão. Na sequência, a divisão é
resolvida. E, finalmente, a subtração.
Finalmente, no quarto quadro (atribuição para a variável D),

aparecem na expressão os operadores de subtração, multiplicação,
divisão e parênteses. Primeiro, é resolvida a expressão dentro
do parêntese mais a esquerda. Posteriormente, a expressão
entre parênteses mais a direita. Finalizando com a resolução da
multiplicação.
80
Programação 2
5.1.2 Operadores Relacionais
Os operadores relacionais são utilizados para comparar valores

de variáveis ou expressões aritméticas. Uma expressão aritmética
tem como resultado um valor numérico. No caso de uma expressão
relacional, o resultado será sempre um valor lógico: “Verdade” ou
“Falso”. Na tabela abaixo são apresentados os operadores relacionais
do C.
Operador Descrição
== Igualdade
!= Diferença ( )
< Menor
> Maior
<= Menor ou Igual ( )
>= Maior ou Igual ( )
Vamos aprender como montar uma expressão relacional. Segue

abaixo as possíveis sintaxes de expressões relacionais.
Sintaxe
Variavel operador Valor
Variável1 operador variável2
Variavel operador Expressão Aritmética
Expressão Aritmética operador Expressão Aritmética
Notem que podemos montar a expressão relacional de várias

formas. Na tabela abaixo são apresentados exemplos de expressões
relacionais.
Exemplo 5.3: Expressões relacionais
1 X == 10
2 X > Y
3 X < Y + Z
4 X * Y > Z / W
81
Programação 2
Na linha 1, temos uma expressão relacional que verifica se a

variável X é igual a 10 (ou ela será igual a 10 ou não, resultando
em verdade ou falso). Na linha 2, temos uma expressão relacional
que compara duas variáveis. Esta expressão verifica se o valor da
variável X é maior que o valor da variável Y. Na linha 3, a expressão
relacional compara o valor da variável X com o resultado da expressão
aritmética Y + Z. Por fim, na linha 4, temos uma expressão relacional
que compara o resultado de duas expressões aritméticas.
Suponha que X = 1, Y = 5, Z = 8 e W = 2. Vamos ver o resultado

das expressões do exemplo 5.3 (V é verdade e F é falso):
Resultados das expressões relacionais do exemplo 5.3
1 X == 10 => 1 == 10 => F
2 X > Y => 1 > 5 => F
3 X < Y + Z => 1 < 5 + 8 => 1 < 13 => V
4 X * Y > Z / W => 1 * 5 > 8 / 2 => 5 > 4 => V
Quando as expressões relacionais são compostas por expressões

aritméticas (como os exemplos das linhas 3 e 4), a prioridade de
resolução é da expressão aritmética. Assim, primeiro resolve-se
a expressão aritmética e a comparação é feita com o resultado da
mesma.
5.1.3 Operadores Lógicos
Os operadores lógicos servem para interligar duas ou mais

expressões relacionais. Uma expressão lógica representa a união
de expressões relacionais, permitindo que os resultados de várias
expressões relacionais sejam transformados em um único resultado
lógico (verdade ou falso).
Os operadores lógicos são: E, OU e NÃO. A tabela a seguir

apresenta como os operadores lógicos são representados na
linguagem C.
82
Programação 2
Operador Lógico Operador Lógico em C
E &&
OU ||
NÃO !
Os resultados das expressões lógicas obedecem às tabelas que

veremos a seguir, que dependem dos resultados das expressões
relacionais envolvidas. Quando montamos uma expressão lógica, as
expressões relacionais devem ser colocadas entre parênteses.
Começaremos estudando a tabela de resultados do operador lógico

E. Quando este operador interliga duas expressões relacionais, o
resultado da expressão lógica só será verdade se as duas expressões
relacionais forem verdade. Em qualquer outra situação, o resultado
será falso.
Tabela de Resultado do Operador Lógico E (&&)
Expressão Relacional 1 Expressão Relacional 2 Resultado
V V V
V F F
F V F
F F F
Vejamos um exemplo: um aluno só será aprovado se a sua média

for maior ou igual a 7. E, se a quantidade de faltas for menor que 15.
As duas condições precisam ser verdade, para o aluno ser aprovado.
Se o aluno tem a média maior que 7, mas tem mais de 15 faltas, ele
não será aprovado. A expressão lógica para testar esta situação é
apresentada na linha 1 do exemplo 5.4, a seguir.
Exemplo 5.4: Expressões Lógicas com operador e (&&)
1 (media >= 7.0) && (faltas < 15)
2 (A < 5) && (B <> 5)
3 (X > 10) && (Y > 50) && (Z < 25)
83
Programação 2
Quando temos mais de duas expressões relacionais, como é o

caso do exemplo da linha 3, a expressão lógica vai sendo resolvida da
esquerda para a direita. Para acompanhar a resolução das expressões
do exemplo, vamos supor que: media = 8.0, faltas = 18, A=3, B=4, X =
15, Y= 70 e Z=30. Vejamos a figura 5.4 a seguir.
Figura 5.4: Resultado das expressões lógicas do operador &&
No primeiro quadro da figura, a primeira expressão relacional é

verdade e a segunda expressão é falsa. De acordo com a tabela
de resultados do operador lógico E, verdade && falso dá falso. No
segundo quadro, as duas expressões relacionais são verdade. Assim,
de acordo com a tabela de resultados do operador lógico E, verdade
&& verdade dá verdade. Finalmente, no terceiro quadro temos três
expressões relacionais. Neste caso, iremos resolver a expressão
lógica, da esquerda para a direita. Começamos encontrando o
resultado da primeira expressão relacional, com a segunda (ou seja,
(X>10) && (Y>50)). E depois, pegamos este resultado e continuamos
resolvendo o restante da expressão, sempre da esquerda para a
direita. Podemos interligar vária expressões relacionais, através dos
operadores lógicos.
Agora vamos analisar a tabela de resultados do operador lógico

OU. Quando tivermos duas expressões relacionais interligadas pelo
operador lógico ou, o resultado da expressão lógica só será falso se
as duas expressões relacionais forem falsas. Nos demais casos, o
resultado da expressão será verdade.
Tabela de Resultado do Operador Lógico OU (||)
Expressão Relacional 1 Expressão Relacional 2 Resultado
V V V
V F V
F V V
F F F
84
Programação 2
Vejamos um exemplo: para o aluno ingressar em um curso superior

- ele deve ser aprovado no vestibular OU ele deve ser um portador de
diploma. Apenas uma situação precisa ser verdade. Assim, se o aluno
nem passou no vestibular, nem é portador de diploma, não poderá
ingressar no curso. A expressão lógica para testar esta situação
é apresentada na linha 1 do exemplo 5.5, a seguir. Vejam outros
exemplos de expressões lógicas com o operador OU.
Exemplo 5.5: Expressões Lógicas com operador ou (||)
1 (Aprovado_Vestibular == ‘S’) || (Portador_Diploma == ‘S’)
2 (A < 3) || (B < 2)
3 (X < 12) || (Y > 1) || (Z < 35)
A tabela de resultados do operador lógico NÃO é apresentada a

seguir. Notem que a finalidade deste operador é inverter(ou negar,
como é comumente chamado) o resultado de uma expressão
relacional. Assim, se a expressão relacional é verdade, a sua negativa
é falso.
Tabela de Resultado do Operador Lógico Não (!)
Expressão Relacional Resultado
V F
F V
No exemplo 5.6, temos duas expressões lógicas com o operador

NAO. Este operador deve ser colocado na frente da expressão
relacional.
Exemplo 5.6: Expressões Lógicas com operador não (!)
1 !(X < 12)
2 !(Y == 10)
A figura 5.5, ilustra uma situação cotidiana, do uso de operadores

lógicos.
85
Programação 2
Figura 5.5: Uso cotidiano de operadores lógicos
Nós também poderemos ter expressões lógicas, em que aparecem

mais de um tipo de operadores lógicos, além de operadores
aritméticos. Vejamos o exemplo 5.7.
Exemplo 5.7: Expressões Lógicas com vários operadores
1 (X > 10) && (Y < 30) || (Z == 1)
2 (A == 2) || (B <> C) && (D < 1) || (E > 10)
3 !(A == 1) || (B <= C + B)
4 (X + Y < Z + W) && (A < 3 + D) || (F < 5)
Nestes casos, vamos ver a tabela de prioridade de operadores,

para a resolução de tais expressões.
Prioridade Operador
1º Operações embutidas em parênteses “mais internos”;
2º Resto e/ou multiplicação e/ou divisão;
3º Adição e/ou Subtração;
4º Operadores Relacionais;
5º Operadores Lógicos.
Primeiro, resolveremos as expressões aritméticas (seguindo

a prioridade dos operadores aritméticos), depois as expressões
relacionais e, finalmente, as expressões lógicas.
86
Programação 2
5.2. Operadores Aritméticos de Atribuição
A linguagem C oferece um conjunto de operadores que é uma

combinação de operador de atribuição e operador aritmético, são
os operadores aritméticos de atribuição. Eles são utilizados para
representar de maneira reduzida uma operação aritmética, seguida de
uma atribuição. A próxima tabela apresenta os operadores aritméticos
de atribuição e como utilizá-los em nossos programas.
Operador Exemplos de Uso Descrição
+= X += 4; Equivale a X = X + 4;
-= Y -= X; Equivale a Y = Y – X;
*= Z *= W; Equivale a Z = Z * W;
/= K /= 7; Equivale a K = K / 7;
%= L %= M; Equivale a L = L % M
Como pode ser visto, a sintaxe do operador aritmético de atribuição

é: um operador aritmético(+, -, *, /, %) seguido do operador da
atribuição (=). Uma expressão com este tipo de operador, significa que
a variável do lado esquerdo da atribuição, além de receber o resultado,
também fará parte da expressão aritmética. Vejamos o exemplo dado
para o operador +=. A expressão X += 4, quer dizer que: será obtido
o valor da variável X, adiciona 4, e este resultado é atribuído a própria
variável X. Neste caso, é como se fosse um acumulador: acumule 4
ao valor que já tem na variável X.
5.3. Operadores ++ e --
Os operadores ++ e -- são utilizados após o nome de uma variável

e servem para incrementar (++) ou decrementar (--) uma unidade da
variável, ou seja, somar 1 ou subtrair 1 do valor da variável. A tabela
abaixo apresenta os operadores ++ e --, seguidos de exemplos de
uso. Após o ++ ou --, devemos colocar um ponto e vírgula.
Operador Exemplos de Uso Descrição
++ X++; Equivale a X = X + 1;
-- Y--; Equivale a Y = Y -- 1;
87
Programação 2
No exemplo X++, significa que, se X=5, será somado 1 ao valor da

variável X, e assim, X finalizará com 6. Da mesma forma, no exemplo
Saiba Mais Y--, significa que, se Y=5, será subtraído 1 do valor da variável Y, e
assim, Y finalizará com 428.
28
Os operadores
++, -- e
operadores
aritméticos 5.4. Conversão de tipo
de atribuição
fazendo com
que as nossas Quando usamos operadores aritméticos, temos que lembrar que
expressões
fiquem menores, o resultado da expressão depende do tipo das variáveis envolvidas.
já que precisamos
escrever menos
Por exemplo, quando dividimos dois números inteiros, o resultado é a
coisas para a parte inteira do quociente da divisão. Mas, quando dividimos números
montagem da
expressão. reais, o resultado vem completo, a parte inteira e a parte fracionária
do quociente. Outro detalhe que precisamos lembrar é que alguns
operadores só podem ser usados por um tipo de dado. Este é o caso
do operador do resto, nós só podemos utilizá-lo com dados do tipo
inteiro.
Por conta disso, algumas vezes desejamos, momentaneamente,

modificar o tipo do conteúdo de uma variável. Isto é, queremos que
uma variável se “comporte” como se ela fosse de um tipo diferente do
que ela foi declarada. Por exemplo: declaramos uma variável como
int e queremos, momentaneamente, que seu conteúdo seja utilizado
como um float. Este procedimento é chamado de conversão de tipo
ou casting (moldagem, em Inglês).
A conversão de tipo é usada em uma expressão aritmética e é feita

da seguinte forma: antes da variável, colocamos entre parênteses, o
tipo que queremos que a variável seja nesta expressão aritmética.
É importante salientar que a conversão de tipo é feita com o dado
armazenado em uma variável, mas a variável continua tendo o seu tipo
original. Vamos ver o exemplo 5.8, que apresenta uso de conversão
de tipo.
88
Programação 2
Exemplo 5.8: Conversão de tipo
1 int A,B,C;
2 float X,Y;
3 A=3;
4 B=5;
5 X=6.5;
6 C = (int)X % B;
7 Y = (float)A/B;
Nas linhas 1 e 2, temos as declarações de cinco variáveis. Nas

linhas 3, 4, e 5 foram atribuídos valores as variáveis A, B e X. Na linha
6, precisamos executar uma operação para obter o resto da divisão
entre a variável X (que é do tipo float) e a variável B (que é do tipo
int). Esta operação não seria possível, já que o operador do resto
não aceita números reais na expressão. No entanto, esta operação
se torna possível, se fizermos a conversão de tipo da variável X.
Queremos que, nesta expressão, o conteúdo de X seja um inteiro.
Para isso, colocamos (int) na frente da variável X, como mostra a linha
6 do exemplo. Como a variável X tem 6.5 armazenado, nesta conta,
a parte fracionária será desprezada e a conta será feita considerando
que X é 6. Assim, 6 % 5 = 1. Então, 1 é o valor que será atribuído a
variável C.
Vamos ver agora a atribuição da linha 7. Neste caso, estamos

querendo fazer a divisão entre dois números inteiros. Esta conta
é possível, mas ela traz como resultado, apenas a parte inteira do
quociente. No entanto, há situações em que queremos dividir dois
números inteiros, e receber o resultado completo, parte inteira
e fracionária do quociente. Este é o caso da linha 7. Para que o
resultado venha completo, basta que o conteúdo de uma das variáveis
se comporte como um float. Com isso, um float dividido por um int,
temos como resultado um float. Dessa forma, fizemos a conversão
de tipo da variável A, solicitando que seu conteúdo se comporte como
um float. Nesta linha 7 teremos, então, 3.0/5 = 0.6. Este é o valor que
será atribuído a variável Y.
89
Programação 2
5.5. Funções Matemáticas (biblioteca math.h)
A linguagem de programação C possui uma biblioteca que agrupa

um conjunto de funções matemáticas. É a biblioteca math.h. Nesta
seção, vamos ver quatro funções matemáticas, da biblioteca math.h,
que utilizaremos com mais frequência nos nossos programas. São as
funções para encontrar a raiz quadrada de um número, potência (elevar
um número a uma potência) e duas funções de arredondamento. Esta
biblioteca possui outras funções, mas estas são as mais utilizadas
nos nossos programas.
As funções matemáticas precisam receber um ou vários parâmetros

e nos retornam um resultado. Por exemplo, para descobrir a raiz
quadrada de um número, a função precisa saber de que número será
calculada a raiz quadrada. Este número que é fornecido a função é o
parâmetro. Vamos ver a tabela a seguir, em que é feita a descrição
destas funções.
Função Descrição Exemplos de uso
sqrt Função para encontrar a raiz R = sqrt(16);

quadrada de um número. A função
sqrt precisa receber como parâmetro, R = sqrt(A);
o número que desejamos encontrar a
sua raiz quadrada. O resultado desta
função é um número real. Como uma
função retorna um resultado, devemos
atribuí-lo a uma variável.
pow Função para encontrar a potência de P = pow(3,4);

um número, ou seja, eleva um número
a um expoente: AB. Assim, se A = 4 e P = pow(A, 3);
B = 3, 4 elevado a 3 é 64. A função
pow irá receber dois parâmetros. O
primeiro é a base (neste exemplo é o
A) e o segundo é o expoente (neste
caso é o B). Esta função retorna um
número real como resultado.
ceil A função ceil serve para arredondar Z = ceil(1.67);

um número real. Esta função
arredonda o número para cima. Z = ceil(Z);
Assim, ela retornará como resultado:
o primeiro número inteiro maior
que o número que desejamos
arredondar. Por exemplo: se
x = 1.34, e desejamos arredondar com
a função ceil, o resultado será 2.0. Ou
seja, o primeiro número inteiro acima
de 1.34. Apesar do arredondamento,
esta função retorna um número real
como resultado.
90
Programação 2
floor A função floor serve para arredondar Z = floor(1.67);

um número real. Esta função
arredonda o número para baixo. Z = floor(Z);
Assim, ela retornará como resultado:
o primeiro número inteiro menor
que o número que desejamos
arredondar. Por exemplo: se
x = 1.34, e desejamos arredondar com
a função floor, o resultado será 1.0. Ou
seja, o primeiro número inteiro abaixo
de 1.34. Apesar do arredondamento,
esta função retorna um número real
como resultado.
Atenção
Sempre que usarmos estas funções nos nossos programas,

devemos incluir a biblioteca matemática, com a diretiva de
compilação: #include <math.h>.
Devemos ficar atentos ao tipo de dado que a função retorna, para

que seja feita a atribuição para uma variável compatível com o tipo do
resultado. Por exemplo, não podemos atribuir o resultado da função
pow, para uma variável inteira.
Programas Resolvidos
Nesta seção, vamos acompanhar a resolução de dois programas

completos, que utilizarão os comando aprendidos neste capítulo.
Vamos lá?
No primeiro programa que iremos analisar, o aluno fornecerá seu

nome e as duas notas que tirou nas provas de programação. Como
resultado, o programa vai imprimir a média do aluno. Segue abaixo o
programa completo 5.1. Em seguida, vamos comentar cada linha.
91
Programação 2
Programa Completo 5.1: Ler o nome e duas notas

do usuário e imprimir a média.
2 //ler o nome e as duas notas do aluno e imprimir a

media
3 main()
4 {
5 char nome[20];
6 float nota1, nota2, media;
7 printf(“Calcular a media do aluno\n\n”);
8 printf(“Seu nome: “);
9 fflush(stdin);
10 gets(nome);
11 printf(“Nota 1: “);
12 scanf(“%f”, &nota1);
14 scanf(“%f”, &nota2);
15 media = (nota1 + nota2)/2;
16 printf(“\n\n%s, sua media = %.2f”, nome,

media);
17 getche();
18 }
Comentários sobre cada linha do Programa completo 5.1:
• Linha 1: Como iremos ler o nome do aluno, precisamos incluir

a biblioteca stdio.h onde estão os comandos fflush e gets.
• Linha 2: Comentário informando o que o programa faz.
92
Programação 2

“main()”.
• Linha 4: um abre chaves, que irá delimitar o corpo do programa

principal.
• Linhas 5 e 6: declarações das quatro variáveis do programa:

nome, nota1, nota2 e média.
• Linha 7: um printf que serve para colocar, no início da tela, o

título do que o programa faz.
• Linha 8: printf para que o usuário saiba que precisa fornecer

seu nome.
• Linha 9: comando fflush, que DEVE sempre vir antes do

comando gets. Utilizado para limpar o buffer de entrada de
dados.
• Linha 10: gets que efetuará a leitura do nome do usuário.
• Linha 11: printf para que o usuário saiba que precisa fornecer a
primeira nota.
• Linha 12: scanf que lê a primeira nota e armazena na variável

nota1.
• Linha 13: printf para que o usuário saiba que precisa fornecer
a segunda nota.
• Linha 14: scanf que lê a segunda nota e armazena na variável

nota2.
• Linha 15: cálculo da média do aluno. Notem que a soma das

nota1 e nota2 aparece entre parênteses. Devemos lembrar que
o operador da divisão tem prioridade maior que o operador da
soma. Assim, para que a soma das notas seja feita primeiro,
ela deve vir entre parênteses. Não esqueçam deste detalhe!
• Linha 16: printf que apresenta a média do aluno. Notem que na

mensagem, também será escrito o nome do aluno. A média do
aluno será apresentada com duas casas decimais (%.2f)
• Linha 17: comando getche que faz com que a tela de

execução do programa fique aberta, e assim podemos ver o
resultado do programa. Nesta linha também poderíamos usar o
system(“pause”).
93
Programação 2

principal.
É importante que vocês digitem estes programas resolvidos, no

Dev-cpp, assim vão se familiarizando com a sintaxe do C, certo?
Vamos fazer o outro programa?
Nosso segundo programa irá ler um número e vai imprimir a sua

raiz quadrada. Segue abaixo o programa completo 5.2. Em seguida,
vamos comentar cada linha.
Programa Completo 5.2: Ler um número e imprimir a raiz quadrada
1 #include <math.h>
2 //ler um número e encontrar a raiz quadrada
3 main()
4 {
5 float num, raiz;
6 printf(“Calcular a raiz quadrada de um numero\

n\n”);
7 printf(“Numero: “);
8 scanf(“%f”, &num);
9 raiz = sqrt(num);
10 printf(“\n\nA raiz quadrada de %.1f = %.1f.”,

num, raiz);
11 getche();
12 }
Comentários sobre cada linha do Programa completo 5.2:
• Linha 1: Para encontrar a raiz quadrada, iremos utilizar a

função sqrt da biblioteca math.h. Assim, precisamos incluí-la no
nosso programa.
• Linha 2: Comentário informando o que o programa faz.
94
Programação 2

“main()”.
• Linha 4: um abre chaves, que irá delimitar o corpo do programa

principal.
• Linha 5: as declarações das duas variáveis do programa: num

e raiz.
• Linha 6: printf que serve para colocar, no início da tela, o título

do que o programa faz.

número.
• Linha 8: scanf que lê o número e armazena na variável num.
• Linha 9: cálculo da raiz quadrada do número. Usamos a função

sqrt, passando como parâmetro o número que foi digitado pelo
usuário (que está armazenado na variável num). O resultado
da função sqrt é atribuído à variável raiz.
• Linha 10: printf que apresenta o resultado. Notem que será

apresentada apenas uma casa decimal (%.1f) das variáveis
num e raiz.
• Linha 11: comando getche que faz com que a tela de execução
do programa fique aberta, e assim podemos ver o resultado do
programa.

principal.
A figura 5.6 apresenta as duas telas de execução dos programas

completos 5.1 e 5.2.
Figura 5.6: Telas de execução dos programas completos 5.1 e 5.2
95
Programação 2
Com estes dois programas comentados, podemos dar início à

resolução de mais uma lista de exercícios. Continuem programando!
Temos mais uma lista de exercícios para consolidar o entendimento

do assunto visto neste capítulo. A maior parte das questões deve ser
resolvida no computador, certo? Continuem fazendo os programas
e sempre que der erro tenham calma para encontrá-los. Fiquem
atentos(as) com a sintaxe de cada comando, para não cometer erros
com tanta frequência. Vamos iniciar nosso novo treino?
1. Dados os valores inteiros abaixo:
MEDIA NOTA TOTAL Z K X I J A
0 2 10 0 7 4 80 -1 -4
Quais os valores resultantes depois da execução dos passos a

seguir:
1) X = TOTAL/NOTA; 6) K += 9;
2) X = X+1; 7) Z = J / 5;
3) NOTA = X; 8) K = I % 5;
4) TOTAL = NOTA + X + TOTAL; 9) I ++;
5) MEDIA = 3; 10) I = I+2*A;
2. De acordo com os valores das variáveis abaixo, encontre o

resultado das expressões lógicas com VERDADE ou FALSO:
A B C D E
10 3 2 2 25
a) A == D
b) (A>B) && (C==D)
c) (E+2<B+C) && (A==10)
96
Programação 2
d) (D*E>100) || (B<5)
e) (E==25) && (A >B+C+D) && (C<B)
f) !(A < 15) && (B>=3)
g) (D>2) || (C == 7) && (E > 20)
3. Faça um programa que leia um número qualquer e imprima o

seu cubo.
4. Uma empresa vai dar um aumento de salário ao seu

funcionário. Faça um programa para ler o salário do funcionário
e o percentual de reajuste. Calcular e escrever o valor do novo
salário.
5. Faça um programa para ler o número de votos brancos, nulos

e válidos de uma eleição. Calcular e escrever o percentual que
cada um representa em relação ao total de eleitores.
6. Faça um programa que leia o número total de prestações de

um consórcio, o total de prestações pagas e o valor atual da
prestação. O programa deve calcular e apresentar o saldo
devedor atual e a quantidade de prestações sem pagar.
7. Dada as seguintes entradas: quilometragem inicial,

quilometragem final, litros consumidos, preço do litro de
combustível. Faça um programa que imprima o seguinte
Relatório: distância percorrida, Valor total gasto e o consumo do
carro(quantos quilômetros percorre com 1 litro de combustível).
8. Um motorista de táxi deseja calcular o rendimento de seu carro

na praça. Sabendo-se que o preço do combustível é de R$2.59,
faça um programa para ler: a marcação do odômetro (Km) no
início do dia, a marcação (Km) no final do dia, a quantidade
de litros de combustível gasto e o valor total (R$) recebido dos
passageiros. Calcular e escrever: a média do consumo em km/l
e o lucro (líquido) do dia.
9. Faça um programa que leia os preços de uma mercadoria em

abril e maio. Tendo como base a variação dos preços desta
mercadoria, calcule a taxa de inflação.
10. Faça um programa que leia o tempo de duração de um evento

em uma fábrica expressa em segundos e mostre-o expresso
em horas, minutos e segundos.
97
Programação 2
11. Faça um programa para um caixa eletrônico, que lê o valor

que o cliente quer sacar e calcula o menor número possível de
notas de 100,00, 50, 20 e 10 reais em que o valor lido pode ser
decomposto. Escrever o valor do saque e a relação de notas
necessárias. Suponha que o sistema monetário não utiliza
centavos. Atenção: Só digite números múltiplos de 10.
Exemplo: Valor: R$ 380,00
Notas de R$ 100,00: 3
Notas de R$ 50,00: 1
Conheça Mais
Pesquisem na Internet outra funções matemáticas disponíveis na

biblioteca math.h. Comecem a pesquisa pelo site:
http://visualcplus.blogspot.com/2006/03/mathh.html
Vamos revisar?
Para revisarmos os tópicos tratados neste capítulo, observem o

resumo a seguir:
• Os operadores aritméticos são utilizados quando desejamos

resolver expressões aritméticas. Devemos prestar atenção no tipo
das variáveis que estão sendo utilizadas na expressão, pois o tipo
interfere no resultado da expressão.
• Os operadores relacionais são utilizados quando desejamos

comparar valores de variáveis. O resultado de uma expressão
relacional é sempre “verdade” ou “falso”.
• Os operadores lógicos servem para interligar duas ou mais

expressões relacionais. O resultado de uma expressão lógica é
sempre “verdade” ou “falso”.
98
Programação 2
• Podemos utilizar os operadores aritméticos de atribuição para

reduzir o tamanho das expressões aritméticas.
• Os operadores ++ e – incrementam ou decrementam 1 de uma

variável.
• Na biblioteca math.h podem ser encontradas funções matemáticas

para encontrar a raiz quadrada de um número, potência,
arredondamento de números reais, dentre outras.
Considerações Finais
Neste volume, tivemos a oportunidade de iniciar nosso

aprendizado na linguagem de programação C. Nos capítulos 1 e
2, conhecemos os principais conceitos desta área (programação,
linguagem de programação, um pouco do histórico do C, dentre
outros), nos preparando para um melhor entendimento da linguagem
de programação C. Nos capítulos 3, 4 e 5, começamos a estudar a
sintaxe da linguagem de programação C, vimos os tipos de dados
manipulados pela linguagem, os comandos de entrada e saída
e a utilização dos operadores aritméticos, relacionais e lógicos.
Estes assuntos nos deram o conhecimento suficiente para iniciar
o desenvolvimento dos nossos primeiros programas em C. Mas
estamos apenas no início. Temos mais três volumes, que nos darão
a capacidade de desenvolver programas mais complexos. Continuem
firmes nos estudos! Até o próximo módulo.
Referências
ARAÚJO, Jairo. Dominando a Linguagem C. São Paulo: Ciência

Moderna, 2004.
ASCENIO, Ana Fernanda Gomes e CAMPOS, Edilene Aparecida

Veneruchi. Fundamentos de Programação de Computadores.
São Paulo: Prentice Hall, 2002.
DEITEL, H, M e DEITEL, P. J. Como Programar em C. Rio de

Janeiro: LTC, 1999.
LAUREANO, Marcos. Programando em C Para Linux, Unix e
99
Programação 2
Windows. Rio de Janeiro: Brasport, 2005.
MIZRAHI, Victorine Viviane. Treinamento em Linguagem C –

Curso Completo. São Paulo: Makron, 1999.
MONTGOMERY, Eduard. Programando em C: Simples e

Prático. São Paulo: Alta Books, 2006.
OLIVEIRA, Ulisses. Programando em C – Volume I –

Fundamentos. São Paulo: Ciência Moderna, 2004.
SCHILDT, Herbert. C Completo e Total. São Paulo: Makron,

1996.
SEBESTA, Robert. Conceitos de Linguagem de Programação.

São Paulo: Makron, 2003.
Conhecendo a Autora
Sou graduada em Ciência da computação pela Universidade

Federal de Sergipe. Fiz mestrado e doutorado na Universidade Federal
de Pernambuco, desenvolvendo pesquisas nas áreas de Sistemas
Distribuídos e Geoprocessamento. Começei a ensinar em 2000, nos
cursos de Ciência da Computação e Sistemas de Informação. Desde
o início da minha carreira como professora, ministro disciplinas de
Programação e tenho uma paixão pela linguagem C. Atualmente,
encontrei uma nova paixão: Educação a Distância.
100
Programação 2
Recife, 2009

Coordenação de Ensino a Distância: Profª Marizete Silva Santos

Capa e Editoração: Allyson Vila Nova, Rafael Lira, Italo Amorim e Márcio Heitor
Revisão Ortográfica: Marcelo Melo
Ilustrações: Diego Almeida e Glaydson da Silva
Sumário
Apresentação.........................................................................................5
Conhecendo o Volume 2.......................................................................6
Capítulo 1 – Estruturas de Seleção......................................................8
1.1. Estruturas de Controle..................................................................8
1.2. If… Else (se… senão)...................................................................9
1.2.1. If Simples.............................................................................10
1.2.2. If Composto.........................................................................14
1.2.3. If Aninhado..........................................................................19
1.3. Switch (Escolha-Caso)...............................................................24
1.4. Identação de um Programa........................................................31
Capítulo 2 – Estruturas de Repetição................................................39
2.1. For (para... faça).........................................................................39
2.2. While (enquanto... faça – teste no início)...................................46
2.3. Do/while (repita... até - teste no final).........................................49
2.4. Uso do break na Estrutura de Repetição....................................56
Capítulo 3 – Modularização.................................................................64
3.1. O que são módulos e por que utilizá-los?..................................64
3.2. Estrutura de um módulo.............................................................66

3.3. Em que ponto do programa os módulos devem ser
implementados?................................................................................69
3.4. Escopo das Variáveis.................................................................70
3.5. Parâmetros.................................................................................71
3.6. Contexto do Módulo (Ação ou Resultado)..................................72
3.7. Ativando Funções.......................................................................73

Apresentação
Caro(a) aluno(a),
Seja bem-vindo (a) ao segundo módulo da disciplina Programação II. Nesta disciplina,
você está aprendendo a programar na linguagem de programação C, uma das mais
utilizadas mundialmente.
No volume I, você aprendeu os comandos básicos do C, que permitiram a construção

dos primeiros programas nesta linguagem. Neste volume II, será dado um novo passo,
conhecendo um pouco mais desta linguagem, analisando novos comandos que
melhorarão a capacidade de resolver problemas computacionais.
Este livro segue a mesma ideia do volume I, os assuntos são apresentados de forma
gradativa, com muitos exemplos de programas completos e comentados, visando um
bom entendimento, principalmente para as pessoas que estão iniciando no mundo da
programação. Ao final de cada capítulo, você poderá testar o seu aprendizado e assimilar
melhor o que foi estudado, através da resolução de exercícios. Isto é muito importante!
Não deixe de resolvê-los.
Vale lembrar que, para um bom andamento dos estudos destes novos assuntos, você
terá que ter assimilado o conteúdo do volume I, pois este continuará sendo utilizado em
todos os nossos programas. Mas isto não é um problema para quem vem resolvendo
questões de programação regularmente, não é mesmo?
O objetivo deste segundo módulo é apresentar as estruturas de controle de fluxo:

seleção e repetição. Além disso, também será analisada a divisão de programas em
módulos/funções, visando a um desenvolvimento mais rápido e um código mais legível.
Ao final deste módulo, você vai perceber o quanto a sua capacidade de resolver
programas foi aumentada. Convido-lhe para uma nova etapa no conhecimento da
linguagem de programação C. Vamos começar?
Bons estudos!

Programação 2
Neste segundo volume, vocês irão encontrar o módulo 02 da

disciplina: Programação II. Este volume está estruturado em três
capítulos, que serão estudados ao longo de 15h/aula. Para facilitar
seus estudos, veja a organização deste volume.
Capítulo 1: Estruturas de Seleção
Objetivos do Capítulo 1: Apresentar a sintaxe das duas

estruturas de seleção (if e switch), disponíveis na linguagem de
programação C.
• Estruturas de controle
• Estrutura de seleção if: simples, composto e aninhado
• Estrutura de seleção switch.
Capítulo 2: Estruturas de Repetição
Objetivos do Capítulo 2: Apresentar a sintaxe das três

estruturas de repetição (for, while e do/while), disponíveis na
linguagem de programação C.
• Estrutura de repetição for
• Estrutura de repetição while
• Estrutura de repetição do/while
• Comando break.
Capítulo 3: Modularização de Programas
Objetivos do Capítulo 3: Apresentar como se criam

módulos(funções e procedimentos) em um programa C.
6
Programação 2
• Estrutura de um módulo
• Variáveis locais e globais
• Parâmetros
• Chamada de um módulo
• Comando return.
Ao final de cada capítulo vocês encontrarão:



7
Programação 2
Capítulo 1 – Estruturas de
Seleção
Nos programas que desenvolvemos até este momento, todos

os comandos que aparecem no programa são executados, ou seja,
o processador vai passando e executando cada um dos comandos
do programa. Existem situações em que não queremos que todos os
comandos sejam executados. Nestes casos, devemos utilizar alguma
estrutura de seleção, que nos permite desviar de uma sequência de
comandos do programa. Neste capítulo, iremos aprender a utilizar as
estruturas de seleção disponíveis na linguagem C, que são: if e switch.
Estas estruturas correspondem ao “se” e “escolha” do Portugol. As
estruturas de seleção também podem ser chamadas de: estruturas
de decisão ou estruturas de desvio. Vamos avançar, um pouco mais,
nossos conhecimentos em C?
1.1. Estruturas de Controle
De um modo geral, os comandos de um programa são executados

um após o outro, na ordem em que foram escritos – de cima para
baixo e da esquerda para a direita. Este é o fluxo de execução de um
programa. Mas, através do uso de estruturas de controle, podemos
controlar o fluxo de execução dos nossos programas. Existem três
tipos de estruturas de controle:
• Sequência: nesta estrutura, todos os comandos são executados

uma única vez, de forma linear, um após o outro. Até então,
nossos programas foram desenvolvidos desta forma.
• Seleção: esta estrutura permite que um grupo de comandos

seja executado ou não, dependendo do resultado de uma
condição (representada por expressões relacionais ou lógicas).
Dessa forma, poderemos ter um conjunto de comandos do
nosso programa que não vai ser executado.
• Repetição: com estas estruturas, poderemos fazer com que

uma sequência de comandos seja executada várias vezes.
8
Programação 2
Para entender melhor as estruturas de controle, vamos fazer a

seguinte analogia: imagine que o nosso programa é uma estrada. As
retas são as sequências. Os entroncamentos são as estruturas de
seleção, que nos permitem pegar um caminho ou outro. As rotatórias
e os retornos são as estruturas de repetição, que nos permitem passar
várias vezes pelo mesmo local. A Figura 1.1 apresenta estradas com
retas, entroncamentos e rotatórias.
Figura 1.1: Retas, entroncamentos e rotatórias
Nas próximas seções, deste capítulo, vamos conhecer as

estruturas de seleção do C. No capítulo seguinte, conheceremos as
estruturas de repetição.
1.2. If… Else (se… senão)
A estrutura de seleção if é a estrutura de seleção mais simples. No

entanto, esta estrutura resolve todo e qualquer problema de seleção.
Esta estrutura permite executar um entre vários blocos de comandos.
A escolha de qual bloco será executado depende do resultado de uma
condição (expressão relacional ou lógica, apresentadas no capítulo Atenção
5 do volume I1). A sintaxe geral para o comando if é apresentada

1
Vale lembrar que
abaixo: o resultado de
uma expressão
relacional ou
Sintaxe expressão lógica
é sempre verdade
ou falso.
if (condição)
bloco_de_comandos1;
else
bloco_de_comandos2;
Neste comando, a condição é verificada e, caso o resultado seja

verdade, o bloco_de_ comandos1 será executado. Caso contrário, o
bloco_de_comandos2 é executado. Note que somente um dos blocos
9
Programação 2
será executado. Apesar de possuir uma forma geral, esta estrutura

pode se apresentar de modos ligeiramente diferentes: if simples,
composto ou aninhado. Nas próximas seções vamos analisar,
separadamente, cada uma das possibilidades de sintaxe.
1.2.1. If Simples
O if simples é o if sem o else. O if simples é utilizado quando se

deseja executar uma sequência de comandos, apenas se a condição
for verdade. Dessa forma, não existe uma sequência de comandos
para ser executada quando a condição é falsa. A figura 1.2 apresenta
o fluxograma do if simples. A condição do if será testada, se for
verdade, o bloco de comandos vinculado ao if é executado. Se for
falso, o bloco de comandos vinculado ao if é desviado.
Figura 1.2: Fluxograma do if simples
As sintaxes para o if simples são as seguintes:
Sintaxe
if (condição) if (condição)
comando; { comando1;
comando2;
Quando o if simples tem apenas um comando, utilizamos a sintaxe

da esquerda. Quando o if simples tem mais de um comando para ser
executado, devemos colocar a sequência de comandos entre chaves.
10
Programação 2
As chaves servem para que o compilador saiba quantos comandos2

vão ser desviados, caso a condição seja falsa. Quando não colocamos
as chaves, o compilador entende que apenas um comando deve ser Atenção
desviado. A figura 1.3 apresenta dois exemplos aplicando a sintaxe do
if simples.
2
Até então,
tínhamos
somente as
chaves que
if simples com um comando if simples com mais de um comando delimitavam
o corpo do
programa
main() main() principal.
Veremos que as
chaves também
{ comando 1; { comando 1;
aparecerão em
outras situações.
comando 2; comando 2;
if (condicao) if (condicao)
comando 4; { comando 4;
comando 6; }
} comando 7;
Figura 1.3: Exemplos de if simples Atenção
As condições do
Vamos analisar os exemplos da figura 1.3. O programa principal if devem vir entre
da esquerda é formado por sete comandos. O programa vai sendo parênteses. Se
tivermos mais de
executado, passando pelos comando1, comando2 e comando3. Ao uma expressão
relacional, estas
chegar no if, a condição é avaliada. Se a condição for verdade, o são conectadas
comando4 será executado. Se esta condição for falsa, o comando4 por operadores
lógicos.
será desviado (ou seja, não será executado). Na sequência, são O abre chaves
que delimita
executados os comando5, comando6 e comando7. o bloco de
comandos
O programa principal da direita também é composto de sete vinculado ao if é
colocado após a
comandos. Os comando1, comando2 e comando3 são executados. condição do if. O
Na seqüência, temos o if, que tem a sua condição avaliada. Se a fecha chaves é
colocado após o
condição for verdade, os comando4 e comando5 são executados. último comando
do bloco de
Caso contrário, os comando4 e comando5 são desviados. Como este comandos do if.
if possui dois comandos, foi necessário colocá-los entre chaves. Na O if e o else
devem ser
sequência, os comando6 e comando7 são executados. escritos todo em
letras minúsculas.
11
Programação 2
Vamos ver um exemplo do uso do if simples? O programa 1.1

solicita o saldo atual do cliente e o valor que ele deseja retirar no
banco. O programa vai calcular e apresentar o valor do saldo do
cliente, após o saque. Caso o saldo fique negativo, deve ser escrito
uma mensagem informando esta situação ao cliente.
Programa Completo 1.1
1 main()
2 {
3 float saldo,valor_saque;
4 printf(“Banco Poupe Aqui\n\n\n”);
5 printf(“Saldo atual: R$ “);
6 scanf(“%f”,&saldo);
7 printf(“\n\nValor do saque: R$ “);
8 scanf(“%f”,&valor_saque);
9 saldo = saldo – valor_saque;
10 printf(“\n\nSaldo apos o saque: R$%.2f

\n\n”,saldo);
11 if(saldo<0)
12 printf(“\nAtencao: sua conta ficou com saldo

NEGATIVO!\a”);
13 getche();
14 }
Comentários sobre o programa completo 1.1:

“main()”.

programa principal.
• Linhas 3: temos as declarações das duas variáveis do

programa: saldo e valor_saque.
• Linha 4: um printf que serve para colocar, no início da tela, o

título do que o programa faz. Neste caso, foi colocado o nome
do banco.
12
Programação 2

seu saldo atual.
• Linha 6: scanf que lê o saldo do cliente.

valor do saque.
• Linha 8: scanf que lê o valor do saque.
• Linha 9: Como já sabemos o valor do saldo e quanto será

sacado, podemos calcular quanto ficará o saldo depois do
saque.
• Linha 10: printf para apresentar o valor do saldo após o saque.
• Linha 11: if que testa se o saldo ficou negativo. A condição

para informar se o saldo está negativo é o saldo ser um valor
menor que zero (saldo < 0). Assim, a condição do if é montada
e colocada entre parênteses. Se o saldo for menor que zero, a
mensagem de saldo negativo deve ser apresentada.
• Linha 12: printf para mostrar que o saldo ficou inválido. Veja
que este comando está vinculado ao if, dessa forma, ele só
será executado se a condição do if for verdade. Como o if tem
apenas um comando, não precisamos colocar chaves.
• Linha 13: comando getche que faz com que a tela de

execução do programa fique aberta, e assim podemos ver o
resultado do programa. Nesta linha também poderíamos usar o
system(“pause”).

principal.
A figura 1.4 apresenta duas telas de execução do programa

completo 1.1. No primeiro caso, o saldo permanece positivo após o
saque. Dessa forma, o comando vinculado ao if não foi executado. No
segundo caso, o saldo ficou negativo após o saque, assim, o comando
vinculado ao if foi executado (printf que imprime mensagem de saldo
negativo).
13
Programação 2
Saldo positivo após o saque
Saldo negativo após o saque
Figura 1.4: Telas de execução do programa completo 1.1
Agora que já sabemos como usar o if simples, vamos aprender a

utilizar o if composto.
1.2.2. If Composto
O if composto é o if com o else, dessa forma, teremos uma

sequência de comandos que é executada quando a condição resulta
em verdade e uma outra sequência que é executada quando a
condição é falsa.
A figura 1.5 apresenta o fluxograma do if composto. A condição do

if será testada, se for verdade, o bloco de comandos 1 é executado.
Se for falsa, o bloco de comandos 2 é executado. Notem que apenas
um dos bloco de comando será executado.
14
Programação 2
Figura 1.5: Fluxograma do if composto
Seguem abaixo as sintaxes para o if composto:
Sintaxe
Caso 1 Caso 2
comando1; { comando1;
else comando2;
comando2; }
else
comando3;
Caso 3 Caso 4
else comando2;
{ comando2; }
comando3; else
} { comando3;
comando4;
De um modo geral, na sintaxe do if composto, teremos o if,

juntamente com a condição que será testada. Abaixo da linha do
15
Programação 2
if, temos um comando ou uma sequência de comandos que será

executada se a condição for verdade. Logo em seguida temos o else e
um comando ou um sequência de comandos que é executada quando
a condição do if é falsa.
Vamos ver qual a diferença entre as quatro sintaxes. Existe uma

regra que diz: se tivermos mais de um comando para ser executado
quando a condição for verdade, temos que colocar a sequência de
comandos entre chaves. Para um único comando, as chaves não são
necessárias. A mesma regra vale para a sequência de comandos do
else, mais de um comando, a sequência deve vir entre chaves.
Analisando a tabela com as quatro sintaxes temos:
• Caso 1: Se a condição for verdade, apenas um comando será

executado. Se a condição for falsa, apenas um comando será
executado. Como tivemos um comando na sequência do if e
um comando na sequência do else, não é necessário colocar
chaves.
• Caso 2: Se a condição for verdade, vários comandos serão

executados. Dessa forma, é necessário colocar as chaves para
delimitar a sequência de comandos do if. Quando a condição
for falsa, apenas um comando será executado. Assim, não
necessita colocar as chaves no comando do else.
• Caso 3: Se a condição for verdade, apenas um comando

será executado. Com isso, não precisamos colocar as chaves
no comando do if. No entanto, se a condição for falsa, vários
comandos devem ser executados. Com isso, a sequência de
comandos do else deve vir entre chaves.
Atenção • Caso 4: Se a condição for verdade, vários comandos serão
executados. Dessa forma, precisamos colocar a sequência de
O else não tem
condição. A comandos do if entre chaves. Se a condição for falsa, também
condição é do if.
Se a condição
serão executados vários comandos. Assim, a sequência do else
for falsa, a precisa ser colocada entre chaves.
sequência do else
é executada.
Tomar cuidado Vamos analisar um programa completo que utiliza o if composto.
com as chaves Este programa lê o nome do aluno e as suas duas notas. Em seguida,
que delimitam
a sequência de calcula a média do aluno e apresenta uma mensagem informando se
comandos do if e
do else. o aluno foi aprovado ou reprovado (considerar que a média para ser
aprovado é igual ou maior que 7.0).
16
Programação 2
2 main()
3 {
4 float n1, n2, media;
5 char nome[20];
6 printf(“Caderneta de Notas\n\n”);
7 printf(“Nome do aluno: “);
8 fflush(stdin);
9 gets(nome);
11 scanf(“%f”,&n1);
13 scanf(“%f”,&n2);
14 media = (n1+n2)/2;
15 if (media>=7)
16 printf(“\n\n%s foi aprovado(a) com media

%.1f\n”,nome, media);
17 else
18 printf(“\n\n%s foi reprovado(a) com media

%.1f\n”,nome, media);
19 getche();
20 }
• Linha 1: inclusão da biblioteca stdio, devido o comando fflush,

que será usado quando formos ler o nome do aluno.

“main()”.

programa principal.
17
Programação 2
• Linhas 4 e 5: temos as declarações das variáveis do

programa.
• Linha 6: o printf que serve para colocar, no início da tela, o título

do que o programa faz. Neste caso, será colocado “caderneta
de notas”.
• Linhas 7 a 13: leitura das variáveis de entrada: nome do aluno,

a primeira e a segunda nota.
• Linha 14: cálculo da média do aluno.
• Linha 15: if composto que verifica qual o valor da média, para

escrever a mensagem se o aluno foi aprovado ou reprovado.
Para o aluno ser aprovado, a média tem que ser maior ou igual
a 7. A montagem da condição é feita utilizando operadores
relacionais. Além disso, a condição foi colocada entre
parênteses.
• Linha 16: printf que é executado quando a condição do if

for verdade. Neste caso, quando a média do aluno for maior
ou igual a 7. Note que a mensagem informa que o aluno foi
aprovado. Como apenas um comando está vinculado ao if, não
houve a necessidade de colocar chaves.
• Linha 17: temos um else, que indica que também teremos uma
sequência de comandos para ser executada quando a condição
do if for falsa, ou seja, média do aluno menor que 7.
• Linha 18: printf que é executado quando a condição do if for

falsa. Note que a mensagem informa que o aluno foi reprovado.
Como apenas um comando está vinculado ao else, não houve
a necessidade de colocar chaves.
programa.

principal.

completo 1.2. No primeiro caso, o aluno é aprovado e no segundo
caso, é reprovado.
18
Programação 2
Aluno aprovado
Aluno reprovado
Agora só falta estudarmos o último tipo de if, que é o if aninhado.

Vamos aprender mais um pouco?
1.2.3. If Aninhado
O if composto, visto na seção anterior, é usado quando temos

duas possibilidades de resposta. Por exemplo, ou o aluno é aprovado
ou é reprovado. Apenas uma situação irá ocorrer. O if aninhado
ocorre quando temos mais de duas possibilidades de respostas (ou
situação). Por exemplo, ao comparar dois números (x e y), temos
três possibilidades de resposta: x é menor que y, x é maior que y, ou
ainda, x e y são iguais. Assim, a primeira possibilidade será testada
na condição do if (verificando se x é menor que y). Se a condição for
falsa, ainda temos duas possibilidades de resposta. Para fazer esta
verificação, necessitamos de um outro if. Este novo if será colocado
dentro da sequência de comandos do else. Assim, teremos um if
dentro do outro, por isso é chamado de if aninhado.
19
Programação 2
A seguir, são apresentadas duas sintaxes de if aninhado. No

caso 1, temos três possibilidades de respostas e no caso 2, quatro
possibilidades. Vale lembrar que podemos ir aninhando um if dentro
do outro, sem um limite de aninhamento. Só depende de quantas
possibilidades de situações teremos que testar.
Sintaxe
Caso 1: três possibilidades de Caso 2: quatro possibilidades de

resposta resposta
if (condição1) if (condição1)
comando1; comando1;
else else
{ if (condicao2) { if (condicao2)
comando2; comando2;
else else
comando3; { if (condicao3)
} comando3;
else
comando4;
No caso 1, se a condição1 do primeiro if for verdade, o comando1

será executado e toda a sequência do else é desviada. No entanto, se
a condição1 do if for falsa, o fluxo do programa é desviado para o else.
Quando chega no else, é encontrada uma sequência de comandos
(por isso é necessário colocá-la entre chaves). Mas, nesta sequência
Atenção
tem um if, que precisa ter a sua condição avaliada. Se a condicao2
deste if for verdade, o comando2 é executado. Caso seja falsa, o
Existe if sem else fluxo do programa é desviado para o else e executa o comando3.
(que é o primeiro
caso de if que Dessa forma, apenas um dos comandos (comando1, comando2 ou
estudamos – if
comando3) será executado, os demais serão desviados.
simples), mas
todo else está
vinculado a um if. Um comportamento similar ocorre com o caso 2, que analisa quatro
Não colocar ponto
possibilidades de respostas.
e vírgula depois
da condição do if Vamos analisar um programa completo que utiliza o if aninhado.
20
Programação 2
Neste programa, serão lidos dois números inteiros(x e y) e seus

valores serão comparados. O programa irá escrever uma das três
mensagens: x é maior que y, x é menor que y ou x e y são iguais. Na
sequência, as linhas do programa serão comentadas.
1 main()
2 {
3 int x, y;
4 printf(“Compara Numeros\n\n”);
5 printf(“X: “);
6 scanf(“%d”,&x);
7 printf(“\nY: “);
8 scanf(“%d”,&y);
9 if (x > y)
10 printf(“\n\n%d eh maior que %d”,x,y);
11 else
12 { if (x < y)
13 printf(“\n\n%d eh menor que %d”,x,y);
14 else
15 printf(“\n\nX e Y sao iguais: %d”,x);
16 }
17 getche();
18 }

“main()”.

programa principal.
• Linha 3: temos as declarações das variáveis do programa.
• Linha 4: o printf que serve para colocar, no início da tela, o título
21
Programação 2
do que o programa faz. Neste caso, será colocado “Compara

Números”.
• Linhas 5 a 8: leitura das variáveis de entrada: x e y.
• Linha 9: Agora que já conhecemos o valor de x e y, devemos

começar a comparação. Nesta linha temos um if, com a
condição para verificar se x é maior que y. Se esta condição
for verdade, o comando da linha 10 será executado e todos os
comandos dentro do else serão desviados.
• Linha 10: printf para escrever que x é maior que y.
• Linha 11: temos um else, o programa terá seu fluxo desviado

para o else, caso a condição do if seja falsa. Notem que, se o
x não é maior que y, ainda temos que descobrir se x é menor
que y ou se x e y são iguais. Por conta disto, na sequência de
comandos deste else, será necessário colocar um if composto.
Por termos uma seqüência de comandos, devemos colocá-la
entre chaves.
• Linhas 12: abre chaves para informar que começará a

sequência de comandos do else, além do if que verifica a
segunda possibilidade de resposta: se x é menor que y.
• Linha 13: printf para escrever que x é menor que y. Este printf
é executado caso a condição do if da linha 12 seja verdade.
• Linhas 14: temos um else, que está vinculado ao if da linha 12.

Ou seja, se a condição deste if for falsa, o fluxo do programa é
desviado para este else.
• Linha 15: printf para escrever que x e y são iguais. Este printf é
executado caso a condição do if da linha 12 seja falsa.
• Linhas 16 e 17: temos o getche() e o fecha chaves, indicando o

final do programa principal.
A figura 1.7 apresenta telas de execução do programa completo

1.3, mostrando as três possibilidades de respostas.
22
Programação 2
X menor que Y
X maior que Y
X igual a Y
Agora que já sabemos utilizar os três casos da estrutura de

seleção if: simples, composto e aninhado, vamos analisar um outro
tipo de estrutura de seleção disponível no C, que é o switch. Vale
lembrar que o if é um tipo de estrutura de seleção que pode ser
aplicada em qualquer situação em que seja necessária tomar uma
decisão no programa. O switch apresenta algumas restrições e nem
sempre poderemos utilizá-lo. No entanto, o switch tem uma sintaxe
mais “limpa” que a do if. Dessa forma, sempre que for possível o seu
uso, é interessante incluí-lo no programa. Vamos ver como o switch
funciona?
23
Programação 2
Figura 1.8: Quadrinhos sobre decisão
1.3. Switch (Escolha-Caso)
O switch é uma estrutura de decisão que permite a execução de uma

sequência de comandos a partir da análise do valor de uma variável
inteira ou de uma variável com um único caractere. Normalmente,
o switch é usado quando sabemos os prováveis valores que uma
variável pode armazenar, e para cada valor, temos que executar uma
sequência de comandos diferente. A grande restrição do switch é que
ele não funciona para variáveis reais, nem cadeia de caracteres. Além
disso, o switch testa se a variável é igual a um valor.
No caso de uma condição usada no if, nós podemos usar qualquer

tipo de variável, além de podermos verificar se seus valores são:
menor que, maior que, diferente de, etc., e não apenas a igualdade.
Por conta dessas restrições, não é em toda situação de seleção que o
switch pode ser utilizado. No Portugol, o switch é o comando escolha-
caso. Significando que uma sequência de comandos será escolhida,
caso a variável tenha um certo valor. Vamos analisar as sintaxes do
switch.
24
Programação 2
Sintaxe
Caso 1: sem o default Caso 2: com o default
switch (variavel) switch (variavel)
{ case valor1: comando1; { case valor1: comando1;
comando2; comando2;
break; break;
case valor2: comando3; case valor2: comando3;
comando4; comando4;
break; break;
case valor3: comando5; case valor3: comando5;
comando6; comando6;
break; break;
} default: comando7;
comando8;
break;
A sintaxe do switch é a seguinte: após o switch, colocamos o nome

da variável que será avaliada, entre parênteses. Para cada possível
valor que a variável pode assumir, colocaremos um case e ao lado, o
valor da variável seguido de dois pontos(:). Em seguida, colocamos
a sequência de comandos que deve ser executada, caso a variável
tenha este valor. A sequência de comandos deve ser finalizada com
o comando break, obrigatoriamente. Assim, para cada valor que a
variável pode assumir, teremos um case e a sequência de comandos.
A sequência de comandos não precisa vir entre chaves. No entanto,
temos as chaves que abre e fecha o comando switch.
Ao executar o switch, o processador irá procurar um case que

tenha o valor que a variável está armazenado no momento. Quando
encontrar, executa a sequência de comandos relacionada a este
valor e o break faz com que o fluxo do programa seja desviado para
o primeiro comando depois da chaves que fecha o switch. Assim,
só será executada a sequência de comandos de um único case. No
entanto, caso a variável não esteja armazenando um dos valores
25
Programação 2
previstos, nenhuma sequência de comandos será executada.
Além dos case com os prováveis valores das variáveis, também

podemos colocar a cláusula default no nosso switch (Caso 2, da
Atenção
sintaxe). O default funciona como um else, ou seja, se a variável
O default deve não tiver nenhum dos valores previstos nos case, será executada
ser, sempre, a a sequência de comandos do default. O default é opcional, assim,
última sequência
de comandos do podemos ter switch com ou sem default.
switch.
Abaixo, temos o exemplo 1.1 que apresenta um switch sem o
Não podemos
colocar dois default. A variável cargo é inteira e pode assumir os valores 1, 2 ou 3.
case testando o
mesmo valor. Dependendo do cargo do funcionário, é dado um aumento diferenciado
ao salário do mesmo. Notem o break no final de cada sequência de
Quando a variável
do switch for um comandos dos case.
char, devemos
colocar os
possíveis valores Exemplo 1.1: Switch sem default
da variável entre
apóstrofos, por
exemplo: case 1 switch (cargo)
‘a’:.
2 { case 1: sal = sal + 200;
3 break;
4 case 2: sal = sal + 400;
5 break;
6 case 3: sal = sal + 600;
7 break;
8 }
No exemplo 1.2 temos um switch com o default. Neste exemplo,

se a variável cargo não estiver com 1, 2 ou 3, será executada a
sequência de comandos do default. Ou seja, qualquer outro valor
diferente dos valores previstos, a sequência de comandos do default
será executada.
26
Programação 2
Exemplo 1.2: Switch com default
1 switch (cargo)
2 { case 1: sal = sal + 200;
3 break;
4 case 2: sal = sal + 400;
5 break;
6 case 3: sal = sal + 600;
7 break;
8 default: sal = sal + 100;
9 break;
10 }
Uma outra situação que pode acontecer é: uma mesma sequência

de comandos deve ser executada para diferentes valores da variável.
Por exemplo, para os funcionários dos cargos 1 e 2 será dado o mesmo
aumento salarial. Assim, para não repetirmos a mesma sequência de
comandos no case 1 e 2, faremos como mostra a linha 2 do exemplo
1.3. Coloca-se o primeiro case com o respectivo valor e após os dois
pontos, vem o próximo case e o valor que será testado. Podemos
colocar quantos case sejam necessários.
Exemplo 1.3: Switch
1 switch (cargo)
2 { case 1: case 2: sal = sal + 200;
3 break;
4 case 3: sal = sal + 600;
5 break;
6 default: sal = sal + 100;
7 break;
8 }
Vamos analisar um programa completo que faz uso do switch. Uma

empresa concederá um aumento de salário aos seus funcionários,
27
Programação 2
variável de acordo com o cargo, conforme a tabela abaixo. Faça

um programa que leia o cargo de um funcionário (1-Gerente,2-
Engenheiro,3-Técnico) e o seu salário atual e calcule o novo salário.
Se o cargo do funcionário for inválido, deverá ser impressa uma
mensagem de erro. Como resultado, mostre o salário antigo, o novo
salário e a diferença de salário.
Cargo Percentual
Gerente 10%
Engenheiro 20%
Técnico 30%
28
Programação 2
1 main()
2 {
3 int cargo;
4 float sal, nsal;
5 printf(“Empresa Legal\n\n\n”);
6 printf(“Cargo(1-Gerente/2-Engenheiro/3-
Tecnico): “);
7 scanf(“%d”,&cargo);
8 printf(“\nSalario atual: “);
9 scanf(“%f”,&sal);
10 switch (cargo)
11 { case 1: nsal=sal*1.1; break;
12 case 2: nsal=sal*1.2; break;
13 case 3: nsal=sal*1.3; break;
14 default: printf(“\n\nCargo Invalido!\n”);

break;
15 }
16 if ((cargo>=1) && (cargo<=3))
17 { printf(“\n\n______________________________
\n”);
18 printf(“\n\nResultados\n\n”);
20 printf(“\nSalario Antigo..............: R$
%.2f\n”,sal);
21 printf(“\nSalario Novo................: R$
%.2f\n”,nsal);
22 printf(“\nDiferenca de Salarios: R$
%.2f\n”,nsal - sal);
23 }
24 getche();
25 }
29
Programação 2
• Linhas 3 e 4: temos as declarações das variáveis do programa.

O cargo do funcionário será armazenado em uma variável do
tipo int. Quando tiver armazenado 1, significa que o funcionário
é um gerente, 2 é engenheiro e 3 é técnico.
• Linha 5: o printf que serve para colocar, no início da tela, o

título da empresa.
• Linha 6: printf que solicita que o usuário digite o cargo do

funcionário. Como estamos usando uma legenda, ou seja, um
número representando cada cargo, precisamos colocar neste
printf o significado de cada número.
• Linha 7: scanf para ler o cargo do funcionário.
• Linha 8: printf para solicitar a digitação do salário do

funcionário.
• Linha 9: scanf para lê o salário do funcionário.
• Linha 10: switch que avalia o cargo do funcionário, para calcular

seu novo salário. Cada cargo tem um aumento de salário
diferente. Como foi solicitado que imprima uma mensagem de
erro quando o cargo foi inválido, será colocado o default.
• Linhas 11 a 15: nestas linhas temos os case de cada valor

da variável cargo, além do default. Para cada case, colocamos
a fórmula para o cálculo do novo salário. No default, temos o
printf que escreve a mensagem de cargo inválido. Notem que
o break aparece no final da sequência de comando de cada
case.
• Linha 16: este if foi colocado para testar se o cargo digitado é

Atenção válido. Sendo válido, podemos apresentar os resultados.
Atenção: neste • Linhas 17 a 23: temos os printf que apresentam os resultados

programa a
variável cargo do programa: o salário antigo, o novo e a diferença dos
armazenará 1 salários.
(quando o cargo
for gerente),
2 (quando for • Linhas 24 e 25: temos o getche() e o fecha chaves, indicando o
engenheiro) e final do programa principal.
3 (quando for
técnico). Dessa
forma, esta A figura 1.9 apresenta duas telas de execução do programa
variável será do completo 1.4.
tipo inteiro.
30
Programação 2
Cargo Válido
Cargo Inválido
Notem que, quando o cargo é inválido, apenas a mensagem de

erro é apresentada. Quando o cargo é válido, os resultados são
apresentados.
Agora que já sabemos usar as estruturas de seleção do C, vamos

abrir um parênteses para falar sobre a identação dos comandos dos
programas.
1.4. Identação de um Programa
A identação é a forma como alinhamos os comandos do nosso

programa. O alinhamento faz com que o código fique mais fácil de
ser lido. Vamos entender a identação do programa completo 1.4,
analisando a figura 1.10.
31
Programação 2
main()
int cargo;
float sal, nsal;
printf(“Empresa Legal\n\n\n”);
printf(“Cargo(1-Gerente\2-Eng.\3-Tecnico): “);
scanf(“%d”,&cargo);
printf(“\nSalario atual: “);
scanf(“%f”,&sal);
switch (cargo)
{ case 1: nsal=sal*1.1; break;
case 2: nsal=sal*1.2; break;
defaul: printf(“\n\nCargo Invalido!\n”);

break;
if ((cargo>=1) && (cargo<=3))
{ prinft(“\n\n____________________________\n”);
prinft(“\n\nResultados\n\n”);
prinft(“\nSalario Antigo...: R$ %.2f\n”, sal);
prinft(“\nSalario Novo....: R$ %.2f\n”, nsal);
prinft(“\nDiferenca: R$ %.2f\n”, nsal - sal);
getche();
Figura 1.10: Código Identado
Cada chaves que abre deve ficar no mesmo alinhamento da chaves

que fecha. Assim, a chaves que abre o programa, fica alinhada com a
chaves que fecha o programa. Com as chaves alinhadas fica mais fácil
32
Programação 2
de verificar se alguma chave está “descasada”. As chaves3também

devem ficar alinhadas com a estrutura que elas estão delimitando.
Vejam a chaves do main, do switch e do if. Dica de
Programação
Notem também, que a sequência de comandos dentro do switch e 3
Sempre que abrir
do if fica um pouco mais para dentro. Dessa forma, nós destacamos uma chaves no
seu programa, já
os comandos que estão dentro da estrutura. Quando colocamos todos coloque a chaves
os comandos do nosso programa no mesmo alinhamento, fica mais que fecha. Assim
não corre o risco
difícil de visualizar quais comandos fazem parte de uma estrutura de de esquecer a
chaves que fecha
controle. uma sequência de
comandos.
A figura 1.11 apresenta o mesmo código, mas sem a identação,
vejam que o switch e o if ficam menos visíveis.
33
Programação 2
main()
int cargo;
float sal, nsal;
printf(“Empresa Legal\n\n\n”);
printf(“Cargo(1-Gerente\2-Engenheiro\3-Tecnico): “);
scanf(“%d”,&cargo);
printf(“\nSalario atual: “);
scanf(“%f”,&sal);
switch (cargo)
{case 1: nsal=sal*1.1; break;
defaul: printf(“\n\nCargo Invalido!\n”); break;}
if ((cargo>=1) && (cargo<=3))
{prinft(“\n\n____________________________\n”);
prinft(“\n\nResultados\n\n”);
prinft(“\nSalario Antigo..........: R$ %.2f\n”, sal);
prinft(“\nSalario Novo...........: R$ %.2f\n”, nsal);
prinft(“\nDiferenca de Salarios: R$ %.2f\n”, nsal -

sal);
getche ();
Figura 1.11: Código sem Identação
Bem melhor ler o código identado, não é mesmo? Não deixem de

identar todos os programas. Vocês verão que fica mais fácil e rápido
de entender.
34
Programação 2
Os nossos programas vão começar a crescer de tamanho e, a cada

capítulo que avançamos, teremos novas possibilidades de fazer coisas
bem interessantes. Nesta seção, temos uma lista de programas que
devemos resolver, para efetivar o nosso conhecimento nas estruturas
de seleção. Vocês irão notar que algumas questões só podem ser
feitas usando o if, mas outras podem ser resolvidas com o uso do
switch. Liguem o computador e comecem a programar!
1. Faça um programa que lê 2 valores A e B (inteiros) e informa se

A é divisível por B ou não.
2. Faça um programa que leia um número inteiro e mostre uma

mensagem indicando se este número é par ou ímpar, e se é
positivo ou negativo.
3. Tendo como dados de entrada a altura e o sexo(1-feminino/2-

masculino) de uma pessoa, construa um programa que calcula
e escreve seu peso ideal, utilizando as seguintes fórmulas:
• para homens: (72.7*altura)-58
• para mulheres: (62.1*altura)-44.7
4. Um hotel cobra R$ 50,00 reais a diária e mais uma taxa de

serviços. A taxa de serviços é de:
• 15,30 por dia, se número de diárias <15
• 10,00 por dia, se número de diárias =15
• 8,50 por dia, se número de diárias >15
Faça um programa que lê a quantidade de dias que o hóspede

ficou no hotel e imprime a taxa e total a pagar.
5. Elaborar um programa que irá ler três números inteiros diferentes

e informa qual é o maior valor.
6. Elaborar um programa que irá ler quatro inteiros diferentes e

informa qual é o menor valor.
7. Escrever um programa que lê a matrícula do aluno e suas 3

notas. Calcular a média e verificar qual o seu conceito, conforme
35
Programação 2
a tabela:
Média Conceito
>= 9,0 A
>= 7,5 e < 9,0 B
>= 6,0 e < 7,5 C
>= 4,0 e < 6,0 D
< 4,0 E
O programa deve escrever a matrícula do aluno, suas notas, a

média, o conceito correspondente e a mensagem: APROVADO
se o conceito for A, B ou C e REPROVADO se o conceito for D
ou E.
8. Escrever um programa que lê a hora de início e hora de término

de um jogo, ambas subdivididas em dois valores distintos: horas
e minutos. Calcular e escrever a duração do jogo, também em
horas e minutos, considerando que o tempo máximo de duração
de um jogo é de 24 horas e que o jogo pode iniciar em um dia e
terminar no dia seguinte.
9. Fazer um programa que leia uma data (dia e mês) e informe se é

primavera, verão, outono ou inverno. Sabe-se que as estações,
no hemisfério sul, começam nas seguintes datas:
• Primavera: 22/Set
• Verão: 21/Dez
• Outono: 20/Mar
• Inverno: 20/Jun
10. Faça um programa para ler o peso de uma encomenda, tipo

de entrega(1-sedex, 2-sedex 10) e região onde será entregue a
encomenda(1- Norte, 2-Nordeste, 3-Centro-Oeste, 4-Sudeste,
5-Sul). Calcular o valor de postagem baseado nas tabelas
abaixo:
Até 1 Kg R$ 5,00
De 1 Kg a 5 Kg R$ 10,00
36
Programação 2
Acima de 5 Kg R$ 15,00 + R$ 3,00 por Kg excedente
Para entrega por Sedex Adicionar R$ 9,00
Para entrega por Sedex 10 Adicionar R$ 11,00
Para entregar na região Norte Adicionar R$ 3,00
Para entregar na região Nordeste Adicionar R$ 2,00
Para entregar na região Centro-Oeste Adicionar R$ 6,00
Para entregar na região Sudeste Adicionar R$ 5,00
Para entregar na região Sul Adicionar R$ 7,00
Conheça Mais
Para ampliar nossos conhecimentos sobre os assuntos tratados

neste capítulo, leiam o capítulo que aborda as estruturas de seleção,
do livro:

1996.
Vamos Revisar?
Vamos revisar um pouco o assunto visto neste capítulo? Façamos

uma leitura do resumo a seguir:
• Estruturas de seleção servem para analisar condições e valores

de variáveis verificando se uma sequência de comandos deve ser
executada ou desviada.
• As estruturas de seleção do C são: if e switch.
• O if pode ser: simples(quando não tem o else), composto

(quando tem o else) e aninhado (quando temos um outro if dentro
da sequência de comandos do else).
37
Programação 2
• O if avalia uma condição, se a mesma for verdade, a sequência

de comandos do if é executada.
• O switch é uma estrutura de seleção que avalia o valor de uma

variável inteira ou caractere.
• No final da sequência de comando do case, devemos colocar um

break, forçando a saída da estrutura de seleção switch.
• A identação dos comando de um programa torna o código mais

legível e fácil de entender.
38
Programação 2
Capítulo 2 – Estruturas de
Repetição
Neste capítulo, vamos abordar as estruturas de repetição. Como

mencionado da seção 1.1 do capítulo anterior, com estas estruturas
poderemos repetir uma sequência de comandos quantas vezes
forem necessário. A linguagem de programação C fornece três
tipos de estrutura de repetição: for, while e do/while. Entendendo as
características de cada estrutura de repetição, poderemos escolher a
mais adequada para resolver um dado problema. Vamos em frente!
Figura 2.1: Quadrinho sobre repetição
2.1. For (para... faça)
A estrutura de repetição for é equivalente ao para/faça do Portugol.

Esta estrutura costuma ser utilizada quando sabemos quantas vezes
a sequência de comandos deve ser repetida. A contagem dos ciclos
é feita por uma variável chamada de contador. A estrutura for também
é chamada de estrutura de repetição com contador. Sua sintaxe é a
seguinte:
39
Programação 2
Sintaxe
for (var-controle = inicio; condição;

atualização_var-controle)
comando1;
for (var-controle = inicio; condição;

atualização_var-controle)
{ comando1;
comando2;
comandon;
Onde:
• var-controle: é a variável que controla a quantidade de

repetições. Esta variável é inicializada e atualizada a cada
repetição.
• início: é o valor inicial da variável que controla o for. Ao iniciar a

repetição, a variável de controle é inicializada com este valor.
• condição: expressão relacional ou lógica que é testada ao final

de cada repetição. Se a condição for verdade a sequência de
comandos é executada mais uma vez. Quando a condição é
falsa, a repetição para. Dessa forma, temos que ter certeza que
algum momento a condição se tornará falsa. Caso contrário,
entraremos em um loop infinito. Ou seja, o programa fica
repetindo a sequência de comandos infinitamente.
• atualização_var-controle: a cada vez que a repetição é

executada, a variável de controle deve ser atualizada. Nesta
parte do for, colocamos a expressão que atualizará a variável
de controle. É com esta atualização que faremos com que a
condição do for se torne falsa e a repetição tenha fim.
Notem que cada parte do for é separada por ponto e vírgula. Mas
não colocamos o ponto e vírgula depois do comando que atualiza a
variável de controle, nem após o fecha parênteses.
A estrutura de repetição for funciona da seguinte forma:
40
Programação 2
• Passo 1: a variável de controle é inicializada.
• Passo 2: a condição é analisada. Se for verdade, a sequência

de comandos da repetição é executada.
• Passo 3: ao terminar de executar a sequência de comandos

da repetição, a variável de controle é atualizada. E retorna ao
passo 2, verificando se a condição continua sendo verdade
(para repetir mais uma vez a sequência de comandos) ou se é
falsa ( parando a repetição).
Atenção
A figura 2.2 apresenta o funcionamento da estrutura de repetição
A variável de
for. controle do for
deve ser do tipo
inteiro.
O for deve ser

escrito todo em
minúsculo.
Figura 2.2 Funcionamento da estrutura de repetição for.
Assim como o if, se houver mais de um comando vinculado ao for,

devemos colocar a sequência de comandos entre chaves. Se houver
apenas um comando, não há necessidade de colocar as chaves.
Vamos ver dois exemplos do uso do for. No exemplo 2.1 temos um

for que será repetido 10 vezes. A variável de controle i é inicializada
Atenção
com 1. Cada vez que é finalizada uma execução do comando vinculado
ao for, é incrementado 1 valor da variável 14. Esta repetição vai parar 4
Estão lembrados
do operador ++?
quando i for igual a 11. Cada vez que o for é executado, é escrito o Este operador
valor atual de i na tela. Assim, será escrito de 1 a 10 na tela. acrescenta uma
unidade a uma
variável. Ele foi
abordado na
Exemplo 2.1: for com variável de controle sendo incrementada
seção 5.3 do
Volume I.
1 for (i=1; i<=10; i++)
2 printf(“\nO valor de i= %d”, i);
No exemplo 2.2, temos um for que também será repetido 10 vezes.

No entanto, a variável de controle inicia com 10 e é decrementada a
41
Programação 2
cada final da repetição. Notem que esta repetição vai parar quando o i
é 0. Este for também faz a impressão de 1 a 10 na tela. Só que, dessa
vez, os números serão impressos na ordem decrescente.
Exemplo 2.2: for com variável de controle sendo decrementada
1 for (i=10; i>=1; i--)
2 printf(“\nO valor de i= %d”, i);
Vamos agora analisar um programa completo que usa o comando

for. Uma loja quer calcular um bônus que dará a cinco clientes. O
bônus depende de quanto cada cliente comprou. Os clientes que
compraram menos de R$ 500 receberão de bônus 10% do valor das
compras. Os clientes que compraram a partir de R$ 500 receberão de
bônus, 15% do valor das compras. O programa deve ler o código do
cliente e o valor das compras e escrever o valor do bônus, para cada
um dos cinco clientes.
42
Programação 2
1 main()
2 { float valor;
3 int cod, i;
4 for (i=1; i<=5; i++)
5 { system(“cls”);
6 printf(“Loja Compre Tudo\n\n”);
7 printf(“Codigo do Cliente %d: “,i);
8 scanf(“%d”,&cod);
9 printf(“\nValor das compras: “);
10 scanf(“%f”,&valor);
11 if (valor<500)
12 printf(“\n\nValor do bonus R$ %.2f\n”,

valor*0.1);
13 else

valor*0.15);
15 printf(“\n\ntecle enter para

continuar...”);
16 getche();
17 }
18 }

O valor das compras, o código do cliente e o i, que será a
variável de controle do for.
• Linha 4: primeira linha do for, indicando que a variável i será

inicializada com 1, a condição para permanecer repetindo é i
ser menor ou igual a 5 e o incremento do i, que terá seu valor
aumentado em uma unidade a cada repetição. Da linha 5 até 17
temos a sequência de comandos que será repetida 5 vezes.
43
Programação 2
• Linha 5: abre chaves para delimitar a sequência de comandos

vinculada ao for. Nesta linha também temos um comando novo:
Atenção system(“cls”); Este comando5 limpa a tela, eliminado tudo que
tem escrito. Com o uso deste comando, cada vez que formos
5
cls significa cadastrar os dados de um novo cliente, a tela é limpa, ficando
clear screen. Ou
seja, limpe a tela. assim mais organizado. Depois vocês podem comentar esse
comando do programa e vejam o que acontece sem ele.
• Linha 6: printf para colocar o nome da empresa.
• Linha 7: printf para solicitar a digitação do código do funcionário.

Vejam que nesta mensagem, é colocado o valor do i, isto é
interessante para que o usuário saiba qual cliente está sendo
digitado no momento, se é o primeiro, o quarto, etc.
• Linha 8: scanf para ler o código do cliente.
• Linha 9: printf que solicita o valor das compras do cliente.
• Linha 10: scanf para ler o valor das compras do cliente.
• Linhas 11: Como já sabemos o valor das compras do cliente,

devemos calcular o valor do bônus. O bônus pode ser de 15%
ou 10%. Para decidir qual bônus o cliente levará, usaremos uma
estrutura de decisão. Assim, nesta linha temos um if composto,
que verifica se o valor das compras é menor que R$500.
• Linhas 12: printf que é executado se a condição do if for

verdade. Notem que no próprio printf é feita a conta de quanto
o cliente receberá de bônus. Aqui é dado um bônus de 10% ao
cliente.
• Linha 13: temos o else, já que se trata de um if composto.
• Linha 14: printf que é executado se a condição do if for falsa.

Aqui é dado um bônus de 15% ao cliente.
• Linha 15: temos os printf que dá uma mensagem para que o

usuário tecle enter e dê prosseguimento a um novo cadastro.
• Linha 16: temos o getche() que faz com que possamos ver o
valor do bônus do cliente.
Atenção
• Linha 17: fecha chaves que delimita a sequência de comandos
6
Fiquem atentos do for.
a identação do
programa. • Linha 18: fecha chaves do programa principal6.
44
Programação 2
A figura 2.3 apresenta uma tela de execução do programa completo

2.1.
Figura 2.3: Tela de execução do programa completo 2.1
Na próxima seção iremos estudar o segundo tipo de estrutura de

repetição do C, o while.
Figura 2.4: Quadrinho - O castigo de Pablo
45
Programação 2
2.2. While (enquanto... faça – teste no início)
A estrutura de repetição while é equivalente ao enquanto/faça do

Saiba Mais Portugol. Nesta estrutura uma condição é avaliada, e enquanto a
condição for verdade, a sequência de comandos será executada. Se
7
Iteração é um
termo muito a condição for falsa, a repetição será interrompida. O while avalia a
utilizado na
computação
condição antes da primeira iteração7, isto significa que, eventualmente,
e significa pode não ocorrer sequer a primeira iteração. Por isso, esta estrutura
repetição.
é chamada também de: repetição que faz teste no início. A sintaxe do
while é a seguinte:
Sintaxe
while (condição)
comando;
while (condição)
{ comando1;
comando2;
comandon;
Ao lado do while colocamos a condição (entre parênteses) que

será avaliada e que faz com que a repetição seja executada ou não.
Ao final de cada iteração, a condição é avaliada para verificar se
continua sendo verdade, para que a repetição seja executada mais
uma vez ou pare. No while também poderá acontecer o problema de
loop infinito. Por isso, temos que ter certeza que em algum momento
a condição se tornará falsa, para que a repetição tenha fim. Seguindo
a mesma regra do if e do for, se tivermos mais de um comando
vinculado ao while, devemos colocar a sequência de comandos entre
chaves. Podemos ler o comando while da seguinte forma: “enquanto
a condição for verdade, faça esta sequência de comandos”. A figura
2.5 apresenta o esquema de funcionamento da estrutura while.
46
Programação 2
Figura 2.5: Funcionamento da estrutura de repetição while
Como podemos ver na figura 2.5, antes de entrar na sequência

de comandos do while a condição é testada, se for verdade, executa
os comandos vinculados ao while, quando termina, retorna para
testar a condição novamente. Enquanto for verdade, fica repetindo
a sequência de comandos. Quando for falsa, desvia para o primeiro
comando depois do while.
Vamos analisar o programa completo 2.2, que resolve a mesma

questão do programa completo 2.1, só que usando a estrutura de
repetição while. Para garantir que a repetição será executada 5
vezes, será declarada uma variável responsável por contar cada vez
que é terminada uma iteração do while. O valor desta variável será
testado na condição do while, e a repetição será executada enquanto
o contador for menor ou igual a 5.
47
Programação 2
1 main()
2 {
3 float valor;
4 int cod, contador;
5 contador = 1;
6 while (contador<=5)
9 printf(“Codigo do Cliente %d: “,contador);
13 if (valor<500)

valor*0.1);
15 else

valor*0.15);
17 contador++;

continuar...”);
19 getche();
20 }
21 }

O valor das compras, o código do cliente e o contador que irá
controlar a repetição.
• Linha 5: Nesta linha temos a inicialização do contador. Assim,
48
Programação 2
é atribuído 1 ao contador. Isto indica que iremos começar a

primeira iteração do while.
• Linha 6: temos o while, juntamente com a condição de

permanência da repetição. Assim, esta repetição é feita
enquanto o contador for menor ou igual a 5. Notem que,
obrigatoriamente, a condição virá entre parênteses, certo?
• Linhas 7 a 20: sequência de comandos vinculada ao while,

que será executada cinco vezes. Para cada cliente é pedido o
seu código e o valor das suas compras. O bônus é calculado de
acordo com o valor das compras e apresentado na tela.
• Linha 17: observem que nesta linha é somado mais 1 ao

valor do contador. Dessa forma, cada vez que passamos pela
repetição, o contador vai aumentado seu valor, até fazer com
que a condição se torne falsa e a repetição pare. Quando
usamos o for, a inicialização, a condição e o incremento da
variável do controle fica tudo ao lado do for. No while, temos
estas três partes, só que separadas: na linha 5 tivemos a
inicialização do contador, na linha 6 temos a condição e na linha
17 o incremento do contador. Se esquecermos de incrementar o
contador, a condição não se tornará falsa, nunca, e entraremos
em um loop infinito.
• Linha 21: fecha chaves do programa principal.
A execução deste programa resulta em uma tela idêntica a do

programa anterior, apresentada na figura 2.3.
Vamos agora entender o funcionamento do terceiro e último tipo

de repetição do C, que é o do/while.
2.3. Do/while (repita... até - teste no final)
A estrutura de repetição do/while equivale ao repita...até do

Portugol. A principal diferença entre o do/while e o while é o ponto
onde a condição é testada. Como vimos na seção anterior, a condição
do while fica no início do bloco e assim, a verificação é feita antes de
executar o bloco de comandos. Se a condição for falsa já no primeiro
teste, os comando vinculados ao while não são executados nenhuma
vez. No caso do do/while, a condição só vem após a sequência de
comandos. Com isso, o teste só é feito após a execução dos comandos
49
Programação 2
do do/while. A sintaxe do do/while é a seguinte:
Sintaxe
do
comando;
while (condição);
do
{ comando1;
comando2;
comandon;
} while (condição);
O comando do/while começa com o do, e logo em seguida

colocamos a sequência de comandos que será repetida. Após a
sequência de comandos, coloca-se o while com a condição que será
testada para verificar se continua a repetição ou não. Quando tivermos
mais de um comando, as chaves que delimitam os comandos do do/
while são obrigatórias. Prestem atenção o local correto das mesmas.
O abre chaves que indica o início da sequência deve vir depois do
do. O fecha chaves que indica o final da sequência, deve vir antes do
Atenção while. Outro detalhe importante é que, depois da condição (que deve
vir entre parênteses), devemos colocar um ponto e vírgula8.
8
Não colocamos
ponto e virgula O esquema da execução do do/while é apresentado na figura 2.6.
após a condição
do if, nem após
a condição do
while.
Figura: 2.6: Funcionamento da estrutura de repetição do/while
O do serve, na verdade, para indicar que a sequência de comandos

vai começar. A sequência de comandos é executada e, ao encontrar
50
Programação 2
o while, a condição é testada. Se a condição for verdade, retorna ao

primeiro comando da sequência. Se a condição for falsa, executa o
primeiro comando depois do do/while. O comando do/while pode ser
lido da seguinte forma: “faça a sequência de comandos enquanto a
condição for verdade”.
Agora, vamos fazer o programa completo 2.1, usando o do/while.

Do mesmo modo que foi necessário no while, teremos que ter uma
variável que serve de contador, para ficar verificando se já executou a
repetição cinco vezes.
51
Programação 2
Programa Completo 2.3: uso do do/while
1 main()
2 {
3 float valor;
4 int cod, contador;
5 contador = 1;
6 do
9 printf(“Codigo do Cliente %d: “,contador);
13 if (valor<500)

valor*0.1);
15 else

valor*0.15);
17 contador++;

continuar...”);
19 getche();
20 } while (contador <=5);
21 }

O valor das compras, o código do cliente e o contador que irá
controlar a repetição.
• Linha 5: Nesta linha temos a inicialização do contador.
52
Programação 2
Linha 6: temos o do, indicando que será iniciada uma estrutura de

repetição do/while.
• Linhas 7 a 19: sequência de comandos vinculada ao do/while,

que será executada cinco vezes. Para cada cliente é pedido o
seu código e o valor das suas compras. O bônus é calculado de
acordo com o valor das compras e apresentado na tela. Notem
que na linha 17 temos o incremento do contador.
• Linha 20: temos o fecha chaves e o while, juntamente com a

condição que é avaliada para que prossiga uma nova repetição
da sequência de comandos ou pare de executar o do/while.
• Linha 21: temos o fecha chaves do programa principal.
Vimos aqui um mesmo problema sendo resolvido com os três tipos

de repetição do C. No problema em questão, foi mencionado quanto
elementos (clientes) seriam cadastrados. Assim, estes programas
SEMPRE repetem a sequência 5 vezes. Em várias situações, não
sabemos previamente quantos elementos serão cadastrados. Dessa
forma, não saberíamos o valor a ser colocado na condição da estrutura
de repetição para indicar a sua parada. Mas tem uma solução: quando
não soubermos quantos elementos serão cadastrados, usaremos o
do/while, da forma como será apresentada no programa completo
abaixo. Este programa tem o mesmo enunciado do programa 2.1,
no entanto, ele poderá cadastrar uma quantidade indeterminada de
clientes.
53
Programação 2
Programa Completo 2.4: uso do do/while
1 main()
2 {
3 float valor;
4 int cod, continuar;
5 do
8 printf(“Codigo do Cliente: “);
12 if (valor<500)

valor*0.1);
14 else

valor*0.15);
16 printf(“\n\n\nDeseja cadastrar outro

(1-sim/2-nao)? “);
17 scanf(“%d”, &continuar);
18 } while (continuar==1);
19 }
• Notem que não teremos a variável contador. Teremos agora

uma variável inteira que foi chamada de continuar. A condição
de parada deste do/while avalia o valor armazenado na variável
continuar.

O valor das compras, o código do cliente e a variável inteira
continuar que irá controlar a repetição.
54
Programação 2
• Linha 5: do que inicia a sequência da repetição.
• Linhas 6 a 17: sequência de comandos vinculada ao do/while.

Nesta sequência temos a solicitação dos dados do cliente, e
apresentação do bônus que o cliente tem direito.
• Linha 16: Após apresentar o valor do bônus, é feita a seguinte

pergunta ao usuário: “deseja cadastrar outro (1-sim/2-não)? “.
Na linha 16 temos o printf que escreve esta pergunta na tela. O
usuário deverá digitar 1 se quiser cadastrar outro, que significa:
“sim, eu quero cadastrar”. Ou digitar 2 porque não tem mais
clientes para cadastrar.
• Linha 17: scanf para ler a resposta do cliente, que deve ser 1
para continuar ou 2 para parar. O valor que o usuário digitar,
será armazenado na variável continuar.
• Linha 18: temos o fecha chaves e o while, juntamente com

a condição que é avaliada para que prossiga uma nova
repetição da sequência de comandos ou pare de executar o
do/while. Notem que a condição é: (continuar == 1). Ou seja,
enquanto o usuário estiver respondendo 1, informando que
quer continuar cadastrando, novos cadastros serão feitos. A
parada ocorre quando o usuário responde 2. Dessa forma, não
precisamos determinar a quantidade de vezes que a repetição
será executada. A execução dependerá apenas da resposta do
usuário. Assim, uma vez nós poderemos executar a repetição
2 vezes, na outra 10, na outra 3, etc. Diferente da outra forma
de resolver, que sempre executava uma quantidade de vezes
pré-determinada. A resolução da questão desta forma, trás
mais flexibilidade ao programa, uma vez que o usuário repete
o cadastro quantas vezes ele desejar. Uma outra observação
é que não houve a necessidade de colocarmos o getche(). A
questão é que, como nós tivemos que fazer a leitura da variável
continuar, o scanf que lê esta variável, faz com que a tela fique
parada esperando o usuário fornecer a resposta. Por isso, não
houve necessidade de colocar o getche().
• Linha 19: temos o fecha chaves do programa principal.
A figura 2.7 apresenta uma tela de execução do programa completo

2.4.
55
Programação 2
Atenção
Todas as
estruturas de De acordo com a figura 2.7, após os usuário fornecer os dados
repetição são
escritas em do cliente e receber o valor do bônus que o cliente tem direito, é
minúsculo.
feita a pergunta se ele deseja ou não cadastrar outro. Assim que for
Atentem a respondido 2, ou seja, não quer mais cadastrar, a janela do programa
identação dos
comandos do irá fechar. Enquanto estiver respondendo 1, novos cadastros são
programa.
feitos.
A sequência de
comandos de
uma estrutura de
controle, seja de 2.4. Uso do break na Estrutura de Repetição
repetição ou de
seleção, poderá
ser composta Vimos anteriormente o comando break finalizando a sequência
por qualquer
comando válido
de comandos de um case, da estrutura de seleção switch. Mas, este
da linguagem. comando também pode ser usado para forçar o encerramento de
Assim,
poderemos ter uma estrutura de repetição. Se um break for executado dentro de
uma estrutura
de repetição
uma estrutura de repetição, o fluxo do programa será desviado para o
dentro da outra. primeiro comando depois da repetição. Mesmo que a repetição ainda
Se houver
necessidade de não tenha sido executada a quantidade de vezes que foi determinada.
colocar um for
na sequência
Normalmente, o comando break é colocado na sequência de comandos
de comandos de uma estrutura de seleção e só é executado, caso alguma situação
de outro for,
devemos utilizar aconteça.
uma variável de
controle diferente Vamos analisar o programa completo 2.5. Neste programa, o
para cada for
cliente tem um limite de R$ 200 no cartão de crédito da loja. Conforme
as suas compras vão sendo passadas no caixa, seu saldo vai sendo
avaliado. Se a compra de um novo item ultrapassar o limite permitido,
o programa deve parar a venda. Mas, se ele tiver limite, a compra
pode ser feita e finalizada normalmente.
56
Programação 2
Programa Completo 2.5: uso do break na repetição
1 main()
2 { float preco, total;
3 int continuar;
4 total = 0;
5 do
7 printf(“Loja Compre Tudo - Adicionar

produto\n\n”);
8 printf(“Preco do produto: “);
9 scanf(“%f”,&preco);
10 if ((total + preco) <= 200)
11 total = total + preco;
12 else
13 { printf(“\n\nA adicao deste produto

vai extrapolar o seu limite!”);
14 printf(“\n\nTecle enter para

finalizar...”);
15 getche();
16 break;
17 }
18 printf(“\n\nDeseja adicionar outro

(1-sim/2-nao)? “);
20 } while (continuar==1);
21 printf(“\n\nTotal a pagar: %.2f”, total);
22 getche();
23 }
• Linhas 2 e 3: declaração das variáveis do programa: preço
57
Programação 2
do produto, total das compras e continuar (para verificar se a

repetição deve ser executada ou não).
• Linha 4: inicialização da variável total, que armazena o valor

Atenção total das compras9.
9
Sempre que
• Linha 5: do que inicia a sequência da repetição.
uma variável
for servir de • Linhas 6 a 20: sequência de comandos vinculada ao do/while.
acumulador, seu
conteúdo deve
Nesta sequência temos a solicitação do preço do produto que
ser inicializado. o cliente está comprando. A cada novo produto comprado é
Normalmente com
zero. preciso verificar se o total da compra extrapola os 200 reais
do limite do cartão. Esta verificação é feita no if da linha 10. Se
o limite extrapolar, será executada a sequência de comandos
do else da linha 12. Assim, é impressa uma mensagem que
não pode mais adicionar produtos e, logo em seguida, executa
o break da linha 16, forçando a saída do do/while. Como não
pode mais comprar produtos, temos que sair da repetição.
Por isso foi usado o break. Mas, se a compra não extrapolar o
limite, o cliente vai fazendo as compras dos produtos que ele
desejar. Dessa forma, a execução do break ocorre mediante
a ocorrência de uma situação, que neste caso foi o estouro do
limite.
• Linha 21: Após sair da repetição, devemos imprimir quanto foi

o valor das compras do cliente. Neste printf será escrito o total.
• Linhas 22 e 23: temos getche() e o fecha chaves do programa

principal.

completo 2.5.
Adição de produto na Nota Fiscal
58
Programação 2
Adição de produto que extrapola o limite
Agora que já vimos alguns exemplos completos de programas

que utilizam as estruturas de repetição, que tal resolvermos umas
questões?
Estamos aqui, mais uma vez, para colocar nossos conhecimentos

em prática. Nesta lista, temos 12 questões que utilizam comandos
de repetição. Nos enunciados, quando for indicado que a quantidade
de elementos é desconhecida, resolva a questão utilizando um do/
while (que pergunta se o usuário quer continuar ou parar). Coloquem
comentários nos seus programas, deixando-os bem documentados.
Além disso, prestem muita atenção para manter o código identado. É
importante ser um programador organizado. Vamos começar?
1. Uma empresa deseja aumentar seus preços em 20%. Faça um

programa que leia o código e o preço de custo de cada produto
e calcule o preço novo. Calcule também, a média dos preços
com e sem aumento. Mostre o código e o preço novo de cada
produto e, no final, as médias. A quantidade de dados que serão
cadastrados é desconhecida.
2. Pablo tem 1,50 m e cresce 2 centímetros por ano, enquanto

Edson tem 1,10 m e cresce 3 centímetros por ano. Construa
um programa que calcule e imprima quantos anos serão
necessários para que Edson seja maior que Pablo.
3. Escrever um programa que leia 5 pares de valores, o primeiro

valor é a matrícula do aluno, e o segundo a sua altura em
59
Programação 2
centímetros. Encontre o aluno mais alto e o mais baixo. Mostre

a matrícula do aluno mais alto e do mais baixo, junto com suas
alturas.
4. Escrever um programa que leia um conjunto de 10 informações

contendo, cada uma delas, a altura e o sexo(1- mas/2- fem),
calcule e mostre o seguinte:
• a maior e a menor altura da turma
• a média da altura das mulheres
• a média da altura da turma.
5. Foi feita uma pesquisa entre os 50 habitantes de uma região.

Foram coletados os dados de idade, sexo (1-mas/2-fem) e
salário. Faça um programa que informe:
• a média de salário do grupo;
• maior e menor idade do grupo;
• quantidade de mulheres com salário até R$ 200.
6. Com o lançamento de notebooks no mercado nacional,

um fabricante deseja obter determinadas informações dos
seus possíveis consumidores. Para cada empresa ou órgão
pesquisado foi digitado os seguintes dados:
• Preferência desejada (fabricante): 1-Toshiba/2-HP/3-Sony
• Possuem computadores de grande porte: 1-Sim/2-Não
• Necessitam de notebooks: 1. Sim/2. Não
Deseja-se saber:
• A quantidade de empresas pesquisadas;
• Quantas empresas possuem computadores de grande porte;
• Percentual de empresa que necessitam de notebooks
• Percentual de empresas que tem preferência pela Toshiba.
A quantidade de dados que serão cadastrados é

desconhecida.
7. Foi feita uma pesquisa estatística nas 50 principais cidades de

quatro Estados para coletar dados sobre acidentes de trânsito.
Foram obtidos os seguintes dados:
60
Programação 2
• Código da cidade
• Estado (1-PE, 2-PB, 3-RN, 4-CE)
• Número de veículos de passeio (em 2008)
• Número de acidentes de trânsito com vítimas (em 2008)
Deseja-se saber:
• qual o maior e o menor índice de acidentes de trânsito e a que

cidades pertencem;
• qual a média de veículos nas cidades;
• qual a média de acidentes com vítimas entre as cidades do

Estado de Pernambuco.
8. A Empresa Legal decidiu fazer um levantamento dos candidatos

que se inscreveram para preenchimento de vaga no seu quadro
de funcionários, utilizando processamento eletrônico e você foi
contratado, então faça um programa que:
Leia um conjunto de informações para cada candidato,

contendo: número de inscrição do candidato, idade, sexo(1-
fem/2-mas), experiência anterior(1-sim/2-nao)
Calcule:
• Quantidade de candidatos
• Quantidade de candidatas
• Média de idade dos homens com experiência
• Percentagem dos homens com mais de 45 anos, entre os

homens
• Quantidade de mulheres com idade inferior a 35 anos e com

experiência
• Menor idade entre as mulheres que já tem experiência no

serviço
A quantidade de dados que serão cadastrados é

desconhecida.
9. Faça um programa para realizar a totalização dos votos da

eleição para a prefeitura concorrida entre 3 candidatos. Para
cada seção são informados o número de votos do candidato
61
Programação 2
A, o número de votos do candidato B, o número de votos do

candidato C, o número de votos brancos e o número de votos
nulos. A quantidade de seções que serão cadastradas é
desconhecida. Determine e imprima:
• O número de votantes;
• O total de votos de cada candidato;
• O total de votos brancos e total de votos nulos;
• O total de votos válidos;
• O candidato com maior número de votos;
• Se a eleição foi válida e para isso o total de votos brancos

mais votos nulos deve ser menor que o total de votos válidos;
• Se haverá segundo turno, para não haver segundo turno basta

que o total de votos do candidato vencedor seja maior que 50%
dos votos válidos
• Percentual de votos nulos.
10. Ler 20 notas e imprimir as três maiores.
Conheça Mais
Vocês poderão encontrar mais detalhes sobre estruturas de

repetição no livro:
ASCENIO, Ana Fernanda Gomes e CAMPOS, Edilene

Aparecida Veneruchi. Fundamentos de Programação de
Computadores. São Paulo: Prentice Hall, 2002.
O interessante é que, os autores primeiro dão as explicações em

Portugol, e depois fazem a tradução para a sintaxe da linguagem de
programação C e Pascal.
62
Programação 2
Vamos Revisar?
Vamos revisar as estruturas de repetição? Observem o resumo a

seguir:
• As estruturas de repetição possibilitam que uma sequência de

comandos possa ser executada várias vezes.
• As estruturas de repetição da linguagem de programação C são:

for, while e do/while.
• A estrutura de repetição for é mais utilizada quando sabemos

quantas vezes uma repetição será executada.
• A estrutura de repetição while avalia o resultado de uma condição

para verificar se deve ou não executar uma sequência de comandos.
Enquanto a condição for verdade, a repetição é executada. A
condição do while fica no início da sequência de comandos.
• A estrutura de repetição do/while também avalia uma condição

para permanecer repetindo a execução de uma sequência de
comandos. No entanto, a condição só é avaliada após a execução
da sequência de comandos.
• O comando break também pode ser utilizado para forçar a parada

de uma repetição.
• Quando não tomamos cuidado de tornar a condição de uma

repetição falsa, ocorre o loop infinito.
63
Programação 2
Capítulo 3 – Modularização
Neste capítulo, vamos aprender a programar de forma

modularizada. Até agora, toda a sequência de comandos dos nossos
programas foi escrita dentro do programa principal (main), em um
bloco único. Vocês vão ver que podemos dividir os nossos programas
em módulos. A modularização é uma das alternativas mais utilizadas
para desenvolver grandes programas, pois deixa o código mais
legível e aumenta a produtividade dos programadores. No entanto, a
modularização apresenta muitas outras vantagens. Vamos descobrir
isso agora?
3.1. O que são módulos e por que utilizá-los?
A melhor maneira de desenvolver um programa grande é construí-

lo a partir de pequenas partes, que são chamadas de módulos. Esta
Saiba Mais
técnica é chamada dividir para conquistar, uma estratégia de guerra
criada pelos romanos e muito utilizada por Napoleão Bonaparte10,
10
Napoleão
Bonaparte foi quando tentou conquistar o mundo. Como o território a ser
imperador da
França e esteve conquistado era muito extenso, ele o dividiu em pequenos territórios e
no poder durante foi conquistando cada parte por vez.
15 anos. Nesse
tempo conquistou
grande parte Uma vantagem desta técnica é que focamos a nossa atenção em
do continente
um problema pequeno de cada vez. No final, teremos a solução do
europeu. Os
biógrafos afirmam problema como um todo. Para compreender melhor este conceito,
que seu sucesso
deu-se devido ao vamos fazer uma analogia: suponham que nós precisamos construir
seu talento como
uma casa. Mas esta não é uma atividade simples, devido a sua
estrategista, além
do seu espírito de complexidade. No entanto, podemos dividir esse problema em partes
liderança.
menores: alvenaria, sistema elétrico, sistema hidráulico, acabamento,
pintura, etc. e assim, fica mais simples de entendermos cada parte
separadamente (Figura 3.1). Caso ainda existam partes complexas,
podemos continuar dividindo em partes ainda menores. Por exemplo,
o sistema hidráulico pode ser dividido em caixa de água, bombas,
canos, registros, etc. Este processo de decomposição contínua
também é conhecido como refinamentos sucessivos, porque se
parte de um problema complexo e abrangente, que é sucessivamente
dividido até resultar em problemas mais simples e específicos.
64
Programação 2
Alvenaria
Sistema Elétrico
Pintura
Sistema Hidráulico
Figura 3.1: Divisões da construção de uma casa
Os módulos (também chamados de funções, rotinas ou

subprogramas) são a essência da programação estruturada. Os
módulos são segmentos de programa que executam uma tarefa
específica. Os módulos servem para dividir um grande programa
em diversas partes menores. De acordo com as boas práticas
de programação: “sempre que possível, evite códigos extensos,
separando os mesmos em módulos, visando a um rápido entendimento
e uma manutenção facilitada”.
A modularização permite que cada módulo do programa seja escrito,

testado e revisado individualmente sem alterar o funcionamento do
programa como um todo. Os programadores podem testar suas
funções separadamente, permitindo que muitos erros do sistema
completo sejam retirados antes que ele esteja totalmente pronto. A
modularização também permite que um programa seja escrito por
vários programadores ao mesmo tempo, cada um desenvolvendo
um módulo em separado. É como a construção de uma casa, que
podemos contratar vários funcionários. Esta divisão do trabalho
acelera o desenvolvimento dos programas e reduz custos. Uma outra
utilização da modularização é quando um trecho de código é utilizado
várias vezes em um programa. Devemos colocar este trecho em um
módulo e, sempre que preciso, fazemos a “chamada” do módulo. Com
isso, reduzimos a quantidade de linhas de código do programa.
A maior parte das linguagens de programação fornece um conjunto

de funções (módulos) que são utilizadas pelos programadores,
evitando que o mesmo tenha que implementá-las. A utilização de
65
Programação 2
funções que já existem, diminui o tempo de desenvolvimento do

programa. Além disso, o fato de utilizar uma função que já foi testada
em diversos programas, reduz o risco de erros. É como se costuma
dizer: “não vamos reinventar a roda”. Se a função está pronta,
disponível e correta, o programador não deve perder tempo em
implementar a mesma coisa. É só fazer uso da mesma. Um exemplo
de uso de módulos que já existem, é quando utilizamos alguma função
da biblioteca math, como sqrt (raiz quadrada) e pow (potência).
As próximas seções descrevem como devemos fazer para

desenvolver programas modularizados.
3.2. Estrutura de um módulo
Ao receber um problema, o programador deverá verificar se

este problema pode ser resolvido com uma solução particionada ou
modularizada. Vamos usar o seguinte exemplo: fazer um programa
que calcule a média do aluno e verifique se o mesmo foi aprovado ou
reprovado. A princípio, podemos pensar que o cálculo da média do
aluno e a descoberta da sua situação (aprovado ou reprovado) serão
implementados em dois módulos. Dessa forma, nosso programa seria
formado por 2 módulos, além do programa principal. Mas poderemos
notar, durante a implementação, que algumas partes de código se
repetem em diversos pontos do programa e por isso, elas também são
candidatas a se tornarem módulos. A sintaxe para construir módulos,
em C, é a seguinte:
Sintaxe
tipo_de_retorno nome_da_função([declaração de
parâmetros])
{ [declaração de variáveis locais]
bloco de instruções da função
[return ]
Toda a declaração de módulos/funções darieve seguir ao formato

acima. As partes entre colchetes são opcionais. Vamos ver o que
significa cada componente da estrutura de um módulo:
• Tipo_de_retorno: especifica qual o tipo de dado é retornado
66
Programação 2
pela função, podendo ser qualquer tipo de dado da linguagem

(int, float, char, etc.). Se a função não retorna nenhum valor,
devemos definir o retorno como void, que significa ausente de
retorno. Vale ressaltar que existe apenas um valor de retorno
para funções em C. Um exemplo de módulo que retorna um
valor é o sqrt, ou seja, ao ser executado, ele nos retorna a raiz
quadrada de um número.
• Nome da função: indica o nome pelo qual o bloco de código

correspondente à função será chamado. É através do nome
da função que poderemos chamá-la quando desejarmos a sua
execução. As regras para nomear um função são as mesmas
que utilizamos para nomear as nossas variáveis.
• Declaração de parâmetros: é na declaração de parâmetros

que informamos ao compilador quais serão as entradas da
função. Para cada um dos parâmetros deve ser declarado o
seu tipo e nome. Se a função não receber nenhum parâmetro,
deve-se deixar os parênteses sem nada entre eles. Os
parâmetros servem para passarmos alguma informação
para a função. A função sqrt recebe um número real como
parâmetro. Para calcular uma raiz quadrada, a função precisa
que o programador informe de qual valor será calculada a raiz
quadrada. O valor que é fornecido a função, é o parâmetro. Já
a função pow, precisa receber dois parâmetros para que possa
elevar um número a um expoente qualquer.
• Declaração das variáveis locais: as variáveis que são

específicas de um módulo são chamadas de variáveis locais.
Todas as variáveis locais devem ser declaradas dentro da
função, antes de qualquer comando. Uma variável local
somente pode ter seu valor acessado dentro da função em que
foi declarada. Um módulo pode não ter nenhuma variável local.
• Corpo da função: sequência de comandos que compõem a

função. É similar ao corpo do programa principal. O corpo de
uma função é delimitado por chaves.
• return: o comando return finaliza a execução da função que

está sendo executada. Se a função retornar algum valor (o
tipo de retorno não é void) este comando é obrigatório. Se a
função tiver retorno do tipo void, este comando não precisa ser
colocado.
67
Programação 2
A figura 3.2 apresenta uma função que calcula a média das duas
notas de um aluno.
Tipo de retorno Lista de parâmetros

Nome da função
float calc_media(float n1, float n2)
{ float m;
m = (n1 + n2)/2;
return m;
Retorno da função
Variável Local
Figura 3.2: Função para calcular a média do aluno
Vamos identificar cada parte da estrutura desta função. Esta função

se chama calc_media e precisa receber dois parâmetros para calcular
a média do aluno. Os parâmetros são as duas notas do aluno: n1 e
n2. Como cada nota é um número real, na frente de cada parâmetro
é colocado o seu tipo (float) e separa por vírgula. Mesmo que os
parâmetros sejam do mesmo tipo, precisamos colocar o tipo de cada
parâmetro, na frente do seu nome.
O objetivo desta função é calcular uma média. Dessa forma, ao

terminar a sua execução, a função irá retornar a média do aluno.
Por isso, o tipo de retorno da função é float. Como esta função tem
um retorno, no final da sequência de comandos, devemos colocar
o comando return, e ao lado dele, o nome da variável que tem
armazenado o valor que será retornado. Neste caso, a variável que
tem este valor é m. Esta é uma variável local, ou seja, uma variável
que foi declarada dentro deste módulo. Por conta disto, só pode ser
usada no módulo calc_media.
Vamos discutir um pouco mais sobre alguns dos conceitos

apresentados, para depois iniciarmos a implementação de mais
funções.
68
Programação 2
3.3. Em que ponto do programa os módulos

devem ser implementados?
A execução de um programa C é sempre iniciada pelo main(), que

é o módulo principal do programa, por isso ele tem esse nome. Um
programa pode ter várias funções, bem como poderá utilizar funções
definidas em outros programas. Além disso, uma função poderá
fazer uso de outra função. Dessa forma, as funções definidas no
programa devem ser escritas antes do programa principal. E ainda,
se a funcao1, faz uso da funcao2, a função2 deve ser escrita antes
da funcao1. Isto é feito por uma razão. Ao compilar o programa, o
compilador precisa conhecer, com antecedência, quais são os tipos de
retorno e quais são os parâmetros das funções para que o código seja
gerado corretamente. É por isto que as funções são colocadas antes
do programa principal. Quando o compilador chegar no programa
principal (main), ele já terá compilado as funções e já saberá seus
formatos.
Quando são utilizadas funções que estão em outros programas, o

programador deverá informar, através da diretiva #include, a biblioteca
ou o arquivo onde a função foi implementada. O caso mais comum é
o uso de funções que estão nas bibliotecas padrão do C, como por
exemplo, o comando para limpar o buffer de entrada: fflush(stdin), que
se encontra na biblioteca stdio (standard in/out).
A figura 3.3 apresenta a nova estrutura dos nossos programas C.
Inclusão das Bibliotecas
Declaração de Constantes
Declaração de Variáveis Globais
Declaração dos Módulos
Programa Principal
Figura 3.3: Nova estrutura dos programas C
O que temos nesta nova estrutura é a seção de declaração de

variáveis globais, que são as variáveis que são utilizadas por todos
os módulos do programa (mais detalhes na próxima seção). Além
da seção de declaração dos módulos, que vem antes do programa
principal. É neste ponto do programa que devemos declarar nossos
módulos.
69
Programação 2
3.4. Escopo das Variáveis
Quando programamos sem utilizar modularização, as variáveis

são declaradas no início do programa principal. Com esta forma de
declaração, as variáveis só podem ser acessadas pelo programa
principal. Agora que começaremos a programar com módulos, para
que uma variável possa ser acessada por todos os módulos do
programa, ela deve ser declarada fora de qualquer módulo. Estas
variáveis são chamadas de globais. As variáveis globais devem ser
declaradas fora de qualquer módulo e programa principal, logo após a
inclusão das bibliotecas.
Quando programamos de forma modularizada, em alguns casos,

uma determinada variável é utilizada apenas por um módulo específico,
o que não justifica uma definição global, pois somente será utilizada
dentro dos limites do módulo. Quando isto acontece, a variável deve
ser declarada dentro do módulo e é denominada variável local.
O escopo ou abrangência de uma variável indica por quais módulos

do programa esta variável é visível e pode ser utilizada. Assim,
podemos dizer, então, que as variáveis globais são visíveis por todos
os módulos, e as variáveis locais, são visíveis apenas ao módulo onde
esta foi declarada. Podemos ter quantos módulos quisermos com
uma variável local chamada x, por exemplo, e elas não apresentarão
conflito entre si. Vamos analisar a figura 3.4 a seguir:
int A, B, C;
Modulo 1
int x, y, z;
Modulo 2
int x, w;
Figura 3.4: Escopo de variáveis locais e globais
As variáveis A, B e C são globais, portanto, podem ser utilizadas

pelos módulos 1 e 2. No módulo 1 temos as variáveis x, y e z, que
só podem ser utilizadas por este módulo. Dessa forma, o módulo 2
70
Programação 2
não tem acesso a tais variáveis. Notem que, tanto o módulo 1 quanto
o módulo 2, tem uma variável chamada x. Variáveis com o mesmo
nome em módulos diferentes não causam conflito no programa.
Também pode ocorrer de uma função ter uma variável local com o
Atenção
mesmo nome de uma variável global, quando isto acontece, a função
dará preferência à variável local11. 11
Lembrem que
não podemos ter
Um ponto interessante que devemos atentar ao declarar as duas variáveis
globais com o
variáveis do programa é que as variáveis locais só existem (e mesmo nome.
consequentemente, ocupam memória) enquanto o módulo estiver
ativo e são destruídas quando a execução do módulo termina. Com
isso, há uma melhor utilização da memória do programa.
3.5. Parâmetros
Ao desenvolver um módulo, devemos ficar atentos para que o

mesmo seja definido de forma bem genérica, com o objetivo de que
este possa ser reutilizado mais vezes. Por exemplo, se criamos
um módulo para calcular 2 elevado a 3, a sua aplicação será muito
restrita. Porém se generalizarmos o módulo de forma a torná-lo capaz
de calcular o valor de qualquer base elevada a qualquer expoente, sua
aplicação será mais abrangente. Portanto, dizemos que um módulo é
generalizado quando ele for parametrizado.
A utilização de parâmetros nos módulos funciona de forma muito

similar às funções matemáticas, como por exemplo:
f (x , y) = x y
• em que x e y são parâmetros.
Essa função foi definida em termos de parâmetros x e y. Para

calcularmos a função para algum valor particular de x e y devemos
substituí-los pelos valores dos argumentos desejados.
f (3 , 2) = 3 2 = 9
Uma correspondência é estabelecida entre os parâmetros da
definição e os argumentos utilizados. No exemplo, o parâmetro x foi
substituído pelo 3 e o parâmetro y foi substituído pelo 2. É importante
perceber que a ordem dos parâmetros é crucial, pois f(3,2) não é o
mesmo que f(2,3).
Uma função pode receber qualquer número de parâmetros. Mas
71
Programação 2
também poderemos escrever uma função que não receba nenhum

parâmetro. No caso de uma função sem parâmetros pode-se escrevê-
la da seguinte forma: deixando a lista de parâmetros vazia, mantendo
entretanto os parênteses. O exemplo 3.1 apresenta uma função sem
parâmetros.
Exemplo 3.1: função sem parâmetro
1 void cabecalho()
3 printf(”Faculdade Legal\n”);
4 printf(“__________________________________\n”);
5 }
A função cabecalho, apresentada no exemplo 3.1 tem o objetivo de

limpar a tela e escrever o nome da empresa no início da tela, além de
passar uma linha logo abaixo. Como esta função não precisou receber
nenhuma informação para a sua execução, ela não tem parâmetros,
mas temos que colocar os parênteses em branco logo após o nome
da função. Esta função também não tem retorno, por isso o tipo de
retorno é void.
3.6. Contexto do Módulo (Ação ou Resultado)
Um módulo possui o contexto de ação quando ele se preocupa com

um processo em particular, como por exemplo, o módulo responsável
por fazer o cadastramento dos dados dos alunos ou o módulo
responsável por apresentar todos os dados dos alunos cadastrados.
Neste tipo de módulo, teremos a execução de uma ação que é o
cadastramento de alunos ou a listagem dos dados dos alunos.
Um módulo possui o contexto de resultado quando a sua

característica é a de calcular um resultado. Para exemplificar podemos
pensar no módulo que é responsável por calcular a média das duas
notas de um aluno. Ao ser executado, este módulo retornará como
resultado, a média do aluno.
A essência de um módulo com contexto de resultado é que seu

conjunto de ações visa um objetivo único, retornar ao ponto de sua
chamada, um valor. Para que um módulo retorne um valor, em C, será
72
Programação 2
necessário que seja indicado qual é o valor a ser retornado, o que

será efetuado com a utilização do comando return. Vamos analisar
mais uma vez a função que calcula a média do aluno.
Exemplo 3.2
1 float calc_media(float n1, float n2)
2 { float m;
3 m = (n1 + n2)/2;
4 return m;
5 }
A função calc_media recebe como parâmetro as duas notas do

aluno e retorna como resultado um float, que é a sua média. As duas
notas passadas como parâmetros nas variáveis n1 e n2 são somadas
e depois divididas por 2. No final da função, temos o comando return,
que retorna o valor da variável local m, que tem armazenado a média
do aluno. Não é necessário usar o comando return nas funções que
não retornam nenhum valor (contexto de ação).
3.7. Ativando Funções
A ativação de um módulo ocorre quando um determinado ponto

do programa contém o identificador do módulo (nome do módulo).
A ativação é conhecida como chamada de um módulo e serve para
executá-lo. Uma chamada de função é feita escrevendo-se o nome da
função seguido dos argumentos fornecidos, entre parênteses. Se não
houver argumentos, ainda assim devem ser mantidos os parênteses,
para que o compilador diferencie a chamada da função de uma
variável. As funções só podem ser chamadas depois de terem sido
declaradas.
Quando queremos chamar uma função que retorna valor, devemos

chamá-la através de um comando de atribuição, para que o valor que
ela retorna de resultado, seja armazenado nesta variável. Este tipo de
função também pode ser chamada/ativada em um comando de saída.
Dessa forma, ao invés de armazenamos o resultado, o apresentamos
na tela.
Durante a chamada de um módulo, o fluxo de execução do
73
Programação 2
programa é desviado para o módulo chamado, e logo após a sua

conclusão, o fluxo de execução do programa retorna para o comando
seguinte após a sua ativação. A figura 3.5 mostra a ativação de dois
módulos no programa. Vale lembrar que após a ativação de um
módulo, todas as suas variáveis locais são desalocadas da memória.
main()
{ comando1; void modulo1()
comando3; comando2;
comando4; comando3;
modulo1();
comando5;
comando6; void modulo2()
{ comando1;
modulo2(); comando2;
comando3;
comando7; comando4;
comando8; }
Figura 3.5: Chamada de Funções
Para ilustrar melhor o assunto explanado, o programa completo

3.1 apresenta um programa que calcula o quadrado de um número.
Foram definidos dois módulos, além do programa principal (main). É
no main que as funções deste exemplo serão chamadas.
74
Programação 2
1 void escreva_cabecalho()
3 printf(“Encontrar quadrado de um numero\n”);
4 printf(“_______________________________\n\n”);
5 }
7 int quadrado(int numero)
8 { int q;
9 q = numero*numero;
10 return q;
11 }
12
13 main()
14 { int n, r;
15 escreva_cabecalho();
16 printf(“\nInforme o numero: “);
17 scanf(“%d”, &n);
18 r = quadrado(n);
19 printf(“\n\nResultado\n\n”);
20 printf(“O quadrado de %d = %d\n\n”, n, r);
21 getche();
22 }
O programa começa a sua execução pelo programa principal (linha

13). Logo no início, encontra a chamada para a função escreva_
cabecalho. A função escreva_cabecalho é usada para escrever o
título do programa, esta função, não recebe parâmetros, nem retorna
nenhum valor, ela apenas escreve um texto na tela. A chamada desta
função foi feita na linha 15, logo após a declaração das variáveis do
programa principal. Para chamar esta função, foi necessário apenas
75
Programação 2
informar o seu nome e, como ela não tem parâmetros, os parênteses

são colocados sem nada entre eles.
Na sequência do programa, será lido o número que se deseja

calcular o quadrado e logo em seguida é feita a chamada da função
quadrado (linha 18). A função quadrado recebe um parâmetro inteiro
(que é o número que se deseja calcular o quadrado) e retorna como
resultado um valor inteiro. Como mencionado anteriormente, funções
que retornam valor, devem ser chamadas através de um comando
de atribuição. Neste caso, a variável r, receberá o retorno da função
quadrado. Além disso, como esta função precisa saber de qual
número será calculado o quadrado, na chamada da função, entre os
parênteses, devemos colocar o valor ou a variável que será utilizada
no cálculo, neste caso, será passado como parâmetro o valor da
variável n. O programa finaliza apresentado o resultado, que é o
quadrado do número (linhas 19 e 20).
A figura 3.6 apresenta a tela de execução do programa completo

3.1
Nos demais volumes deste livro, estaremos desenvolvendo nossos

programas de forma modularizada. Quando passarmos a desenvolver
programas maiores, veremos com mais clareza as vantagens de usar
a modularização.
Atividades e Orientações de Estudos
Vamos treinar o desenvolvimento de módulos? Para cada questão

abaixo, crie um programa principal, para que se possa testar/chamar
76
Programação 2
o módulo desenvolvido.
1. Desenvolva uma função que recebe as três notas do aluno como

parâmetro e retorne a sua média.
2. Desenvolva uma função que recebe dois números inteiros como

parâmetro, e retorna o resto da divisão do primeiro parâmetro
pelo segundo.
3. Desenvolva uma função que receba três números inteiros como

parâmetros e retorne o menor valor.
4. Desenvolva uma função que recebe o ano de nascimento do

usuário e retorna a sua idade. Faça o cálculo usando o ano
atual.
5. Desenvolva uma função que recebe como parâmetro o mês

atual e retorna quantos meses faltam para o final do ano.
6. Desenvolva uma função que recebe como parâmetros o dia do

mês, o mês e o ano e retorna quantos dias faltam para o final do
mês. Lembrem que os meses que têm 28, 29, 30 ou 31 dias.
Será realizado um fórum de discussão que discutirá sobre

modularização de programas em C. É importante que vocês participem
ativamente deste fórum. É uma oportunidade para discutirmos e
trocarmos idéias sobre este assunto tão abrangente. Apareçam por
lá!
Conheça Mais
Vocês podem aumentar o entendimento deste assunto lendo o

capítulo 7 do livro:

Vamos Revisar?
77
Programação 2
fazendo a leitura do resumo a seguir:
• Modularização é um técnica de programação que tem como

objetivo desenvolver o programa de maneira mais simples e
legível.
• Um módulo deve ser bem específico, ou seja, deve ser projetado

para resolver uma única ação.
• As variáveis declaradas dentro de um módulos são de uso

exclusivo deste módulo e são chamadas de variáveis locais.
• As variáveis globais podem ser acessadas por qualquer módulo

do programa.
• Um programa C começa a sua execução a partir do programa

principal (main).
• Se o módulo retornar algum valor, devemos utilizar o comando

return.
• Os módulos que recebem parâmetros tem mais chances de serem

reutilizados.
• Para ativar a execução de um módulo, devemos fazer a sua

chamada.
• Ao iniciar a execução de um módulo, o fluxo do programa é

desviado para o módulo chamado. Ao terminar, o fluxo de execução
do programa volta para o ponto onde o módulo foi chamado.
78
Programação 2
Neste volume, demos continuidade ao nosso aprendizado na

linguagem de programação C. Nos capítulos 1 e 2, conhecemos as
estruturas de repetição, que tem a capacidade de mudar o fluxo de
execução do programa, desviando de uma parte de comandos ou
fazendo com que um grupo de comandos fosse executado várias
vezes. No capítulo 3, foi abordada a modularização, que nos permite
uma programação mais organizada, reaproveitamento de código
e desenvolvimento do programa em etapas. Esperamos que vocês
estejam a cada dia, gostando mais da linguagem de programação C.
Temos mais dois volumes, que nos darão a capacidade de desenvolver
programas ainda mais complexos. Continuem firmes nos estudos! Até
o próximo módulo.
Referências
ARAÚJO, Jairo. Dominando a Linguagem C. São Paulo:

Ciência Moderna, 2004.


Janeiro: LTC, 1999.





1996.
79
Programação 2
Conhecendo a Autora
Sou graduada em Ciência da computação pela Universidade

Federal de Sergipe. Fiz mestrado e doutorado na Universidade Federal
de Pernambuco, desenvolvendo pesquisas nas áreas de Sistemas
Distribuídos e Geoprocessamento. Começei a ensinar em 2000, nos
cursos de Ciência da Computação e Sistemas de Informação. Desde
o início da minha carreira como professora, ministro disciplinas de
Programação e tenho uma paixão pela linguagem C. Atualmente,
encontrei uma nova paixão: Educação a Distância.
80
Programação 2
Recife, 2009

Coordenação de Ensino a Distância: Profª Marizete Silva Santos

Capa e Editoração: Allyson Vila Nova, Rafael Lira, Italo Amorim e Marcella Almeida
Revisão Ortográfica: Marcelo Melo
Ilustrações: Diego Almeida e Glaydson da Silva
Sumário
Apresentação.........................................................................................5
Conhecendo o Volume 3.......................................................................6
Capítulo 1 – Armazenamento de Dados em Vetores..........................8
1.1 O que são vetores?.......................................................................8
1.2 Declaração de Vetores..................................................................9
1.3 Referência a elementos de vetor................................................. 11
1.4 Inicialização de vetores...............................................................13
1.5 Leitura de elementos para o vetor...............................................15
1.6 Impressão dos elementos de um vetor........................................22
1.7 Tamanho de um vetor e segmentação de memória....................27
1.8 Passando vetores como parâmetros de funções........................28
Capítulo 2 – Armazenamento de Dados em Registros.....................35
2.1 O que são registros?...................................................................35
2.2 Declaração de um Registro.........................................................36
2.3 Acessando os campos do registro...............................................39
2.4 Vetor de registro..........................................................................40
2.5 Acessando os campos do vetor de registro.................................42
2.6 Usando vetor de registro.............................................................43

Capítulo 3 – Armazenamento de Dados em Arquivos......................61
3.1 O que são arquivos?....................................................................61
3.2 Comandos para manipular arquivos binários..............................64
3.3 Implementação das operações básicas em um arquivo..............76
Considerações Finais........................................................................102
Conhecendo a Autora........................................................................104
Apresentação
Caro(a) aluno(a),
Seja bem-vindo (a) ao terceiro módulo da disciplina Programação II. Neste módulo,
vamos dar mais um passo no nosso aprendizado sobre a linguagem de programação
C.
Nos dois volumes anteriores, aprendemos os comandos básicos do C, a utilizar

as estruturas de controle (seleção e repetição) e a modularizar nossos programas em
módulos ou funções. Com estes assuntos, adquirimos a capacidade de desenvolver
programas mais elaborados.
Neste livro, nós vamos aprender novas formas de armazenar nossos dados. Com os
vetores e registros, poderemos manusear um volume maior de dados, de forma facilitada.
Outro assunto muito importante que será abordado neste volume é o armazenamento de
dados em arquivos. Atualmente, ao terminar a execução do programa, todos os dados
que foram digitados são perdidos. Com o armazenamento de dados em arquivos, isto
não acontece. Assim, iremos desenvolver programas com operações como: cadastro de
elementos, remoção, alteração, consultas, listagens, etc.
Continuem resolvendo as questões propostas no final de cada capítulo, além de

executar buscas na Internet, visando um maior aprofundamento de cada assunto. Ao final
deste módulo, teremos a capacidade de resolver questões com operações presentes
nos principais sistemas de controle do mercado, como por exemplo: sistema de controle
de estoque, sistema de controle de cliente, etc. Vamos começar mais uma nova etapa
no conhecimento da linguagem de programação C?
Bons estudos!
Professora Sônia Virginia Alves França

Programação 2
Neste terceiro volume, vocês irão encontrar o módulo 03 da

disciplina: Programação II. Este volume está estruturado em três
capítulos, que serão estudados ao longo de 15h/aula. Para facilitar
seus estudos, veja a organização deste volume.
Capítulo 1: Armazenamento de Dados em Vetores
Objetivos do Capítulo 1: Apresentar o uso de vetores para o

armazenamento de dados.
• Definição de vetores;
• Declaração, leitura e escrita de dados em vetores;
• Passagem de vetores como parâmetros de funções;
Capítulo 2: Armazenamento de Dados em Registros
Objetivos do Capítulo 2: Apresentar o uso de registros para o

armazenamento de dados.
• Definição de registros;
• Declaração, leitura e escrita de dados em registros;
• Vetor de registro;
Capítulo 3: Armazenamento de Dados em Arquivos
Objetivos do Capítulo 3: Apresentar os principais comandos para

o armazenamento de dados em arquivos. Com os arquivos, os dados
manipulados no programa podem ser armazenados definitivamente.
• Definição de arquivos;
6
Programação 2
• Ponteiros;
• Comandos para manipulação de dados em arquivos;
Ao final de cada capítulo vocês encontrarão:



7
Programação 2
Capítulo 1 – Armazenamento de
Dados em Vetores
Neste terceiro volume, vamos aprender novas formas de armazenar

nossos dados. Começaremos aprendendo como armazenar os dados
em vetores. Com os vetores, nós podemos armazenar um grande
conjunto de dados, facilitando o acesso e manuseio dos mesmos. Os
dados são a “alma” de um programa. Assim, a manipulação dos dados
de forma mais adequada e facilitada, trará ganhos para o programa e
para o programador. Vamos continuar a nossa caminhada?
1.1 O que são vetores?
Imaginem que um professor nos encomendou um programa, que

tenha que armazenar as médias dos 50 alunos de uma turma. Como
faríamos para armazenar essas médias? Até o ponto que estudamos
a linguagem C, teríamos que declarar 50 variáveis do tipo float, uma
por uma. Que trabalheira, não é mesmo? E se o professor tivesse 300
alunos? Passaríamos um tempão só declarando variáveis e, além
disso, teríamos muito trabalho para fazer o controle das mesmas.
Mas não se preocupem, com os vetores, o professor pode ter mais de
1000 alunos, que a declaração e manuseio dos dados será bem fácil.
Os vetores são usados quando precisamos armazenar um conjunto

Saiba Mais
de dados do mesmo tipo. Por exemplo: armazenar as 50 médias dos
alunos de uma turma (todas as médias são do tipo float). Os vetores
1
Em inglês, um
vetor é chamado são bem convenientes já que iremos colocar todas as informações
de array (que
significa cadeia). dentro de um mesmo conjunto e faremos referência de cada dado,
Assim, quando individualmente, através de um índice1. De maneira mais formal, os
temos um array,
temos uma cadeia vetores são chamados de estruturas de dados homogêneas (já
de inteiros, reais
ou caracteres. que armazenam dados do mesmo tipo). Os vetores são formados
por dados de mesmo tipo (homogêneo) e possuem número fixo de
elementos (estático).
Para entendermos melhor os vetores, vamos visualizar a sua

representação gráfica, na figura 1.1.
8
Programação 2
media 3.0 7.5 5.8 9.5 8.2
0 1 2 3 4
Figura 1.1: Representação gráfica de um vetor
Na figura 1.1 temos um vetor chamado media, formado por 5

elementos. Vocês lembram quando tínhamos uma variável simples?
Representávamos com uma única caixa. Agora, com os vetores,
teremos um conjunto de dados, por isso ele é formado por várias
caixas. Em cada uma delas poderemos armazenar um valor. Todas as
caixas têm um único nome. Neste exemplo, o vetor se chama media.
Notem que, abaixo de cada caixa temos um número. Estes números
são chamados de índices. É através do índice, que iremos informar
qual das caixas do vetor é que estamos querendo acessar. Já que
todas as caixas têm um único nome (media), a forma de diferenciar
uma da outra é o índice. Entenderam?
Na linguagem C, o índice de um vetor, começa a partir de 0. Assim,

em um vetor com 5 elementos, os índices variam de 0 a 4 (como no
exemplo da figura 1.1). Por isso, o primeiro elemento do vetor media
está na posição de índice 0. Podemos dizer que a média do segundo
aluno está na posição de índice 1 do vetor media, e é igual a 7.5.
Esta não é a única maneira de estruturar um conjunto de dados.

Também podemos organizar dados sob forma de tabelas. Neste caso,
cada dado é referenciado por dois índices e dizemos que se trata de
um conjunto bidimensional (ou matriz).
Vamos aprender, nas próximas seções, como manusear os vetores

nos nossos programas.
1.2 Declaração de Vetores
Como já foi mencionado, um vetor é um conjunto de variáveis

do mesmo tipo, que possuem um nome identificador e um índice de
referência. A sintaxe para a declaração de um vetor é a seguinte:
Sintaxe
tipo identificador[tamanho];
9
Programação 2
onde:
• tipo: é o tipo de dados que o vetor armazena: int, float, char,

etc.
• identificador: é o nome do vetor. As regras para nomear um

vetor são as mesmas usadas para nomear variáveis, constantes
e funções.
• tamanho: é o tamanho do vetor. Isto é, o número de elementos

que o vetor pode armazenar.
A seguir, são apresentados exemplos de declarações de vetores.

Os vetores são declarados na seção de declaração de variáveis do
programa. Se estivermos desenvolvendo um programa modularizado,
podemos declarar o vetor como uma variável local de um módulo.
Exemplo 1.1: declaração de vetores
1 int idade[100];
2 float nota[25];
3 char nome[80];
No primeiro exemplo, temos a declaração de um vetor chamado

Atenção
idade, que pode armazenar até 100 números inteiros. No segundo
2
Nós já havíamos exemplo, temos um vetor chamado nota, com capacidade para
utilizado vetor
de caracteres, já
armazenar até 25 números reais. E, finalmente, no terceiro exemplo,
que trabalhamos temos um vetor chamado nome, com capacidade de armazenar até
com variáveis
que armazenam 80 caracteres2.
uma cadeia de
caracteres. No Ao declararmos o vetor, já temos que ter uma previsão de quantos
próximo volume,
teremos um elementos serão armazenados no mesmo. Com isso, o processador
capítulo dedicado
a este assunto.
saberá quanto de memória precisa ser reservada para armazenar os
dados do vetor, ao executar o programa. A quantidade de memória
(em bytes) usada para armazenar um vetor pode ser calculada como:
quantidade de memória = tamanho do tipo * tamanho do vetor
O tamanho do tipo indica quantos bytes um determinado tipo de

variável utiliza para ser armazenado (vimos este assunto no Volume
1 – Capítulo 3). Ao compilar o programa, a quantidade de memória
necessária para armazenar o vetor é alocada. Os vetores têm
tamanhos fixos e não podemos armazenar mais elementos do que a
quantidade que foi solicitada no momento da declaração do vetor. Por
10
Programação 2
isso, são chamados de estáticos. A quantidade de elementos não

pode aumentar em tempo de execução do programa.
Também é possível declarar um vetor com tamanho parametrizado:

usando uma constante. Declaramos uma constante com a diretiva
#define, no início do programa, e depois declaramos o vetor com
esta constante como tamanho do vetor. Deste modo, podemos alterar
o número de elementos do vetor antes de qualquer compilação do
programa. Esta é uma maneira simples de administrar o espaço de
memória usado pelo programa, e também testar os limites de um
vetor.
Exemplo 1.2:
Declaração de vetor usando uma constante no local do tamanho do vetor.
1 #define TAMANHO 30
2 int valor[TAMANHO];
No exemplo 1.2, o vetor valor terá capacidade de armazenar 30

elementos (este é o valor da constante TAMANHO).
1.3 Referência a elementos de vetor
Agora que já sabemos como criar os vetores, a partir da sua

declaração, vamos aprender como acessar um elemento do vetor.
Segue abaixo a sintaxe.
Sintaxe
identificador[indice]
onde:
• identificador: é o nome do vetor que queremos acessar.
• índice: é o índice do elemento do vetor que queremos acessar.
Cada elemento do vetor é referenciado pelo nome do vetor e,

entre colchetes, tem-se o índice, que é um número inteiro. O índice
irá indicar qual elemento do vetor estamos querendo referenciar. A
seguir, são apresentadas algumas atribuições a elementos de um
vetor chamado valor, que é composto por 10 elementos do tipo float.
11
Programação 2
Exemplo 1.3: Acessando os elementos de um vetor
1 float valor[10]; //declaração do vetor
2 int x;
3 x = 3;
4 valor[1] = 6.6;
5 valor[x] = 9.9
6 valor[x+2] = 10.0;
Entre os colchetes, que indicam o índice do vetor que será

acessado, podemos ter: um valor (exemplo da linha 4), uma variável
(exemplo da linha 5) ou uma expressão (exemplo da linha 6).
Devemos ter cuidado quando usamos variáveis e expressões, pois
estas devem ser inteiras e devem ter um valor dentro da capacidade
de armazenamento do vetor. Ou seja, se o vetor foi declarado com
tamanho 10, não podemos tentar acessar o índice 18 do vetor.
Na linha 4, foi atribuído 6.6 ao elemento de índice 1 do vetor valor.

Na linha 5, como a variável x tem armazenado 3, então o valor[3],
receberá 9.9. Quando temos uma expressão, que é o caso da linha
6, a expressão é resolvida primeiro. Assim, como x = 3, e entre os
colchetes temos x+2, o resultado será 5. Dessa forma, valor[5]
receberá 10.0. A seguir, temos a situação final do vetor valor, após as
atribuições dos valores do exemplo.
Valor 6.6 9.9 10.0
0 1 2 3 4 5 6 7 8 9
Figura 1.2: Situação do vetor valor após atribuições
Viram como é fácil trabalhar com vetor? Em uma única linha, nós
criamos um conjunto de variáveis, do tamanho da nossa necessidade.
Posteriormente, acessamos cada uma destas variáveis utilizando o
nome do vetor e o índice da variável.
Na próxima seção, vamos ver como fazemos para inicializar os

elementos de um vetor, no momento da declaração.
12
Programação 2
1.4 Inicialização de vetores
No momento da declaração de um vetor, também podemos

inicializar os seus elementos, fazendo a atribuição de valores aos
mesmos. A sintaxe para a inicialização dos elementos de um vetor é
a seguinte:
Sintaxe
tipo identificador[tamanho] = {lista de valores};
Onde:
• tipo: é o tipo dos elementos do vetor: int, float, char, etc.
• identificador: é o nome do vetor.
• tamanho: é o tamanho do vetor. Isto é, o número de elementos

que o vetor pode armazenar.
• lista de valores: é uma lista, separada por vírgulas, dos valores

de cada elemento do vetor. A lista de valores é colocada entre
chaves.
Vamos ver a seguir, exemplos de inicialização de vetores.
Exemplo 1.4: Inicialização de vetores
1 int idade[7] = {12, 30, 14, 7, 13, 15, 6};
2 char vogal[5] = {‘a’, ‘e’, ‘i’, ‘o’, ‘u’};
3 float nota[5] = {8.4, 6.9, 4.5};
4 float media[5] = {0};
No exemplo da linha 1, temos o vetor chamado idade e para cada

posição do vetor, foi atribuído um valor. Após esta atribuição, o vetor
idade ficará assim:
idade 12 30 57 25 18 15 13
0 1 2 3 4 5 6
Figura 1.3: Situação do vetor idade após inicialização
No segundo exemplo, temos um vetor de caracteres, chamado

vogal. Quando inicializamos um vetor deste tipo de variável, os valores
13
Programação 2
devem ser colocados entre apóstrofo. Ao final desta atribuição, o vetor

vogal ficará como mostra a figura 1.4.
vogal a e i o u
0 1 2 3 4
Na linha 3, temos a inicialização do vetor nota, que é composto

por cinco elementos. Notem que, entre as chaves, não temos cinco
valores. Temos apenas três. Quando não quisermos inicializar todo o
vetor, podemos colocar apenas os valores dos primeiros elementos, e
aos demais, será atribuído zero (automaticamente). Vejam na figura
1.5 como ficará o vetor nota, após a sua inicialização.
nota 8.4 6.9 4.5 0.0 0.0
0 1 2 3 4
Seguindo o raciocínio do exemplo anterior, quando precisarmos

inicializar todos os elementos do vetor com zero, fazemos como
mostra o exemplo da linha 4. Colocamos apenas um zero entre as
chaves, o primeiro elemento será inicializado com zero, e os demais
também. Neste caso, o vetor media ficará como apresentado na figura
1.6.
media 0.0 0.0 0.0 0.0 0.0
0 1 2 3 4
Figura 1.6: Situação do vetor media após inicialização
Opcionalmente, podemos inicializar os elementos do vetor

enumerando-os um a um. No exemplo 1.5, a seguir, observem que
estas duas inicializações são possíveis:
14
Programação 2
Exemplo 1.5: Inicialização de vetores
1 int valor[3] = {7,4,20};
2 ou
3 int valor[3];
4 valor[0] = 7;
5 valor[1] = 4;
6 valor[2] = 20;
Na próxima seção, vamos aprender a armazenar, em um vetor,

valores que são fornecidos via teclado.
1.5 Leitura de elementos para o vetor
Agora suponham que os valores que vão ser armazenados no

vetor sejam fornecidos pelo usuário, via teclado. O que devemos
fazer? Devemos utilizar uma estrutura de repetição, para controlar o
preenchimento dos dados no vetor, um por um. Assim, podem ocorrer
duas situações:
• Nós sabemos quantos elementos o usuário vai digitar;
• Nós não sabemos a quantidade de elementos que o usuário

vai digitar.
Vamos ver como tratar cada uma das situações? Quando nós
sabemos quantos elementos o usuário vai digitar, poderemos usar
uma estrutura de repetição como o for, que irá repetir a leitura dos
elementos, na quantidade definida. Vamos ver o Programa Completo
1.1 a seguir: o usuário precisa armazenar 5 elementos em um vetor
de inteiros, chamado valor.
15
Programação 2
Programa Completo 1.1:

Ler 5 números inteiros, armazenando-os em um vetor
1 main()
2 {
3 int valor[5];
4 int i;
5 printf(“Cadastro dos elementos do vetor Valor

\n\n”);
6 for (i=0; i<5; i++)
7 { printf(“\n\nElemento %d: “,i+1);
8 scanf(“%d”,&valor[i]);
9 }
10 getche();
11 }
Comentários sobre o Programa Completo 1.1:
• Linha 3: declaração do vetor valor, que tem a capacidade de

armazenar 5 números inteiros.
• Linha 4: declaração da variável i, que irá controlar o for.
• Linha 5: printf para que o usuário saiba que será feito o cadastro
dos elementos no vetor.
• Linha 6: for que será repetido 5 vezes, fazendo a leitura dos

elementos do vetor. Notem que a variável de controle do for, o i,
é inicializado com 0. Isso acontece porque o primeiro índice do
vetor é 0.
• Linha 7: Abre chaves que inicia a sequência de comandos

do for (já que teremos mais de um comando). Nesta linha,
também temos o printf para que o usuário saiba qual elemento
do vetor está sendo cadastrado no momento. Vejam que neste
printf temos a expressão: i+1. O motivo de colocarmos esta
expressão no printf é que, como o i começa com zero e vai até
4, não ficaria muito interessante que saísse uma mensagem, na
tela, informando que o usuário estaria cadastrando o elemento
0. O correto é dizer que ele está cadastrando o elemento 1. Por
16
Programação 2
isso, usamos a expressão i+1.
• Linha 8: scanf que lê o valor, armazenando no vetor. Notem

que estamos usando a variável i, no índice do vetor. Dessa
forma, o i vai variando a cada vez que o for é repetido, e assim,
os elementos são armazenados em índices diferentes do vetor.
Com isso, nenhum elemento irá sobrepor o outro.
• Linha 9: fecha chaves que indica o final da sequência de

comandos do for.
programa.

principal.
A figura 1.7, apresenta a tela de execução do Programa Completo

1.1.
Figura 1.7: Tela de execução do Programa Completo 1.1
Para facilitar o entendimento, vamos fazer um acompanhamento

dos valores das variáveis do Programa Completo 1.1, ao longo da
sua execução. Vamos considerar que o usuário está cadastrando os
valores apresentados na figura 1.7. A figura 1.8 mostra os valores das
variáveis do programa, conforme o programa vai sendo executado.
17
Programação 2
i i+1 valor
0 1 10
0 1 2 3 4
10 15
1 2
0 1 2 3 4
2 3 10 15 9
0 1 2 3 4
10 15 9 6
3 4
0 1 2 3 4
4 5 10 15 9 6 12
0 1 2 3 4
Figura 1.8: Acompanhamento das variáveis do Programa Completo 1.1
O que fazemos quando não sabemos quantos elementos serão

armazenados no vetor? Neste caso, como não sabemos quantas
vezes o for deve ser executado, poderemos fazer a leitura dos dados
que serão colocados no vetor, usando um do/while, como mostra o
Programa Completo 1.2, a seguir. Neste programa, iremos fazer
a leitura de uma quantidade indeterminada de números inteiros,
armazenando em um vetor.
18
Programação 2
Programa Completo 1.2:

Ler um conjunto de números inteiros, armazenando-os em um vetor.
1 main()
2 { int valor[5];
3 int q, continuar;
4 q=0;

\n\n”);
6 do
7 { printf(“\n\nElemento %d: “,q+1);
8 scanf(“%d”,&valor[q]);
9 q++;
10 printf(“\n\nCadastrar outro elemento

(1-sim/2-nao)? “);
12 } while ((continuar==1) && (q<5));
13 }
Neste caso, a leitura será finalizada quando o vetor ficar cheio,

com cinco elementos, ou quando o usuário decidir que não deseja
mais continuar a leitura. Neste último caso, saberemos quantos Atenção
elementos foram armazenados no vetor através da variável q. É esta 3

Quando não
variável que indica, também, em qual índice do vetor o elemento deve sabemos quantos
elementos serão
ser armazenado3. cadastrados,
temos que
Comentários sobre o Programa Completo 1.2: estipular um valor
para a quantidade
• Linhas 2: declaração do vetor valor, que tem a capacidade de de elementos
que serão
armazenar 5 números inteiros. armazenados no
vetor. Isso se dá
porque temos que
• Linha 3: declaração das variáveis q (que controla a quantidade
saber o tamanho
de elementos que já foram cadastrados no vetor) e continuar do vetor no
momento da sua
(que armazena a resposta do usuário informando se quer declaração.
cadastrar mais elementos ou não).
• Linha 4: inicialização da variável q com 0.
• Linha 5: printf para que o usuário saiba que será feito o cadastro
19
Programação 2
dos elementos no vetor.
• Linha 6: do indicando o início da repetição.
• Linha 7: Abre chaves que inicia a sequência de comandos do

do/while (já que teremos mais de um comando). Nesta linha
também temos o printf para que o usuário saiba qual elemento
do vetor está sendo cadastrado no momento.
• Linha 8: scanf que lê o valor que será armazenado no vetor.

Notem que estamos usando a variável q, no índice do vetor.
• Linha 9: incremento da variável q, indicando que mais um

elemento foi cadastrado no vetor. Através do valor de q,
saberemos se o vetor já está cheio ou não.
• Linha 10: prinft que pergunta ao usuário se deseja cadastrar

outro elemento no vetor. O usuário pode parar o cadastro dos
elemento do vetor, no momento que ele desejar. Nesse caso, o
vetor pode ficar com posições sem valores armazenados.
• Linha 11: scanf para ler a resposta do usuário.
• Linha 12: fecha chaves do do/while e while com a condição

que faz com que a repetição fique sendo executada. Como
a condição é formada por duas expressões relacionais, nós
colocamos cada expressão relacional entre parênteses e depois
colocamos toda a expressão entre parênteses. As expressões
estão conectadas pelo operador && (e). Com isso, quando uma
das expressões der falso, a repetição para. Vai parar porque
o vetor está cheio (q=5) ou porque o usuário desejou parar,
respondendo 2 a pergunta se deseja continuar.

principal.
A figura 1.9, apresenta a tela de execução do Programa Completo

1.2.
20
Programação 2
Vamos acompanhar o valor das variáveis do Programa Completo

1.2? A Figura 1.9 mostra o cadastramento de 3 elementos no vetor. O
usuário respondeu que não queria mais cadastrar após dar entrada
ao terceiro elemento. A figura 1.10 mostra os valores das variáveis do
programa, conforme o programa vai sendo executado.
q q+1 valor
12
0 1
0 1 2 3 4
12 15
1 2
0 1 2 3 4
2 3 12 15 18
0 1 2 3 4
Figura 1.10: Acompanhamento das variáveis do Programa Completo 1.2
Agora que já sabemos colocar informações em um vetor via

teclado, vamos ver como apresentar, na tela, os valores armazenados
em um vetor.
21
Programação 2
1.6 Impressão dos elementos de um vetor
Quando desejarmos apresentar os elementos que estão

armazenados no vetor, devemos utilizar uma estrutura de repetição,
que fará com que cada uma das posições do vetor seja “visitada” e
seu conteúdo apresentado. Vale lembrar que, quando declaramos um
vetor, indicamos a sua capacidade de armazenamento. Mas durante a
execução do programa, pode ser que o usuário não armazene dados
suficiente para preencher todas as posições do vetor. Assim, quando
formos imprimir os dados de um vetor, precisamos saber quantos
elementos têm armazenado no momento da impressão. O Programa
Completo 1.3, mostra a leitura e a impressão dos dados armazenados
em um vetor.
Programa Completo 1.3: Ler e imprimir um conjunto de números inteiros,

armazenando-os em um vetor.
1 main()
2 { int valor[5];
3 int q, continuar, i;
4 q=0;

\n\n”);
6 do
7 { printf(“\n\nElemento %d: “,q+1);
8 scanf(“%d”,&valor[q]);
9 q++;
10 printf(“\n\nCadastrar outro elemento

(1-sim/2-nao)? “);
13 printf(“\n\nElementos do Vetor: “);
14 for (i=0; i<q; i++)
15 printf(“ %d “,valor[i]);
16 getche();
17 }
22
Programação 2
Até a linha 12, o Programa Completo 1.3 é, praticamente, idêntico

ao Programa Completo 1.2. A única diferença é que temos, na linha
3, a declaração da variável i, que será usada no for que imprimirá os
elementos do vetor. Vamos ver o que está acontecendo nas demais
linhas?
• Linha 13: printf para informar que serão apresentados os

elementos do vetor. Notem que o texto entre aspas não termina
com \n. Isso se dá porque não queremos que o cursor vá para
a linha seguinte.
• Linha 14: for que será utilizado para percorrer o vetor,

acessando cada uma das posições do vetor. A variável que tem
a informação de quantos elementos foram armazenados no
vetor é q. Dessa forma, o i do for vai variar de 0 até q-1. Uma
vez que se q for 3, a última posição ocupada no vetor é 2.
• Linha 15: printf que apresenta o elemento do vetor, na posição

de índice i. Este printf também não tem o \n, porque queremos
que os elementos do vetor sejam impressos um ao lado do
outro. Este é o único comando do for, por isso não houve a
necessidade de delimitar com chaves.
• Linha 16: getche que evita o fechamento da janela de execução

do programa, e assim poderemos ver os elementos do vetor
impresso.

principal.
A figura 1.11 apresenta a tela de execução do programa 1.3. Foram

cadastrados os mesmos valores do exemplo anterior.
23
Programação 2
Neste caso, apesar do vetor ter sido declarado com 5 posições, só

foram preenchidas 3 posições. Vejam que, após o usuário responder
que não quer mais cadastrar, os elementos do vetor são apresentados
um ao lado do outro.
Vamos ver outro Programa Completo? Neste programa iremos

ler as matrículas e notas dos alunos de uma turma e imprimir as
matrículas dos alunos de tiveram nota acima da média das notas da
turma.
1 main()
2 { int mat[10];
3 float nota[10];
4 int q, i, continuar;
5 float soma, media;
6 soma = 0;
7 q=0;
8 do
10 printf(“Universidade Aberta do Brasil -

UFRPE\n\n”);
24
Programação 2
11 printf(“\n\nDados do Alunos %d\n\n”,

q+1);
12 printf(“\nMatricula: “);
13 scanf(“%d”,&mat[q]);
14 printf(“\nNota: “);
15 scanf(“%f”,&nota[q]);
16 soma = soma + nota[q];
17 q++;
18 printf(“\n\nCadastrar outro(1-sim/2-nao)?
“);
21 media = soma/q;
22 system(“cls”);
23 printf(“Universidade Aberta do Brasil - UFRPE

\n\n”);
24 printf(“Media da turma: %.2f\n\n\n”,media);
25 printf(“Alunos com nota acima da media da

turma\n\n”);
26 for (i=0; i<q; i++)
27 { if (nota[i]>media)
28 printf(“%d \n”,mat[i]);
29 }
30 printf(“\n\nDigite qualquer tecla para sair

“);
31 getche();
32 }
Comentários sobre o Programa Completo 1.4:
• Linhas 2 a 5: declaração das variáveis do programa. Vejam

que precisamos de um vetor para armazenar as matrículas e
um outro para armazenar as notas.
25
Programação 2
• Linhas 6 e 7: inicialização das variáveis soma (que acumula as

notas de todos os alunos) e q (que conta quantos elementos
foram cadastrados no vetor).
• Linhas 8 a 20: do/while que faz a leitura das matrículas e das

notas de cada aluno, armazenando nos respectivos vetores.
Neste do/while, o usuário pode parar o cadastro no momento
que ele desejar. Para calcularmos a média da turma, temos que
somar as notas de todos os alunos e dividir pela quantidade
de alunos. Assim, enquanto estivermos no do/while, estamos
acumulando as notas de todos os alunos na variável soma.
• Linha 21: ao sair do do/while, a média da turma pode ser

calculada.
• Linha 22: usa o system(“cls”) para limpar a tela e dar início a

tela que irá apresentar os resultados.
• Linha 24: printf para apresentar a média da turma.
• Linhas 26 a 29: for para visitar cada posição do vetor que

armazena as notas dos alunos. Quando verifica que a nota do
aluno é maior que a média da turma (armazenada na variável
media), a matrícula do aluno é apresentada.
A figura 1.12 apresenta a tela de execução do programa 1.4, na

fase do cadastramento dos dados dos alunos (matrícula e nota).
Figura 1.12: Tela de Execução do Programa Completo 1.4 – Cadastro de Alunos

1.4, na fase do apresentação dos resultados.
26
Programação 2
Figura 1.13: Tela de Execução do Programa Completo 1.4 – Apresentação dos Resultados
1.7 Tamanho de um vetor e segmentação de

memória
Na linguagem C, devemos ter cuidado com os limites de um vetor.

Embora na declaração tenhamos que definir o tamanho de um vetor,
o C não faz nenhum teste de verificação de acesso a um elemento
dentro do vetor ou não.
Por exemplo, se declaramos um vetor como int valor[5],

teoricamente, só tem sentido usarmos os elementos valor[0], valor[1],
valor[2] , valor[3] e valor[4]. Porém, o C não acusa erro se usarmos
valor[12] em algum lugar do programa. Estes testes de limite devem
ser feitos dentro do programa, pelo programador.
Este fato se deve à maneira como o C trata os vetores. A memória

do computador é um espaço (físico) particionado em porções de 1
byte. Se declararmos um vetor como int valor[3], estamos reservando
12 bytes (3 segmentos de 4 bytes – lembrando que cada int ocupa
4 bytes) de memória para armazenar os seus elementos. O primeiro
segmento será reservado para valor[0], o segundo segmento para
valor[1] e o terceiro segmento para valor[2]. O segmento inicial é
chamado de segmento base, de modo que valor[0] será localizado no
segmento base. Quando acessamos o elemento valor[i], o processador
acessa o segmento localizado em base+i. Se i for igual a 2, estamos
acessando o segmento base+2 ou valor[2] (o último segmento
reservado para o vetor). Porém, se i for igual a 7, estamos acessando
o segmento base+7 que não foi reservado para os elementos do vetor
e que provavelmente está sendo usado por uma outra variável ou
contém uma informação inesperada (lixo).
27
Programação 2
Observem que o acesso a um segmento fora do espaço destinado

a um vetor pode destruir informações reservadas de outras variáveis.
Estes erros são difíceis de detectar, pois o compilador não gera
nenhuma mensagem de erro. Por isso, a solução mais adequada é
sempre avaliar os limites de um vetor antes de manipulá-lo. Como
feito no Programa Completo 1.2 que vai cadastrando os elementos no
vetor e para quando o vetor completa a sua capacidade.
A princípio, este fato poderia parecer um defeito da linguagem,

mas na verdade trata-se de um recurso muito poderoso do C. Poder
manipular sem restrições todos os segmentos de memória é uma
flexibilidade apreciada por programadores mais experientes.
1.8 Passando vetores como parâmetros de

funções
Os vetores, assim como as variáveis simples, podem ser usados

como argumentos de funções. Veremos como se declara uma função
que recebe um vetor como parâmetro e como se chama uma função
passando um vetor como parâmetro.
A sintaxe de uma função que recebe um vetor como parâmetro é a

seguinte:
Sintaxe
tipo_retorno nome_função(tipo_vetor nome_vetor[])
//corpo da função
Onde:
• tipo_retorno: é o tipo de retorno da função.
• nome_função: é o nome da função.
• tipo_vetor: é o tipo de dados dos elementos do vetor.
• nome_vetor: é o nome do vetor. Observe que depois do nome

do vetor temos o [ e o ], mas não colocamos nada entre eles.
Neste caso, não é necessário informar o tamanho do vetor.
Quando formos chamar uma função que recebe um vetor como
28
Programação 2
parâmetro, usamos a seguinte sintaxe:
Sintaxe
nome_da_função(nome_do_vetor);
Onde:
• nome_da_função: é o nome da função que será chamada.
• nome_do_vetor: é o nome do vetor que queremos passar

como parâmetro. Neste caso, indicamos apenas o nome do
vetor, sem os colchetes.
O exemplo 1.6, a seguir, apresenta a declaração de uma função

que tem um vetor como parâmetro e a chamada da função.
Exemplo 1.6:
declaração e chamada de uma função que tem um vetor como parâmetro
1 float media(float vetor[],float N)
2 {
3 //corpo da função
4 }
6 main()
7 { float valor[30]; // declaração do vetor
8 float n;
9 ...
10 med = media(valor, n); // passagem do vetor

para a função
11 ...
12 }
Atenção: Ao contrário das variáveis comuns, o conteúdo de um

vetor pode ser modificado pela função chamada. Isto significa que
podemos passar um vetor para uma função e alterar os valores de
seus elementos. Isto ocorre porque a passagem de vetores para
funções é feita de modo especial dito passagem por endereço.
Portanto, devemos ter cuidado ao manipular os elementos de um
29
Programação 2
vetor dentro de uma função para não modificá-los por descuido.
Vamos fazer um conjunto de exercícios, usando o assunto que

acabamos de aprender? Segue abaixo uma lista de exercícios em
que os dados serão armazenados em vetores. Vamos começar?
1. Ler um conjunto de números e imprimi-los na ordem inversa da

leitura. A quantidade de números também será lida e será no
máximo 10.
2. Ler o tamanho e os elementos de dois vetores e, em seguida,

caso os vetores tenham o mesmo tamanho, gere e imprima o
vetor SOMA, onde seus elementos serão formados pela soma
dos elementos de mesmos índices dos dois vetores lidos.
Exemplo:
A 1 4 7 2 9
0 1 2 3 4
B 3 5 11 4 8
0 1 2 3 4
Soma 4 9 18 6 17
0 1 2 3 4
3. Ler um vetor de números e imprimir os valores armazenados

nas posições PARES e, em seguida, os valores armazenados
nas posições ÍMPARES. Exemplo:
V 1 4 7 2 9
0 1 2 3 4
Valores nas posições pares: 1 7 9
30
Programação 2
Valores nas posições impares: 4 2
4. Ler dois vetores e caso tenham tamanhos iguais, armazene seus

elementos alternadamente em um terceiro vetor. Exemplo:
A 1 4 7 2 12
0 1 2 3 4
B 3 5 11 4 15
0 1 2 3 4
Resultante 1 3 4 5 7 11 2 4 12 15
0 1 2 3 4 5 6 7 8 9
5. Ler um vetor de números inteiros e imprimir as posições do

maior e do menor elemento do vetor. Assuma que não existem
elementos repetidos no vetor. Exemplo:
V 14 13 7 22 9
0 1 2 3 4
O menor elemento se encontra na posição 2
O maior elemento se encontra na posição 3
6. Ler um vetor de números e inverter a ordem dos elementos

desse vetor no próprio vetor. Exemplo:
Vetor antes de ser invertido:
V 14 13 7 22 9
0 1 2 3 4
Vetor depois de ser invertido:
31
Programação 2
V 9 22 7 13 14
0 1 2 3 4
7. Ler dois vetores de números e gerar um terceiro vetor formado

pela INTERSECÇÃO dos dois vetores lidos. O resultado da
interseção de dois conjuntos é: os elementos que fazem parte
dos dois conjuntos. Exemplo:
A 1 4 7 2 12
0 1 2 3 4
B 3 4 2 14 25
0 1 2 3 4
interseccao 4 2
0 1 2 3 4

pela DIFERENÇA dos dois vetores lidos. O resultado da
diferença de dois conjuntos é: os elementos do conjunto A que
não fazem parte do conjunto B. Exemplo:
A 1 4 7 2 12
0 1 2 3 4
B 3 4 2 14 25
0 1 2 3 4
Diferenca 1 7 12
0 1 2 3 4
32
Programação 2

pela UNIÃO dos dois vetores lidos. O resultado da união de dois
conjuntos é: todos os elementos que fazem parte dos conjuntos
A e B. Exemplo:
A 1 4 7 2 12
0 1 2 3 4
B 3 4 2 14 25
0 1 2 3 4
União 1 4 7 2 12 3 14 25
0 1 2 3 4 5 6 7 8 9
10. Ler um vetor de números e imprimir os números que se repetem

nesse vetor. Exemplo:
V 1 4 7 1 2 1 4 25 3 7
0 1 2 3 4 5 6 7 8 9
Os números que se repetem no vetor são: 1 4 7
Conheça Mais
Para ampliar nossos conhecimentos sobre os assuntos tratados

neste capítulo, leiam o capítulo que aborda armazenamento em
vetores, do livro:
• SCHILDT, Herbert. C Completo e Total. São Paulo: Makron,

1996.
33
Programação 2
Vamos Revisar?
Vamos lembrar rapidinho o que foi visto neste capítulo?

Leia o resumo a seguir, composto com os principais conceitos
apresentados.
Vetores: conhecidos como estruturas de dados homogêneas, os

vetores são um conjunto de variáveis que armazenam elementos
do mesmo tipo.
Índices: para acessar um elemento do vetor, precisamos indicar em

que posição do vetor está o elemento.
No momento da declaração dos vetores, precisamos indicar quantos

elementos serão armazenados no mesmo.
É de responsabilidade do programador o acesso aos elementos do

vetor. Se o programa tentar acessar uma posição que não existe no
vetor, o compilador não indicará o erro.
Quando passamos um vetor como parâmetro de uma função, seus

valores podem ser alterados
34
Programação 2
Dados em Registros
Neste capítulo, vamos aprender mais uma forma de armazenamento

de dados, que são os registros. Nos registros podemos agrupar dados
de tipos diferentes. Por conta disto, os registros são chamados de
estruturas de dados heterogêneas. Assim como os vetores, os registros
vão facilitar o gerenciamento dos dados dos nossos programas, que
estão cada vez maiores. Veremos, também, como unir os conceitos
de vetores e registros, trabalhando com vetor de registro. Leiam este
capítulo com calma e atenção, uma vez que iremos utilizar registros
em muitas situações nos nossos programas, certo?
2.1 O que são registros?
Nós já sabemos que um conjunto homogêneo de dados é composto

por variáveis do mesmo tipo (vetores). Mas, e se tivermos um conjunto
em que os elementos não são do mesmo tipo? Teremos, então, um
conjunto heterogêneo de dados, que são chamados de registros.
O registro é uma das principais formas de estruturar os dados no
programa. O conceito de registro visa facilitar o agrupamento de
variáveis de tipos diferentes, mas que possuem uma relação lógica.
Um registro é um conjunto de uma ou mais variáveis, que podem

ser de tipos diferentes, agrupadas sobre um único nome. O fato de
variáveis agrupadas em um registro poderem ser referenciadas por
um único nome, facilita a manipulação dos dados armazenados nestas
estruturas. Como exemplo de um registro, imaginem uma estrutura que
armazene as diversas informações do boletim de um aluno. O boletim
é formado por um conjunto de informações logicamente relacionadas,
porém de tipos diferentes, tais como: número de matrícula (inteiro),
nome do aluno (caractere), nome da disciplina (caractere), média (real)
e situação (caractere), que são subdivisões do registro (elementos
de conjunto), também chamadas de campos. Logo, um registro é
composto por campos que são partes que especificam cada uma das
informações. A figura 2.1 apresenta o boletim de notas de um aluno.
35
Programação 2
Boletim de Notas
Matricula...: 12345
Nome........: Michel
Disciplina..: Matemática
Média........: 10.0
Situação....: Aprovado
Figura 2.1 Boletim de Notas
Notem que, o boletim é composto por informações de diferentes

tipos. No entanto, todas as informações do boletim estão relacionadas
ao mesmo aluno. O agrupamento de informações de tipos diferentes,
que tem uma relação lógica, facilitará a manipulação de dados.
Nas próximas seções, vamos aprender a declarar e manipular

registros.
2.2 Declaração de um Registro
Para declarar uma variável, precisamos informar o seu tipo e dar

um nome à mesma. Mas, um registro é formado por várias variáveis
de tipos diferentes. Como iremos declarar um registro? Para declarar
um registro, é necessário informar quais variáveis, e seus respectivos
tipos, fazem parte do registro. Dessa forma, precisamos declarar
cada campo do registro, agrupando-os em um novo tipo de dado.
A declaração de um registro passa por duas fases: definição de um
novo tipo de dado e declaração do registro propriamente dito. Vamos
entender melhor isso tudo?
Primeiramente, precisamos definir quais campos fazem parte

do registro e criar um novo tipo de dado para o nosso programa.
Precisamos criar um novo tipo de dado porque não conseguiríamos
representar o tipo de informação que o registro armazena, utilizando
os tipos primitivos disponíveis na linguagem: int, float, char, etc. Uma
vez que o registro agrupa variáveis de tipos de dados diferentes. Para
criar um novo tipo de dado, utilizamos a seguinte sintaxe:
36
Programação 2
Sintaxe
typedef struct { declaração das variáveis;
} nome_do_tipo;
Onde:
• typedef: indica que um novo tipo de dado será definido.
• struct: indica que o tipo de dado que será definido é um

registro, ou seja, um agrupamento de variáveis de tipos de
dados diferentes.
• declaração das variáveis: são as variáveis que fazem parte do

registro. Neste local, precisamos especificar quais as variáveis
irão compor o registro, além do tipo das mesmas. As variáveis
são colocadas entre chaves.
• nome_do_tipo: é dado um nome ao novo tipo de dado que

está sendo criado. Só depois que o novo tipo de dado é criado,
é que o registro poderá ser declarado.
Na sequência, vamos ver a declaração de um registro. Assim como

toda variável, ao declarar uma variável que é um registro, precisamos
dizer que tipo de dado o registro armazena. Neste caso, iremos dizer
que o registro é do tipo de dado que acabamos de definir no typedef.
A sintaxe é a seguinte:
Sintaxe
nome_do_tipo nome_do_registro;
Onde:
• nome_do_tipo: é o nome do tipo de dado que definimos

no nosso programa, formado pelo agrupamento de várias
variáveis.
• nome_do_registro: é o nome da variável registro que está

sendo declarada. O nome de um registro segue as regras dos
identificadores.
O exemplo 2.1 apresenta a declaração do registro do boletim do

aluno:
37
Programação 2
Exemplo 2.1: Definição de tipo e declaração de registro
1 typedef struct { int matricula;
2 char nome[20], disciplina[20],

situação[10];
3 float media;
4 } Tipo_Aluno;
5 Tipo_Aluno aluno;
Primeiramente, entre as linhas 1 e 4, foi definido o conjunto de

variáveis que fazem parte do registro. É nesta parte que está sendo
definido um novo tipo de dado.
• Linha 1: com o typedef estamos informando que será definido

um novo tipo de dado. O struct indica que este tipo é um
agrupamento de variáveis de tipos diferentes, ou seja, um
registro. Colocamos o abre chaves e começamos a declarar
as variáveis que irão compor o registro. Começamos com a
declaração da variável inteira matricula. Se houvesse mais
variáveis do tipo int, poderiam ser declaradas nesta mesma
linha.
• Linha 2: declaração das variáveis do tipo char: nome, disciplina

e situacao.
• Linha 3: declaração da variável media que é do tipo float.
• Linha 4: Após a declaração de todas as variáveis que compõe

o registro, podemos fechar a chaves e, em seguida, dar um
nome a esse tipo de agrupamento, que acabamos de definir.
Neste caso, o tipo foi chamado de Tipo_Aluno. Ao definirmos
um tipo de dado no nosso programa, significa que: podemos
declarar variáveis dos tipos de dados primitivos (int, float, char,
etc), além de variáveis do tipo de dado que nós definimos, neste
caso, Tipo_Aluno.
• Linha 5: declaração de uma variável chamada aluno, e o tipo

de dado que ela armazena é Tipo_Aluno, ou seja, armazena:
matricula, nome, disciplina, situacao e media.
A figura 2.2 mostra a representação gráfica da variável aluno, que

é do tipo Tipo_Aluno.
38
Programação 2
matricula
nome
disciplina
situacao
media
aluno
Figura 2.2: Representação gráfica do registro aluno
Notem que, a variável aluno (que é um registro) é formada pelos

campos definidos no Tipo_Aluno.
Como uma variável registro é formada por vários campos,

precisamos utilizar uma forma diferenciada para informar qual campo
do registro nós estamos querendo acessar. Lembram dos vetores, que
precisávamos dizer qual elemento do vetor seria acessado? Com os
registros vai acontecer algo parecido. Mas isto, nós vamos aprender
na próxima seção.
2.3 Acessando os campos do registro
De acordo com a figura 2.2, a variável aluno é um registro formado

por vários campos. Para acessar um campo de um registro, devemos
usar a seguinte sintaxe:
Sintaxe
nome_do_registro.campo
Onde:
• nome_do_registro: é o nome da variável registro que queremos

acessar.
• Após o nome_do_registro devemos colocar um ponto, que

irá separar o nome do registro, do campo que vem logo em
seguida.
• campo: é o campo do registro que será acessado.
39
Programação 2
Pensem da seguinte forma: suponham que queremos acessar

o registro aluno, do exemplo 2.1. Ao acessarmos esta variável, ela
possui vários campos. Precisamos dizer qual deles será acessado
no momento. A seguir, são apresentados exemplos de acesso aos
campos do registro aluno. Ao acessar um campo do registro, podemos
atribuir valores, como mostra o exemplo 2.2.
Exemplo 2.2: Acesso aos campos de um registro
1 aluno.matricula = 12345;
2 scanf(“%f”, &aluno.media);
3 gets(aluno.nome);
4 printf(“Situacao do aluno: %s”, aluno.situacao);
Na linha 1, estamos acessando o campo matricula do registro

Saiba Mais aluno. Assim, colocamos o nome do registro, o ponto e o campo que
queremos acessar. Com acesso ao campo, fizemos uma atribuição4.
4
O ponto que
aparece neste
comando, deve Na linha 2, estamos acessando o campo media do registro aluno.
ser lido como Neste caso, ao invés de atribuir um valor ao campo de registro, estamos
“campo”. Assim,
a leitura do fazendo uma leitura via teclado e armazenando o valor digitado no
comando da linha
1 seria: aluno no campo media. Como o campo media é do tipo float, colocamos o %f
campo matricula no scanf, indicando que será lido um número real.
recebe 12345.
Na linha 3, temos o comando de leitura gets, responsável por ler

variáveis do tipo char. Neste gets, estamos fazendo uma leitura via
teclado e armazenando o valor digitado no campo nome do registro
aluno.
Na linha 4, temos um printf que apresenta a situação do aluno.

Para isso, acessamos o campo situacao do registro aluno.
Notem que, se tivermos vários alunos em uma turma, precisaremos

de várias variáveis registro do tipo Tipo_Aluno, uma para cada
aluno. Para fazer isso de forma mais simplificada, devemos juntar os
conceitos de vetores e registros e criar um vetor de registro. Vamos
aprender como faz isto?
2.4 Vetor de registro
Os vetores são formados por um conjunto de dados do mesmo

tipo. No capítulo anterior, utilizamos vetores que armazenavam dados
40
Programação 2
de tipos primitivos, ou seja, tipos disponíveis na linguagem – int,

float, char, etc. Veremos que podemos utilizar como elemento do vetor
não apenas um tipo primitivo, mas também os tipos construídos (tipos
definido pelo programador), neste caso, os registros. Imaginem que
queremos armazenar os boletins dos 50 alunos de uma turma. Para
isso, será necessário um registro diferente para cada aluno. Para
agrupar todos estes registros, iremos definir um vetor de registro.
Como possuímos 50 alunos, podemos criar um vetor no qual cada
posição, armazena um Tipo_Aluno.
Para declarar um vetor de registro, precisamos antes definir os

elementos do registro, utilizando o typedef struct, e assim, definir um
novo tipo de dado que será utilizado no programa. Após definirmos o
novo tipo de dado, o vetor poderá ser declarado. Para declararmos
um vetor, precisamos informar o tipo de dado que o vetor armazena,
damos um nome ao vetor e informamos, entre colchetes, o tamanho
do vetor. O exemplo 2.3 apresenta a declaração do vetor de registro
alunos:
Exemplo 2.3: definição do registro e declaração do vetor de registro
1 typedef struct { int matricula;
2 char nome[20], disciplina[20],

situação[10];
3 float media;
4 }Tipo_Aluno;
5 Tipo_Aluno alunos[50];
Neste exemplo, cada uma das 50 posições do vetor alunos irá

armazenar todos os dados que compõe o Tipo_Aluno, ou seja:
matricula, nome, disciplina, situacao e media. A figura 2.3, a seguir,
representa o vetor de registro declarado no exemplo.
matricula matricula matricula matricula

nome nome nome nome
alunos disciplina disciplina disciplina disciplina
media media media media
situacao situacao situacao situacao
0 1 ... 48 49
Figura 2.3: Representação gráfica do vetor de registro aluno
41
Programação 2
Se apenas com os vetores, já havíamos adquirido uma facilidade

na declaração e manipulação de um grande conjunto de variáveis,
com os vetores de registros, esta facilidade será aumentada.
Vamos aprender, na próxima seção, como acessamos um campo

de um vetor de registro.
2.5 Acessando os campos do vetor de

registro
Quando precisamos acessar um elemento do vetor, informamos,

entre colchetes, o índice do elemento do vetor que será acessado.
Quando queremos acessar um campo do registro, informamos o
nome da variável registro, colocamos um ponto e o nome do campo
que queremos acessar. Já no caso de um vetor de registro, temos
que usar a seguinte sintaxe:
Sintaxe
nome_do_vetor[indice].campo
Onde:
nome_do_vetor: nome do vetor que queremos acessar.
[índice]: índice do vetor que será acessado.
.campo: campo do registro que será acessado.
O exemplo 2.4 apresenta acessos a campos do vetor de registro

alunos.
Exemplo 2.4: Acesso aos elementos de um vetor de registro
1 alunos[2].media = 7.5;
2 alunos[3].matricula = 12345;
3 gets(alunos[0].nome);
4 scanf(“%d”,&alunos[2].matricula);
Na linha 1, acessamos o elemento de índice 2 do vetor alunos e

atribuímos 7.5 ao campo media. Na linha 2, acessamos o elemento
de índice 3 do vetor alunos e atribuímos 12345 ao campo matricula.
Nas linhas 3 e 4, temos acessos através de comandos de entrada
42
Programação 2
de dados. Na linha 3, temos um gets, que obtém o nome do aluno, via

teclado, e armazena no índice 0 do vetor alunos, no campo nome. Na
linha 4, temos o scanf que lê a matrícula do aluno, armazenando no
índice 2 do vetor alunos, no campo matricula.
2.6 Usando vetor de registro
Vamos fazer um programa completo usando vetor de registro?

Este programa será um pouco maior do que os outros programas que
já fizemos, e apresentará uma gama de coisas novas. Além do uso
de vetor de registro, aprenderemos a mostrar os dados do vetor de
registro em forma de tabela. Vamos começar?
Primeiramente, vamos ler e entender o enunciado do Programa

Completo 2.1: Faça um programa que cadastre e apresente os
dados dos alunos de uma escola. Os dados dos alunos devem
ser armazenados em um vetor de registro, com a capacidade de
armazenar até 20 alunos. A quantidade de alunos que será cadastrada
é desconhecida. No momento do cadastro serão informados os
seguintes dados para cada aluno: matrícula, nome, série(1-4) e se
tem irmão na escola (1-sim/0-nao). O programa irá calcular o valor
da mensalidade do aluno, que depende da série do aluno e se o
mesmo tem irmão na escola. Valor da Mensalidade: 1ª Serie: R$110,
2ª Serie: R$130, 3ª Serie: R$160, 4ª Serie: R$170. O aluno que tiver
irmão na escola, receberá 20% de desconto no valor da mensalidade.
Quando o usuário decidir que não deseja mais cadastrar, o programa
apresentará os dados de todos os alunos, em forma de tabela. Para
facilitar o entendimento deste enunciado, vejam os exemplos das telas
que são apresentadas durante a execução do programa:
Colégio Legal
Cadastro de Aluno
Matricula..:
Nome.......:
Serie(1-4):
Irmao na escola (1-sim/0-nao):
Cadastrar outro aluno (1-sim/0-nao)?
43
Programação 2
Colégio Legal
Relatório Geral
Matricula Nome Serie Irmao Mensalidade
xx xxxxx x x xx.xx
xx xxxxx x x xx.xx
xx xxxxx x x xx.xx
xx xxxxx x x xx.xx
xx xxxxx x x xx.xx
Tecle enter para sair...
Figura 2.4:Exemplos de telas do programa completo 2.1
A primeira tela representa a operação de cadastramento dos

dados dos alunos. Nesta tela, é que serão fornecidos os dados para o
cadastramento dos alunos. Como a mensalidade é um dado calculado
pelo programa, o usuário não fornecerá este dado no momento do
cadastro.
A segunda tela representa a apresentação dos dados de todos

os alunos, em forma de tabela (listagem ou relatório). Cada linha da
tabela apresentará os dados de um aluno.
Como precisamos armazenar os vários dados de cada um dos

alunos da escola, se faz necessário o uso de um vetor de registro.
Segue o código do programa completo 2.1, que será comentado
posteriormente.
44
Programação 2
2 main()
3 { typedef struct{ int mat, serie, irmao;
4 char nome[20];
5 float mens;
6 } Tipo_Aluno;
7 Tipo_Aluno alunos[20];
8 int qa, i, resp;
9 qa =0;
10 do
12 printf(“Colegio Legal\n”);
13 printf(“\n\nCadastro de Alunos\n\n”);
14 printf(“\nMatricula.: “);
15 scanf(“%d”,&alunos[qa].mat);
16 printf(“\nNome......: “);
17 fflush(stdin);
18 gets(alunos[qa].nome);
19 printf(“\nSerie(1-4): “);
20 scanf(“%d”,&alunos[qa].serie);
21 printf(“\nIrmao na escola(1-sim/0-nao):
“);
22 scanf(“%d”,&alunos[qa].irmao);
23 switch(alunos[qa].serie)
24 { case 1: alunos[qa].mens = 110; break;
25 case 2: alunos[qa].mens = 130; break;
28 }
45
Programação 2
29 if (alunos[qa].irmao == 1)
30 alunos[qa].mens = alunos[qa].mens*0.8;
31 qa++;
32 printf(“\n\nDeseja cadastrar outro aluno(1-

sim/0-nao)? “);
33 scanf(“%d”,&resp);
34 }while ((resp == 1) && (qa <20));
35 system(“cls”);
36 printf(“Colegio Legal\n”);
37 printf(“\n\nRelatorio Geral\n”);
38 printf(“\n________________________________”);
39 printf(“\nMatricula Nome Serie Irmao

Mensalidade”);
40 printf(“\n________________________________”);
41 for(i = 0; i < qa; i++)
42 printf(“\n%9d %-20s %5d %5d %11.2f”,

alunos[i].mat, alunos[i].nome, alunos[i].serie,
alunos[i].irmao, alunos[i].mens);
43 printf(“\n_______________________________”);
44 printf(“\nTecle enter para sair...”);
45 getche();
46 }
Comentários sobre o Programa Completo 2.1
• Linha 1: inclusão da biblioteca stdio.h devido o uso do comando

fflush.
• Linha 2: início do programa principal.
• Linhas 3 a 6: definição de um novo tipo de dado, que será

chamado de Tipo_Aluno. O Tipo_Aluno é formado pelos dados
dos alunos: mat (matrícula), nome, serie, irmao (indica se tem
irmão na escola) e mens (mensalidade).
• Linha 7: declaração do vetor de registro alunos, com capacidade

de armazenar 20 elementos do Tipo_Aluno.
46
Programação 2
• Linha 8: declaração das variáveis qa (que irá controlar a

quantidade de alunos cadastrados no vetor), i (utilizada como
variável de controle do for) e resp (utilizada para saber se o
usuário deseja continuar cadastrando novos alunos).
• Linha 9: inicialização da variável qa com 0;
• Linhas 10 a 34: repetição do tipo do/while que irá controlar

o cadastro dos dados dos alunos no vetor de registro. Este
do/while irá parar a sua execução se o vetor ficar cheio (20
elementos) ou se o usuário não quiser mais cadastrar.
• Linha 11: Cada vez que o do/while é executado, queremos que

a tela seja limpa. Para isso, usamos o system(“cls”). Esta linha
tem, também, o abre chaves que indica o início da sequência
de comandos do do/while.
• Linhas 12 e 13: printf para indicar o nome do colégio (Colégio

Legal) e para indicar o que está sendo feito nesta tela (Cadastro
de Alunos).
• Linhas 14 e 15: printf informando que o usuário deve digitar

a matrícula do aluno e scanf que obtêm a matrícula do aluno,
armazenado-a no vetor de registro alunos, na posição qa e no
campo mat. Notem que a variável qa iniciou com 0. Na primeira
vez que o do/while for executado, os dados dos alunos serão
armazenados na posição 0 do vetor. A cada vez que a repetição
é executada, a variável qa é incrementada de uma unidade.
Assim, os dados de cada aluno serão armazenados em uma
posição, diferente, no vetor de registro.
• Linhas 16 a 18: printf informando que o usuário deve digitar o

nome do aluno. fflush para limpar o buffer e, em seguida, o gets
responsável por ler o nome do aluno, armazenando no vetor de
registro alunos, na posição qa e no campo nome.
• Linhas 19 e 20: printf informando que o usuário deve digitar a

série do aluno (que pode ser de 1 a 4). scanf responsável por
ler a série do aluno, armazenando no vetor de registro alunos,
na posição qa e no campo serie.
• Linhas 21 e 22: printf informando que o usuário deve digitar se

o aluno tem irmão na escola (digitar 1 se tiver irmão e 0 se não
tiver irmão na escola). scanf responsável por ler se o aluno tem
irmão na escola, armazenando no vetor de registro alunos, na
47
Programação 2
posição qa e no campo irmao.
• Linhas 23 a 28: depois de obter todos os dados de um aluno,

o programa vai calcular o valor da mensalidade do aluno,
verificando a série e se tem irmão na escola. Como cada uma
das séries da escola tem um valor diferente de mensalidade,
este switch serve para verificar em que série o aluno está
matriculado, para atribuir ao campo mens do registro do aluno,
o valor da mensalidade correspondente a sua série.
• Linhas 29 e 30: if para verificar se o aluno tem irmão na escola.

De acordo com o enunciado, os alunos que tem irmão na escola,
recebem uma desconto de 20% na sua mensalidade. Como o if
só tem um comando, não foi necessário o uso de chaves.
• Linha 31: neste momento, todo o registro do aluno já foi

preenchido. Com isso, fazemos o incremento da variável qa,
informando que mais um aluno acabou de ser cadastrado.
• Linhas 32 e 33: printf que pergunta se o usuário deseja

continuar cadastrando novos alunos. scanf para ler a resposta
do usuário (1 se ele deseja continuar cadastrando e 0 se deseja
parar).
• Linha 34: fechamento do do/while com a condição que faz a

repetição parar. Como mencionado anteriormente, este do/
while fica em execução enquanto tem posições disponíveis no
vetor ou enquanto o usuário desejar. Nesta linha, termina a fase
de cadastramento dos dados dos alunos no vetor de registro.
• Linhas 35 a 47: Esta sequência de comando serve para

apresentar os dados dos alunos que foram armazenados
no vetor de registro. Por uma questão de organização, estes
dados serão apresentados na forma de tabela. Assim, cada
linha da tabela corresponderá aos dados de um aluno, ou
seja, uma posição do vetor de registro. Para que a tabela fique
alinhada, precisamos saber que: a tela tem 80 colunas por 25
linhas. Dessa forma, temos que distribuir as informações de um
jeito que não extrapole as 80 colunas da tela. Para entender
melhor esta parte do programa, acompanhem os comandos,
observando a figura 2.9 (tela de execução do programa).
• Linha 35: limpa a tela para darmos início à apresentação dos

dados de todos os alunos.
48
Programação 2
• Linhas 36 e 37: printf para informar o nome do colégio e para

informar o que esta tela faz (Relatório Geral).
• Linha 38: printf para passar uma linha na tela. Esta linha vai
delimitar o cabeçalho da tabela.
• Linha 39: printf que imprime os títulos de cada coluna da tabela.

A tabela será composta pelas seguintes colunas: Matricula,
Nome, Serie, Irmao e Mensalidade. Os títulos que devemos
dar as colunas da tabela são sempre indicados nos enunciados
das questões, certo? Sigam esta dica, porque vocês estão
começando a aprender a fazer tabelas agora. Este printf é cheio
de detalhes, mas vamos ver isso agora, observando a figura
2.5. O resultado deste printf é a linha que está indicada com a
seta.
Figura 2.5: Apresentação dos dados em forma de tabela
• Vamos ver quais são os passos para montar o printf da linha 39

(cabeçalhos/títulos das colunas da tabela).
» Para cada coluna da tabela, verifiquem quantas letras tem

no seu cabeçalho. Por exemplo, a palavra matrícula, tem 9
letras. Vejam que, na figura 2.5, tem a indicação de quantas
letras tem em cada um dos cabeçalhos. A quantidade de
letras que tiver o cabeçalho, será a largura da coluna.
» Agora, precisamos verificar se os dados dos alunos vão

extrapolar a largura de cada uma das colunas da tabela.
Vamos ver uma por uma:
√ Matricula: a coluna que será utilizada para apresentar

a matrícula, tem uma largura de 9 espaços (quantidade
de letras da palavra matrícula). Vamos considerar que
nossas matrículas tem sempre menos que 9 dígitos.
49
Programação 2
Assim, a largura de 9 espaços para esta coluna, é

suficiente.
√ Nome: a palavra nome só tem 4 letras. Vejam que o

nome do aluno foi declarado com 20 letras. Assim, se
deixarmos a coluna Nome, com largura 4, não será
suficiente para apresentar os nomes dos alunos.
Quando a quantidade de letras do cabeçalho é menor
que o conteúdo que vem na coluna da tabela, devemos
completar a coluna com espaços em branco até fazer
com que a coluna tenha a largura que precisamos.
√ Série: tem 5 letras. A série do aluno varia entre 1 e 4,

dessa forma, a largura da coluna Serie (5 espaços),
será suficiente para apresentar o dado.
√ Irmão: também tem 5 letras. A variável que armazena

se o aluno tem ou não irmão na escola, varia entre 0 e
1, dessa forma, a largura da coluna Irmao (5 espaços),
será suficiente para apresentar o dado.
√ Mensalidade: tem 11 letras. Esta largura é suficiente

para apresentar o valor da mensalidade do aluno.
» Agora que já sabemos que apenas a coluna Nome não tem

largura suficiente para apresentar os nomes dos alunos,
vamos ver quantos espaços em branco nós temos que
colocar depois da palavra Nome, para que esta coluna
tenha a largura que precisamos. Se o nome do aluno tem
até 20 letras e a palavra Nome tem apenas 4 letras, faremos
a seguinte conta: 20 – 4 = 16. Assim, depois da palavra
Nome, temos que colocar 16 espaços em branco, para que
a nossa coluna passe a ter a largura que precisamos (20).
» Por fim, temos que definir um espaçamento para separar

uma coluna da outra. Nos nossos exemplos, vamos usar
sempre três espaços separando uma coluna da outra.
A padronização do espaçamento entre as colunas visa
facilitar a programação, já que estamos vendo este assunto
agora e o mesmo é cheio de detalhes.
» Agora vamos montar o printf, vejam a figura 2.6. Nós

vamos colocando os títulos das colunas da tabela, e entre
cada palavra, vamos colocando três espaços em branco,
50
Programação 2
que foi o espaçamento definido para separar as colunas.

Só no caso da coluna nome, que depois que colocamos
Nome, devemos dar os 16 espaços em branco para que ela
passe a ser uma coluna de largura 20. Mas ainda teríamos
que dar mais 3 espaços em branco, que é para separar a
coluna nome, da coluna serie.
Figura 2.6: Detalhamento do printf da linha 39
» O printf está pronto! A primeira vista, parece complicado,

mas depois vocês estarão fazendo a tabela bem rápido.
delimitar o cabeçalho da tabela.
• Linha 41: for para visitar cada uma das posições do vetor e
apresentar os dados dos alunos. A variável de controle do for,
o i, vai variar de 0 até a ultima posição ocupada do vetor. A
variável que tem esta informação é o qa.
• Linha 42: este printf é que vai fazer a montagem das linhas
da tabela, apresentado os dados dos alunos que estão
armazenados no vetor de registro. Este printf também tem
macetes, pois está relacionado com o printf da linha 39. Vamos
lá! Lembram que fizemos a contagem para saber a largura
de cada coluna da tabela? Vamos precisar desta informação
agora.
» Na primeira parte do printf, temos a string de controle

(a figura 2.7 faz o detalhamento dessa parte do printf).
Sabemos que as colunas da tabela são: matricula( número
inteiro e esta coluna deve ter largura 9), nome (vetor de
caracteres com até 20 letras), serie (número inteiro e esta
coluna tem largura 5), irmão (número inteiro e esta coluna
tem largura 5) e mensalidade (número real e esta coluna
tem largura 11). Além disso, sabemos que entre cada
coluna, nós colocamos três espaços em branco. Com estas
informações, vamos montar a string de controle do printf da
51
Programação 2
linha 42.
Figura 2.7: Detalhamento do printf da linha 42
» Entre o % e a letra que indica o que vai ser impresso (%d,

%s ou %f), devemos colocar a largura da coluna. A primeira
coluna da tabela é a da matricula, que é um número inteiro
e que tem largura 9. Por isso, temos o %9d. Após cada
uma das formatações, colocamos três espaços em branco,
já que foi o espaçamento definido entre as colunas da
tabela. No caso da variável caractere nome do aluno (que
é a segunda coluna da tabela) colocamos %-20s (o – é
para que o nome do aluno seja alinhado pela esquerda).
Nas demais formatações não precisamos colocar o -, só
utilizamos em campos caractere.
» Após a string de controle, colocamos as variáveis que serão

apresentadas na tela, na ordem em que as colunas foram
definidas.
fechar a tabela.
• Linha 44: printf que informa que o usuário deve teclar enter
para sair.
• Linha 45: getche() que evita que a tela de execução feche

antes de vermos os resultados.

fase do cadastramento dos alunos.
52
Programação 2
Figura 2.8: Tela de execução do programa completo 2.1 - Cadastro

fase do apresentação dos dados de todos os alunos cadastrados, em
forma de tabela.
Figura 2.9: Tela de execução do programa completo 2.1 – Relatório Geral
Viram como esta questão é cheia de detalhes? Mas não se

assustem, a explicação precisava ser minuciosa, para que cada linha
do programa fosse entendida. Agora precisamos treinar esse tipo de
questão. Não percam tempo!
Vamos resolver mais uma lista de exercícios? Esta lista é composta

por questões em que se faz necessário o uso de vetor de registro.
DICA: sempre coloque as tabelas com os mesmos cabeçalhos
propostos nos enunciados (exemplos de telas). Mãos a obra!
1. Uma empresa de turismo deseja um programa que calcule o

valor das viagens dos clientes. Serão informados os seguintes
53
Programação 2
dados: código do cliente, nome, roteiro desejado(1-Brasil,

2-EUA, 3-África), tipo de quarto (1-Standard, 2-Luxo), Se deseja
alugar carro(1-sim/0-nao) e a quantidade de dias. A quantidade
de clientes é desconhecida. O programa irá calcular o total da
viagem usando os valores da tabela abaixo, que variam de
acordo com o roteiro escolhido. A diária do quarto de luxo é
R$30 mais cara que o valor da diária em um quarto standard.
Exemplo: Se a pessoa escolher roteiro 2, em quarto de luxo, a
diária irá custar: 320 + 30 = R$ 350.
Roteiro Diária – Hotel Diária - Aluguel

Quarto Standard de carro
1 R$ 170 R$ 50
2 R$ 350 R$ 60
3 R$ 370 R$ 75
Total da Viagem:
dias*diáriahotel + dias*diariacarro(se o cliente for alugar carro)
Armazenar os dados em um vetor de registro. Imprimir os dados

em forma de tabela. Exemplo das telas:
Viagem Legal – Turismo
Cadastro de Cliente
Codigo:
Nome:
Roteiro (1-Brasil, 2-EUA, 3-África):
Tipo de Quarto (1- Standard, 2-Luxo):
Alugar Carro (1-sim/0-nao)?
Quantidade de Dias:
Inserir outro (1-sim,0-nao)?
Viagem Legal – Turismo
Relatório Geral
Código Nome Roteiro Quarto Carro Dias Total
xx xxxxx x x x xx xx.xx
54
Programação 2
2. Faça um programa para montar a folha de pagamento dos

empregados de uma empresa. Para cada empregado serão
lidos os seguintes dados: matricula, nome, cargo(1-Analista
de Sistemas/2- programador), sexo(1-mas/2-fem), anos de
experiência e quantidade de filhos. O programa irá calcular
para cada empregado o seu salário. Sabe-se que:
Cargo Salário Base
1 R$ 2500
2 R$ 1700
O salário será calculado da seguinte forma: Cada cargo tem

o salário base. Além do salário base, o empregado recebe os
seguintes adicionais: R$ 50, para cada ano de experiência e R$
40 por cada filho. Portanto, um analista de sistemas com três
anos de experiência e dois filhos terá o salário = 2500 + 50*3 +
40*2 = R$ 2730.
Armazenar as informações em um vetor de registros. Imprimir

o relatório geral em forma de tabela contendo os dados de
cada empregado. A quantidade de empregados da empresa é
desconhecida (declarar o vetor com capacidade de armazenar
20 funcionários). Exemplos das telas:
Empresa Legal
Cadastro de Funcionario
Matricula:
Nome:
Cargo(1-Analista de Sistemas, 2- programador):
Sexo(1-mas/2-fem):
Anos de experiência:
Quantidade de filhos:
Cadastrar outro (1-sim/2-nao)?
55
Programação 2
Empresa Legal
Listagem Geral
Matricula Nome Cargo Sexo Anos Q. Filho Salário
xx xxxxx x x xx x xxx.xx
3. Faça um programa para uma empresa de celular contendo as

seguintes operações: cadastro de clientes e listagem geral.
Para cada cliente devemos armazenar: código, nome, sexo
(1-feminimo/2-masculino), quantidade de ligações, plano que
o cliente está associado (1-Dia/2-Noite/3-Fixo/4-Empresarial) e
Valor da conta. O programa irá calcular o valor da conta de cada
cliente. Sabe-se que, cada plano tem uma tarifa diferenciada,
segundo a tabela abaixo:
Plano Valor de 1 ligação
Dia 1.30
Noite 1.60
Fixo 1.25
Empresarial 1.10
Armazenar os dados em um vetor de registro. Após o cadastro dos

clientes, apresentar a listagem com os dados de todos os clientes, em
forma de tabela. A quantidade de clientes é desconhecida. Declare o
vetor com capacidade de receber até 50 clientes.
Exemplos das telas:
56
Programação 2
Ligue Mais
Cadastro de Cliente
Código:
Nome:
Sexo(1-fem/2-mas):
Quantidade de Ligações:
Plano(1-Dia/2-Noite/3-Fixo/4-Empresarial):
Cadastrar outro (1-sim/0-nao)?
Ligue Mais
Listagem Geral
Codigo Nome Sexo Quant. Lig. Plano Total
xx xxxxx x xx x xxx.xx
4. Um professor quer um programa para o cálculo da média dos

alunos de uma turma. Serão informadas a matrícula, nome (20
caracteres), e as três notas dos alunos. O professor descarta
a menor nota do aluno e a media é calculada com as duas
maiores notas. Calcular a média e apresentar os resultados em
forma de tabela, após o cadastramento. Armazenar os dados em
um vetor de registro. A quantidade de alunos é desconhecida,
declare o vetor com capacidade de receber até 20 alunos.
Exemplos das Telas:
Universidade Legal
Cadastro de aluno
Matricula:
Nome:
Nota 1:
Nota 2:
Nota 3:
Cadastraroutro (1-sim/0-nao)?
57
Programação 2
Universidade Legal
Relatório Geral
Matricula Nota1 Nota2 Nota3 Media
x xxxxxxxxx x.x x.x x.x x.x
5. O MEC quer um programa para fazer um relatório sobre os

pólos de educação a distância da UFRPE. Para cada pólo são
informados os seguintes dados: código do pólo, cidade, total
de alunos, total de tutores, se possui laboratório de informática
(1-sim/0-não) e se possui laboratório de ciências (1-sim/0-não).
O MEC quer saber quanto deve ser liberado de verba para cada
pólo. O calculo será feito da seguinte forma:
• Por cada aluno são liberados: R$ 100
• Por cada tutor são liberados: R$ 500
• Se o pólo tem não tem laboratório de informática são liberados:

R$ 20.000
• Se o pólo não tem laboratório de ciências são liberados: R$

17.000
Ex: um pólo com 150 alunos, com 15 tutores, que tem laboratório
de informática, mas não tem laboratório de ciências: Verba = 100 x
150 + 500 x 15 + 17000 = 15000 + 7500 + 17000 = 39500.
Armazenar os dados dos pólos em um vetor de registro. A

quantidade de pólos é desconhecida. Declarar o vetor com a
capacidade de armazenar até 20 pólos. Após o cadastros dos pólos,
apresentar todos os dados dos pólos em forma de tabela.
Exemplos das telas:
58
Programação 2
Ministério da Educação
Cadastro de Polo
Codigo:
Cidade:
Quantidade de alunos:
Quantidade de tutores:
Tem lab. de informatica (1-sim/0-nao)?
Tem lab. de ciencias (1-sim/0-nao)?
Cadastrar outro pólo (1-sim,0-nao)?
Ministério da Educação
Listagem Geral
Codigo Cidade Alunos Tutores LI LC Verba Liberada
xx xxxxx xxx xxx x x xxxxx.xx
Conheça Mais
Vocês poderão aprender mais sobre registros e vetores de registros

lendo os livros:


1996.
Vamos Revisar?
Nesta seção iremos revisar os principais tópicos vistos neste
59
Programação 2
capítulo. Vale a pena dar uma lida para verificar como está o nosso
aprendizado. Observem o resumo a seguir:
Os registros são um agrupamento de variáveis de tipos diferentes,

mas que tem uma relação lógica.
Por ser formado por elementos de diferentes tipos, os registros são

chamados de estruturas de dados heterogêneas.
Para declarar uma variável registro, precisamos definir um novo

tipo de dado para o programa, utilizando o typedef.
Cada elemento do registro é chamado de campo.
Unindo os conceitos de vetores e de registros, temos os vetores

de registro que facilitam a declaração e o manuseio de grandes
volumes de dados.
60
Programação 2
Dados em Arquivos
Neste capítulo, vamos aprender a armazenar nossos dados de

forma definitiva. Até então, ao terminar a execução de um programa,
todos os dados que foram armazenados nas variáveis eram perdidos.
Em muitas aplicações isto não pode acontecer. Por exemplo, um
professor precisa ter certeza de que todo o trabalho para digitar
as notas dos alunos da turma não será perdido quando ele fechar
o programa. Com os arquivos, poderemos armazenar os dados e
recuperá-los quando necessário. Este capítulo abordará os comandos
que nos possibilitarão manipular dados armazenados em um arquivo.
Vamos começar?
3.1 O que são arquivos?
Os arquivos são estruturas de dados manipuladas fora do ambiente

do programa. Considera-se como ambiente do programa a memória
principal, onde nem sempre é conveniente manter certas estruturas
de dados. De modo geral, os arquivos são armazenados na memória
secundária, como, por exemplo: disco rígido (HD), CD e pendrive.
3.1.1. Como os arquivos são organizados?
A linguagem C utiliza o conceito de fluxo de dados (stream) para

manipular os vários tipos de dispositivos de armazenamento e seus
diferentes formatos. Os dados podem ser manipulados em dois
diferentes tipos de fluxos: fluxos de texto e fluxos binários.
Um fluxo de texto (text stream) é composto por uma sequência

de caracteres, que pode ou não ser dividida em linhas, terminadas
por um caractere de final de linha. Um fluxo binário (binary stream) é
composto por uma sequência de bytes, que são lidos, sem tradução,
diretamente do dispositivo externo. A Figura 3.1 ilustra estes dois tipos
de fluxos.
61
Programação 2
Figura 3.1: Fluxo de dados
No fluxo de texto, os dados são armazenados como caracteres

sem conversão para a representação binária. Cada um dos caracteres
ocupa um byte. O número 12 ocupa dois bytes e o número 113 ocupa
3 bytes. Um caractere em branco foi inserido entre cada um dos
números para separá-los, de modo que a função de entrada e saída
possa descobrir que são dois números inteiros (12 e 113) e não o
número 12113. No fluxo binário, cada número inteiro ocupa 32 bits (4
bytes) e é armazenado na forma binária. Observem que, em arquivos
binários, não há necessidade de separar os números já que eles
sempre ocupam 32 bits.
Os arquivos binários são utilizados quando queremos armazenar

registros completos. Com estes arquivos, poderemos acessar
qualquer registro de forma mais rápida. No caso dos arquivos texto,
quando queremos encontrar alguma informação, temos que fazer uma
varredura sequencial no arquivo, tornando a busca pouco eficiente.
Neste capítulo, será dada ênfase ao armazenamento de dados

em arquivos binários. Nas próximas seções, iremos conhecer os
comandos para manipular este tipo de arquivo.
3.1.2 Ponteiros
Antes de começarmos a conhecer os comandos de manipulação

de arquivos binários, vamos ver um conceito que será utilizado
neste capítulo, que é: ponteiro. Um ponteiro é um tipo de variável
que armazena um endereço de memória. Nós já vimos variáveis que
armazenam números inteiros, números reais e caracteres. Ao trabalhar
com arquivos, precisamos saber em qual endereço de memória o
arquivo está armazenado. O endereço de memória onde o arquivo
62
Programação 2
está armazenado será colocado em uma variável que armazena

endereço de memória (ponteiro).
Para declarar uma variável que é capaz de armazenar um endereço

de memória, usamos a seguinte sintaxe:
Sintaxe
tipo *nome_do_ponteiro;
Onde:
• tipo: tipo de variável que o ponteiro armazena endereço.

Podemos dizer que nosso ponteiro armazena o endereço de
uma variável inteira, real, caractere, etc. Para este capítulo,
estaremos utilizando um ponteiro que vai armazenar o endereço
de um arquivo.
• *: o asterisco na frente do nome de uma variável simboliza que

a variável que está sendo declarada é um ponteiro.
• nome_do_ponteiro: daremos um nome à nossa variável que

armazena endereços.
O exemplo 3.1 apresenta exemplos de declarações de ponteiros

que armazenam endereços de memória de arquivos.
Exemplo 3.1: Declaração de ponteiros para arquivos
1 FILE *p aluno;
2 FILE *p produto;
Na linha 1, temos a declaração do ponteiro paluno, que irá

armazenar o endereço de um arquivo (FILE). Devemos colocar o
FILE em maiúsculo. Na linha 2, temos a declaração de outro ponteiro,
pproduto, que armazena o endereço de um FILE.
Quando queremos inicializar uma variável real ou inteira, atribuímos

zero às mesmas. Quando precisarmos inicializar um ponteiro,
devemos atribuir: NULL. Quando um ponteiro armazena NULL, quer
dizer que ele não está armazenando um endereço no momento.
Tenham calma, daqui a pouco o conceito de ponteiros ficará mais

claro. Vamos começar a conhecer os comandos de manipulação de
arquivos binários e entenderemos melhor onde o conceito de ponteiro
será aplicado.
63
Programação 2
3.2 Comandos para manipular arquivos

binários
Como já mencionado, os arquivos binários são utilizados quando

queremos armazenar registros. É como se tivéssemos um vetor de
registro, só que os dados não são perdidos ao terminar a execução do
programa. A figura 3.2 mostra a representação gráfica de um arquivo
binário.
Figura 3.2: Representação gráfica de um arquivo binário
O arquivo binário é formado por um conjunto de registros,

armazenados um após o outro. As operações realizadas em um
arquivo binário dependerão do local onde se encontrar o leitor. Pense
no leitor como se fosse a agulha de uma vitrola (Figura 3.3). Para
tocar uma música, a agulha passa sobre o disco, fazendo a leitura da
música. Dependendo de onde a agulha seja posicionada, é tocada
uma música do disco.
Figura:3.3: Vitrola com agulha tocando uma música
O leitor do arquivo passará sobre os registros, fazendo a leitura

dos mesmos. Nós podemos colocar o leitor sobre qualquer registro
e executar uma operação sobre o mesmo (leitura e/ou gravação). O
arquivo tem uma marcação indicando onde ele termina (end of file).
Nas próximas seções, iremos detalhar os comandos para manipular

arquivos binários. As operações para a manipulação de arquivo estão
na biblioteca stdio.h. Com isso, ao trabalhar com arquivos, devemos
64
Programação 2
incluir esta biblioteca nos nossos programas.
3.2.1 Declaração de um ponteiro para arquivo
Na linguagem C, as funções que manipulam arquivos trabalham

com o conceito de ponteiros para arquivo. Com isso, teremos
uma variável que armazenará o endereço de memória onde está
armazenado nosso arquivo. Nós vimos na seção 3.2.1 (exemplo 3.1),
como fazemos para declarar um ponteiro para um arquivo. Devemos
declarar um ponteiro para cada arquivo que formos manipular no
nosso programa.
3.2.2 Comando para abrir um arquivo
A maior parte das operações sobre um arquivo (leitura, gravação,

etc) só pode ser executada com o arquivo aberto. O comando de
abertura do arquivo (fopen) apresenta a seguinte sintaxe:
Sintaxe
ponteiro_arquivo = fopen(“nome_do_arquivo”,
“modo_de_abertura”);
Onde:
• ponteiro_arquivo: ao abrir um arquivo, a função fopen retorna

o endereço de memória do arquivo. Por conta disso, devemos
atribuir o endereço de memória do arquivo, para um ponteiro.
Após o arquivo ser aberto, usaremos este endereço de memória
para acessá-lo.
• nome_do_arquivo: determina qual arquivo deverá ser aberto.

Neste espaço é colocado o nome do arquivo, da forma que
foi salvo no diretório. O comando fopen procura o arquivo que
desejamos abrir, no mesmo diretório onde está armazenado o
programa executável.
• modo_de_abertura: informa que tipo de uso você vai fazer do

arquivo. O modo de abertura indica o que faremos no arquivo:
leitura, gravações e alterações. Além disso, o modo de abertura
também vai indicar se queremos que um novo arquivo seja
criado. A tabela abaixo, apresenta os principais modos de
abertura.
65
Programação 2
Modo Significado
“r+b” Abre um arquivo binário para leitura e escrita. O arquivo deve

existir antes de ser aberto. Dessa forma, este modo de abertura
só pode ser usado se o arquivo que estamos querendo abrir, já
existe no nosso computador.
“w+b” Cria um arquivo binário para leitura e escrita. Se o arquivo não
existir, ele será criado. Se já existir, o conteúdo anterior será
destruído. Este modo de abertura tem a capacidade de criar novos
arquivos. Mas, se solicitarmos que seja aberto um arquivo que já
existe, o conteúdo do arquivo será apagado.
“a+b” Acrescenta dados ou cria um arquivo binário para leitura e escrita.

Caso o arquivo já exista, novos dados podem ser adicionados,
apenas, no final do arquivo. Se o arquivo não existir, um novo
arquivo será criado.
O exemplo 3.2, apresenta o uso do fopen.
Exemplo 3.2: Abertura de arquivo
1 FILE *paluno, *pprofessor;
2 paluno = fopen(“alunos.bin”, “w+b”);
3 pprofessor = fopen(“professores.bin”, “r+b”);
4 if (pprofessor == NULL)
5 printf(”Arquivo de professores não existe”);
Na linha 1, temos a declaração de dois ponteiros para armazenar

os endereços dos arquivos que iremos abrir logo em seguida.
Na linha 2, temos um fopen que irá abrir o arquivo alunos.bin,

utilizando o modo de abertura w+b. Caso o arquivo alunos.bin não
exista, ele será criado (com o nome que passamos como parâmetro).
Normalmente, usamos o modo de abertura w+b quando executamos
o nosso programa pela primeira vez. Neste momento, o arquivo ainda
não existe. Dessa forma, desejamos que o mesmo seja criado. Mas,
se o arquivo alunos.bin já existir, todo o seu conteúdo será apagado.
E, como resultado, teremos o arquivo aberto, mas sem nenhum
registro armazenado. Ao abrir o arquivo, o endereço de memória do
arquivo será armazenado no ponteiro paluno.
Na linha 3, temos um fopen que abrirá o arquivo professores.

bin, utilizando o modo de abertura r+b. Este modo de abertura só é
utilizado para arquivos que já existem, pois, diferente do modo de
abertura w+b, ele não tem a capacidade de criar um arquivo novo. Se
tentarmos abrir um arquivo que não existe, o fopen retornará NULL.
66
Programação 2
Para saber se um arquivo foi aberto corretamente, podemos fazer

um teste como mostra as linhas 4 e 5. Após executar um fopen,
verificamos se o ponteiro está com NULL. Caso afirmativo, é porque a
abertura não foi executada corretamente.
Uma vez aberto, o arquivo fica disponível para leituras e gravações

através da utilização de funções adequadas.
3.2.3 Comando para fechar um arquivo
Após terminar de usar um arquivo, devemos fechá-lo. Para isso,

usamos a função fclose, que tem a seguinte sintaxe.
Sintaxe
fclose(ponteiro_arquivo);
Onde:
• ponteiro_arquivo: é o ponteiro que tem armazenado o

endereço de memória do arquivo que queremos fechar.
Só podemos fechar arquivos que estão abertos. O exemplo 3.3,

apresenta o uso do comando fclose. Vamos utilizar os ponteiros
declarados no exemplo anterior.
Exemplo 3.3: Fechamento de arquivo
1 fclose(palunos);
2 fclose(pprofessores);
Na linha 1, fechamos o arquivo que está armazenado no endereço

de memória palunos (que é o ponteiro que armazena o endereço do
arquivo). Nós só utilizamos o nome do arquivo (o nome que está salvo
no diretório), no momento da abertura. Depois de aberto, só utilizamos
seu endereço de memória, certo?
3.2.4 Comando para ler um registro armazenado no arquivo
Vamos aprender a ler os dados de um registro armazenado no

arquivo? Neste comando, teremos vários detalhes e devemos ter em
mente o seguinte:
• A leitura é feita a partir do ponto onde o leitor se encontra. Ao

abrir o arquivo, o leitor é posicionado no início do primeiro
67
Programação 2
registro, como mostra a figura 3.2. À medida que vamos

executando leituras, o leitor vai se deslocando. Dessa forma,
precisamos ter noção da posição onde o leitor se encontra.
• Nos arquivos binários, SEMPRE fazemos a leitura de um

registro completo, independente de quantos campos ele tenha.
• Um arquivo deve armazenar registro do mesmo tipo. Se os

registros são do mesmo tipo, cada um deles ocupará o mesmo
espaço de memória. Dessa forma, o leitor sempre se deslocará
em intervalos regulares. Vamos entender isto melhor, daqui a
pouco.
Vamos, primeiro, ver a sintaxe do comando de leitura:
Sintaxe
fread (&registro, numero_de_bytes, quantidade,
ponteiro_arquivo);
Onde:
• &registro: é o registro que armazenará os dados do registro

lido do arquivo. É assim, nós pegamos um registro que está no
arquivo, e armazenamos no registro passado como parâmetro.
• numero_de_bytes: na verdade, o que o comando de leitura

faz é informar que o leitor precisa se deslocar, fazendo a leitura
de uma certa quantidade de bytes. A quantidade de bytes que o
leitor deve se deslocar é exatamente quantos bytes de memória
o registro ocupa. Por exemplo: se o nosso arquivo armazena
registros de alunos, composto pelos campos: matricula (int),
nota1 (float), nota2 (float) e media (float). Sabe-se que um int
ocupa 4 bytes e um float, também, ocupa 4 bytes. Dessa forma,
teremos: 4 bytes para a matricula + 4 bytes para a nota1 + 4
bytes para a nota2 + 4 bytes para a media = 16 bytes. Assim,
esse registro ocupa 16 bytes (Figura 3.4). É esse o número de
bytes que o leitor deverá ler, para recuperar o registro de um
aluno, armazenado no arquivo. Existe uma função chamada
sizeof que informa quantos bytes ocupa um tipo de dado.
Assim, não precisamos estar lembrados de quantos bytes um
int ocupa. Além disso, não precisamos fazer as contas para
saber quantos bytes o nosso registro ocupa. Para utilizar a
função sizeof, precisamos apenas, passar como parâmetro
68
Programação 2
para a função, que tipo de dado queremos saber quantos bytes

ele ocupa. Por exemplo: sizeof(int) ou sizeof(TAluno). No caso
de um registro, a função vai fazer as contas de quantos bytes
cada um dos campos do registro ocupa, e retorna a soma.
4 bytes 4 bytes 4 bytes 4 bytes
matricula nota1 nota2 media
Figura 3.4: Campos do registro aluno
• quantidade: neste terceiro parâmetro, usaremos SEMPRE 1.

Este parâmetro significa quantas vezes a leitura será executada.
Nós sempre queremos que seja feita a leitura de um registro
por vez. Por isso, sempre utilizaremos 1.
• ponteiro_arquivo: precisamos informar em qual arquivo a

leitura será feita. Com isso, passamos o endereço de memória
onde o arquivo que será lido está armazenado. Assim, utilizamos
o ponteiro que tem o endereço do arquivo.
Agora vamos ver o exemplo 3.4, que apresenta a leitura de um

registro do arquivo. Para um melhor entendimento, foram feitas as
declarações das variáveis que serão usadas no fread.
Exemplo 3.4: Leitura de um registro do arquivo
1 typedef { int matricula;
3 } TAluno
5 TAluno aluno;
6 FILE *paluno;
8 fread(&aluno, sizeof(TAluno), 1, paluno);
Nas linhas 1 a 3 temos a declaração de um novo tipo de dado,

que é o agrupamento dos dados do aluno. Este tipo foi chamado de
TAluno. Na linha 5, temos a declaração da variável aluno, que é um
69
Programação 2
registro do tipo TAluno. Na linha 6 declaramos um ponteiro chamado

paluno, que armazena endereço de memória de arquivo.
Na linha 8 é que temos o comando de leitura. Vamos interpretar

Atenção
cada parte do comando. No primeiro parâmetro, temos a variável
5
Não esquecer registro que vai armazenar as informações lidas do arquivo5. Assim, o
de colocar o & na registro que for lido do arquivo, será armazenado no registro aluno. No
frente da variável.
segundo parâmetro, precisamos dizer quantos bytes serão lidos. Se
iremos ler os dados do registro do aluno, precisamos saber quantos
bytes ele ocupa. Para isso, foi usada a função sizeof. Como parâmetro
do sizeof foi colocado TAluno, que é um tipo criado no programa e que
queremos saber quantos bytes esse tipo de dado ocupa. No terceiro
parâmetro, nós sempre usaremos 1. Finalmente, no quarto parâmetro
informamos o endereço do arquivo em que será feita a leitura. Neste
caso, o endereço do arquivo está armazenado no ponteiro paluno.
Após a leitura de um registro do arquivo, o leitor estará posicionado

no início do próximo registro. A Figura 3.5 apresenta a posição do
leitor antes e depois da execução do fread.
Figura 3.5: Posição do leitor antes e após a execução de um fread
Agora que já sabemos como fazer para ler um registro que está
armazenado no arquivo, vamos aprender a gravar um registro no
arquivo.
70
Programação 2
3.2.5 Comando para gravar um registro no arquivo
Para gravar um registro em um arquivo binário, nós utilizamos

o comando fwrite. Este comando é muito parecido com o fread.
A diferença é que o fread lê uma sequência de bytes no arquivo, e
armazena em um registro (primeiro parâmetro do fread). E o fwrite,
pega um registro, e armazena suas informações no arquivo. Vamos
ver a sintaxe do fwrite:
Sintaxe
fwrite(&registro, numero_de_bytes, quantidade,
ponteiro_arquivo);
Onde:
• &registro: é o registro que será armazenado no arquivo.
• numero_de_bytes: é a quantidade de bytes que serão

gravadas no arquivo. Neste parâmetro, também usaremos o
sizeof.
• quantidade: neste terceiro parâmetro, também, usaremos

SEMPRE 1. Este parâmetro significa quantas vezes a gravação
será executada. Nós sempre queremos que seja feita a
gravação de um registro por vez. Por isso, sempre utilizaremos
1.
• ponteiro_arquivo: precisamos informar em qual arquivo a

gravação será feita. Assim, utilizamos o ponteiro que tem o
endereço do arquivo.
Agora vamos ver o exemplo 3.5, que apresenta a gravação de um

registro no arquivo. Para um melhor entendimento, foram feitas as
declarações das variáveis que serão usadas no fwrite.
71
Programação 2
Exemplo 3.5: Leitura de um registro do arquivo
1 typedef { int matricula;
3 } TAluno
5 TAluno aluno;
6 FILE *paluno;
8 fwrite(&aluno, sizeof(TAluno), 1, paluno);
Na linha 8 é que temos o comando de gravação. Vamos interpretar

cada parte do comando. No primeiro parâmetro, temos a variável
registro que será gravada no arquivo. No segundo parâmetro,
precisamos dizer quantos bytes serão gravados. Para isso, foi usada
a função sizeof. No terceiro parâmetro, nós sempre usaremos 1.
Finalmente, no quarto parâmetro informamos o endereço do arquivo
em que será feita a gravação. Neste caso, o endereço do arquivo está
armazenado no ponteiro paluno.
Devemos lembrar que o comando de gravação no arquivo (fwrite)

é executado na posição onde o leitor se encontra no momento. Se o
leitor estiver posicionado no início de um registro e executarmos um
fwrite, o registro será gravado sobre o outro. Dessa forma, quando
vamos inserir um novo registro no arquivo, devemos posicionar o leitor
num ponto do arquivo que não tenha nenhum registro armazenado,
ou seja, no final do arquivo. Vamos ver como faz isso?
3.2.6 Comando para posicionar o leitor em um ponto do

arquivo
As operações de leitura e gravação são feitas na posição onde o

leitor se encontra no momento. Podemos mudar a posição do leitor,
colocando-o em um ponto específico do arquivo. Este comando é o
fseek. A sintaxe do fseek é a seguinte:
Sintaxe
fseek(ponteiro_arquivo,numero_de_bytes, origem);
72
Programação 2
Onde:
• ponteiro_arquivo: precisamos informar em qual arquivo o leitor

está sendo posicionado.
• numero_de_bytes: é a quantidade de bytes que o leitor irá se

deslocar pelo arquivo, até chegar no local desejado.
• origem: determina a partir de onde os número_de_bytes de

deslocamento do leitor serão contados. Os possíveis valores
são:
Origem Significado
SEEK_SET O deslocamento do leitor será contado a partir do início do

arquivo.
SEEK_CUR O deslocamento do leitor será contado a partir da sua posição

corrente.
SEEK_END O deslocamento do leitor será contado a partir do final do

arquivo.
O exemplo 3.6 apresenta o uso do comando fseek.
Exemplo 3.6: Comando fseek
1 fseek(paluno, 0,SEEK_END);
2 fseek(paluno, 2*sizeof(paluno), SEEK_SET);
No exemplo da linha 1, temos um fseek que será muito utilizado

em nossos programas. Neste fseek é solicitado que seja feito Atenção
o posicionamento do leitor do arquivo de endereço paluno. O
6
O parâmetro
deslocamento do leitor será feito iniciando a contagem a partir do origem, deve ser
fim do arquivo (SEEK_END)6. O número de bytes que o leitor irá se colocado todo em
letra maiúscula.
deslocar é 0. Este tipo de fseek é usado quando queremos gravar um
novo registro do nosso arquivo. Jogamos o leitor para o fim do arquivo
e não deslocamos nenhum byte. Com isso, temos a garantia que o
leitor não está sobre nenhum registro. Dessa forma, podemos gravar
um novo registro, sem perder registros que já haviam sido gravados
no nosso arquivo.
No fseek da linha 2, foi solicitado que o leitor seja posicionado no

início do arquivo (SEEK_SET), antes do deslocamento ser efetivado.
Notem que, no segundo parâmetro, foi passada uma expressão 2 * o
tamanho de um registro. Neste caso, significa que o leitor irá deslocar
a quantidade de bytes ocupadas por 2 registros, com isso, irá se
posicionar no início do terceiro registro.
73
Programação 2
A figura 3.6 apresenta a posição do leitor após a execução dos

fseek do exemplo.
Figura 3.6: Posição do leitor após a execução dos fseek do exemplo 3.6
3.2.7 Comando para posicionar o leitor no início do arquivo
Nós podemos posicionar o leitor no início do arquivo, utilizando o

comando rewind. A sua sintaxe é a seguinte:
Sintaxe
rewind(ponteiro_arquivo);
Onde:
• ponteiro_arquivo: é o ponteiro que tem o endereço do arquivo

que queremos posicionar o leitor.
O exemplo 3.7 apresenta o uso do comando rewind.
Exemplo 3.7: Uso do comando rewind
1 rewind(paluno);
O comando rewind é utilizado quando precisamos fazer uma

varredura por todos os registros do arquivo. A varredura é iniciada
colocando o leitor no início do arquivo.
74
Programação 2
3.2.8 Comando para verificar se chegou ao final do arquivo
Quando fazemos uma varredura no arquivo, não sabemos quantos

registros tem armazenados no mesmo. No entanto, precisamos saber
o momento de parar de executar a leitura dos registros. O comando
feof (end of file) informa se o leitor chegou ao final do arquivo ou não.
A sintaxe do feof é a seguinte:
Sintaxe
int feof(ponteiro_arquivo);
Onde:
• int: é o retorno da função. A função feof retorna um número

inteiro, que indica se o arquivo terminou ou não. Quando a
função retorna zero, significa que ainda não chegou no final do
arquivo. Qualquer valor diferente de zero, indica que chegou ao
final do arquivo.
• ponteiro_arquivo: é o ponteiro que tem o endereço do arquivo

que queremos verificar se chegou ao fim.
O exemplo 3.8 apresenta o uso do comando feof.
Exemplo 3.8: uso do comando feof
1 while (feof(paluno)==0)
Normalmente, o feof é usando como condição de um while, como

mostra o exemplo 3.8. Este while será executado enquanto não
chegar no final do arquivo.
3.2.9 Comando para remover um arquivo
Quando desejamos apagar um arquivo do diretório, podemos

utilizar o comando remove. Este comando só pode ser utilizado em
arquivos fechados. A sua sintaxe é a seguinte:
Sintaxe
remove(“nome_do_arquivo”);
Onde:
• nome_do_arquivo: é o nome do arquivo que queremos apagar.
75
Programação 2
Neste caso, é utilizado o nome do arquivo salvo no diretório do

nosso computador.
O exemplo 3.9 apresenta o uso do comando remove.
Exemplo 3.9: uso do comando remove
1 remove(“alunos.bin”);
Neste exemplo, o arquivo alunos.bin será removido do

computador.
3.2.10 Comando para renomear um arquivo
Nós podemos renomear um arquivo no diretório do nosso

computador. Para isso, utilizamos o comando rename. Este comando,
também, só pode ser utilizado em arquivos fechados. A sua sintaxe é
a seguinte:
Sintaxe
rename(“nome_do_arquivo”, “novo_nome_do_arquivo”);
Onde:
• nome_do_arquivo: é o nome do arquivo que queremos

renomear. Neste caso; é utilizado o nome do arquivo salvo no
diretório do nosso computador.
• novo_nome_do_arquivo: é o novo nome para o nosso

arquivo.
O exemplo 3.10 apresenta o uso do comando rename.
Exemplo 3.10: uso do comando rename
1 rename(“alunos.bin”, “alunos_temp.bin”);
Neste exemplo, o arquivo alunos.bin, será renomeado para

alunos_temp.bin.
3.3 Implementação das operações básicas

em um arquivo
Agora é a hora de fazermos o nosso programa completo, que
76
Programação 2
irá aplicar os comandos de manipulação de arquivo, descritos na

seção 3.2. Este programa irá gerenciar os dados dos alunos de uma
turma, que serão armazenados em um arquivo. O registro do aluno
é composto pela matrícula, nome e média do aluno. O programa
implementará as seguintes operações: cadastrar aluno, remover
aluno, consultar aluno por matrícula, alterar média do aluno e listagem
de todos os alunos.
Mais uma vez, teremos um programa cheio de detalhes, bem maior

do que os que fizemos até então. Por isso, o programa completo 3.1
foi desenvolvido de forma modularizada. Para facilitar o entendimento
deste programa, que tem quase 200 linhas, o mesmo foi dividido em 8
partes. Vamos começar?
Na primeira parte do programa completo 3.1, teremos as

declarações das variáveis globais do programa. Além, de módulos
auxiliares, que serão utilizados ao longo do programa, por outros
módulos.
Programa Completo 3.1- Parte 1
3 typedef struct{ int mat;
4 char nome[20];
5 float med;
6 } TAluno;
8 FILE *paluno;
9 TAluno aluno_aux, aluno_nulo;
10
11 void linha()
12 { int i;
13 for (i=1; i<=80; i++)
14 printf(“_”);
15 }
16
77
Programação 2
17 void cabec()
19 printf(“Universidade Federal Rural de

Pernambuco\n”);
20 linha();
21 }
22
23 void abre_arquivo()
24 { paluno = fopen(“aluno.dat”, “r+b”);
25 if (paluno == NULL)
26 paluno = fopen(“aluno.dat”, “w+b”);
27 }
Comentários sobre o Programa Completo 3.1, Parte 1:
• Linha 1: inclusão da biblioteca stdio.h devido o uso do comando

fflush e comandos de manipulação de arquivo.
• Linhas 3 a 6: definição de um novo tipo de dados – TAluno,

que agrupa os dados de um aluno. O tipo TAluno é composto
pela matrícula, nome e média do aluno.
• Linha 8: declaração do ponteiro paluno, que armazenará o

endereço do arquivo com os registros dos alunos.
• Linha 9: declaração de dois registros: aluno_aux e aluno_nulo.

O registro aluno_aux, será utilizado quando precisamos ler
ou gravar um registro no arquivo. O registro aluno_nulo será
utilizado no momento da remoção de um aluno do arquivo.
As variáveis declaradas nas linhas 8 e 9 são globais, por isso,
podem ser acessadas por todos os módulos do programa.
• Linhas 11 a 15: temos o primeiro módulo do nosso programa. O

módulo linha tem como objetivo, passar uma linha na tela. Este
módulo será chamado pelos demais módulos do programa.
• Linhas 17 a 21: temos a sequência de comandos do módulo

cabec. O módulo cabec faz o cabeçalho das tela. Ao iniciar uma
operação do programa (cadastro, remoção, etc), a tela deve ser
limpa e precisamos colocar o nome da universidade no topo
78
Programação 2
da tela. O módulo cabec vai: limpar a tela, colocar o nome da

instituição e passar uma linha (fazendo uso do módulo linha).

que é responsável por abrir o arquivo dos alunos, e deixá-lo
disponível para uso. Vamos entender a lógica deste módulo? Atenção
Primeiramente, é feita uma tentativa de abrir o arquivo dos
alunos – alunos.dat – com o modo de abertura r+b, no comando 7
O nome do
arquivo que
fopen. Lembrem que o modo de abertura r+b só pode ser nós passarmos
como parâmetro
utilizado quando o arquivo já existe. O processador vai procurar o
no fopen será
arquivo alunos.dat no diretório. Se o arquivo não for encontrado, utilizado para
salvar nosso
o ponteiro paluno, ficará com NULL. Mas, se for encontrado, o arquivo no
diretório. Por
endereço de memória do arquivo será armazenado no ponteiro
exemplo, após
paluno. Na sequência (linha 25), temos um if que testa o valor a execução do
módulo abre_
do ponteiro paluno. Se o ponteiro paluno estiver com NULL, arquivo, teremos
um arquivo
significa que o arquivo alunos.dat não existe ainda e precisa
chamado alunos.
ser criado. Se isso acontecer, o comando vinculado ao if é dat no diretório
onde está salvo
executado. Este comando é um fopen, só que agora utiliza o o programa
executável. Por
modo de abertura w+b, que deve ser utilizado para arquivos
convenção,
que não existe. Mas, por que não abrimos o arquivo usando coloque os
arquivos de
logo o w+b? Vocês devem estar lembrados, que o modo de dados sempre
com a extensão
abertura w+b apaga todos os registros de um arquivo quando
dat ou bin.
ele já existe. Assim, tentamos primeiro abrir o arquivo com r+b
(utilizado para arquivos que já existem e abre o arquivo sem
apagar os registros). Se der erro, é porque o arquivo não existe.
Com isso, tentamos abrir com o modo de abertura w+b.
Vamos agora para a parte 2 do programa completo 3.1. Nesta

parte temos o módulo inserir, que é responsável pelo cadastro dos
registros dos alunos no arquivo. Para fazer o cadastro de um registro
no arquivo binário, devemos obter os dados do aluno, montando o
registro que iremos gravar no arquivo. Quando o registro estiver com
todas as informações do aluno (mat, nome e media), o mesmo poderá
ser gravado no final do arquivo.
79
Programação 2
28 void inserir()
29 { int resp;
30 do { cabec();
31 printf(“\n\nCadastrar novo aluno\n\n”);
32 printf(“\nMatricula: “);
33 scanf(“%d”, &aluno_aux.mat);
34 printf(“\nNome.....: “);
35 fflush(stdin);
36 gets(aluno_aux.nome);
37 printf(“\nMedia....: “);
38 scanf(“%f”, &aluno_aux.med);
39 fseek(paluno, 0, SEEK_END);
40 fwrite(&aluno_aux, sizeof(TAluno), 1,
paluno);
41 printf(“\n\nAluno cadastrado com sucesso!

\n\n”);
42 printf(“\nDeseja cadastrar outro

(1-sim/0-nao)? “);
43 scanf(“%d”, &resp);
44 } while (resp ==1);
45 }
Comentários sobre o Programa Completo 3.1, Parte 2
• Linha 28: início do módulo inserir.
• Linha 29: declaração da variável resp. Esta variável irá

armazenar a resposta do usuário, quando for perguntado se ele
deseja cadastrar mais alunos.
• Linha 30: início de um do/while. O módulo inserir ficará

executando enquanto o usuário desejar cadastrar novos alunos.
Nesta linha, também temos a chamada do módulo cabec. Cada
vez que um cadastro é feito, a tela vai ser limpa, para iniciar um
80
Programação 2
novo cadastro.
• Linha 31: printf que informa o que esta tela faz – cadastro de
alunos.
• Linhas 32 e 33: printf solicitando que seja digitada a matrícula

do aluno e scanf que lê esta informação. Os dados do aluno
vão sendo colocados no registro aluno_aux.
• Linhas 34 a 36: printf solicitando que seja digitado o nome do

aluno, fflush para limpar o buffer de entrada (já que teremos a
leitura de uma sequência de caractere) e o gets que lê o nome
do aluno e armazena no registro aluno_aux.
• Linhas 37 e 38: printf solicitando que seja digitada a média do

aluno e scanf que lê esta informação. Neste momento, o registro
aluno_aux acabou de ser todo preenchido com os dados do
aluno e já pode ser gravado no arquivo.
• Linha 39: para gravar o registro no arquivo, devemos posicionar

o leitor no final do arquivo para não correr o risco de fazer a
gravação sobre algum outro registro. Para isso, é executado o
fseek.
• Linha 40: com o leitor posicionado no final do arquivo, podemos

executar o fwrite, que vai gravar o conteúdo do registro aluno_
aux, no nosso arquivo.
• Linha 41: printf para informar que o aluno foi cadastrado com
sucesso.
• Linhas 42 e 43: printf para pergunta se o usuário deseja

cadastrar outro aluno e scanf que lê a resposta para esta
pergunta.
• Linha 44: final do do/while, com a condição de parada. O do/

while é executado enquanto o usuário estiver respondendo que
quer cadastrar mais alunos. Notem que, não precisamos nos
preocupar com a capacidade do arquivo. Vamos armazenando
quantos registros desejarmos.
• Linha 45: fecha chaves que indica o final do módulo inserir.
A figura 3.7 apresenta a tela de execução do programa 3.1, na tela

de cadastro de novo aluno.
81
Programação 2
Figura 3.7: Tela de cadastro de aluno
Vamos ver agora o código de dois módulos que serão utilizados

pelos módulos: consultar aluno por matrícula, remover aluno e alterar
média do aluno. Quando fazemos uma consulta, alteração ou remoção,
precisamos localizar o registro do aluno no arquivo e apresentar o
registro para o usuário. Por isso, foi criado um módulo responsável
para procurar um registro no arquivo e, outro módulo, responsável por
apresentar os dados do registro de um aluno. Vamos lá, entender a
parte 3 do nosso programa completo 3.1!
46 int procura(int matp)
47 { int p;
48 p = 0;
49 rewind(paluno);
50 fread(&aluno_aux, sizeof(TAluno), 1, paluno);
52 { if (aluno_aux.mat == matp)
53 return p;
54 else
55 { fread(&aluno_aux, sizeof(TAluno), 1,
paluno);
56 p++;
82
Programação 2
57 }
58 }
59 return -1;
60 }
61
62 void mostre(int pos)
63 { fseek(paluno, pos*sizeof(TAluno), SEEK_SET);
65 printf(“\n\n”);
66 linha();
67 printf(“Matricula Nome Media\n”);
68 linha();
69 printf(“%9d %-20s %5.1f\n”, aluno_aux.mat,
70 aluno_aux.nome, aluno_aux.med);
71 linha();
72 }

procura. O módulo recebe um parâmetro, que é a matrícula do
aluno que está sendo procurado. Ao finalizar a sua execução,
esse módulo retorna um int que pode ser: -1 (significa que
procurou o registro do aluno no arquivo e não achou) ou um
número positivo (que significa em qual posição do arquivo
o registro foi encontrado). Este módulo possui uma variável
local p, que é incrementada cada vez que é feita a leitura de
um registro no arquivo. É o valor desta variável que indica em
que posição do arquivo o registro foi encontrado. Para localizar
o registro de um aluno, com uma dada matrícula, precisamos
percorrer todo o arquivo, até encontrar o registro ou até o
arquivo chegar ao fim. Para percorrer o arquivo, colocamos
o leitor no início do mesmo (usando o rewind – linha 49) e
efetuamos vários fread, até que chegue no final do arquivo
(while da linha 51). Logo após posicionar o leitor no início do
83
Programação 2
arquivo, fazemos a leitura do primeiro registro do arquivo, para

verificar se não é o final de arquivo (end of file). Lembrem que,
assim que um fread é executado, o leitor já fica posicionado no
início do próximo registro, pronto para um novo fread. Quando
um registro do arquivo tem a mesma matrícula que está sendo
procurada, significa que encontramos o aluno. Com isso, já
pode ser dado o retorno, indicando a posição onde o registro
foi encontrado (linha 52 e 53). Se fizermos a leitura de todos
os registros do arquivo e não encontrar nenhum aluno com a
matrícula procurada, o módulo retornará -1 (linha 59).

mostre. Este módulo recebe como parâmetro a posição do
registro que deve ser apresentado, recupera o registro no
arquivo e apresenta os dados do registro em forma de tabela.
O módulo começa com o posicionamento do leitor no início do
registro que deve ser mostrado (linha 63). Notem que, no fseek,
no campo que indica o tamanho do deslocamento que o leitor
vai dar, é feita a conta: pos*sizeof(TAluno). Vamos entender
o porquê desta conta. A variável pos indica em que posição
o registro está armazenado no arquivo (se ele é o primeiro,
segundo, etc.). Consequentemente, saberemos quantos
registros tem armazenados antes do registro que queremos
mostrar. E assim, saberemos sobre quantos registros o leitor
dever se deslocar, até ser posicionado no início do registro
desejado. Com o leitor no ponto certo, podemos fazer a leitura
do registro do aluno, armazenando seus dados no registro
aluno_aux (linha 64). Após isto, precisamos apenas apresentar
os dados do aluno (linhas 65 a 71).
Vamos agora entender o módulo responsável por consultar um

aluno através do seu número de matrícula. O módulo consultar
vai solicitar que o usuário informe a matrícula do aluno que deseja
consultar. Através do uso do módulo procura é descoberta em que
posição o registro do aluno se encontra armazenado no arquivo. Se o
aluno estiver armazenado no arquivo, seus dados são apresentados,
através do uso do módulo mostre. Se o aluno não for encontrado, é
apresentada uma mensagem de erro.
84
Programação 2
73 void consultar()
74 { int resp, matcon, posicao;
75 do{ cabec();
76 printf(“\n\nConsultar Aluno\n\n\n”);
77 printf(“Matricula do aluno: “);
78 scanf(“%d”, &matcon);
79 posicao = procura(matcon);
80 if (posicao == -1)
81 printf(“\n\nMatricula nao encontrada!

\n\n”);
82 else
83 mostre(posicao);
84 printf(“\n\nDeseja consultar outro

(1-sim/0-nao)? “);
86 } while (resp == 1);
87 }
• Linha 73: início do módulo consultar.
• Linha 74: declaração das variáveis locais: resp, matcon

(matricula que será consultada) e posicao (armazena em que
posição o registro foi localizado).
• Linha 75: início de um do/while. O módulo consultar ficará

executando enquanto o usuário desejar consultar alunos. Nesta
linha, também temos a chamada o módulo cabec. Cada vez
que uma consulta é feita, a tela vai ser limpa, para iniciar uma
nova consulta.
• Linha 76: printf que informa o que esta tela faz – consultar
aluno.
85
Programação 2
do aluno que deseja consultar e scanf que lê esta informação.
• Linha 79: chamada do módulo procura, passando a matrícula

que desejamos consultar como parâmetro. O retorno do módulo
procura é armazenado na variável posicao.
• Linhas 80 a 83: if que verifica se a variável posicao tem

armazenado -1. Se sim, é porque o aluno não foi encontrado.
Com isso, é escrita uma mensagem de erro. Caso posicao não
esteja com -1, é porque o aluno foi encontrado e seus dados
devem ser apresentados. Para apresentar os dados do aluno,
fazemos uma chamada ao módulo mostre, passando a posição
onde o aluno foi encontrado, como parâmetro.
• Linhas 84 e 85: printf para perguntar se o usuário deseja

consultar outro aluno e scanf que lê a resposta para esta
pergunta.

quer consultar mais alunos.
• Linha 87: fecha chaves que indica o final do módulo consultar.

3.1, na tela de consulta aluno por matrícula.
Figura 3.8: Tela de consulta aluno por matrícula
Vamos agora entender o módulo responsável por remover um

aluno do arquivo. O módulo da remoção inicia de forma muito similar
ao da consulta. Primeiro, é solicitado o número da matrícula do aluno
86
Programação 2
que será removido, seu registro é localizado e apresentado para que o

usuário possa ter certeza que vai remover o registro certo. Na verdade,
um registro não é removido do arquivo, o que fazemos é gravar sobre
o registro do aluno que queremos remover, um registro com os dados
zerados (aluno_nulo). Assim, toda vez que temos um registro com
a matrícula igual a zero no arquivo, significa que ele é um registro
que foi removido. Se o aluno não for encontrado, é apresentada uma
mensagem de erro.
88 void remover()
89 { int matrem, conf, resp, posicao;
90 aluno_nulo.mat = 0;
91 aluno_nulo.med = 0;
92 do{ cabec();
93 printf(“\n\nRemover aluno\n\n\n”);
94 printf(“Matricula: “);
95 scanf(“%d”, &matrem);
96 posicao = procura(matrem);
98 printf(“\nAluno nao encontrado!!\a”);
99 else
100 { mostre(posicao);
101 printf(“\n\nDeseja remover o aluno

(1-sim/0-nao)? “);
102 scanf(“%d”, &conf);
103 if (conf == 1)
104 { f s e e k ( p a l u n o , p o s i c a o * s i z e o f
(TAluno),SEEK_SET);
105 f w r i t e ( & a l u n o _ n u l o ,
sizeof(TAluno), 1, paluno);
106 printf(“\n\nAluno removido com

sucesso!”);
107 }
87
Programação 2
108 else
109 printf(“\nRemocao cancelada!”);
110 }
111 printf(“\n\n\nDeseja remover outro

(1-sim/0-nao)? “);
113 } while (resp ==1);
114 }
• Linha 88: início do módulo remover.
• Linha 89: declaração das variáveis locais: resp, matrem

(matricula que será removida), conf (confirmação se deseja
remover realmente) e posicao (armazena em que posição o
registro foi localizado).
• Linhas 90 e 91: inicialização dos campos do registro aluno_

nulo.
• Linha 92: início de um do/while. O módulo remover ficará

executando enquanto o usuário desejar remover alunos. Nesta
linha, também temos a chamada do módulo cabec. Cada vez
que uma remoção é feita, a tela vai ser limpa, para iniciar uma
nova remoção.
• Linha 93: printf que informa o que esta tela faz – remover
aluno.

do aluno que deseja remover e scanf que lê esta informação.

que desejamos remover como parâmetro. O retorno do módulo

88
Programação 2

onde o aluno foi encontrado como parâmetro. Após ver os dados
do aluno, o usuário pode desistir de removê-lo. Na linha 102,
temos o scanf que lê se o usuário confirma ou não a remoção. A
remoção, propriamente dita, é executada nas linhas 104 e 105.
Na linha 104 temos o posicionamento do leitor sobre o registro
que queremos remover. E, na linha 105, temos a gravação do
registro aluno_nulo sobre o registro antigo.

remover outro aluno e scanf que lê a resposta para esta
pergunta.

quer remover mais alunos.
• Linha 114: fecha chaves que indica o final do módulo remover.
A figura 3.9 apresenta a tela de execução do programa 3.1, na tela

de remoção de aluno.
Figura 3.9: Tela de remoção do registro do aluno
Agora vamos entender o módulo responsável pela alteração da

média do aluno. Este módulo é parecido com a remoção. Primeiro,
é solicitado o número da matrícula do aluno que será alterado, seu
registro é localizado e apresentado para que o usuário possa ter
certeza que vai alterar o registro certo. Na alteração, gravamos um
registro com a média alterada, sobre o antigo registro do aluno.
89
Programação 2
115 void alterar()
116 { int matalt, conf, resp, posicao;
117 do { cabec();
118 printf(“\n\nAlterar media do aluno\n\

n\n”);
119 printf(“Matricula: “);
120 scanf(“%d”, &matalt);
121 posicao = procura(matalt);
123 printf(“\nAluno,nao encontrado!!\a”);
124 else
125 { mostre(posicao);
126 printf(“\n\nAlterar a media do

aluno(1-sim/0-nao)? “);
127 scanf(“%d”, &conf);
128 if (conf == 1)
129 { printf(“\nNova media: “);
130 scanf(“%f”, &aluno_aux.med);
131 printf(“\nMedia alterada com sucesso!

\n\n”);
132 fseek(paluno,posicao*sizeof(TAluno),
SEEK_SET);
133 fwrite(&aluno_aux,sizeof(TAluno), 1,
paluno);
134 mostre(posicao);
135 printf(“\nMedia do aluno alterada com

sucesso!\n”);
136 }
137 else
90
Programação 2
138 printf(“\n\nAlteracao cancelada!

\n\n”);
139 }
140 printf(“\n\nDeseja alterar outro

(1-sim/0-nao)? “);
142 }while (resp ==1);
143 }
• Linha 115: início do módulo alterar.
• Linha 116: declaração das variáveis locais: resp, matalt

(matricula que será alterada), conf (confirmação se deseja
alterar a média do aluno) e posicao (armazena em que posição
o registro foi localizado).
• Linha 117: início de um do/while. O módulo alterar ficará

executando enquanto o usuário desejar alterar alunos. Nesta
linha, também temos a chamada do módulo cabec. Cada vez
que uma alteração é feita, a tela vai ser limpa, para iniciar uma
nova alteração.
• Linha 118: printf que informa o que esta tela faz – alterar média
do aluno.

do aluno que deseja alterar e scanf que lê esta informação.

que desejamos alterar como parâmetro. O retorno do módulo

onde o aluno foi encontrado como parâmetro. Após ver os dados
do aluno, o usuário pode desistir de alterar a sua média. Na
91
Programação 2
linha 127, temos o scanf que lê se o usuário confirma ou não a

alteração. Se o usuário confirma que quer alterar, é solicitada
a nova média do aluno (linha 130). A alteração, propriamente
dita, é executada nas linhas 132 e 133. Na linha 132, temos o
posicionamento do leitor sobre o registro que queremos alterar.
E, na linha 133, temos a gravação do registro alterado sobre o
registro antigo. Após os dados serem alterados, o registro do
aluno é reapresentado através de uma chamada ao módulo
mostre (linha 134).

alterar outro aluno e scanf que lê a resposta para esta
pergunta.

quer alterar mais alunos.
• Linha 143: fecha chaves que indica o final do módulo alterar.

3.1, na tela de alteração de média do aluno.
Figura 3.10: Tela de alteração de média do aluno
Veremos, agora, o último módulo do programa, que é a listagem.

Este módulo é responsável por apresentar todos dados dos alunos
que estão armazenados no arquivo. Os dados serão apresentados
em forma de tabela. Devemos lembrar que só iremos apresentar os
92
Programação 2
registros válidos do arquivo, ou seja, registros com matrícula zerada

não devem ser apresentados.
144 void listagem()
145 { cabec();
146 printf(“\n\nListagem Geral\n\n\n”);
147 linha();
148 printf(“Matricula Nome Media\n”);
149 linha();
150 rewind(paluno);
153 { if (aluno_aux.mat != 0)
154 printf(“%9d %-20s %5.1f\n”, aluno_aux.

mat,

155 aluno_aux.nome, aluno_aux.med);
156 fread(&aluno_aux, sizeof(TAluno), 1,

paluno);
157 }
158 linha();
159 printf(“tecle enter para voltar ao menu...”);
160 getche();
161 }
• Linha 144: início do módulo listagem.
• Linha 145: chamada ao módulo cabec, responsável por limpar

a tela e escrever o nome da instituição.
• Linha 146: printf que informa o que esta tela faz – listagem
geral.
• Linha 147: chamada do módulo linha, para iniciar o desenho

da tabela.
93
Programação 2
• Linha 148: printf que escreve os cabeçalhos das colunas da

tabela.
• Linha 149: mais uma chamada ao módulo linha.
• Linha 150: posiciona o leitor no início do arquivo, para que

possamos “varrer” o arquivo, visitando todos os registros do
arquivo.
• Linha 151: Leitura do primeiro registro do arquivo, para verificar

se não é o final do arquivo.
• Linhas 152 a 157: while que é executado enquanto não chegar

no final do arquivo. Para cada registro lido, é verificado se o
mesmo tem a matrícula igual a zero. Se sim, o registro não é
apresentado na listagem.
• Linha 158: chamada do módulo linha, para fechar a tabela.
• Linha 159: printf informando que o usuário deve teclar enter

para sair da listagem.
• Linha 160: getche para que possamos ver a listagem.
• Linha 161: fecha chaves que indica o final do módulo listagem.

3.1, na tela de listagem dos dados de todos os alunos.
Figura 3.11: Tela de listagem de dados de todos os alunos
O programa principal do programa completo 3.1 é apresentado a

seguir. É no programa principal que serão feitas as chamadas aos
módulos que o usuário deseja executar no momento.
94
Programação 2
162 main()
163 { int op;
164 abre_arquivo();
165 do{ cabec();
166 printf(“\n\nOpcoes: \n\n\n”);
167 printf(“ 1- Cadastrar novo aluno\n\n”);
168 printf(“ 2- Remover aluno\n\n”);
169 printf(“ 3- Consultar aluno por

matricula\n\n”);

170 printf(“ 4- Alterar media do aluno
\n\n”);
171 printf(“ 5- Listagem geral\n\n”);
172 printf(“ 0- Sair\n\n”);
173 linha();
174 printf(“Informe a opcao desejada: “);
175 scanf(“%d”, &op);
176 switch(op)
177 { case 1: inserir(); break;
178 case 2: remover(); break;
179 case 3: consultar(); break;
180 case 4: alterar(); break;
181 case 5: listagem(); break;
182 case 6: limpar(); break;
183 case 0: fclose(paluno); break;
184 default: printf(“\n\n\aOpcao

invalida!”);
185 break;
95
Programação 2
186 }
187 } while (op != 0);
188 }
• Linha 162: início do programa principal.
• Linha 163: declaração da variável local op, que vai armazenar

a operação que o usuário deseja executar.
• Linha 164: chamada do módulo abre_arquivo, disponibilizando

o mesmo para uso.
• Linhas 165 a 187: do/while responsável por ler a operação

que o usuário que executar e fazer a chamada do módulo que
executará a implementa a operação.

tela do menu principal, onde é informada a operação que desejamos
executar.
Figura 3.12: Tela do menu principal
E assim, terminamos mais um programa completo. Agora, é colocar

a mão no teclado e começar a programar, armazenando dados em
arquivos.
96
Programação 2
Temos agora mais uma lista de exercícios para consolidar o nosso

entendimento do assunto visto neste capítulo. Se preparem, pois as
questões estão maiores. Mas, isso é bom porque vemos que estamos
fazendo programas interessantes, não é mesmo?
1. Faça um programa para um shopping contendo as seguintes

telas:
Tela de Menu
Shopping Center
Opções:
1 .Cadastrar loja
2. Consultar loja
3. Listagem de todas as lojas
0. Sair
Entre com a opção:
Cadastro
Shopping Center
Cadastro de Loja
Código:
Nome:
Área:
Tipo(1-Confecções, 2-Alimentação, 3-Livros, 4- Serviços):
Cadastrar outra (1-Sim/0-Nao)?
Consulta
Shopping Center
Consultar Loja
Código da loja que deseja consultar:
Código Nome Área Tipo Condomínio
xxx xxxxxxx xx xx xxxx
Consultar outra (1-Sim/0-Nao)?
97
Programação 2
Relatório Geral
Shopping Center
Listagem Geral
Codigo Nome Área Tipo Condomínio
xxx xxxxxxx xx xx xxxxx
Tecle enter para voltar ao menu...
• O programa irá armazenar os dados das lojas em um arquivo.
• O programa irá calcular o valor do condomínio de cada loja. O

valor do condomínio depende da área e do tipo da loja. Veja
tabela abaixo:
Tipo da loja Valor do m²
1 R$ 50
2 R$ 65
3 R$ 80
4 R$ 95
2. Faça um programa para uma Agência de Turismo armazenando

os dados em um arquivo. O programa deverá ter as seguintes
funções: Cadastrar roteiro, Consultar roteiro, Listagem de todos
os roteiros e Simular valor de viagem. A seguir, sugestões de
telas.
Tela Principal
Vida Boa Turismo
Opções:
1- Cadastrar roteiro
2- Consultar roteiro
3- Listagem de todos os roteiros
4- Simular viagem
0- Sair
Entre com a opção:
98
Programação 2
Tela de Cadastro
Vida Boa Turismo
Cadastrar Roteiro
Código:
País(1-Brasil, 2-Espanha, -3-Italia):
Cidade:
Diária de Hotel: R$
Diária Aluguel de Carro: R$
Inserir outro(1-sim,2-não)?
Tela de Remoção de Roteiro
Vida Boa Turismo
Consultar Roteiro
Código do roteiro a ser consultado:
Código País Cidade Diária Hotel Carro
xxx x xxxxxxxx xxx xxxx
Consultar outro (1-Sim/0-Nao)?
Tela de Listagem de todos os roteiros
Vida Boa Turismo
Listagem de todos os roteiros
Página x de x... Tecle enter
Tecle enter para voltar ao menu...
99
Programação 2
Tela para simular valor de viagem
Vida Boa Turismo
Simular Viagem
Código do roteiro:
Quantidade de dias:
Alugar carro(1-sim, 2-não)?
Valor total da viagem = R$ xxxxx
Simular outro roteiro(1-sim, 2-não)?
Observações:
• Os dados do roteiro devem ser armazenados em um arquivo.

Não pode cadastrar roteiros com códigos repetidos.
• O valor da viagem deve ser calculado com base nos valores do

roteiro escolhido; viagem = quantos dias * valor diária hotel +
quantos dias * valor diária carro (caso alugue carro).
• Na consulta deve passar o código do roteiro e apresentar os

dados do roteiro.
• Na listagem, apresentar os dados de todos os roteiros em forma

de tabela.
Conheça Mais
Para melhorar o nosso conhecimento sobre manipulação de

arquivos binários, vejam este assunto nos livros:
• LAUREANO, Marcos. Programando em C Para Linux, Unix e

• MIZRAHI, Victorine Viviane. Treinamento em Linguagem C –

100
Programação 2
Vamos revisar?
lendo o resumo a seguir:
• Os arquivos servem para armazenar nossos dados de forma

definitiva.
• Os arquivos binários são adequados para o armazenamento de

registros.
• Cada registro que é armazenado no arquivo ocupa a mesma

quantidade de memória.
• Toda operação sobre um arquivo será executada no ponto onde

o leitor se encontra.
• Com o comando fseek, podemos colocar o leitor sobre o registro

que desejamos ler ou gravar.
• Só podemos manipular um arquivo que esteja aberto. Após o uso

do arquivo, devemos fechá-lo.
• O arquivo criado pelo programa é salvo no mesmo diretório em

que está armazenado o nosso programa executável.
101
Programação 2
Neste volume, tivemos a oportunidade de aprender como

armazenar dados em vetores, registros e arquivos. O armazenamento
adequado dos dados possibilitou o desenvolvimento de programas
com operações mais elaboradas como: cadastro de elementos,
remoção, alteração, consultas e listagens. Perceberam o quanto
nossos programas evoluíram desde o nosso primeiro programa
completo, até hoje? Vejam que todos os conceitos que aprendemos
estão sempre em uso nos nossos programas. Isto é bom porque nos
acostumamos com a sintaxe dos comandos. Agora, temos apenas
mais um módulo para finalizar a nossa caminhada, em busca do
aprendizado da linguagem de programação C. Continuem firmes nos
estudos! Estamos quase no final! Até o próximo módulo.
102
Programação 2
Referências
ARAÚJO, Jairo. Dominando a Linguagem C. São Paulo:

Ciência Moderna, 2004.


Janeiro: LTC, 1999.





1996.
103
Programação 2
Conhecendo a Autora
Sou graduada em Ciência da computação pela Universidade Federal

de Sergipe. Fiz mestrado e doutorado na Universidade Federal de
Pernambuco, desenvolvendo pesquisas nas áreas de Sistemas Distribuídos
e Geoprocessamento. Começei a ensinar em 2000, nos cursos de Ciência
da Computação e Sistemas de Informação. Desde o início da minha carreira
como professora, ministro disciplinas de Programação e tenho uma paixão
pela linguagem C. Atualmente, encontrei uma nova paixão: Educação a
Distância.
104

Introdução à Programação C

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Introdução à Programação C

Diunggah oleh

Hak Cipta:

Format Tersedia

Introdução a Programação

Reitor: Prof. Valmar Corrêa de Andrade

Produção Gráfica e Editorial

Conhecendo o Volume 01...................................................................10

Capítulo 1 – Introdução ao C..............................................................13

1.1. Programas e Programação de Computadores...........................13

1.2. Linguagens de Programação......................................................15

1.3. Breve Histórico da Linguagem de Programação C....................18

1.4. Criação, Compilação e Execução de um Programa...................19

Capítulo 2 – Conceitos Preliminares para Programar em C............24

2.1. Estrutura de um Programa Básico em C....................................25

2.2. Palavras Reservadas do C.........................................................28

2.3 Uso de Comentários....................................................................29

2.4. Os Fundamentos do Ambiente C................................................31

2.5. Conhecendo o Dev-cpp..............................................................34

Capítulo 3 – Tipos de Dados, Variáveis e Constantes......................40

3.1. Tipos de dados...........................................................................40

3.2. Variáveis e Constantes...............................................................42

3.3. Operador de Atribuição (=).........................................................49

4.1. Entrada de Dados.......................................................................54

4.2. Saída de Dados..........................................................................59

4.3. Erros Frequentes no Uso dos Comandos de Entrada e Saída..65

4.4. Primeiros programas em C.........................................................66

Capítulo 5 – Operadores, Expressões e Funções Matemáticas......75

5.1. Operadores Básicos...................................................................75

5.2. Operadores Aritméticos de Atribuição .......................................87

5.3. Operadores ++ e --.....................................................................87

5.4. Conversão de tipo.......................................................................88

5.5. Funções Matemáticas (biblioteca math.h)..................................90

Carga horária: 60h

Introdução à linguagem de programação C. Tipos de dados, variáveis, operadores

• Apresentar técnicas de programação estruturada utilizando como ferramenta a

• Desenvolver a capacidade de solução de problemas de programação, com o uso

• Introduzir métodos de otimização para garantir eficiência e segurança aos

Módulo 1 - Introdução à Linguagem de Programação C

Carga Horária do Módulo 01: 15 h

Objetivo do Módulo 01: Introdução ao C e seus comandos básicos, para

Conteúdo Programático do Módulo 1

○ Introdução ao C: Um breve histórico

○ Etapas de desenvolvimento de um programa

○ Variáveis, constantes, identificadores e atribuição

○ Comandos de entrada e saída

○ Operadores aritméticos, relacionais e lógicos

○ Modificadores de tipos de dados

Módulo 2 – Estruturas de Controle de Fluxo e Modularização

Carga Horária do Módulo 2: 15 h

Objetivo do Módulo 2: Possibilitar o conhecimento das estruturas de controle

Conteúdo Programático do Módulo 2:

• Estruturas de Controle de Fluxo

○ Estrutura de seleção: If e Switch

○ Estrutura de repetição: for, do/while e while

○ Construção de módulos: funções e procedimentos

○ Passagem de parâmetros e escopo de variáveis

Carga horária do Módulo 03: 15 h

Objetivo do Módulo 03: Apresentar as formas de armazenamento de dados

Conteúdo Programático do Módulo 03:

• Tipos de Dados Homogêneos e Heterogêneos

○ Comandos para manipulação de arquivo

Módulo 4 – Comandos Avançados

Carga Horária do Módulo 4: 15 h

Objetivo do Módulo 4: Apresentar comandos mais avançados da linguagem

Conteúdo Programático do Módulo 4:

• Comandos para Manipulação de Caracteres e Strings