CRC

LABORATRIO DE PROGRAMAO
CURSOS DE GRADUAO EAD
Laboratrio de Programao Prof. Dr. Rodrigo de Oliveira Plotze.
Meu nome Rodrigo de Oliveira Plotze. Sou doutor na rea de Computao Grfica e Processamento de
Imagens pelo Instituto de Cincias Matemticas e de Computao da USP So Carlos. Desenvolvo
pesquisas na rea de Viso Computacional aplicada Biologia e Medicina, na qual tenho diversos
trabalhos publicados em peridicos nacionais e internacionais. Trabalho como docente dos cursos de Ps-
Graduao em Desenvolvimento de Software (Java e .NET) no Claretiano Centro Universitrio, e,
tambm, em cursos de graduao em Cincia da Computao, Engenharia da Computao e Sistemas de
Informaes em outras Instituies de Ensino Superior.
e-mail: rodrigoplotze@gmail.com
Fazemos parte do Claretiano - Rede de Educao

Rodrigo de Oliveira Plotze
LABORATRIO DE PROGRAMAO
Batatais
Claretiano
2014
Ao Educacional Claretiana, 2010 Batatais (SP)
Verso: dez./2014
005.133P786l

Plotze,RodrigodeOliveira
Laboratriodeprogramao/RodrigodeOliveiraPlotzeBatatais,SP:
Claretiano,2014.
330p.

ISBN:9788583772583
1.Estruturascondicionaisederepetio.2.Vetores.3.Matrizes.4.Registros.
5.Ponteiros.6.Programaomodular.7.Recursividade.I.Laboratriodeprogramao.

CDD005.133
Corpo Tcnico Editorial do Material Didtico Mediacional

Coordenador de Material Didtico Mediacional: J. Alves
Preparao Reviso
Aline de Ftima Guedes Ceclia Beatriz Alves Teixeira
Camila Maria Nardi Matos Eduardo Henrique Marinheiro
Carolina de Andrade Baviera Felipe Aleixo
Filipi Andrade de Deus Silveira
Ctia Aparecida Ribeiro
Juliana Biggi
Dandara Louise Vieira Matavelli Paulo Roberto F. M. Sposati Ortiz
Elaine Aparecida de Lima Moraes Rafael Antonio Morotti
Josiane Marchiori Martins Rodrigo Ferreira Daverni
Lidiane Maria Magalini Snia Galindo Melo
Talita Cristina Bartolomeu
Luciana A. Mani Adami
Vanessa Vergani Machado
Luciana dos Santos Sanana de Melo
Patrcia Alves Veronez Montera Projeto grfico, diagramao e capa
Raquel Baptista Meneses Frata Eduardo de Oliveira Azevedo
Rosemeire Cristina Astolphi Buzzelli Joice Cristina Micai
Simone Rodrigues de Oliveira Lcia Maria de Sousa Ferro
Luis Antnio Guimares Toloi
Raphael Fantacini de Oliveira
Bibliotecria Tamires Botta Murakami de Souza
Ana Carolina Guimares CRB7: 64/11 Wagner Segato dos Santos
Todos os direitos reservados. proibida a reproduo, a transmisso total ou parcial por qualquer forma
e/ou qualquer meio (eletrnico ou mecnico, incluindo fotocpia, gravao e distribuio na web), ou o
arquivamento em qualquer sistema de banco de dados sem a permisso por escrito do autor e da Ao
Educacional Claretiana.
Claretiano - Centro Universitrio

Rua Dom Bosco, 466 - Bairro: Castelo Batatais SP CEP 14.300-000
cead@claretiano.edu.br
Fone: (16) 3660-1777 Fax: (16) 3660-1780 0800 941 0006
www.claretianobt.com.br
Fazemos parte do Claretiano - Rede de Educao

SUMRIO
CADERNO DE REFERNCIA DE CONTEDO

1 INTRODUO ............................................................................................................................................... 7
2 ORIENTAES PARA ESTUDO......................................................................................................................8
3 REFERNCIA BIBLIOGRFICA .....................................................................................................................19
Unidade1 INTRODUO PROGRAMAO DE COMPUTADORES

1 OBJETIVOS.................................................................................................................................................... 21
2 CONTEDOS................................................................................................................................................. 21
3 ORIENTAES PARA O ESTUDO DA UNIDADE...........................................................................................21
4 INTRODUO UNIDADE...........................................................................................................................22
5 ORGANIZAO DE COMPUTADORES.........................................................................................................22
6 LINGUAGENS DE PROGRAMAO..............................................................................................................27
7 AMBIENTES DE DESENVOLVIMENTO..........................................................................................................31
8 QUESTES AUTOAVALIATIVAS ...................................................................................................................47
9 CONSIDERAES.......................................................................................................................................... 48
10 REFERNCIAS BIBLIOGRFICAS.................................................................................................................48
Unidade2 FUNDAMENTOS DA LINGUAGEM DE PROGRAMAO C

1 OBJETIVOS.................................................................................................................................................... 49
2 CONTEDOS................................................................................................................................................. 49
5 ESTRUTURA BSICA DE UM PROGRAMA NA LINGUAGEM C...................................................................50
6 TIPOS DE DADOS E VARIVEIS....................................................................................................................52
7 COMANDOS DE ENTRADA E SADA.............................................................................................................61
8 EXPRESSES ARITMTICAS.........................................................................................................................74
9 EXPRESSES LGICAS ................................................................................................................................. 81
10 BIBLIOTECAS................................................................................................................................................ 86
11 EXERCCIOS RESOLVIDOS............................................................................................................................90
12 QUESTES AUTOAVALIATIVAS ..................................................................................................................114
13 CONSIDERAES......................................................................................................................................... 116
14 REFERNCIA BIBLIOGRFICA.....................................................................................................................116
Unidade3 ESTRUTURAS DE CONTROLE

1 OBJETIVOS.................................................................................................................................................... 117
2 CONTEDOS................................................................................................................................................. 117
5 ESTRUTURA CONDICIONAL.........................................................................................................................118
6 ESTRUTURA DE REPETIO.........................................................................................................................128
8 QUESTES AUTOAVALIATIVAS....................................................................................................................179
9 CONSIDERAES.......................................................................................................................................... 179
Unidade4 ESTRUTURA DE DADOS E PONTEIROS

1 OBJETIVOS.................................................................................................................................................... 181
2 CONTEDOS................................................................................................................................................. 181
5 VETORES........................................................................................................................................................ 182
6 MATRIZES...................................................................................................................................................... 186
7 REGISTROS.................................................................................................................................................... 190
8 PONTEIROS................................................................................................................................................... 194
9 EXERCCIOS RESOLVIDOS ............................................................................................................................201
10 QUESTES AUTOAVALIATIVAS ..................................................................................................................255
11 CONSIDERAES ........................................................................................................................................ 256
12 REFERNCIA BIBLIOGRFICA.....................................................................................................................256
Unidade5 PROGRAMAO MODULAR

1 OBJETIVOS.................................................................................................................................................... 257
2 CONTEDOS................................................................................................................................................. 257
5 FUNES....................................................................................................................................................... 258
6 PASSAGEM DE PARMETROS......................................................................................................................263
7 RECURSIVIDADE........................................................................................................................................... 270
9 QUESTES AUTOAVALIATIVAS ...................................................................................................................297
10 CONSIDERAES......................................................................................................................................... 297
Unidade6 ARQUIVOS
1 OBJETIVO...................................................................................................................................................... 299
2 CONTEDO................................................................................................................................................... 299
5 ESTRUTURA BSICA PARA MANIPULAO DE ARQUIVOS.......................................................................300
7 QUESTES AUTOAVALIATIVAS....................................................................................................................328
8 CONSIDERAES ......................................................................................................................................... 328
9 REFERNCIA BIBLIOGRFICA......................................................................................................................329
Caderno de
Referncia de
Contedo
CRC
Contedo
Introduo aos conceitos bsicos de programao de computadores. Instalao e configurao de ambiente de
desenvolvimento. Estruturas condicionais. Estruturas de repetio. Vetores e Matrizes. Registros. Ponteiros. Progra-
mao modular. Passagem de parmetros. Recursividade. Arquivos.
1. INTRODUO
Seja bem-vindo!
Voc est iniciando o estudo de Laboratrio de Programao, na qual ter a possibilidade
de aprender como desenvolver programas de computador utilizando a linguagem de programa-
o C. Para facilitar a sua compreenso, o contedo foi dividido em seis unidades.
Durante este estudo, voc conhecer desde os conceitos fundamentais para construo
de programas, como estruturas sequenciais, estruturas de controle e estruturas de dados, at
aspectos avanados, como programao modular e alocao dinmica de memria.
Um dos aspectos fundamentais para o desenvolvimento de programas o armazenamen-
to de informaes. Para isso, estudaremos como manipular arquivos por meio da linguagem de
programao C. Com o contedo a ser estudado, alm de criar arquivos no sistema operacional,
saberemos como gravar e recuperar informaes.
Tambm fundamental que voc, como desenvolvedor, acompanhe a evoluo das tec-
nologias utilizadas no desenvolvimento de aplicaes. Para isso, no utilize apenas este material
como fonte de informao. essencial que complemente sua formao consultando outras fon-
tes, como livros, revistas e internet. Alm disso, no se esquea de compartilhar suas experin-
8 Laboratrio de Programao
cias por meio dos Fruns e da Lista na Sala de Aula Virtual, pois assim, alm de contribuir para o
aprendizado de outras pessoas, voc consolidar seu conhecimento.
Aps essa introduo aos conceitos principais, apresentamos a seguir, no tpico Orienta-
es para Estudo, algumas orientaes de carter motivacional, dicas e estratgias de aprendi-
zagem que podero facilitar o seu estudo.
Que voc tenha um bom e proveitoso estudo!
2. ORIENTAES PARA ESTUDO
Abordagem Geral
Neste tpico, apresenta-se uma viso geral do que ser estudado nesta obra. Aqui, voc
entrar em contato com os assuntos principais deste contedo de forma breve e geral e ter
a oportunidade de aprofundar essas questes no estudo de cada unidade. No entanto, essa
Abordagem Geral visa fornecer-lhe o conhecimento bsico necessrio a partir do qual voc pos-
sa construir um referencial terico com base slida cientfica e cultural para que, no futuro
exerccio de sua profisso, voc a exera com competncia cognitiva, tica e responsabilidade
social.
Laboratrio de Programao tem como objetivo principal a sua iniciao desenvolvimento
de programas de computador. Alm disso, voc conhecer a linguagem de programao C e as
principais estruturas utilizadas na elaborao de programas.
Antes de iniciar o estudo especfico sobre a programao, importante que alguns aspec-
tos a respeito da organizao dos computadores sejam apresentados. As mquinas de computar,
popularmente conhecidas como computadores, tm como principal objetivo o processamento
de informaes. Para isso, um fluxo linear de transformao realizado em dados, os quais so
inseridos por meio de um dispositivo de entrada. Os dados so processados, e, por fim, apresen-
tados em perifricos conhecidos como dispositivos de sada.
O processamento das informaes efetuado por um componente especfico do compu-
tador, conhecido como processador. Essa parte integrante fundamental para o funcionamento
do sistema e geralmente conhecida como o crebro do computador. Para que as informa-
es sejam processadas, o processador possui um conjunto finito de instrues, as quais reali-
zam tarefas especficas.
Por exemplo: o processador possui uma instruo destinada realizao de contas de so-
mar, conhecida como sum. Todas as informaes processadas no processador so armazenadas
em um componente denominado memria principal. A memria principal mantm os dados
enquanto o programa de computador est sendo executado, por isso esse tipo de memria
conhecida como voltil. Alm disso, o computador pode utilizar informaes armazenadas de
maneira persistente. Ele utiliza um tipo especfico de memria conhecida como memria secun-
dria. Os principais exemplos de memria secundria so os discos rgidos, o CD-ROM (Compact
Disc Read Only Memory Disco Compacto Memria Somente de Leitura), o DVD-ROM (Digital
Versatile Disk Read Only Memory Disco Verstil Digital Somente de Leitura), o BD-ROM (Bluray
Disc Real Only Memory), entre outros.
Para que o computador seja capaz de processar as informaes, necessrio que os dados
sejam alimentados por meio dos dispositivos de entrada. Esses dispositivos tm como objetivo
carregar os dados no computador. Os principais exemplos de dispositivo de entrada so o mouse
Caderno de Referncia de Contedo 9
e os digitalizadores. Por outro lado, a funcionalidade de apresentao de dados por meio do

computador executada por meio dos dispositivos de sada. Nesses dispositivos, os dados po-
dem ser apresentados no formato digital e apenas para visualizao, como, por exemplo, nos
monitores, bem como apresentados no formato impresso, utilizando para isso os diversos tipos
de impressora, como matricial, a jato de tinta e a laser.
Conforme foi comentado, o principal objetivo de um computador o processamento de
informaes, ou simplesmente a transformao de dados. Para que esse processamento seja
realizado, o computador utiliza um conjunto de instrues que so interpretadas pelo proces-
sador. Essas instrues permitem disparar todas as funcionalidades que o computador pode
executar e para isso precisam ser escritas, ou codificadas, em uma linguagem que o computador
entenda perfeitamente. As linguagens entendidas pelo computador so conhecidas como lin-
guagens de programao.
De modo geral, uma linguagem de computador possibilita que um programador desenvol-
va programas de computador, de maneira que o computador seja capaz de executar um conjun-
to determinado de aes, as quais realizam os mais variados tipos de tarefas. Podemos construir
programas de computador, por exemplo, para calcular a mdia final de uma disciplina, ou ainda
para organizar as informaes financeiras de uma empresa. A complexidade do programa est
intimamente relacionada com o nmero de instrues, ou linhas de cdigos, necessrias no
programa.
Devemos tambm atentar para o nmero de linguagens de programao existentes atu-
almente. Uma simples pesquisa em um site de busca pelo termo linguagens de programao
retornar alguns milhares de resultados. Alm disso, essa diversidade pode tornar a produo
de computadores uma tarefa altamente complexa, uma vez que os computadores teriam de
entender os mais variados tipos de linguagem.
Para simplificar esse problema, os computadores so capazes de entender uma nica lin-
guagem de programao, conhecida como linguagem de mquina. Por outro lado, a linguagem
de mquina, tambm referenciada como cdigo de mquina, possui uma estrutura pouco orga-
nizada e pouco intuitiva para seres humanos. Dessa maneira, o desenvolvimento de progra-
mas de computador utilizando os cdigos de mquina pode ser considerado uma tarefa pratica-
mente impossvel nos dias atuais.
Em sistemas operacionais Microsoft, tais como o Microsoft Windows 7, Microsoft Windows
XP, entre outros, possvel visualizar os cdigos de mquina utilizados para construo dos pro-
gramas utilizando o comando debug por exemplo, debug programa.exe.
Para simplificar a construo de aplicaes, o programador pode utilizar um conjunto de
instrues que se referem s operaes bsicas que o computador pode executar. Essas ins-
trues so de mais simples compreenso e so conhecidas como mnemnicos. Em termos
prticos, os mnemnicos representam uma abreviao de um conjunto de instrues numricas
(hexadecimais) utilizadas nos cdigos de mquina. As linguagens de programao que utilizam a
simbologia de mnemnicos no desenvolvimento de programas so conhecidas como linguagens
de montagem. Porm, importante notar que mesmo construindo programas com linguagens
de montagem, os mnemnicos no so entendveis pelo computador. Assim, aps construir o
programa, necessrio realizar um processo de traduo da linguagem de montagem para a
linguagem de mquina. Esse procedimento realizado por programas especficos, conhecidos
como montadores ou assemblers.

Com a evoluo dos computadores, tanto em relao aos componentes fsicos (hardware),
quanto aos componentes lgicos (software), a complexidade do desenvolvimento dos programas
foi aumentando. Para simplificar a escrita e principalmente para agilizar o processo de elabora-
o dos programas de computadores, foram criadas linguagens de programao mais prximas
ao cotidiano dos programadores. Essas linguagens so conhecidas como linguagens de progra-
mao de alto nvel. Por meio delas, as instrues de programao foram agrupadas em um ni-
co comando. Por exemplo, se com uma linguagem de mquina era necessrio escrever algumas
dezenas de linhas para exibir o nome de uma pessoa na tela ou o resultado do clculo de uma
equao, com as linguagens de mquina essas linhas foram reduzidas para uma nica instruo.
Na linguagem de programao Pascal, o comando que exibe uma informao na tela denomi-
nado writeln, enquanto na linguagem de programao C, que ser abordada neste material, o
comando chamado printf. Com a evoluo das linguagens de programao, o desenvolvimen-
to de programas de computador se tornou algo fascinante.
Quando voc utiliza uma linguagem de programao para escrever programas, as instru-
es usadas no desenvolvimento so conhecidas como cdigo-fonte do programa, ou simples-
mente cdigo-fonte. A principal vantagem em utilizar linguagens de alto nvel para elaborao
de cdigos-fontes est na relao entre a linguagem de programao e o algoritmo. O primeiro
passo para a elaborao de um programa de computador com qualidade a codificao do al-
goritmo. Um algoritmo representa a sequncia organizada de instrues que devero ser reali-
zadas para a execuo de uma determinada tarefa. Os algoritmos so especificados por meio de
uma linguagem comum aos seres humanos, a qual podem ser definida, por exemplo, utilizando
portugus estruturado. Neste caso, voc pode utilizar instrues do tipo escreva, leia, dentre
outras. Com a elaborao do algoritmo, torna-se mais simples o desenvolvimento do programa
com a linguagem de alto nvel, pois necessria apenas a traduo do algoritmo para a lingua-
gem de programao escolhida.
O processo de desenvolvimento de um programa utilizando uma linguagem de programa-
o envolve uma etapa fundamental, que a verificao do cdigo-fonte. Essa verificao tem
como objetivo avaliar se o cdigo foi escrito de maneira correta, a partir das instrues dispon-
veis na linguagem de programao escolhida. Todo esse processo gerenciado e realizado por
um programa especfico, conhecido como compilador. De forma prtica, o compilador verifica
o cdigo-fonte do programa, e caso as instrues tenham sido codificadas de maneira correta
transforma o cdigo-fonte em cdigo-objeto. O cdigo-objeto representa o cdigo compilado
do programa; porm, no permite sua execuo.
Para transformar um cdigo-objeto em um programa executvel, necessrio outro pro-
grama especfico, denominado linker. Na linguagem de programa C, por exemplo, o processo
completo de compilao de um programa realizado em trs fases: programa.c programa.
obj programa.exe.
Os programas de computador so criados em programas especficos conhecidos como
ambientes de desenvolvimento, do ingls Integrated Development Environment, ou simples-
mente IDE. Esses ambientes oferecem aos desenvolvedores de programas um conjunto imenso
de recursos capazes de facilitar e simplificar a elaborao do programa. Alm disso, permitem
que os programas sejam exaustivamente testados para que nenhum erro seja detectado aps o
lanamento ou disponibilizao da verso final do programa.
Neste estudo, voc aprender a elaborar programas utilizando a linguagem de programa-
o de alto nvel C. Assim, para a codificao, sero necessrias a instalao e a configurao de
um ambiente de desenvolvimento integrado. Para usurios de sistemas operacionais Microsoft,
ou sistemas operacionais baseados em Linux, ser possvel utilizar um ambiente totalmente

gratuito chamado Code::Blocks. Outros ambientes de desenvolvimento tambm podem ser uti-
lizados ao longo deste estudo, tais como Microsoft Visual C++, ou ainda o NetBeans.
Fundamentos da linguagem de programao C

A linguagem de programao C uma linguagem estruturada muito utilizada para o desen-
volvimento de aplicaes comerciais e cientficas. Foi criada em 1970 pelo pesquisador Dennis
Ritchie. No incio da dcada de 1970, a linguagem C era empregada na construo de programas
para o sistema operacional Unix e a estrutura sinttica da linguagem foi elaborada com base em
uma antiga linguagem de programao conhecida como BCPL.
Os programas construdos utilizando a linguagem de programao C podem ser usados em
qualquer sistema operacional, como nas diversas edies do Microsoft Windows, nas verses
do sistema operacional Linux e Unix, e tambm nos sistemas da Apple, como o MacOS. Um fato
importante a respeito da portabilidade da linguagem de programao C a necessidade de
compilao do programa no sistema operacional em que ele ser executado. Assim, para que
um programa escrito em linguagem C possa ser executado no ambiente Microsoft Windows,
necessrio que ele seja compilado por um compilador especfico para Windows. Da mesma
maneira, para que o programa funcione nos sistemas operacionais abertos, como o Linux, por
exemplo, preciso compilar o programa com o compilador destes ambientes. Outro fato funda-
mental e que no pode ser interpretado de maneira equivocada que a linguagem de progra-
mao C portvel, porm no multiplataforma.
A estrutura mnima de um programa na linguagem de programao C precisa inicialmente
da incluso de cabealhos por meio da diretiva include. Os cabealhos podem ser considerados
bibliotecas de programao, nos quais as diversas funes previamente definidas podem ser
utilizadas pelos programadores. No mnimo, um programa de computador codificado utilizando
a linguagem C precisa da incluso da biblioteca stdio.h. Essa biblioteca responsvel pelos co-
mandos de entrada e sada denominados scanf e printf.
O comando conhecido como printf necessrio para exibir informaes na tela. Com ele,
o programador pode exibir diversas informaes processadas ao longo das linhas do programa.
Esse comando tambm pode ser adequado para exibir na tela valores referentes aos contedos
de variveis. O outro comando, denominado scanf, empregado na leitura de informaes for-
necidas pelo usurio. Essas informaes so entradas por meio de um teclado, em que o usurio
poder digitar qualquer tipo de informao. Porm, importante salientar que o tipo de infor-
mao recebida pelo comando scanf deve estar de acordo com o tipo de varivel utilizada para
receber esse valor, caso contrrio o programa poder apresentar um erro em sua execuo. Esse
tipo de erro muito comum nos programas da linguagem de programao C, principalmente
devido aos diferentes tipos de dados.
O trecho de cdigo a seguir demonstra um simples programa utilizando a linguagem de
programao C. Neste exemplo, possvel notar a presena dos comandos de entrada e sada
(printf e scanf).
Alm disso, no programa foi utilizado um dos conceitos mais fundamentais da progra-
mao de computadores, que denominado varivel. Uma varivel um espao de endere-
amento de memria reservado para armazenar informaes utilizadas pelo programa. Essas
informaes podem ser resultantes de um clculo matemtico, ou, em alguns casos, podem ser
o resultado da entrada do usurio fornecida por meio de um teclado.

Para cada varivel utilizada no programa de computador, um tipo est associado. A associa-
o de um tipo a uma varivel conhecida como tipo de dados. Uma varivel pode armazenar
apenas informaes do tipo a que est vinculada, e com isso poder executar um conjunto de
operaes. Por exemplo: um tipo de dados para armazenamento de informaes numricas na
linguagem de programao C denominado int. Esse tipo adequado para manipulao de va-
lores numricos inteiros, ou seja, que no possuam a parte fracionria. Um tipo inteiro permite
o armazenamento de valores como -5, -32, -85, 0, 12, 48, 43452. Alm disso, esse tipo permite a
realizao das seguintes operaes: soma, subtrao, multiplicao, diviso e resto da diviso.
#include <stdio.h> //biblioteca do programa
//programa principal
void main()
{
//declarao das variveis
int a;
int b;
int c;
//entrada de dados da varivel a

printf(Informe o primeiro valor: );
scanf(%i,&a);
//entrada de dados da varivel b

printf(Informe o primeiro valor: );
scanf(%i,&b);
//clculo matemtico que resulta na soma de a e b

c = (a+b);
//sada na tela
printf(O resultado da soma %i \n, c);
A linguagem de programao C possui um recurso interessante, denominado cdigos de

barra invertida. Esses cdigos, que na verdade so caracteres, fornecem um suporte interes-
sante para o controle das informaes que so exibidas na tela. Por exemplo, o cdigo de barra
invertida denominado \n (leia-se barra n), utilizado para mudana de linha. Em outras pala-
vras, ele empregado na quebra de linhas. Outro cdigo bastante utilizado na construo dos
programas o \t, cujo objetivo realizar uma tabulao horizontal das informaes que esto
sendo exibidas na tela. No exemplo apresentado, foi possvel visualizar a utilizao do cdigo de
barra invertida \n.
Como na maioria das linguagens de programao, a linguagem C possui um conjunto de
operaes para realizao de clculos matemticos. Esses operadores so conhecidos como
operadores aritmticos e possuem um conjunto de smbolos que podem ser utilizados para
formular as expresses. Na linguagem de programao C, a operao matemtica de adio
representada pelo smbolo +, enquanto a operao de subtrao especificada pelo smbolo
-. Alm disso, existem tambm o operador matemtico para multiplicao, representado pelo
smbolo *, o operador matemtico da diviso, cujo smbolo /, e o operador que determina o
resto da diviso em divises inteiras, simbolizado por %.
Outros operadores importantes na linguagem de programao C so:
operadores de igualdade, os quais so utilizados para estabelecer relaes de equi-
valncia entre informaes manipuladas pelos programas. Com esses operadores,
possvel determinar a igualdade ou a diferena entre valores;
operadores relacionais, por meio dos quais possvel estabelecer comparaes entre
as informaes manipuladas pelos programas, tais como maior que, menor que,
maior ou igual a, menor ou igual a;
operadores lgicos, adequados para situaes em que necessrio agrupar diversas
expresses lgicas. A utilizao desses operadores muito semelhante aos operadores
empregados na lgica matemtica e o resultado de sua avaliao associado s tabe-
las verdade. Para cada operador lgico da linguagem de programao C anexado um
smbolo. Por exemplo: para o operador lgico que representa a operao de conjuno
(e) so utilizados os smbolos &&, e a operao de disjuno (ou) simbolizada pelos
caracteres ||.
Estruturas de Controle
A linguagem de programao C possui um conjunto de estruturas de controle que possibilita
ao programador controlar o fluxo de execuo dos programas. Essas estruturas so essenciais para
a construo de qualquer tipo de programa de computador e so utilizadas tambm em aplicaes
comerciais e cientficas. Na linguagem de programao C, as estruturas de controle so divididas
em dois grupos, que so denominados estruturas condicionais e estruturas de repetio.
As estruturas condicionais so utilizadas para determinar a direo do fluxo de execuo
no interior dos programas. Por meio da avaliao de uma expresso condicional, o programa
poder executar uma ou outra tarefa. Nesse contexto, a linguagem de programao C possui
trs estruturas capazes de especificar condies:
1) estrutura condicional simples: a execuo de um determinado trecho de cdigo de-
pende da avaliao de uma condio, e o trecho ser executado apenas e somente
quando o resultado da avaliao for verdadeiro. Na programao, essa estrutura con-
dicional conhecida como if;
2) estrutura condicional composta: semelhante estrutura condicional simples. A prin-
cipal diferena em relao anterior o mapeamento do que ser executado quando
o resultado da avaliao condicional for falso. Assim, a estrutura condicional compos-
ta determina o que ser executado pelo programa tanto para o resultado for verda-
deiro quanto para o resultado falso. Na programao, essa estrutura representada
pela instruo if...else;
3) estrutura de seleo mltipla: nesse tipo de estrutura, um determinado trecho de c-
digo ser executado a partir da avaliao mutuamente exclusiva de uma condicional.
Dessa forma, considerando um conjunto de possibilidades de execuo, o programa
executar apenas um determinado trecho de cdigo. Na linguagem de programao
C, esse tipo de estrutura pode ser codificado por meio das instrues if...else if...else,
ou tambm pela utilizao de uma estrutura condicional denominada switch.
As estruturas de repetio tambm fazem parte da estrutura de controle da linguagem de
programao C. Uma estrutura de repetio permite a especificao de um lao de repetio no
interior dos programas. Esses laos podero ser executados uma nica vez, mas tambm pode-
ro ser executados vrias vezes. Existe tambm a possibilidade de um lao de repetio no ser
executado, a partir da avaliao da condicional associada ao critrio de parada do lao.
Na linguagem de programao C, as estruturas de repetio podem ser codificadas por
meio de dois comandos:
1) for, o qual permite ao programador definir quantas vezes um trecho de cdigo do
programa ser executado. Nesse tipo de estrutura, necessrio que uma varivel de
controle seja associada para contar o nmero de vezes que o trecho do cdigo j foi
repetido;

2) while, possibilita ao programador construir uma estrutura de repetio que ser exe-
cutada sempre que o resultado de uma expresso condicional for verdadeira. O fun-
cionamento da estrutura de repetio while muito semelhante ao for. Porm, com
essa estrutura, possvel solucionar problemas em que no previamente definido o
nmero de vezes que um bloco de comandos deve ser repetido.
Estrutura de Dados e Ponteiros

A manipulao de grandes quantidades de informaes na linguagem de programao C
realizada por meio de estruturas de dados homogneas e heterogneas. Alm disso, existe a
possibilidade de utilizao da alocao dinmica de memria, por meio de um recurso compu-
tacional conhecido como ponteiros.
Um vetor uma estrutura de dados homognea, na qual cada posio armazena uma in-
formao do mesmo tipo. Por exemplo, uma estrutura do tipo vetor, tambm conhecida como
arranjo, pode ser utilizada para armazenar as alturas de um conjunto de mil crianas em idade
escolar. Nesse caso, possvel criar um vetor do tipo de dados float ou double. Alm disso, tam-
bm permitida a criao de vetores de outros tipos, tais como int e char.
Uma matriz tambm representa uma estrutura de dados homognea, em que os dados
so representados por meio de tabelas. Dessa forma, as informaes so dispostas em linhas e
colunas, e por meio da interseo de linha e coluna possvel atribuir ou recuperar uma infor-
mao armazenada na matriz.
Os registros representam um recurso computacional em que possvel agregar informa-
es de tipos de dados diferentes. Por isso, esse tipo de estrutura de dados conhecido como
heterognea. Assim, em uma mesma estrutura de dados possvel associar dados inteiros, pon-
to flutuante, caracteres, entre outros elementos. Na linguagem C, a definio de uma estrutura
do tipo registro especificada pela instruo struct.
A alocao dinmica de memria representa um recurso muito importante disponvel na
linguagem de programao C. Esse tipo de recurso adequado para a soluo de problemas em
que no possvel determinar previamente a quantidade de informaes que ser manipulada.
Para utilizao de ponteiros na construo dos programas necessrio apenas incluir um smbo-
lo de asterisco antes da especificao do nome da varivel. Por exemplo, um ponteiro para uma
varivel do tipo int declarado da seguinte forma: int *pInteiro.
Programao modular
A reutilizao de cdigo-fonte na programao de computadores um recurso fundamen-
tal para elaborao de sistemas com qualidade. A programao modular representa uma tcnica
eficiente para o reaproveitamento de cdigo, e utiliza como estratgia a diviso do cdigo em
pequenas partes denominadas funes.
Arquivos
A manipulao de informaes de maneira persistente uma tcnica que pode ser em-
pregada por meio da utilizao dos arquivos. Um arquivo permite que os dados manipulados
pelos programas sejam armazenados em um dispositivo de memria secundria, tal como um
disco rgido.
Enfim, chegamos ao final de nossa abordagem, e esperamos que voc tenha aproveitado
ao mximo os tpicos apresentados. muito importante destacar que apenas o estudo terico
da linguagem de programao C no ser suficiente para seu aprendizado: fundamental que
voc pratique! Para isso, instale o ambiente de desenvolvimento de sua preferncia e comece
desde j a programar!
Glossrio de Conceitos
O Glossrio de Conceitos permite a voc uma consulta rpida e precisa das definies con-
ceituais, possibilitando-lhe um bom domnio dos termos tcnico-cientficos utilizados na rea de
conhecimento dos temas tratados em Laboratrio de Programao. Veja, a seguir, a definio
dos principais conceitos:
1) Algoritmo: o algoritmo a descrio de uma sequncia de passos que deve ser segui-
da para a realizao de uma tarefa (Ascencio, 1999).
2) Arquivos: so utilizados para o armazenamento persistente de informaes. Esse tipo
de estrutura capaz de guardar dados na memria secundria de maneira permanente.
3) Comandos de atribuio: para inserirmos os valores ou operaes em uma varivel,
utilizamos os comandos de atribuio. Por meio deles, conseguimos adicionar um de-
terminado valor na posio de memria reservada pela varivel.
4) Comentrio: um recurso imprescindvel para uma boa prtica de programao. Por
meio dos comentrios, o programador pode documentar o algoritmo e, com isso, au-
mentar a clareza do cdigo. Um aspecto importante a ser destacado a respeito dos
comentrios que eles so desconsiderados durante a execuo do algoritmo ou do
programa. Isso significa que eles no interferem no contedo do algoritmo; por isso,
podemos escrever qualquer tipo de informao para facilitar seu entendimento.
5) Constante: um dado definido no algoritmo que no pode ter seu valor modificado.
O conceito de constante que uma determinada informao no poder ser alterada
ao longo da execuo.
6) Estrutura condicional: quando voc utiliza uma estrutura condicional na elaborao
de um algoritmo, possvel selecionar, com base em uma ou mais condies, qual
parte do algoritmo dever ser executada.
7) Estruturas de dados: estabelecem mecanismos para a organizao dos dados, de for-
ma que podemos trabalhar com as informaes de maneira prtica e eficiente. Alm
disso, elas so capazes de manipular grandes quantidades de informaes. As estru-
turas de dados tambm so conhecidas como variveis compostas. So divididas em
dois grupos: estruturas de dados homogneas e estruturas de dados heterogneas.
8) Estrutura de repetio: so recursos utilizados na construo de algoritmos e progra-
mas que permitem ao programador definir quais blocos de instrues sero repetidos
at que ocorra certa condio.
9) Identificador: o nome de uma varivel. O identificador possui regras muito bem
definidas para a especificao de nomes. Alm dos nomes das variveis, os nomes dos
algoritmos, das constantes e das sub-rotinas tambm so considerados identificado-
res.
10) Programa: conjunto de instrues que realizam um determinado nmero de tarefas
por meio do computador.
11) Programao modular: tem como objetivo a construo de algoritmo em pequenas
partes, ou mdulos, que so chamadas de sub-rotinas.
12) Variveis: dados que podem ter seu valor alterado durante a execuo do algoritmo.
Quando voc declara uma varivel em um programa, significa que voc est reser-
vando um espao da memria principal (RAM) para o armazenamento de uma de-
terminada informao. O tamanho do espao reservado depende do tipo de dados
utilizado na varivel.

Esquema dos Conceitos-chave

Para que voc tenha uma viso geral dos conceitos mais importantes deste estudo, apre-
sentamos, a seguir (Figura 1), um Esquema dos Conceitos-chave. O mais aconselhvel que
voc mesmo faa o seu esquema de conceitos-chave ou at mesmo o seu mapa mental. Esse
exerccio uma forma de voc construir o seu conhecimento, ressignificando as informaes a
partir de suas prprias percepes.
importante ressaltar que o propsito desse Esquema dos Conceitos-chave representar,
de maneira grfica, as relaes entre os conceitos por meio de palavras-chave, partindo dos
mais complexos para os mais simples. Esse recurso pode auxiliar voc na ordenao e na se-
quenciao hierarquizada dos contedos de ensino.
Com base na teoria de aprendizagem significativa, entende-se que, por meio da organiza-
o das ideias e dos princpios em esquemas e mapas mentais, o indivduo pode construir o seu
conhecimento de maneira mais produtiva e obter, assim, ganhos pedaggicos significativos no
seu processo de ensino e aprendizagem.
Aplicado a diversas reas do ensino e da aprendizagem escolar (tais como planejamentos
de currculo, sistemas e pesquisas em Educao), o Esquema dos Conceitos-chave baseia-se,
ainda, na ideia fundamental da Psicologia Cognitiva de Ausubel, que estabelece que a apren-
dizagem ocorre pela assimilao de novos conceitos e de proposies na estrutura cognitiva
do aluno. Assim, novas ideias e informaes so aprendidas, uma vez que existem pontos de
ancoragem.
Tem-se de destacar que aprendizagem no significa, apenas, realizar acrscimos na es-
trutura cognitiva do aluno; preciso, sobretudo, estabelecer modificaes para que ela se con-
figure como uma aprendizagem significativa. Para isso, importante considerar as entradas de
conhecimento e organizar bem os materiais de aprendizagem. Alm disso, as novas ideias e os
novos conceitos devem ser potencialmente significativos para o aluno, uma vez que, ao fixar
esses conceitos nas suas j existentes estruturas cognitivas, outros sero tambm relembrados.
Nessa perspectiva, partindo-se do pressuposto de que voc o principal agente da cons-
truo do prprio conhecimento, por meio de sua predisposio afetiva e de suas motivaes
internas e externas, o Esquema dos Conceitos-chave tem por objetivo tornar significativa a sua
aprendizagem, transformando o seu conhecimento sistematizado em contedo curricular, ou
seja, estabelecendo uma relao entre aquilo que voc acabou de conhecer com o que j fazia
parte do seu conhecimento de mundo (adaptado do site disponvel em: <http://penta2.ufrgs.
br/edutools/mapasconceituais/utilizamapasconceituais.html>. Acesso em: 11 mar. 2010).
Organizao de
Computadores
Comandos de Compiladores e
Entrada e Sada Interpretadores
Processador e
Memria
Programao de
Tipos de Dados
int, char, float, Computadores
etc.
Estrutura
Sequencial
Estrutura de
Controle
Constantes e
Variveis if e switch
printf e scanf Estrutura de

for, while e Dados
do..while
Expresses
Matemticas e Lgicas
registros
vetores e (struct)
matrizes
ponteiros
Arquivos
Modularizao
Figura 1 Esquema dos Conceitos-chave de Laboratrio de Programao.
Como pode observar, esse Esquema oferece a voc, como dissemos anteriormente, uma
viso geral dos conceitos mais importantes deste estudo. Ao segui-lo, ser possvel transitar
entre os principais conceitos abordados e descobrir o caminho para construir o seu processo de
ensino-aprendizagem, como, por exemplo, o conceito de estrutura de controle, o qual implica
o conhecimento das estruturas condicionais if e switch, alm das estruturas de repetio for,
while e do..while.

O Esquema dos Conceitos-chave mais um dos recursos de aprendizagem que vem se

somar queles disponveis no ambiente virtual, por meio de suas ferramentas interativas, bem
como queles relacionados s atividades didtico-pedaggicas realizadas presencialmente no
polo. Lembre-se de que voc, aluno EaD, deve valer-se da sua autonomia na construo de seu
prprio conhecimento.
Questes Autoavaliativas
No final de cada unidade, voc encontrar algumas questes autoavaliativas sobre os con-
tedos ali tratados, as quais podem ser de mltipla escolha ou abertas com respostas objetivas
ou dissertativas.
Responder, discutir e comentar essas questes, bem como relacion-las com a prtica do en-
sino de algoritmos e programao pode ser uma forma de voc avaliar o seu conhecimento. Assim,
mediante a resoluo de questes pertinentes ao assunto tratado, voc estar se preparando para
a avaliao final, que ser dissertativa. Alm disso, essa uma maneira privilegiada de voc testar
seus conhecimentos e adquirir uma formao slida para a sua prtica profissional.
Bibliografia Bsica
fundamental que voc use a Bibliografia Bsica em seus estudos, mas no se prenda s
a ela. Consulte, tambm, as bibliografias complementares.
Figuras (ilustraes, quadros...)

Neste material instrucional, as ilustraes fazem parte integrante dos contedos, ou seja,
elas no so meramente ilustrativas, pois esquematizam e resumem contedos explicitados no
texto. No deixe de observar a relao dessas figuras com os contedos abordados, pois relacio-
nar aquilo que est no campo visual com o conceitual faz parte de uma boa formao intelectual.
Dicas (motivacionais)
Este estudo convida voc a olhar, de forma mais apurada, a Educao como processo de
emancipao do ser humano. importante que voc se atente s explicaes tericas, prticas e
cientficas que esto presentes nos meios de comunicao, bem como partilhe suas descobertas
com seus colegas, pois, ao compartilhar com outras pessoas aquilo que voc observa, permite-
-se descobrir algo que ainda no se conhece, aprendendo a ver e a notar o que no havia sido
percebido antes. Observar , portanto, uma capacidade que nos impele maturidade.
Voc, como aluno dos Curso de Graduao, necessita de uma formao conceitual slida
e consistente. Para isso, voc contar com a ajuda do tutor a distncia, do tutor presencial e,
sobretudo, da interao com seus colegas. Sugerimos, pois, que organize bem o seu tempo e
realize as atividades nas datas estipuladas.
importante, ainda, que voc anote as suas reflexes em seu caderno ou no Bloco de
Anotaes, pois, no futuro, elas podero ser utilizadas na elaborao de sua monografia ou de
produes cientficas.
Leia os livros da bibliografia indicada, para que voc amplie seus horizontes tericos. Co-
teje-os com o material didtico, discuta a unidade com seus colegas e com o tutor e assista s
videoaulas.
No final de cada unidade, voc encontrar algumas questes autoavaliativas, que so im-
portantes para a sua anlise sobre os contedos desenvolvidos e para saber se estes foram
significativos para sua formao. Indague, reflita, conteste e construa resenhas, pois esses pro-
cedimentos sero importantes para o seu amadurecimento intelectual.
Lembre-se de que o segredo do sucesso em um curso na modalidade a distncia parti-
cipar, ou seja, interagir, procurando sempre cooperar e colaborar com seus colegas e tutores.
Caso precise de auxlio sobre algum assunto, entre em contato com seu tutor. Ele estar
pronto para ajudar voc.
3. REFERNCIA BIBLIOGRFICA
ASCENCIO, A. F. G. Lgica de programao com Pascal. So Paulo: Makron Books, 1999.

Introduo Programao
de Computadores
1. OBJETIVOS
Compreender os conceitos de organizao de computadores.
Reconhecer e interpretar as principais linguagens de programao.
Instalar e configurar o ambiente para desenvolvimento.
2. CONTEDOS
Organizao de computadores.
Sistemas operacionais.
Linguagens de programao.
Ambientes de desenvolvimento integrados.
3. ORIENTAES PARA O ESTUDO DA UNIDADE

Antes de iniciar o estudo desta unidade, importante que voc leia as orientaes a se-
guir:
1) O incio deste estudo envolve alguns aspectos tericos que sero fundamentais ao
longo de todo o aprendizado. Dessa forma, utilize um bloco de anotaes para des-
tacar os principais conceitos, tais como: compilador, interpretador, cdigo-fonte etc.
2) Para saber mais sobre algumas linguagens de programao e ambientes para progra-
mao, acesse os sites indicados no decorrer desta unidade.
3) Tenha sempre mo o significado dos conceitos explicitados no Glossrio e suas li-

gaes pelo Esquema de Conceitos-chave para o estudo de todas as unidades desta
obra. Isso poder facilitar sua aprendizagem e seu desempenho.
4) Leia os livros da bibliografia indicada para que voc amplie seus horizontes tericos.
Coteje-os com o material didtico e discuta a unidade com seus colegas e com o tutor.
4. INTRODUO UNIDADE
Nesta primeira unidade, voc ter a oportunidade de estudar como os computadores so
organizados e quais so seus principais componentes fsicos e lgicos. Tais conceitos so essen-
ciais para a construo de programas de computadores.
Alm disso, ao longo desta unidade voc poder aprender quais so os principais elemen-
tos que compem a arquitetura de um computador, desde o processador at o sistema opera-
cional.
Voc conhecer, ainda, quais passos so necessrios para construir um programa e os
principais conceitos envolvidos nesse contexto, tais como: compiladores, linguagens de progra-
mao e ambientes de desenvolvimento.
5. ORGANIZAO DE COMPUTADORES
O principal objetivo de um computador realizar o processamento de grandes volumes
de dados. Considerando essa capacidade, eles executam milhares de operaes a velocidades
incrveis. Essas operaes so organizadas por meio de um conjunto de instrues que so cha-
madas de programas de computador.
Segundo Tanenbaum (2003), um programa determina quais aes so necessrias para
um computador realizar o processamento dos dados. Para que isso ocorra, os programas con-
tam com diversos tipos de instrues para manipulao de dados. Essas instrues so executa-
das por meio de um componente de hardware denominado processador.
O processador, por sua vez, considerado o crebro do computador; ele possui um con-
junto especfico de instrues que pode executar, e sua principal funcionalidade a transfor-
mao de dados, os quais ficam armazenados em um componente conhecido como memria
principal. A memria principal, ou memria RAM, um local em que o processador busca as
informaes e as instrues que devem ser executadas. Essa memria pode guardar qualquer
tipo de dados. No entanto, esses dados ficam disponveis apenas enquanto o computador esti-
ver ligado. Alternativamente, esses dados podem ser armazenados de maneira permanente por
meio da memria secundria, como, por exemplo, em discos rgidos.
Geralmente, o carregamento dos dados na memria do computador realizado por meio
de elementos conhecidos como dispositivos de entrada. Como exemplos desses dispositivos
de entrada, temos: teclado, mouse, digitalizadores (scanner), dentre outros. Em contrapartida,
a disponibilizao das informaes realizada por meio de componentes conhecidos como dis-
positivos de sada, tais como: monitores, impressoras etc.
A Figura 1 representa graficamente um computador e seus respectivos componentes.
U1 - Introduo Programao de Computadores 23
memria
secundria
dispositivos dispositivos
de entrada de sada
memria
principal
Figura 1 Representao dos principais componentes de um computador.
Sistemas operacionais
Um sistema operacional um programa de computador que possui caractersticas espe-
ciais, responsvel por gerenciar os recursos computacionais, alm de fornecer uma interface
entre os programas do usurio e o hardware do computador (Tanenbaum, 2003).
Todo usurio de computador utiliza algum tipo de sistema operacional, mesmo sem saber,
pois ele o primeiro programa executado quando o computador ligado. Os primeiros siste-
mas operacionais eram complexos e poucos usurios eram capazes de manipul-los. Entretanto,
hoje em dia, eles se tornaram mais simples e intuitivos, de forma que qualquer tipo de usurio,
desde uma criana at um adulto, pode oper-lo facilmente.
Existem diversos tipos de sistemas operacionais, cujas principais diferenas esto relacio-
nadas aos recursos que cada um disponibiliza aos usurios. Em geral, esses sistemas podem ser
divididos em dois grupos:
sistemas operacionais para uso domstico;
sistemas operacionais para uso comercial (servidores).
Veremos, a seguir, quais so os sistemas operacionais para uso domstico e para uso co-
mercial.
Os sistemas operacionais para uso domstico tm como principal caracterstica a facilida-
de de uso. Eles so adequados para usurios que no possuem grandes habilidades com com-
putadores. Nessa famlia de sistemas operacionais, podemos destacar:
Microsoft Windows (Figura 2).
Linux (Figura 3).
Mac OS (Figura 4).
Nas Figuras 2, 3 e 4, voc pode observar as imagens que representam cada um desses
sistemas operacionais.

Microsoft Windows
Figura 2 Sistema Operacional Microsoft Windows Vista.
A famlia de sistemas operacionais Microsoft Windows possui uma gama de programas

para auxiliar os usurios menos experimentes a utilizar o computador. Os principais sistemas
dessa famlia so: Windows 98, Windows XP e Windows Vista.
Linux
Figura 3 Sistema Operacional Linux, distribuio Suse.

Ultimamente, os sistemas operacionais Linux vm ganhando mercado, especialmente

pelo fato de serem gratuitos. H centenas de distribuies desse sistema operacional. Dentre as
principais, podemos citar: Suse, Red Hat, Ubuntu e Debian.
Mac OS
Figura 4 Sistema Operacional Mac OS.
O sistema operacional Mac OS distribudo pela Apple e muito utilizado por usurios
que precisam trabalhar com recursos grficos, como, por exemplo, processamento de imagens
e editorao de vdeo. A verso mais recente desse sistema operacional a Mac OS X.
O Quadro 1 apresenta os principais sistemas operacionais disponveis no mercado e seus
respectivos endereos na internet. Esses endereos so ricas fontes de informaes a respeito
de cada sistema operacional e foram acessados em 12 de mar. 2012.
Quadro 1 Principais sistemas operacionais para uso domstico.

SISTEMAS OPERACIONAIS PARA USO DOMSTICO
SISTEMA OPERACIONAL ENDEREO
Microsoft Windows (todos) <http://www.microsoft.com/brasil/windows/>
Microsoft Windows Vista <http://www.microsoft.com/brasil/windows/windows-vista/>
Linux Suse <http://www.suse.com/>
Linux Red Hat <http://www.redhat.com/>
Linux Ubuntu <http://www.ubuntu-br.org/>
Linux Debian <http://www.debian.org/>
Apple Mac OS X <http://www.apple.com/br/macosx/>

Agora, veremos os sistemas operacionais para uso comercial. Esses sistemas possuem as
mesmas caractersticas de um sistema operacional para uso domstico. No entanto, eles esto
preparados para gerenciar recursos computacionais de grande porte. Os sistemas operacionais
para uso comercial so geralmente conhecidos como sistemas operacionais para servidores.

Existem alguns sistemas operacionais que possuem verses para usurios domsticos e
tambm para servidores, como o caso do Windows e do Linux. Entretanto, alguns sistemas
operacionais so exclusivos para servidores, como, por exemplo, o Unix e o Solaris. A Figura 5
apresenta uma tela do sistema operacional Solaris.
O sistema operacional Solaris desenvolvido pela Sun Microsystems e da famlia Unix.
Inicialmente, era um sistema operacional proprietrio, mas atualmente possui uma verso gra-
tuita denominada OpenSolaris.
Figura 5 Sistema operacional Solaris.
O Quadro 2 apresenta os principais sistemas operacionais para servidores e seus respecti-

vos endereos na internet. Os endereos foram acessados em 26 mar. 2012.
Quadro 2 Principais sistemas operacionais para servidores.

SISTEMAS OPERACIONAIS PARA SERVIDORES
SISTEMA OPERACIONAL ENDEREO
Microsoft Windows Server <http://www.microsoft.com>
Linux Suse Enterprise <http://www.suse.com>
Linux Red Hat Enterprise <http://www.redhat.com/>
Unix <http://www.unix.org>
Solaris <http://www.sun.com/software/solaris/>
6. LINGUAGENS DE PROGRAMAO
Como vimos no incio desta unidade, os computadores so capazes de executar aes
que so especificadas por meio dos programas. Dessa forma, para que um computador realize
tarefas, necessrio que os programas sejam escritos em uma linguagem que ele entenda. Essa
linguagem conhecida como linguagem de programao.
Uma linguagem de programao permite que o computador seja programado para execu-
tar um conjunto determinado de aes. Com a linguagem de programao, podemos construir
programas para os mais variados propsitos, tais como: controlar o estoque de uma empresa,
analisar operaes financeiras de um banco, calcular a mdia entre duas notas de alunos, dentre
tantas outras.
Na prtica, o computador entende uma nica linguagem de programao, que conhe-
cida como linguagem de mquina. No entanto, essa linguagem pouco intuitiva para os seres
humanos, tornando quase impossvel o desenvolvimento de programas.
Segundo Deitel (2005), cada computador possui uma linguagem de mquina especfica,
que definida pelo seu projeto de hardware. Dessa forma, a programao de computadores por
meio da linguagem de mquina realizada utilizando instrues numricas, que so representa-
das por sequncias binrias de zeros (0s) e uns (1s). Alternativamente, essas sequncias podem
ser representadas em sistemas de numerao hexadecimal.
Observe, a seguir, uma instruo tpica em linguagem de mquina:
0100 1111 1010 0110
A instruo anterior poderia representar, por exemplo, a leitura de uma informao do

teclado, ou ainda a soma entre dois nmeros. Esse tipo de programao baseada em linguagem
de mquina complexo e tedioso, alm de ser pouco produtivo.
Alm disso, um programa escrito em linguagem de mquina no pode ser visualizado em
editores de texto comuns, como, por exemplo, o bloco de notas. Para visualizar os cdigos de
mquina de um programa, voc deve utilizar programas especficos, chamados de programas
editores binrios. O utilitrio debug, disponvel nas verses do Windows, um deles.
Por exemplo, para visualizar os cdigos de mquina do programa Paint, clique no menu
Iniciar, em seguida em Executar, digite o comando a seguir e veja a representao na Figura 6.
debug c:\windows\system32\mspaint.exe
Figura 6 Execuo do programa Debug.

Em seguida, digite o comando:
d 0 100
O resultado da execuo do programa Debug o demonstrado na captura de tela a seguir.
cdigos de mquina em hexadecimal.
Em seguida, pressione a tecla q (quit), e depois enter, para sair do programa.

Veja como "simples" escrever um programa em linguagem de mquina!
Para facilitar o desenvolvimento de programas, foi criado um conjunto de instrues, as
quais representam as operaes bsicas que um computador pode realizar. Assim, em vez de
utilizar uma sequncia numrica de difcil compreenso, o programador pode utilizar um con-
junto de nomes, conhecidos como mnemnicos. Essa linguagem baseada em abreviaes e
smbolos chamada de linguagem de montagem.
Um programa escrito em linguagem de montagem pode ser traduzido para linguagem de
mquina por meio de programas chamados de montadores ou assembler. Para ilustrar a criao
de programas utilizando a linguagem de montagem, observe o cdigo a seguir, o qual apresenta
a soma de dois nmeros. O programa soma os valores 100 e 200 e armazena-os em resultado
(adaptado de DEITEL, 2005).
1 load 100
2 add 200
3 store resultado
Certamente, o cdigo em linguagem montadora muito mais simples do que os cdigos

escritos em linguagem de mquina. No entanto, apesar da evoluo entre as linguagens, um
nmero grande de instrues era necessrio para executar as mais simples tarefas.
Para tornar mais simples a escrita de programas e acelerar o processo de desenvolvimen-
to, foram criadas as linguagens de alto nvel. Com essas linguagens, foi possvel agrupar conjun-
tos de instrues da linguagem de mquina em uma nica instruo.
Por exemplo, suponha que voc precise escrever uma determinada mensagem no mo-
nitor. Em linguagem de montagem, voc precisaria escrever um conjunto substancial de linhas
para executar essa tarefa. Entretanto, em uma linguagem de alto nvel, como, por exemplo, a
linguagem de programao C, voc tem uma nica instruo que realiza essa tarefa (printf).
Veja o cdigo a seguir, que ilustra como possvel escrever uma mensagem na tela utilizando a
linguagem C.

1 printf(Ol seja bem-vindo!);
Os programas de computador escritos em linguagem de alto-nvel so comumente cha-

mados de cdigo-fonte do programa, ou simplesmente cdigo-fonte. O cdigo-fonte de um
programa semelhante a um algoritmo. No entanto, enquanto o algoritmo escrito em pseu-
docdigo, o cdigo-fonte escrito utilizando as instrues da linguagem de programao esco-
lhida.
Para que o cdigo-fonte de um programa possa ser executado, preciso que ele seja trans-
formado em linguagem de mquina. Esse processo realizado por um programa especfico cha-
mado de compilador, que transforma o cdigo-fonte em cdigo-objeto. Na maioria das vezes,
esse cdigo compilado um arquivo executvel que pode ser reproduzido pelo sistema opera-
cional.
O cdigo-objeto possui todas as instrues necessrias para o processador executar o
programa. importante observar que o processo de compilao de um cdigo-fonte o torna
executvel apenas no sistema operacional em que ele foi compilado e, tambm, apenas para
uma famlia de processadores especficos. Isso significa que um programa compilado no sistema
operacional Windows XP, por exemplo, funcionar apenas nos sistemas operacionais da famlia
Windows, enquanto um programa compilado no sistema operacional Linux SUSE, funcionar
apenas nos sistemas operacionais baseados em Linux. Veja a Figura 7, que ilustra o processo de
compilao de um cdigo-fonte.
entrada
cdigo cdigo
sada
fonte objeto
Figura 7 Processo de compilao de um cdigo-fonte.
Na linguagem de programao C, por exemplo, o cdigo-fonte de um programa possui a

extenso .C (meuprograma.c) e o cdigo-objeto possui a extenso .obj (meuprograma.obj). Um
programa chamado de linkador transforma o arquivo objeto em executvel (meuprograma.
exe). A Figura 8 ilustra o processo de compilao na linguagem de programao C.

Figura 8 Processo de compilao de um cdigo-fonte na linguagem de programao C.
A seguir, apresentamos uma listagem com algumas linguagens de programao que reali-
zam a compilao do cdigo-fonte:
1) C;
2) C++;
3) Cobol;
4) Delphi (Object-Pascal);
5) Fortran;
6) Pascal;
7) Visual Basic.
Algumas linguagens de programao no executam o processo de compilao em seus c-

digos-fontes. Essas linguagens realizam um procedimento conhecido como interpretao. Para
isso, elas utilizam um programa chamado interpretador. Durante a interpretao, o cdigo-fon-
te analisado (ou traduzido) linha por linha e diretamente executado. Assim, a cada execuo
do programa, o cdigo-fonte precisa ser novamente interpretado, para que o resultado seja
reproduzido corretamente. A Figura 9 ilustra o processo de interpretao de um cdigo-fonte.
Figura 9 Processo de interpretao de um cdigo-fonte.

Veja, agora, algumas linguagens de programao que so interpretadas:

1) Basic;
2) Perl;
3) PHP;
4) Python;
5) Lisp.
importante salientar que algumas linguagens de programao executam os dois pro-
cessos, o de compilao e o de interpretao, para execuo dos programas. Em um primeiro
momento, o cdigo-fonte compilado e, em seguida, interpretado. Essa uma caracterstica
importante, pois torna os programas multiplataforma, ou seja, os programas podem ser exe-
cutados em vrios sistemas operacionais sem a necessidade de recompilao. Para a execuo
dos programas, essas linguagens utilizam um recurso conhecido como mquina virtual. Um
exemplo de linguagem compilada e interpretada a linguagem Java, que pode ser encontrada
no site <http://java.sun.com>.
7. AMBIENTES DE DESENVOLVIMENTO
Os ambientes de desenvolvimento integrados, do ingls Integrated Development Environment
(IDE), fornecem aos programadores todos os recursos necessrios para escrever e testar os pro-
gramas de computador.
Aprenderemos, tambm, a construir programas na linguagem de programao C. Precisa-
remos, ento, utilizar um ambiente de desenvolvimento integrado que suporte essa linguagem.
H dezenas de ambientes para programao para a linguagem C. Os principais so:
Netbeans (disponvel em: <http://www.netbeans.org/>. Acesso em: 12 mar. 2012).
O NetBeans um ambiente de desenvolvimento que suporta diversas linguagens;
muito utilizado para programao na linguagem Java, mas tambm oferece recursos
para desenvolvimento de programas na linguagem C. um ambiente de desenvolvi-
mento gratuito e de cdigo-fonte aberto, distribudo pela empresa Sun Microsystems
(disponvel em: <http://www.sun.com/>. Acesso em: 12 mar. 2012). Alm disso, um
ambiente multiplataforma, o que significa que funciona em qualquer sistema opera-
cional, como, por exemplo, Windows e Linux.
Code::Blocks (disponvel em: <http://www.codeblocks.org/>. Acesso em: 12 mar. 2012).
O Code::Blocks, ou simplesmente C::B, um ambiente de desenvolvimento integrado
para as linguagens C e C++. um ambiente multiplataforma, gratuito e de cdigo-
-fonte aberto, possuindo verses para Windows e Linux.
Microsoft Visual C++ Express Edition (disponvel em: <http://www.microsoft.com/
Express/vc/>. Acesso em: 12 mar. 2012).
O Visual C++ Express Edition o ambiente para desenvolvimento da Microsoft para
construes de programas na linguagem C e C++. A expresso "Express Edition refe-
re-se a um conjunto de ambientes para desenvolvimento que a Microsoft disponibiliza
de forma gratuita.
Outros ambientes de desenvolvimento, no menos importantes, so:
Dev-C++ (disponvel em: <http://www.bloodshed.net/devcpp.html>. Acesso em: 12
mar. 2012).

Eclipse for C/C++ Developers (disponvel em: <http://www.eclipse.org/>. Acesso em:

12 mar. 2012).
Borland C++ (disponvel em: <http://www.codegear.com/downloads/free/cppbuilder>.
Acesso em: 12 mar. 2012).
Neste estudo, voc poder utilizar o ambiente de desenvolvimento de sua preferncia.
Para facilitar a instalao e configurao do ambiente, so apresentados os procedimentos para
dois ambientes: NetBeans e Code::Blocks.
O ambiente NetBeans oferece suporte completo ao desenvolvimento de aplicaes em
diversas linguagens. Sua instalao um pouco complexa, mas funciona perfeitamente em di-
versos sistemas operacionais. J o ambiente Code::Blocks possui um processo de instalao
simplificado, sendo indicado para o desenvolvimento dos exemplos e exerccios ao longo deste
estudo.
Instalao e configurao do ambiente Netbeans

Agora, voc ter a oportunidade de aprender a instalar e a configurar o ambiente Netbe-
ans. Para isso, fique atento s explicaes e siga os passos corretamente.
Inicialmente, voc dever fazer alguns downloads. Veja, a seguir, os endereos em que
esto disponveis. Todos os sites foram acessados em 12 de maro de 2012.
Java SE Development Kit
<http://java.sun.com/javase/downloads/>
NetBeans
<http://www.netbeans.org/downloads/index.html>
Compilador da linguagem C
MinGW: <http://prdownloads.sourceforge.net/mingw/MinGW-3.1.0-1.exe?download>
MSYS: <http://downloads.sourceforge.net/mingw/ MSYS-1.0.10.exe>
Em seguida, vamos iniciar a instalao do Java SE Development Kit. Para tanto, siga os
passos a seguir.
1) Acesse o endereo <http://java.sun.com/javase/downloads/> e selecione Java SE
Development Kit (Figura 10).
Figura 10 Site para download do Java SDK.
2) Selecione o sistema operacional, Windows ou Linux, e, em seguida, clique no item I

agree to the...; finalmente, clique no boto Continue (Figura 11).
Figura 11 Seo da Plataforma do Java SDK.

3) Clique no link para download do programa. Quando a janela de download aparecer,

selecione a opo para salvar o arquivo no disco (Figura 12).
Figura 12 Download do Java SDK.
4) Depois de terminado o download, clique duas vezes em cima do arquivo de instalao.

Voc no precisa alterar nenhum tipo de configurao na instalao do JDK; assim,
voc pode clicar seguidas vezes no boto Prximo (next), at a instalao comear. Ao
final, voc visualizar a tela exibida na Figura 13.
Figura 13 Instalao do Java SDK.
Instalao do NetBeans
1) Acesse o endereo <http://www.netbeans.org/downloads/index.html> e selecione a
opo de download do NetBeans para C/C++ (Figura 14).
Figura 14 Download do ambiente NetBeans.
2) Depois de terminado o download, clique duas vezes no arquivo de instalao. A ins-

talao bastante simples e no necessita de configuraes adicionais. Dessa forma,
clique para aceitar os termos de licena e, em seguida, clique no boto Prximo at
visualizar a tela de instalao da Figura 15.
Figura 15 Instalao do programa NetBeans.
3) O ambiente de desenvolvimento NetBeans foi perfeitamente instalado.

Instalao do compilador para linguagem C

1) Faa o download dos programas necessrios e salve os arquivos em uma pasta.
MinGW (disponvel em: <http://prdownloads.sourceforge.net/mingw/Min-
GW-3.1.0-1.exe?download>. Acesso em: 13 mar. 2012). Faa o download do arqui-
vo.
MSYS (disponvel em: <http://downloads.sourceforge.net/mingw/MSYS-1.0.10.
exe>. Acesso em: 13 mar. 2012).
2) Depois de terminado o download, clique duas vezes no arquivo MinGW-3.1.0-1.exe.
A instalao do programa muito simples: basta aceitar os termos e clicar no boto
Next para instalar. Ao final, voc visualizar a tela apresentada na Figura 16.
Figura 16 Tela de instalao do programa MinGW.
3) O prximo passo a instalao do programa MSYS-1.0.10.exe. A instalao tambm

bastante simples. Em determinando momento, ser necessrio preencher algumas
informaes. Na primeira pergunta, digite y, conforme ilustrado na Figura 17.
Figura 17 Instalao do programa MSYS.

4) Digite novamente y para a prxima pergunta, conforme apresentado na Figura 18.
5) Finalmente, devemos especificar o diretrio de instalao do MinGW. Para isso, digite

o diretrio da seguinte forma: c:/MinGW (conforme ilustrado na Figura 19).
6) Com isso, o compilador est devidamente instalado.
Configurao do Compilador C no NetBeans

1) No NetBeans, clique no menu Ferramentas, Opes. Em seguida, no menu, selecione
C/C++, e, finalmente, clique no boto Adicionar. Na janela aberta (Figura 20), selecio-
ne o local de instalao dos arquivos binrios do MinGW, que so instalados por pa-
dro em c:\MinGW\bin. Clique, ento, no boto OK. O resultado pode ser visualizado
na Figura 21a.

Figura 20 Configurao do compilador C no ambiente NetBeans.
Figura 21a Configurao do compilador C no ambiente NetBeans.
2) Caso seja necessrio, voc pode configurar o Comando Make, informando o diretrio
de instalao (Figura 21b).
Figura 21b Diretrio de instalao do programa Make.
3) Finalmente, o ambiente est devidamente configurado.
Criao e compilao de um programa na linguagem C

1) Com o NetBeans aberto, clique no menu Arquivo, Novo Projeto...; voc visualizar a
tela apresentada na Figura 22.
Figura 22 Criando um novo projeto C.
2) Na janela Novo Projeto, selecione a categoria C/C++, e, em projetos (lado direito) se-
lecione Aplicativo de C/C++. Clique no boto Prximo. Especifique o nome do projeto.
Por exemplo, MeuPrimeiroProjeto, e clique no boto Finalizar.
3) Com o novo projeto criado, clique com o boto direito do mouse em Arquivos de
cdigo-fonte. Selecione a opo Novo, e, em seguida, clique em Arquivo C Principal
(Figura 23).

Figura 23 Criando um Novo Arquivo C Principal.
4) Na janela Novo Arquivo C Principal, defina o Nome do Arquivo. Por exemplo:

MeuPrimeiroPrograma. Clique no boto Finalizar. Seu ambiente de desenvolvimento
ser semelhante ao da Figura 24.
Figura 24 Primeiro programa no ambiente de desenvolvimento NetBeans.
5) No cdigo-fonte do programa MeuPrimeiroPrograma.C, faa as alteraes necessrias

para que o cdigo seja semelhante ao programa a seguir:
6) Finalmente, vamos executar o programa implementado. Para isso, clique no menu

Executar, Executar Main Project... ou simplesmente pressione a tela F6. O resultado
apresentado na captura de tela a seguir:
7) Com isso, seu ambiente est pronto para escrever novos programas!
Instalao e configurao do ambiente Code::Blocks

Agora, voc poder aprender a instalar e a configurar o ambiente Code::Blocks. Para isso,
importante ficar atento s explicaes e seguir os passos corretamente.
Inicialmente, necessrio fazer o download do Code::Blocks com Compilador MinGW, no
endereo <http://downloads.sourceforge.net/codeblocks/codeblocks-8.02mingw-setup.exe>.
Acesso em: 13 mar. 2012.
Em seguida, vamos iniciar a instalao do Code::Blocks passo a passo.
1) Acesse o endereo <http://www.codeblocks.org/downloads/5> para fazer o download
do Code::Blocks e selecione a verso desejada. Alternativamente, voc pode acessar
diretamente o link para download <http://downloads.sourceforge.net/codeblocks/co-
deblocks-8.02mingw-setup.exe>

2) Depois de terminado o download, clique duas vezes no arquivo de instalao do

Code::Blocks. Assim, a tela inicial de instalao ser apresentada. Em seguida, clique
no boto Next (Figura 25).
Figura 25 Instalao do programa Code::Blocks.
3) Aceite os termos de licena clicando no boto I Agree e, em seguida, clique no boto

Next. Finalmente, aparecer o boto Install. Clique nesse boto para iniciar a instala-
o do programa (Figura 26).
Figura 26 Instalao do programa Code::Blocks.

4) Terminada a instalao, voc pode executar o ambiente. Na primeira vez que o am-
biente for executado, selecione qual compilador C ser utilizado na gerao dos pro-
gramas. Selecione o GNU GCC Compiler e, em seguida, clique em OK (Figura 27).
Figura 27 Seleo do compilador para o programa Code::Blocks.
5) A tela inicial do Code::Blocks dever ser semelhante da Figura 28.
Figura 28 Ambiente de desenvolvimento Code::Blocks.
6) Dessa forma, seu ambiente de desenvolvimento est pronto para voc escrever pro-
gramas na linguagem C.

Criao e compilao de um programa na linguagem C

1) Com o programa Code::Blocks aberto, clique no menu File, New Project...
2) Selecione o projeto Console application e, em seguida, clique no boto Go, conforme
demonstra a Figura 29.
Figura 29 Criando novos projetos Console Application.
3) Na primeira vez que um novo projeto criado, voc visualizar a tela mostrada na
Figura 30. Selecione a opo "Skip this page next time e clique em Next.

4) Selecione projetos do tipo C e, em seguida, clique em Next (Figura 31).
5) Na Figura 32, esto ilustrados a definio, o ttulo do projeto (Project Title) e a pasta
na qual o projeto ser criado (Folder to create project in). Finalmente, clique em Next.
6) Verifique se o compilador selecionado o GNU GCC Compiler (Figura 33).

7) Pronto! Seu primeiro projeto na linguagem C est criado. O arquivo que contm o
cdigo-fonte do programa pode ser visualizado na guia Projects, do lado esquerdo
(Figura 34).
Figura 34 Estrutura de um projeto Console Application.

8) Para executar a aplicao, voc pode, alternativamente, utilizar o cone na barra de

menus, conforme demonstra a seta na Figura 35, ou selecionar o menu Build, Build
and Run ou, ainda, pressionar a tecla F9.
Figura 35 Execuo de programas no Code::Blocks.
9) O resultado da aplicao apresentado na captura de tela a seguir.
8. QUESTES AUTOAVALIATIVAS
Sugerimos que voc procure responder, discutir e comentar as questes a seguir que
tratam da temtica desenvolvida nesta unidade.
A autoavaliao pode ser uma ferramenta importante para voc testar o seu desempenho.
Se voc encontrar dificuldades em responder a essas questes, procure revisar os contedos
estudados para sanar as suas dvidas. Esse o momento ideal para que voc faa uma reviso
desta unidade. Lembre-se de que, na Educao a Distncia, a construo do conhecimento
ocorre de forma cooperativa e colaborativa; compartilhe, portanto, as suas descobertas com os
seus colegas.
Confira, a seguir, as questes propostas para verificar o seu desempenho no estudo desta
unidade:
1) O que um programa de computador?
2) Qual a funo do processador e qual sua relao com os programas de computador?

3) Reflita sobre a diferena entre memria principal e memria secundria.
4) Conceitue e apresente exemplos de dispositivos de entrada e dispositivos de sada.
5) O que so sistemas operacionais?
6) Os computadores so capazes de executar aes que so especificadas por meio dos programas. Dentro deste
contexto, o que linguagem de programao?
7) Relacione linguagem de mquina e linguagem de montagem. Pensando nas duas definies, investigue: o que
so montadores ou assemblers?
8) Considerando a elaborao de um programa de computador, explique o que o cdigo-fonte do programa.
9) Qual a utilidade de um compilador?
10) Reflita sobre a diferena entre o cdigo-objeto e o cdigo-fonte.
11) Compare o processo de compilao de um cdigo-fonte e o processo de compilao de um cdigo-fonte na

linguagem de programao C.
12) Apresente pelo menos trs exemplos de linguagens de programao compiladas.
13) O que interpretador? Explique o processo de interpretao de um cdigo-fonte.
14) Apresente pelo menos trs exemplos de linguagens de programao interpretadas.
15) Explique o processo de criao e compilao de um programa na linguagem C utilizando o ambiente Code::Blocks.
9. CONSIDERAES
Terminamos o estudo da primeira unidade! Nela, voc teve a oportunidade de aprender
os principais conceitos sobre organizao de computadores, sistemas operacionais e linguagens
de programao. Alm disso, conheceu os procedimentos para a instalao e configurao do
ambiente de desenvolvimento integrado para programao na linguagem C. Esse ambiente ser
fundamental para o estudo das prximas unidades, nas quais escreveremos diversos programas
na linguagem C.
10. REFERNCIAS BIBLIOGRFICAS

DEITEL, H. M. Java: como programar. 6. ed. So Paulo: Prentice-Hall, 2005.
TANENBAUM, A. S. Sistemas operacionais modernos. 2. ed. So Paulo: Prentice-Hall, 2003.
Fundamentos da Linguagem
de Programao C
1. OBJETIVOS
Elaborar programas com a linguagem de programao C.
Criar programas que possibilitem a exibio e o recebimento de informaes digitadas
pelo usurio.
Criar programas que utilizem expresses aritmticas e lgicas.
2. CONTEDOS
Introduo linguagem de programao C.
Comandos de entrada e sada.
Expresses aritmticas.
Expresses lgicas.
Bibliotecas (math.h e string.h).
Exerccios resolvidos (transformando algoritmos em programas).

guir:
1) Antes de iniciar o estudo desta unidade, essencial que voc tenha instalado e con-
figurado o ambiente de desenvolvimento. Para facilitar a instalao, sugerimos que
opte pelo ambiente Code::Blocks.
2) Para o estudo desta unidade, sugerimos que voc leia o Captulos 1, Conceitos bsi-
cos e o Captulo 2, Estrutura sequencial, da obra: ASCENCIO, A. F. G. Fundamentos
da programao de computadores: algoritmos, Pascal e C/C++. So Paulo: Prentice
Hall, 2002.
3) Ao final da unidade, voc encontrar um conjunto de exerccios resolvidos. funda-
mental para seu aprendizado que voc os codifique no ambiente de sua preferncia.
Para verificar o funcionamento correto dos programas, voc pode comparar a sada da
implementao realizada por voc com as sadas ao final de cada algoritmo, indicadas
como "Resultado da execuo do programa".
4. INTRODUO UNIDADE
Nesta unidade, iniciaremos nosso estudo sobre o desenvolvimento de programas utili-
zando a linguagem de programao C. Antes de comearmos, fundamental que voc j tenha
instalado e configurado seu ambiente de desenvolvimento (os passos para instalao esto des-
critos na Unidade 1).
Veremos, agora, um pouco de histria.
A linguagem de programao C, ou simplesmente linguagem C, foi inventada e implemen-
tada na dcada de 1970 por Dennis Ritchie. Inicialmente, foi utilizada para o desenvolvimento de
programas para o sistema operacional Unix. Essa linguagem nasceu a partir de uma linguagem
mais antiga chamada BCPL (desenvolvida por Martin Richards), que influenciou outra linguagem
chamada B (inventada por Ken Thompson). A evoluo da linguagem B levou ao desenvolvimen-
to da linguagem C (SCHILDT, 1997).
A linguagem C permite a construo de programas em diversos sistemas operacionais,
como Windows, Linux, Unix, Solaris etc. No entanto, ela no multiplataforma, o que significa,
por exemplo, que os programas para Windows no funcionam em outros sistemas operacionais.
Para que um programa escrito em Windows funcione em outros sistemas operacionais, ele pre-
cisa ser recompilado.
Para conhecer um pouco mais sobre a linguagem C, ao longo desta unidade teremos a
oportunidade de iniciar os conceitos introdutrios para a construo de programas que a utili-
zam. Para isso, veremos desde os principais conceitos para entrada e sada de informaes at
os operadores aritmticos e lgicos.
Dessa forma, observaremos, finalmente, como possvel transformar algoritmos em pro-
gramas.
Bom estudo!
5. ESTRUTURA BSICA DE UM PROGRAMA NA LINGUAGEM C

Para um programa funcionar corretamente, necessrio um conjunto mnimo de instru-
es. Na linguagem C, um programa deve possuir, no mnimo, a seguinte estrutura:
1 #include <stdio.h>
2
3 main()
4 {
5 printf(Meu primeiro programa!);
6 }
U2 Fundamentos da Linguagem de Programao C 51
Resultado da execuo do programa:

Meu primeiro programa!
A primeira linha do programa contm uma instruo utilizada para a incluso de bibliote-
cas. As bibliotecas, por sua vez, possuem funes que o programador pode utilizar para facilitar
o desenvolvimento do seu programa. Por exemplo, a linguagem C possui uma biblioteca espec-
fica para funes matemticas (math.h). Nessa biblioteca, voc encontra funes para calcular
raiz quadrada, seno, cosseno, tangente, logaritmo, dentre outras.
Suponha que voc est construindo um programa para calcular a raiz quadrada de um
nmero. Com a utilizao da biblioteca matemtica, no preciso estudar como a raiz quadrada
de um nmero calculada. Em vez disso, voc apenas utiliza a funo para o clculo da raiz qua-
drada (sqrt). Essa funo calcula a raiz e retorna o resultado. Simples, no?!
Depois de declaradas as bibliotecas, um programa em C deve obrigatoriamente possuir
uma funo principal (main). A funo principal (ou bloco principal) responsvel por determi-
nar o local em que os comandos do programa so escritos.
Para definirmos um bloco principal, utilizamos a instruo main(), seguida de um smbolo
de abre chaves {. A partir desse ponto, todas as instrues para o funcionamento do programa
devem ser definidas. Ao final das instrues, devemos fechar o bloco principal, com o smbolo
de fecha chaves }.
O comando printf (Linha 5 da estrutura anterior) uma das principais instrues da lin-
guagem C. Por meio dele, podemos exibir informaes na tela. Esse comando pode ser utilizado
diversas vezes ao longo do programa.
O programa a seguir demonstra uma verso alternativa para uma estrutura bsica de
um programa na linguagem C. Veja no exemplo que, em vez de utilizarmos apenas a instruo
main(), usamos, tambm, int main(). Alm disso, uma instruo return 0 foi adicionada ao pro-
grama.
comum desenvolvermos programas que executam funes e retornam resultados. Em
geral, esses resultados so retornados para o sistema operacional. Quando definimos o bloco
principal como int main(), significa que o resultado da execuo desse bloco ser um nmero in-
teiro. J a instruo return 0 indica que o valor 0 retorna com a execuo do programa. Convm
ressaltar que poderamos utilizar qualquer valor de retorno.
Assim, quando escrevemos programas na linguagem C que no retornam valores, pode-
mos receber mensagens de aviso durante o processo de compilao. Isso ocorre, pois alguns
compiladores utilizam as especificaes definidas pela ANSI (American National Standards
Institute). Segundo a ANSI, a estrutura bsica de um programa na linguagem C deve conter as
seguintes instrues:
2
3 int main()
4 {
5 printf(Meu segundo programa! \n);
6 return 0;
7 }


Meu segundo programa!
Na estrutura bsica apresentada anteriormente, a Linha 1 especifica a biblioteca que ser

utilizada no programa. Para incluir bibliotecas nos programas, precisamos utilizar a diretiva
#include <nome_da_biblioteca>. A instruo include chamada de diretiva de pr-proces-
samento.
No exemplo, foi includa a biblioteca stdio.h, a qual contm um conjunto de funes para
entrada e sada de informaes. Ao longo do curso, estudaremos diversas bibliotecas da lingua-
gem C.
O comando utilizado na Linha 5, printf, um comando para exibir informaes na tela
(sada); por isso, para utilizarmos esse comando, precisamos, necessariamente, da biblioteca
stdio.h.
A Linha 3 determina o bloco principal do programa, com a instruo int main(). Na Linha 4,
definido o incio do programa {, e, na Linha 7, o fim }. As Linhas 5 e 6 representam o bloco de
comandos do programa. Esse programa muito simples, pois apenas exibe a mensagem Meu
segundo programa! na tela.
Ao comparar algoritmos e programas, podemos fazer algumas correspondncias. Veja no
Quadro 1.
Quadro 1 Comparaes entre algoritmos e programas.

ESTRUTURA BSICA
ALGORITMO PROGRAMA
inicio {
fimalgoritmo }
Pensando na estrutura bsica de um algoritmo, voc pde observar algumas correspon-

dncias com um programa.
6. TIPOS DE DADOS E VARIVEIS

Os programas tm como objetivo principal a manipulao de dados, os quais possuem
tipos especficos em funo das caractersticas das informaes que armazenam.
Observe, a seguir, os principais tipos de dados da linguagem C:
1) int: o tipo de dado mais comum da linguagem C. utilizado para armazenar nme-
ros inteiros, positivos, negativos ou iguais a zero. O tipo int tem tamanho de 16 bits
(ou 2 bytes), o que representa o espao necessrio para armazenar uma informao
desse tipo na memria principal.
Assim, se armazenarmos uma informao do tipo int na memria, significa que esta-
mos ocupando 16 bits do seu espao. J se armazenarmos dez informaes do tipo int,
estaremos ocupando 160 bits (10 * 16 bits) de memria (20 bytes).
2) char: esse tipo de dado utilizado para armazenar e manipular caracteres. Os carac-
teres na linguagem C so representados por meio de aspas simples, por exemplo, 'a',
'b', 'c' etc. O tipo de dado char ocupa 8 bits (1 byte) de memria.
3) float: esse tipo de dado utilizado para manipulao de nmeros reais. Um nmero
real aquele que pode possuir uma parte decimal, ou seja, nmeros com casas deci-
mais, por exemplo: 5,32; 10,28; -15,19; 0,93. Um dado do tipo float ocupa 32 bits (4
bytes) de memria e possui 6 dgitos de preciso (0.123456).
Vale ressaltar que os nmeros so especificados segundo o padro americano. Portan-
to, a separao de casas decimais realizada por meio de ponto (.) e no de vrgula
(,), como estamos acostumados no padro brasileiro. Por exemplo, o valor real 324,56
deve ser especificado como 324.56.
4) double: esse outro tipo de dado que pode ser utilizado para armazenar valores reais.
A principal diferena entre o tipo float e double com relao preciso. Enquanto o
tipo float possui seis dgitos de preciso, o tipo double tem preciso de at 10 dgitos
(0.1234567890).
Nesse caso, o armazenamento de uma informao em memria com o tipo double
ocupa 64 bits (8 bytes).
5) void: esse tipo de dado utilizado para representar ausncia de valor. No comum
associarmos o tipo void a uma determinada informao dentro do programa. Ele
mais utilizado para definir valores de retorno de funes ou para criao de ponteiros.
Esses tpicos sero aprofundados nas prximas unidades.
O Quadro 2 apresenta os principais tipos de dados da linguagem C. Observe.
Quadro 2 Tipos de dados da linguagem C.

PRINCIPAIS TIPOS DE DADOS
TIPO DE DADOS TIPO DE DADOS TAMANHO EXEMPLO
LINGUAGEM C ALGORITMO APROXIMADO
int inteiro 2 bytes 523
0
892
char caractere 1 byte a
4
$
float real 4 bytes 5.234432
0.9123453
9832.332
double real 8 bytes 1.234823882
0.00003234
29382.232423
void - - -
Recursos utilizados na construo de programas
Variveis
Um programa de computador manipula constantemente informaes armazenadas na
memria principal (RAM). Para que isso seja possvel, cada posio da memria possui um en-
dereo nico. Assim, os programas podem facilmente acessar as informaes.
Uma varivel a principal forma de manipulao de informaes dentro dos programas.
Cada uma possui um nome que representa uma posio especfica na memria do computador,
o que facilita a manipulao dos dados, uma vez que no precisamos guardar os endereos re-
ferentes s posies em que os dados se encontram na memria.

Ao longo da execuo do programa, uma varivel, como o prprio nome indica, pode ter
seu valor modificado. A alterao do valor contido em uma varivel realizada por meio do ope-
rador de atribuio. Esse operador representado pelo smbolo de igualdade (=).
Dentro da estrutura bsica de um programa escrito na linguagem de programao C, a
declarao das variveis sempre deve ser realizada dentro do bloco principal do programa, logo
aps o smbolo de abre chaves {, que indica o incio do bloco.
Para declararmos uma varivel, sempre devemos indicar, inicialmente, qual o seu tipo
(int, char, float, double etc.), e, em seguida, qual o seu nome. Tambm no podemos nos es-
quecer de inserir um smbolo de ponto-e-vrgula ao final da instruo. A sintaxe da declarao
de variveis definida do seguinte modo:
<tipo_da_varivel> <nome_da_varivel>;
No comando de atribuio, o nome da varivel que receber o valor deve sempre ser co-
locado ao lado esquerdo do operador de atribuio. Do lado direito, devemos especificar qual
valor, ou expresso, ser armazenado na varivel. Por fim, devemos inserir o smbolo de ponto-
-e-vrgula para indicar o final da instruo. O comando de atribuio possui a seguinte sintaxe:
<nome_da_varivel> = <valor> ou <operao>;
O Cdigo 1, do programa a seguir, tem como objetivo ilustrar a declarao de variveis,

alm da utilizao do comando de atribuio.
cdigo 1
1 /*
2 * Programa para exemplificar a declarao
3 * de variveis e a atribuio de valores.
4 *
5 * Autor: Joo da Silva
6 */
7
8 //declarao das bibliotecas
10
11 int main()
12 {
13 // declarao das variveis
14 int idade;
15
16 //atribui o valor 22 varivel idade
17 idade = 22;
18
19 //exibe o valor da varivel na tela
20 printf(Idade = %i \n, idade);
21
22 return 0;
23 }
fim cdigo 1

Idade = 22
As linhas de 1 a 6 do Cdigo 1 so utilizadas para descrever qual a funcionalidade do

programa e tm apenas carter informativo. Esse conjunto de linhas representa um comentrio
e no interfere na execuo do programa. Os comentrios so essenciais para documentar o
cdigo-fonte do programa e so recursos essenciais para uma boa prtica de programao.
Na linguagem C, existem dois tipos de comentrios:
comentrios de mltiplas linhas: que so delimitados pelo bloco /* e */, que
indicam, respectivamente, o incio e o final do comentrio. Por exemplo, como foi
definido nas linhas de 1 a 6.
comentrios de uma nica linha: que podem ser especificados pelas barras
duplas //. Observe, no exemplo anterior, as Linhas 8, 13, 16 e 19, que representam
comentrios de uma nica linha.
A Linha 14 ilustra como deve ser realizada a declarao de uma varivel. Note que essa
declarao segue a sintaxe definida anteriormente, na qual devemos inicialmente especificar o
tipo de dados, que, nesse caso, int (inteiro), e, em seguida, o nome da varivel (que foi definida
como idade).
Na Linha 17, demonstrada a atribuio de um valor a uma varivel previamente declarada.
Veja que, para isso, necessrio utilizarmos o comando de atribuio com o operador igual (=).
Nesse caso, o valor 22 foi atribudo varivel idade.
O comando da Linha 20 uma instruo para exibir informaes na tela e ser detalhado
em breve.
No Cdigo 2, voc pode ver mais um programa, o qual ilustra outro exemplo de declarao
de variveis. Neste exemplo, podemos notar que variveis de um mesmo tipo de dados podem
ser declaradas na mesma linha. Alm disso, podemos notar, que possvel atribuir o valor de
uma varivel a outra varivel.
cdigo 2
1 /*
2 * Programa para exemplificar a declarao
3 * de diversas variveis do mesmo tipo e a
4 * atribuio de valores de uma varivel
5 * outra varivel.
6 *
8 */
9
12
13 int main()
14 {
16 int a,b,c;
17

18 // atribuio de valores s variveis

19 a = 10;
20 b = 20;
21 c = 30;
22
23 //exibe o valor das variveis na tela
24 printf(A = %i \n, a);
25 printf(B = %i \n, b);
26 printf(C = %i \n, c);
27
28 // atribuio do valor das variveis
29 a = b; // a recebe o valor 20
30 b = c; // b recebe o valor 30
31 c = a; // c recebe o valor 20
32
37
38 return 0;
39 }
fim cdigo 2
A = 10
B = 20
C = 30
A = 20
B = 30
C = 20
Veja que, no Cdigo 2, na Linha 16, so declaradas trs variveis do tipo int. Como essas
variveis so do mesmo tipo, no precisamos declar-las em linhas separadas, como mostrado
a seguir:
16 int a;
17 int b;
18 int c;
Da forma como foi declarada na Linha 16, economizamos algumas linhas de cdigo. Entre-
tanto, essa simplificao pode ser realizada apenas com variveis do mesmo tipo.
Nas linhas de 19 a 21, so realizadas as atribuies de valores s variveis a, b, c, respecti-
vamente, 10, 20 e 30. Nas linhas de 24 a 26, os valores armazenados nas variveis so exibidos
na tela.
As linhas de 29 a 31 ilustram outra maneira de atribuio, na qual, em vez de atribuir valo-
res diretamente, foram atribudos os valores contidos nas variveis. Esse tipo de atribuio ser
muito utilizado ao longo dos exemplos que estudaremos.
importante ressaltar que, quando declaramos uma varivel dentro de um programa,

imprescindvel atribuir algum valor a essa varivel antes de realizarmos qualquer operao. Na
linguagem C, quando uma varivel declarada, ela recebe um valor aleatrio, que comumente
descrito como lixo de memria. Vejamos um exemplo, no Cdigo 3:
cdigo 3
1 /*
2 * Programa para exemplificar a importncia
3 * da atribuio de valores s variveis.
4 *
6 */
7
10
11 int main()
12 {
14 int a;
15
18
19 return 0;
20 }
fim cdigo 3
Note que, nesse exemplo, uma varivel do tipo inteiro declarada (Linha 14), porm,
nenhum valor atribudo a ela. Em seguida, na Linha 17, o contedo dessa varivel exibido
na tela. Quando executamos esse programa pela primeira vez, temos o seguinte resultado (o
resultado pode variar de computador para computador):

A = 2147299328
Se executarmos esse programa novamente, as seguintes informaes so exibidas na tela:

A = 2147303424
Veja que, cada vez que o programa executado, a varivel a recebe um valor diferente.
Esse fato demonstra que as variveis, quando so criadas, possuem um valor aleatrio. Por isso,
fundamental que sejam atribudos valores a todas as variveis declaradas.
Outra maneira de atribuir valores s variveis durante sua declarao. Dessa forma, po-
demos declarar e inicializar o valor da varivel. O Cdigo 4 do programa a seguir demonstra
como possvel atribuir valores s variveis durante a sua declarao.

cdigo 4
1 /*
2 * Programa para exemplificar como possvel
3 * declarar e inicializar o valor de uma varivel
4 *
6 */
7
10
11 int main()
12 {
14 int a = 10;
15 int b = 20, c = 30;
16
21
22 return 0;
23 }
fim cdigo 4

A = 10
B = 20
C = 30
Constantes
As constantes so um recurso utilizado na construo dos programas para definir que uma
determinada informao no pode ter seu valor alterado. como se voc atribusse um valor a
uma varivel e esse valor no pudesse ser modificado ao longo da execuo do programa.
A declarao de uma constante segue praticamente a mesma sintaxe da declarao de
uma varivel. No entanto, precisamos adicionar a palavra reservada const antes do tipo da vari-
vel. Assim, a sintaxe de uma constante tem a seguinte estrutura:
Const <tipo_da_varivel> <nome_da_constante> = valor;
O Cdigo 5 ilustra a utilizao de constantes na construo de programas.

cdigo 5
1 /*
2 * Programa para exemplificar a utilizao
3 * de constantes
4 *
6 */
7
10
11 int main()
12 {
13 // declarao da constante
14 const int a = 10;
15
16 //exibe o valor na tela
18
19 return 0;
20 }
fim cdigo 5

A = 10
Na Linha 14, temos a definio de uma constante do tipo inteiro denominada a. Note que,
alm de especificarmos o nome da constante, temos de definir, tambm, qual valor est asso-
ciado a ela. A atribuio de um valor a uma constante pode ser realizada apenas no ato da sua
declarao.
A tentativa de atribuir um valor a uma constante em outras partes do programa gera um
erro de compilao, e, com isso, o programa no pode ser executado. Por exemplo, se adicionar-
mos a instruo a seguir na Linha 15 do programa, o cdigo-fonte no ser compilado.
15 a = 20;
Uma mensagem de erro semelhante a essa ser exibida pelo compilador:
Mensagem de erro do compilador (ambiente

Code::Blocks):
C:\Programas\exemplo.c||In function `main:|
C:\Programas\exemplo.c |15|error: assignment of
read-only variable `a|
||=== Build finished: 1 errors, 0 warnings ===|
A mensagem indica que foi atribudo um valor a uma varivel somente de leitura, ou seja,
uma constante.

Identificadores
Os nomes utilizados para definir variveis e constantes so chamados de identificadores.
Esses nomes, tambm, sero utilizados para especificar os nomes de funes, o que aprende-
remos nas prximas unidades.
importante observar que a linguagem de programao C faz diferena entre letras mai-
sculas e minsculas. Isso significa que um identificador definido com letras minsculas, por
exemplo, idade, diferente de um identificador especificado com letras maisculas, tal como
IDADE. O termo comumente utilizado para diferenciao de maisculas e minsculas case-
-sensitive.
Por exemplo, as linhas a seguir representam trs variveis que, apesar de possurem o
mesmo nome de identificao, so consideradas diferentes pela linguagem de programao C.
1 int numero;
2 int Numero;
3 int NUMERO;
O Quadro 3 apresenta alguns exemplos de identificadores vlidos na linguagem de pro-

gramao C.
Quadro 3 Exemplos de identificadores vlidos da linguagem C.

IDENTIFICADORES VLIDOS NA LINGUAGEM C
NOME DO IDENTIFICADOR EXEMPLO DE UTILIZAO
A int A;
a a = 246;
numero int numero = 5;
Numero int Numero = 20;
A32 A32 = a;
usuario_01 usuario_01 = 23;
IDADE IDADE = 25;
$ano $ano = 2009;
Conhea, a seguir, no Quadro 4, alguns exemplos de identificadores que no so vlidos.
Quadro 4 Exemplos de identificadores invlidos da linguagem C.

IDENTIFICADORES QUE NO SO VLIDOS NA LINGUAGEM C
NOME DO IDENTIFICADOR PROBLEMA
5b Comear com um nmero
e 12 Conter um espao em branco
x-y Conter um caractere especial, o smbolo -
nota() Conter caracteres especiais ()
main Utilizar uma palavra reservada
Int Utilizar uma palavra reservada
operao Utilizar acentos e/ou cedilha.
7. COMANDOS DE ENTRADA E SADA

Quando escrevemos um programa de computador, essencial que ele receba algum tipo
de informao a ser processada, e, em seguida, apresente o resultado do processamento.
A operao de leitura ou de recebimento de dados pelo programa realizada por meio
dos comandos de entrada, enquanto o procedimento de exibio das informaes na tela (ou
na impressora) executado pelos comandos de sada.
Os comandos de entrada so responsveis pela leitura dos dados digitados pelo usurio.
Essas informaes so recebidas e armazenadas na memria por meio de variveis. Assim, a
cada comando de entrada necessrio definir qual varivel receber o valor informado pelo
usurio.
Quando manipulamos informaes por meio dos comandos de entrada ou sada, devemos
indicar qual tipo de dados estamos utilizando. Por exemplo, quando realizamos a leitura de um
nmero pelo teclado, necessrio evidenciar qual o tipo desse nmero: int, float ou double.
A indicao do tipo de dados a ser manipulado pelos comandos de entrada e sada re-
alizada por meio dos especificadores de formato. Um especificador de formato comea com o
smbolo de %, seguido por um caractere que representa o tipo de dados.
O Quadro 5 apresenta os principais especificadores de formato.
Quadro 5 Especificadores de formato da linguagem C.

PRINCIPAIS ESPECIFICADORES DE FORMATO
ESPECIFICADOR DE FORMATO TIPO DE DADOS
%c char (caracteres individuais)
%s char (conjunto de caracteres)
%d ou %i int
%f float
%lf double
%e nmero em notao cientfica, por exemplo, 10.2e-8
%x nmero em hexadecimal, por exemplo, 32F2
%u endereo de memria
A principal instruo para entrada de dados na linguagem C o comando scanf. Esse co-
mando faz parte da biblioteca stdio.h; assim, necessariamente, todo programa que utilizar esse
comando incluir essa biblioteca.
Para utilizao desse comando, devemos indicar qual tipo de dados ser recebido por
meio de um especificador de formato. Alm disso, uma varivel deve ser informada para rece-
ber o valor digitado pelo usurio. O Cdigo 6, do programa apresentado a seguir, ilustra a utili-
zao do comando scanf para leitura de dados.
cdigo 6
1 /*
3 * do comando scanf para entrada de dados
4 *

6 */
7
10
11 int main()
12 {
13
15 int numero;
16
17 // entrada de dados
18 printf(Digite um numero e pressione ENTER: );
19 scanf(%i, &numero);
20
21
22 // exibio do resultado na tela
23 printf(O numero digitado foi %i \n, numero);
24
25 return 0;
26 }
fim cdigo 6

Digite um numero e pressione ENTER: 12
O numero digitado foi 12
No exemplo do Cdigo 6, voc pde observar a utilizao do comando scanf para entrada
de dados (Linha 19). Note que a informao recebida do usurio do tipo inteiro, e, por isso, foi
necessria a utilizao do especificador de formato %i.
Quando utilizamos o comando scanf, dois pontos precisam ser destacados:
O especificador de formato deve sempre ser indicado entre aspas duplas, como, por
exemplo, %i.
Uma varivel deve ser informada para receber o valor digitado pelo usurio. Alm dis-
so, necessrio que o smbolo & seja especificado antes do nome da varivel, como,
por exemplo, &numero. A utilizao do smbolo & significa que o valor recebido ser
armazenado no endereo de memria da varivel numero. importante destacar que
a omisso do smbolo & no comando scanf um dos principais erros cometidos pelos
iniciantes em programao.
O Cdigo 7 demonstra a utilizao do comando scanf para entrada de dados do tipo float.
cdigo 7
1 /*
4 *
6 */
7
10
11 int main()
12 {
13
15 float nota1, nota2, media;
16
17 // entrada de dados
18 printf(Informe a primeira nota: );
19 scanf(%f, &nota1);
20
21 printf(Informe a segunda nota: );
22 scanf(%f, &nota2);
23
24 // clculo da mdia aritmtica
25 media = (nota1+nota2)/2;
26
27
29 printf(Media = %f \n, media);
30
31 return 0;
32 }
fim cdigo 7

Informe a primeira nota: 8.5
Informe a segunda nota: 6.0
Media = 7.250000
Note que no exemplo do Cdigo 7 utilizamos uma varivel para calcular a mdia aritmti-
ca entre as notas informadas pelo usurio (Linha 25). Como as variveis de entrada so do tipo
float, os especificadores de formato utilizados foram %f.
Como o tipo de dados float tem preciso de seis dgitos, o resultado da mdia exibido
com seis casas decimais (0.000000). Em breve, aprenderemos como formatar corretamente a
sada, de acordo com o nmero de casas decimais que desejamos.
O exemplo do Cdigo 8 demonstra a utilizao do comando de entrada scanf para o tipo
de dados char. Lembre-se de que esse tipo de dados empregado na manipulao de caracte-
res.
cdigo 8
1 /*

4 *
6 */
7
10
11 int main()
12 {
13
15 char tamanho;
16
17
printf(Qual o tamanho de camiseta que voce usa [P, M ou G] : );
18 scanf(%c,&tamanho);
19
20
22
printf(Voce usa camiseta no tamanho %c \n, tamanho);
23
24 return 0;
25 }
fim cdigo 8

Qual o tamanho de camiseta que voce usa [P,
M ou G]: P
Voce usa camiseta no tamanho P
Outra forma de ler caracteres do teclado por meio do comando getchar, o qual realiza a
leitura de um caractere informado pelo usurio e aguarda o pressionamento da tecla enter. No
Cdigo 8, podemos substituir a utilizao do comando scanf pelo comando getchar modifican-
do apenas a Linha 18.
18 tamanho = getchar();
Voc tambm pode realizar a leitura de caracteres por meio do comando getch, que fun-
ciona exatamente da mesma forma que o comando getchar, com uma nica diferena: o usu-
rio no precisar pressionar a tecla enter. A leitura realizada automaticamente. Voc pode
alterar o programa anterior para utilizao do getch.
18 tamanho = getch();
O tipo de dados char tambm pode ser utilizado para leitura de conjuntos de caracteres.
Esses conjuntos so conhecidos em programao como strings. Para realizar a leitura de uma
string, necessrio informar o seu nmero de caracteres. Para identificar o final da string,
colocado um caractere especial NULL, representado por \0.
Por exemplo: a instruo a seguir declara uma varivel do tipo char capaz de armazenar
um conjunto de at 10 caracteres.
1 char nome[10];
Suponha que essa varivel receba a seguinte informao: Joo da Silva. Visualmente, te-
mos a seguinte representao:
J o o d a S i l v a \0
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
Note que as posies para armazenamento da informao variam de 0 a 14, sendo um

total de 15 posies, como foi declarado (nome[15]). Outro ponto importante que ao final do
conjunto de caracteres o smbolo especial \0 inserido para indicar o final da string.
No Cdigo 9, o programa ilustra a utilizao do comando de entrada scanf para a leitura de
conjunto de caracteres. O especificador de formato utilizado para esse caso o %s.
cdigo 9
1 /*
4 *
6 */
7
10
11 int main()
12 {
13
15 char nome[20];
16
17 printf(Informe seu nome: );
18 scanf(%s, &nome);
19
20 printf(Ola, %s seja bem-vindo! \n, nome);
21
22 return 0;
23 }
fim cdigo 9

Informe seu nome: Joao
Ola, Joao seja bem-vindo!

Um aspecto importante a ser observado a respeito do comando scanf, ao realizar a leitura

de um conjunto de caracteres, que ele no aceita espaos entre os caracteres. Por exemplo, se
o nome informado pelo usurio fosse Joo da Silva, o resultado da execuo seria:

Informe seu nome: Joao da Silva
Ola, Joao da Silva seja bem-vindo!
Veja que todos os caracteres aps o espao foram desconsiderados.

Para solucionar esse problema com a leitura de conjuntos de caracteres, podemos utilizar
outro comando de entrada chamado gets. Esse comando empregado apenas para leitura de
conjunto de caracteres, podendo, assim, ser utilizado apenas para o tipo de dados char.
O Cdigo 10 ilustra a utilizao do comando gets para leitura de conjuntos de caracteres:
cdigo 10
1 /*
4 *
6 */
7
10
11 int main()
12 {
13
15 char nome[20];
16
18 gets(nome);
19
20 printf(Ola, %s seja bem-vindo! \n, nome);
21
22 return 0;
23 }
fim cdigo 10
Note que, com o comando gets, no necessrio indicar o especificador de formato, e,

alm disso, no preciso inserir o smbolo & antes do nome da varivel. O resultado da execu-
o para esse programa :

Ola, Joao da Silva seja bem-vindo!
A apresentao de informaes na tela realizada por meio de instrues conhecidas

como comandos de sada. Esses comandos tm como objetivo exibir dados na tela ou na im-
pressora.
Como voc j deve ter notado nos exemplos anteriores, o principal comando para exibio
de informaes na tela o printf. Esse comando permite que qualquer tipo de dado seja exibido
na tela. A maneira mais simples de utilizar o comando printf para exibio de informaes tex-
tuais, como, por exemplo, para exibirmos a mensagem Seja bem-vindo!, que possui o seguinte
resultado:

Seja bem-vindo!
importante observar que todas as informaes literais exibidas pelo comando printf de-
vem ser colocadas entre aspas duplas.
O comando printf tambm pode ser utilizado para exibir o contedo de variveis. Para
isso, basta indicar qual o tipo de varivel ser exibida por meio de um especificador de formato.
Por exemplo, para exibir uma varivel do tipo inteiro, utilizamos o especificador %i:
1 int numero = 10;

2 printf(Numero = %i , numero);

Numero = 10
Voc pode notar que, quando o programa est sendo executado, o especificador de for-
mato substitudo pelo contedo da varivel. No exemplo anterior, o especificador de formato
%i substitudo pelo valor 10, contido na varivel nmero.
Podemos utilizar o comando printf para exibir diversas informaes ao mesmo tempo.
Para isso, utilizamos a regra anterior, em que indicamos qual tipo de dados ser apresentado.
Nesse caso, para cada varivel exibida na tela, devemos inserir um especificador de formato. Por
exemplo:
1 int A = 10;
2 int B = 20;
3 int C = 30;
4 printf(A = %i, B = %i e C = %i, A,B,C);

A = 10, B = 20 e C = 30
Alm disso, podemos mesclar a exibio de tipos de dados, ou seja, em um mesmo printf,
podemos apresentar dados de tipos diferentes.

1 int A = 10;
2 char B = F;
3 float C = 125.80;
4 printf(A = %i, B = %c e C = %f , A,B,C);

A = 10, B = F e C = 125.800000
Podemos, ainda, utilizar o comando printf para exibir o resultado de uma expresso. Por
exemplo:
1 int A = 10;
2 int B = 20;
3 int C = 30;
4 printf(Resultado = %i , (A+B+C));

Resultado = 60
Como aprendemos anteriormente, toda varivel ocupa uma posio na memria princi-
pal. Utilizando o comando printf e o especificador de formato %u, podemos visualizar qual o
endereo de memria em que a varivel foi armazenada. O exemplo no Cdigo 11 demonstra
esse recurso. Perceba que, alm de utilizar o especificador de formato, precisamos utilizar o
operador & na varivel.
cdigo 11
1 /*
3 * do especificador de formato %u e o operador &
4 *
6 */
7
9
10 int main()
11 {
12 int numero;
13
14 printf(Informe um numero: );
16
17
printf(Numero = %i, endereco = %u \n, numero, &numero);
18
19 return 0;
20 }
fim cdigo 11
O comando printf suporta um conjunto de caracteres especiais que so chamados de c-

digos de barra invertida. Esses caracteres podem ser utilizados para controlar o modo como as
informaes sero exibidas na tela.
O Quadro 6 apresenta os principais cdigos de barra invertida e seus respectivos signifi-
cados.
Quadro 6 Cdigos de barra invertida.

PRINCIPAIS CDIGOS DE BARRA INVERTIDA
CDIGO SIGNIFICADO
\n Mudana para uma nova linha
\t Realiza a tabulao horizontal
\ Exibe uma aspa dupla
\ Exibe uma aspa simples
\\ Exibe uma barra invertida
\a Emite um alerta (beep).
Fonte: adaptado de Schildt (1997, p. 159).
No Cdigo 12, o programa apresenta a utilizao dos principais cdigos de barra invertida.
cdigo 12
1 /*
3 * dos cdigos de barra invertida
4 *
6 */
7
10
11 int main()
12 {
13 // exemplo do cdigo para nova linha
14 printf(Ola, \nJoao da Silva \nseja bem-vindo ao sistema!\n);
15
16 //pular uma linha
17 printf(\n);
18
19 // exemplo do cdigo de tabulao
20 printf(Nome \tIdade \n);
21 printf(Carlos \t21 \n);
22 printf(Ana \t32 \n);
23 printf(Jose \t28 \n);
24 printf(\n);
25
26 // aspas duplas
27 printf(Texto entre \aspas duplas\ n\n);
28
29 // aspas simples

30 printf(Texto entre \aspas simples\ \n\n);

31
32 // exibio da barra invertida
33 printf(Exibicao de uma barra invertida \\ \n\n);
34
35 // alerta (beep)
36 printf(Atencao! \a );
37
38 return 0;
39 }
fim cdigo 12

Ola,
Joao da Silva
seja bem-vindo ao sistema!
Nome Idade
Carlos 21
Ana 32
Jose 28
Texto entre aspas duplas
Texto entre aspas simples
Exibicao de uma barra invertida \
Atencao!
Quando utilizamos o comando printf, podemos controlar a largura das informaes que
sero exibidas na tela. Para isso, podemos utilizar alguns caracteres entre o smbolo de i% e o
caractere que representa o formato. O exemplo do Cdigo 13 ilustra a utilizao desse tipo de
controle:
cdigo 13
1 /*
3 * do controle de largura dos campos
4 *
6 */
7
10
11 int main()
12 {
13 /*
14 * Exemplo para nmeros
15 */
16
17 //preencher com espaos em branco

18 printf(Resultado = %5d \n, 5);
22
23 //preencher com zeros
28
29 //alinhamento esquerda
30 printf(Resultado = %-5d \n, 5);
34 printf(\n\n);
35
36 /*
37 * Exemplo para caracteres
38 */
39 //preenchimento com espao em branco
40 printf(Nome = %10s \n, Jose);
41 printf(Nome = %10s \n, Antonio);
42 printf(Nome = %10s \n, Ana);
43
44 //alinhamento esquerda
45 printf(Nome = %-10s \n, Jose);
46 printf(Nome = %-10s \n, Antonio);
47 printf(Nome = %-10s \n, Ana);
48
49 return 0;
50 }
fim cdigo 13


Resultado = 280
Resultado = 1360
Resultado = 00005
Resultado = 00064
Resultado = 00280
Resultado = 01360
Resultado = 5
Resultado = 64
Resultado = 280
Resultado = 1360
Nome = Jose
Nome = Antonio
Nome = Ana
Nome = Jose
Nome = Antonio
Nome = Ana
Nome = Jose
Nome = Antonio
Nome = Ana
Outra propriedade interessante do comando printf a possibilidade de controlarmos o

nmero de casas decimais. Esse recurso chamado de controle de preciso. O Cdigo 14 ilustra
a utilizao dessa caracterstica:
cdigo 14
1 /*
3 * do controle de preciso
4 *
6 */
7
10
11 int main()
12 {
13 float x = 1.23456;
14
15 printf(X = %.1f \n, x); // 1.2
16 printf(X = %.2f \n, x); // 1.23
17 printf(X = %.3f \n, x); // 1.235
18 printf(X = %010.3f \n, x); // 000001.235
19
20 return 0;
21 }
fim cdigo 14

X = 1.2
X = 1.23
X = 1.235
X = 000001.235
Alm do comando printf, temos mais dois comandos que podem ser utilizados para exibi-
o de informaes na tela:
putchar: utilizado, exclusivamente, para exibio de caracteres (char) na tela.
puts: utilizado para exibio de conjuntos de caracteres (strings) na tela.
Observe, no Cdigo 15, a aplicao desses comandos.
cdigo 15
1 /*
3 * dos comandos putchar e puts
4 *
6 */
7
10
11 int main()
12 {
13 char nome[20];
14 char sexo;
15
16 //leitura das informaes
17 printf(Informe o nome: );
18 gets(nome);
19
20 printf(Informe o sexo [M ou F]: );
21 sexo = getchar();
22
23 //exibio dos dados na tela
24 printf(Seu nome e: );
25 puts(nome);
26 printf(Seu sexo e: );
27 putchar(sexo);
28
29 return 0;
30 }
fim cdigo 15


Informe o nome: Joao da Silva
Informe o sexo [M ou F]: M
Seu nome e: Joao da Silva
Seu sexo e: M
Os comandos de entrada e sada so essenciais para a construo de programas. Esses

comandos so utilizados para interao e exibio de informaes para o usurio. Dentro desse
contexto, reflita sobre como possvel utilizar os comandos de entrada e sada para facilitar a
interao entre o usurio e os programas.
8. EXPRESSES ARITMTICAS
Os computadores so especialistas na resoluo de clculos matemticos. Para realizar
esses clculos, eles utilizam as expresses matemticas. Essas expresses so formadas por um
conjunto de smbolos especiais conhecidos como operadores aritmticos.
Observe os principais operadores aritmticos da linguagem C, listados no Quadro 7.
Quadro 7 Operadores aritmticos da linguagem C.

PRINCIPAIS OPERADORES ARITMTICOS DA LINGUAGEM C
OPERAO OPERADOR EXEMPLO
Adio + 10 + 20 30
Subtrao 92 7
Multiplicao * 2*4 8
Diviso / 6/3 2
Mdulo (resto da diviso inteira) % 5/3 2
O Cdigo 16 ilustra a utilizao de operadores aritmticos. Esse programa tem como obje-
tivo a converso entre temperaturas em Fahrenheit para graus Celsius.
cdigo 16
1 /*
3 * dos operadores aritmticos
4 *
6 */
7
10
11 int main()
12 {
13
14 float temperatura;
15 float conversao;
16
17 printf(Informe a temperatura em Fahrenheit: );
18 scanf(%f, &temperatura);
19
20 //converso de F para C
21 conversao = (temperatura-32) * 5/9;
22
23 //resultado
24 printf(Temperatura em graus Celsius = %.2f \n, conversao);
25
26 return 0;
27 }
fim cdigo 16

Informe a temperatura em Fahrenheit: 98
Temperatura em graus Celsius = 36.67
No prximo programa (Cdigo 17), demonstraremos a utilizao do operador aritmtico

mdulo. Veja que, com ele, possvel calcular o resto da diviso entre nmeros inteiros.
cdigo 17
1 /*
3 * do operador de mdulo
4 *
6 */
7
10
11 int main()
12 {
13
14 int num1, num2;
15 int divisao, resto;
16
17
18 printf(Informe o primeiro numero: );
19 scanf(%i, &num1);
20 printf(Informe o segundo numero: );
22
23 // diviso entre nmeros inteiros
24 divisao = num1/num2;
25
26 //resto da diviso entre nmeros inteiros
27 resto = num1%num2;
28
29
printf(%i dividido por %i = %i \n,num1,num2,divisao);

30
printf(O resto da divisao e igual a %i \n, resto);
31
32 return 0;
33 }
fim cdigo 17

Informe o primeiro numero: 5
Informe o segundo numero: 3
5 dividido por 3 = 1
O resto da divisao e igual a 2
Qualquer tipo de expresso matemtica pode ser resolvida utilizando os operadores arit-
mticos. Entretanto, devemos obedecer ordem dos parnteses utilizados nas expresses.
Como exemplo, considere a expresso a seguir:
26 (10 + ( 20 / 3) )
+ 5* ( 4* ( 3 8 ) )
12
( 9%2 )
O programa que resolve essa expresso ser apresentado no Cdigo 18.
cdigo 18
1 /*
2 * Programa para demonstrar a resoluo de
3 * expresses matemticas complexas
4 *
6 */
7
10
11 int main()
12 {
13
14 float expressao;
15
16 expressao = (26/12)+5*( (10+(20/3))/(9%2) ) - (4*(3-8) );
17
18 printf(Resultado da expressao = %.2f \n,expressao);
19
20 return 0;
21 }
fim cdigo 18

Resultado da expressao = 102.00
Ao resolvermos expresses matemticas, fundamental que a prioridade dos operadores

seja respeitada. Essa prioridade determina quais operaes devem ser realizadas inicialmente.
Uma expresso que envolva mais de um operador deve obedecer a seguinte ordem:
Quadro 8 Ordem de precedncia dos operadores.

ORDEM DOS OPERADORES
ORDEM OPERADOR
1 Parnteses mais internos
2 Potenciao raiz
3 * /
4 +
Em algumas expresses, podemos ter operadores com a mesma prioridade. Nesses casos,
resolvemos inicialmente os operadores que esto mais esquerda, e, em seguida, os operado-
res mais direita. Por exemplo, considere a seguinte expresso matemtica:
10 + 20 6* 2 / 4
A expresso matemtica pode ser apresentada na linguagem C da seguinte maneira:
1 resultado = 10+20-6*2/4;
Inicialmente, resolvemos 6*2, cujo resultado 12, e, em seguida, dividimos o resultado

por 4, obtendo 3. Em decorrncia dos operadores * e / terem a mesma prioridade, resolvemos o
operador que est mais esquerda *, e, depois, o mais direita /. O prximo passo resolver a
adio 10+20, que igual a 30, e, finalmente, subtrair do resultado j obtido 6*2/4 (que igual
a 3). Assim, o resultado final da expresso 27.
Operadores de incremento e decremento

H dois operadores especiais que so utilizados para incrementar e decrementar o valor
de uma varivel.
Quando incrementamos uma varivel, significa que o valor 1 (um) adicionado ao seu
contedo. O smbolo do operador de incremento ++.
Por exemplo:
1 int numero = 10;

2 numero++;
3 printf(Numero = %i n, numero);

Nmero = 11;
J o operador de decremento, simbolizado por --, subtrai 1 (um) ao contedo da varivel.

Por exemplo:

1 int numero = 10;

2 numero--;

Numero = 9;
Os operadores de incremento e decremento podem ser utilizados de duas maneiras:

prefixada: em que o operador definido antes do nome da varivel.
++numero;
ps-fixada: em que o operador definido aps o nome da varivel.
numero++;
O Cdigo 19 demonstra a utilizao dos operadores de incremento e decremento. Neste

exemplo, so aplicados os dois tipos de operadores: prefixado e ps-fixado.
cdigo 19
1 /*
3 * dos operadores pr e ps-fixados.
4 *
6 */
7
10
11 int main()
12 {
13
14 int num1;
15 int num2;
16
17 // operador ps-fixado
18 num1 = 10;
19 num2 = num1++;
20
21 printf(Numero 1 = %i \n, num1);
22 printf(Numero 2 = %i \n\n, num2);
23
24 // operador pr-fixado
25 num1 = 10;
26 num2 = ++num1;
27
30
31 return 0;
32 }
fim cdigo 19

Numero 1 = 11
Numero 2 = 10
Numero 1 = 11
Numero 2 = 11
Na operao ps-fixada (num2=num1++), inicialmente o valor da varivel num1 (10)

atribudo varivel num2, fazendo com que a varivel num2 recebesse o valor 10. Somente
aps a operao de atribuio que o valor da varivel num1 incrementado. por isso que a
varivel num2 manteve o valor 10.
Em contrapartida, na operao prefixada (num2=++num1), inicialmente a operao de
incremento da varivel num1 executada; assim, a varivel num1 obtm o valor 11. Em seguida,
efetuada a operao de atribuio, fazendo que o valor 11 da varivel num1 fosse armazenado
na varivel num2.
Operadores de atribuio
Os operadores de atribuio tm como objetivo a alterao do valor de uma varivel le-
vando em considerao seu valor inicial. Por exemplo, considere a operao tpica de atribuio
a seguir:
1 int numero = 10;

2 numero = 20;

Numero = 20;
Quando utilizamos o operador de atribuio, o novo valor da varivel nmero depende

do valor inicial que ela contm. Por exemplo:
1 int numero = 10;

2 numero += 20;

Numero = 30;
Note que, na operao de atribuio, em vez de utilizarmos apenas o operador =, foi em-
pregado o operador +=. Essa operao equivalente seguinte expresso:
2 numero = numero + 20;

O Quadro 9 apresenta os principais operadores de atribuio:
Quadro 9 Principais operadores de atribuio da linguagem C.

OPERADORES DE ATRIBUIO DA LINGUAGEM C
OPERAO OPERADOR EXEMPLO EQUIVALENTE
Adio += num += 10; num = num + 10;
Subtrao = num = 10; num = num 10;
Multiplicao *= num *= 10; num = num * 10;
Diviso /= num /= 10; num = num / 10;
Mdulo %= num %= 10; num = num % 10;
O Cdigo 20 demonstra a utilizao dos operadores de atribuio.

cdigo 20
1 /*
3 * dos operadores de atribuio
4 *
6 */
7
10
11 int main()
12 {
13
14 int num;
15
16 printf(Operador: += \n);
17 num = 10;
18 num += 5;
19 printf(Numero = %i \n\n,num);
20
21 printf(Operador: -= \n);
22 num = 10;
23 num -= 2;
25
26
27 printf(Operador: *= \n);
28 num = 10;
29 num *= 5;
31
32 printf(Operador: /= \n);
33 num = 10;
34 num /= 2;
36
37
38 printf(Operador: %= \n);
39 num = 10;
40 num %= 7;
42
43 return 0;
44 }
fim cdigo 20

Operador: +=
Numero = 15
Operador: -=
Numero = 8
Operador: *=
Numero = 50
Operador: /=
Numero = 5
Operador: =
Numero = 3
9. EXPRESSES LGICAS
As expresses lgicas permitem ao programador estabelecer relaes entre valores ou
variveis dentro dos programas. Uma expresso lgica sempre resulta em um valor lgico, que
pode ser considerado verdadeiro ou falso.
Quando trabalhamos com expresses lgicas, trs tipos de operadores podem ser empre-
gados:
Operadores de igualdade: utilizados para estabelecer equivalncia entre dados pre-
sentes nos programas, tambm podem ser empregados para avaliar se uma determi-
nada varivel igual, ou diferente, outra varivel. Os operadores de igualdade so
listados no Quadro 10:
Quadro 10 Operadores de igualdade.

OPERADORES DE IGUALDADE
OPERADOR SMBOLO EXEMPLO RESULTADO
Igualdade == 10 == 20 Falso
Diferena != 10 !=20 Verdadeiro
O Cdigo 21, descrito no programa a seguir, no demonstra a utilizao dos operadores de

igualdade e de diferena.

cdigo 21
1 /*
3 * dos operadores de igualdade
4 *
6 */
7
10
11 int main()
12 {
13 int num1, num2;
14 int op_igualdade, op_diferenca;
15
18
21
22 //operador de igualdade
23 op_igualdade = num1 == num2;
24
25 //operador de diferena
26 op_diferenca = num1 != num2;
27
28 printf(%i e igual a %i = %i \n, num1,num2,op_igualdade);
29 printf(%i e diferente de %i = %i \n, num1,num2,op_diferenca);
30
31 return 0;
32 }
fim cdigo 21
10 e igual a 5 = 0
10 e diferente de 5 = 1
importante observar que a linguagem C no possui um tipo de dados para representar

valores lgicos, ou seja, um tipo de dados que armazene os valores: verdadeiro ou falso. Em vez
disso, podemos utilizar nmeros inteiros para representar esses valores lgicos, em que o valor
Verdadeiro (true) igual a 1 e o valor Falso (false) igual a 0.
Operadores relacionais: empregados na comparao entre dados do mesmo tipo. As
possveis relaes a serem estabelecidas entre dois valores so: maior que, menor que,
maior ou igual que, menor ou igual que. No Quadro 11, veja quais so os operadores
relacionais.
Quadro 11 Operadores relacionais.

OPERADORES RELACIONAIS
OPERADOR SMBOLO EXEMPLO RESULTADO
Maior que > 10 > 20 Falso
Menor que < 8<2 Falso
Maior ou igual que >= 5 >= 5 Verdadeiro
Menor ou igual que <= 25 <= 38 Verdadeiro
No Cdigo 22, temos um programa que demonstra a utilizao dos operadores relacio-
nais, verifique:
cdigo 22
1 /*
3 * dos operadores relacionais
4 *
6 */
7
10
11 int main()
12 {
13 int num1, num2;
14 int maior,menor,maiorigual,menorigual;
15
18
21
22 maior = num1 > num2;
23 menor = num1 < num2;
24 maiorigual = num1 >= num2;
25 menorigual = num1 <= num2;
26
27
printf(%i e maior que %i = %i \n, num1,num2,maior);
28
printf(%i e menor que %i = %i \n, num1,num2,menor);
29
printf(%i e maior ou igual que %i= %i \n, num1,num2,maiorigual);
30
printf(%i e menor ou igual que %i= %i \n, num1,num2,menorigual);
31
32 return 0;
33 }
fim cdigo 22


10 e maior que 5 = 1
10 e menor que 5 = 0
10 e maior ou igual que 5 = 1
10 e menor ou igual que 5 = 0
Lembre-se de que utilizamos nmeros inteiros para representar esses valores lgicos, em
que o valor Verdadeiro (true) igual a 1 e o valor Falso (false) igual a 0.
Operadores lgicos: utilizados para concatenar, ou seja, ligar diversas expresses lgi-
cas. Esses operadores seguem os mesmos tipos de conectivos lgicos da lgica mate-
mtica; no entanto, na linguagem C, eles recebem uma simbologia diferente. O Quadro
12 apresenta os principais operadores lgicos.
Quadro 12 Principais operadores lgicos.

PRINCIPAIS OPERADORES LGICOS
REPRESENTAO NA REPRESENTAO NA
OPERADOR EXEMPLO
LGICA MATEMTICA LINGUAGEM C
Conjuno E (^) && A && B
Disjuno OU () || A || B
Disjuno exclusiva OU Exclusivo () ^ A^B
Negao Negao (~) ! !A
As tabelas verdade possuem os mesmos resultados da lgica matemtica.
Tabela 1 Tabela verdade dos principais conectivos lgicos.

A B A && B A || B A^B
1 0 1 1 0
1 0 0 1 1
0 1 0 1 1
0 0 0 0 0
O Cdigo 23 do programa a seguir apresenta os principais operadores lgicos da lingua-

gem C. Neste exemplo, demonstrada a construo de tabelas verdade a partir dos operadores.
O resultado 1 representa o valor lgico verdadeiro, enquanto o resultado 0 representa o valor
lgico falso.
cdigo 23
1 /*
3 * dos operadores lgicos
4 *
6 */
7

10
11 int main()
12 {
13
14 printf(-----------------------\n);
15 printf( Tabelas Verdade \n);
16 printf(-----------------------\n);
17 printf(\n);
18 printf(Negacao (!) \n);
19 printf( !1 \t= %i \n, !1);
20 printf( !0 \t= %i \n, !0);
21 printf(\n);
22
23 printf(Conjuncao (&&) \n);
24 printf( 1 && 1 = %i \n, 1 && 1);
25 printf( 1 && 0 = %i \n, 1 && 0);
26 printf( 0 && 1 = %i \n, 0 && 1);
27 printf( 0 && 0 = %i \n, 0 && 0);
28 printf(\n);
29
30 printf(Disjuncao (||) \n);
31 printf( 1 || 1 = %i \n, 1 || 1);
32 printf( 1 || 0 = %i \n, 1 || 0);
33 printf( 0 || 1 = %i \n, 0 || 1);
34 printf( 0 || 0 = %i \n, 0 || 0);
35
36 printf(\n);
37 printf(Disjuncao Exclusiva (^) \n);
38 printf( 1 ^ 1 = %i \n, 1 ^ 1);
39 printf( 1 ^ 0 = %i \n, 1 ^ 0);
40 printf( 0 ^ 1 = %i \n, 0 ^ 1);
41 printf( 0 ^ 0 = %i \n, 0 ^0);
42
43 return 0;
44 }
fim cdigo 23


-----------------------
Tabelas Verdade
-----------------------
Negacao (!)
!1 = 0
!0 = 1
Conjuncao (&&)
1 && 1 = 1
1 && 0 = 0
0 && 1 = 0
0 && 0 = 0
Disjuncao (||)
1 || 1 = 1
1 || 0 = 1
0 || 1 = 1
0 || 0 = 0
Disjuncao Exclusiva (^)

1 ^ 1 = 0
1 ^ 0 = 1
0 ^ 1 = 1
0 ^ 0 = 0
10. BIBLIOTECAS
A linguagem de programao C possui uma infinidade de bibliotecas que auxiliam o traba-
lho do programador. Essas bibliotecas, quando utilizadas, devem ser referenciadas no cabealho
do programa por meio da diretiva include.
Uma biblioteca importante da linguagem C a biblioteca math.h, que contm diversas
funes matemticas implementadas, as quais podem ser utilizadas na construo de progra-
mas. O Quadro 13 apresenta algumas funes da biblioteca math.h.
Quadro 13 Funes da biblioteca matemtica.

FUNES DA BIBLIOTECA MATEMTICA
FUNO UTILIZAO EXEMPLO RESULTADO
ceil Arredondamento de nmeros reais para cima. ceil(2.3) 3
floor Arredondamento de nmeros reais para baixo. ceil(2.3) 2
abs ou fabs Valor absoluto de um nmero. abs(4) 4
exp Logaritmo natural (x elevado potncia y). exp(2) 7.39
log Logaritmo natural de x. log(2) 0.69
log10 Logaritmo de base 10 de x. log10(2) 0.30
pow Potenciao: x elevado a y. pow(2,3) 8
sqrt Raiz quadrada. sqrt(25) 5
cos Cosseno de ngulos em radianos. cos(3.1415) 1
sin Seno de ngulos em radianos. sin(3.1415) 0
tan Tangente de ngulos em radianos. tan(3.1415) 0
O Cdigo 24 ilustra algumas das principais funes disponveis na biblioteca math.h.
Lembre-se de que, para utilizar essa biblioteca, voc dever adicionar a diretiva #include <math.
h>:
cdigo 24
1 /*
2 * Programa para demonstrar algumas
3 * funes da biblioteca math.h
4 *
6 */
7
9 #include <math.h>
10
11 int main()
12 {
13 float numero;
14
15
printf(===== Biblioteca Matematica =====\n);
16
17 printf(\n=> Arredondamento \n);
19 scanf(%f, &numero);
20
printf(Arredondamento para cima = %.2f \n, ceil(numero));
21
printf(Arredondamento para baixo = %.2f \n, floor(numero));
22
23 printf(\n=> Valor Absoluto \n);
24 printf(Informe um numero negativo: );
26
printf(Valor absoluto = %.2f \n, fabs(numero));
27
28 printf(\n=> Logaritmo \n);
31
printf(Log natural e^x = %.2f \n, exp(numero));
32
printf(Log natural = %.2f \n, log(numero));
33
printf(Log de base 10 = %.2f \n, log10(numero));
34
35 printf(\n=> Potenciacao \n);
38
printf(%.2f ao quadrado = %.2f \n, numero, pow(numero,2));
39
printf(%.2f ao cubo = %.2f \n, numero,pow(numero,3));
40
41 printf(\n=> Raiz Quadrada \n);
44
printf(Raiz quadrada de %.2f= %.2f \n,numero,sqrt(numero));
45
46 return 0;
47 }
fim cdigo 24


===== Biblioteca Matematica =====
=> Arredondamento
Informe um numero: 8.62
Arredondamento para cima = 9.00
Arredondamento para baixo = 8.00
=> Valor Absoluto

Informe um numero negativo: -4.23
Valor absoluto = 4.23
=> Logaritmo
Informe um numero: 2.5
Log natural e^x = 12.18
Log natural = 0.92
Log de base 10 = 0.40
=> Potenciacao
Informe um numero: 2
2.00 ao quadrado = 4.00
2.00 ao cubo = 8.00
=> Raiz Quadrada

Raiz quadrada de 25.00 = 5.00
Esse outro exemplo, descrito no Cdigo 25, demonstra a utilizao da biblioteca math.h
na resoluo de problemas trigonomtricos envolvendo seno, cosseno e tangente. Nesse pro-
grama, o usurio dever informar um ngulo em graus, o qual ser convertido para radianos. Em
seguida, sero calculados seu seno, cosseno e tangente.
cdigo 25
1 /*
4 *
6 */
7
9 #include <math.h>
10
11 int main()
12 {
13 const float PI = 3.1415;
14
15 float graus, radianos;
16
17 printf(Informe um angulo em graus: );
18 scanf(%f, &graus);
19
20 radianos = (graus*PI)/180;
21
printf(%.2f graus = %.2f radianos \n,graus,radianos);
22
23
printf(Cosseno %.2f graus = %.2f \n,graus, cos(radianos));
24
printf(Seno %.2f graus = %.2f \n,graus, sin(radianos));
25
printf(Tangente %.2f graus = %.2f \n,graus, tan(radianos));
26
27 return 0;
28 }
fim cdigo 25

Informe um angulo em graus: 180
180.00 graus = 3.14 radianos
Cosseno 180.00 graus = -1.00
Seno 180.00 graus = 0.00
Tangente 180.00 graus = -0.00
Outra biblioteca importante da linguagem C a string.h. Essa biblioteca especializada

na manipulao de conjuntos de caracteres e algumas das suas principais funes esto listadas
no Quadro 14.
Quadro 14 Principais funes da biblioteca matemtica.

PRINCIPAIS FUNES DA BIBLIOTECA MATEMTICA
FUNO UTILIZAO EXEMPLO RESULTADO
strcat Concatenar duas strings. strcat("Joo",da Silva); "Joo da Silva"
Copiar o contedo de uma string para
strcpy strcpy("Jos", Carlos); Carlos
outra.
strcmp("Joo", Joo"); 0
strcmp Comparar duas strings.
strcmp("Joo", Jos"); 1
strlen Retornar o tamanho de uma string. strlen("Joo da Silva"); 13
O exemplo do Cdigo 26 demonstra a utilizao de algumas das principais funes da bi-
blioteca string.h.
cdigo 26
1 /*
3 * funes da biblioteca string.h
4 *
6 */
7
9 #include <string.h>
10
11 int main()
12 {
13 char nome[20];
14 char sobrenome[10];
15

16 strcpy(nome,Joao);
17 strcpy(sobrenome,da Silva);
18 printf(Nome = %s \n, nome);
19 printf(Sobrenome = %s \n, sobrenome);
20
21 strcat(nome,sobrenome);
22 printf(Nome = %s \n, nome);
23
24
printf(O nome e Joao da Silva? %i\n,strcmp(nome,Joao da Silva));
25
printf(O nome e Joao da Silva? %i\n, strcmp(nome,Jose da Silva));
26
27
printf(O nome %s possui %i caracteres \n, nome, strlen(nome));
28
29 return 0;
30 }
fim cdigo 26

Nome = Joao
Sobrenome = da Silva
Nome = Joao da Silva
O nome digitado e Joao da Silva? 0
O nome digitado e Joao da Silva? -1
O nome Joao da Silva possui 13 caracteres
11. EXERCCIOS RESOLVIDOS

No final desta e das prximas unidades, voc encontrar um tpico chamado Exerccios
Resolvidos. Nele, voc poder visualizar a implementao de programas completos e que fun-
cionam perfeitamente.
Voc pode encontrar os problemas propostos nesses tpicos em outros estudos que re-
alizar. No entanto, aqui, voc encontrar as solues escritas na linguagem de programao C.
1) Construa um programa que calcule a rea de um tringulo. Lembre-se de que para
base * altura
realizar esse clculo necessrio utilizar a frmula: rea = .
2
cdigo 27
1 /*
2 * Programa para calcular a rea de
3 * um tringulo
4 *
6 */
7
10
11 int main()
12 {
13 float base, altura, area;
14
15 printf(Calculo da Area do Triangulo\n);
16
17 printf(Informe a base: );
18 scanf(%f, &base);
19 printf(Informe a altura: );
20 scanf(%f,&altura);
21
22 //clculo da rea do tringulo
23 area = (base*altura)/2;
24
25 //resultado
26 printf(A area do triangulo e = %.2f, area);
27
28 return 0;
29 }
fim cdigo 27

Calculo da Area do Triangulo
Informe a base: 6.5
Informe a altura: 2.2
A area do triangulo e = 7.15
2) Escreva um algoritmo que receba um nmero inteiro do teclado e imprima na tela seu
sucessor (numero +1) e seu antecessor (numero 1).
cdigo 28
1 /*
2 * Programa para determinar o sucessor
3 * e o antecessor de um nmero inteiro.
4 *
6 */
7
10
11 int main()
12 {
13 int numero;
14
18
19 //escrita do resultado na tela

20 printf(Sucessor = %i \n, (numero+1));

21 printf(Antecessor = %i \n, (numero-1));
22
23 return 0;
24 }
fim cdigo 28

Sucessor = 11
Antecessor = 9
3) Escreva um algoritmo que receba um nmero inteiro positivo e maior que zero. Cal-
cule e apresente na tela:
a) a raiz quadrada do nmero;
b) o nmero ao quadrado;
c) o nmero ao cubo.
cdigo 29
1 /*
4 *
6 */
7
9 #include <math.h>
10
11 int main()
12 {
13 float numero, raizquadrada;
14 float quadrado, cubo;
15
18
19 //raiz quadrada
20 raizquadrada = sqrt(numero);
21
22 //nmero elevado ao quadrado
23 quadrado = pow(numero, 2);
24
25 //nmero elevado ao cubo
26 cubo = pow(numero,3);
27
28 //resultado
29 printf(Raiz quadrada = %.2f \n, raizquadrada);
30 printf(Quadrado = %.2f \n, quadrado);
31 printf(Cubo = %.2f \n, cubo);
32
33 return 0;
34 }
fim cdigo 29
Raiz quadrada = 5.00
Quadrado = 625.00
Cubo = 15625.00
4) Um trabalhador recebeu seu salrio mensal e precisa pagar as contas de gua, luz e
telefone. Escreva um algoritmo que solicite ao usurio o salrio e os valores das contas
de gua, luz e telefone. Em seguida, calcule e apresente na tela quanto sobrou para o
trabalhador aps o pagamento das contas.
cdigo 30
1 /*
2 * Programa para calcular o restante do
3 * salrio de um trabalhador
4 *
6 */
7
9
10
11 int main()
12 {
13 float salario, agua, luz, telefone;
14 float restante;
15
16 printf(Informe seu salario: );
17 scanf(%f,&salario);
18 printf(Valor da conta de Agua: );
19 scanf(%f,&agua);
20 printf(Valor da conta de Luz: );
21 scanf(%f,&luz);
22 printf(Valor da conta de Telefone: );
23 scanf(%f,&telefone);
24
25 //clculo do restante
26 restante = salario - (agua+luz+telefone);
27
28 //resultado
29 printf(O restante do seu salario R$ %.2f , restante);
30
31 return 0;
32 }
fim cdigo 30


Informe seu salario: 950.00
Valor da conta de Agua: 32.45
Valor da conta de Luz: 88.50
Valor da conta de Telefone: 42.30
O restante do seu salario e R$ 786.75
5) Elabore um algoritmo que realize a converso de moedas. Esse algoritmo dever so-
licitar ao usurio a cotao do dlar, bem como a cotao do euro. Em seguida, o
usurio dever informar o valor, em reais, que deseja converter. Aps os clculos ne-
cessrios, o algoritmo exibir na tela:
a) o valor em reais convertido para dlar;
b) o valor em reais convertido para euro.
cdigo 31
1 /*
2 * Programa para converter moedas
3 *
5 */
6
8
9 int main()
10 {
11 float valor_reais, cotacao_dolar, cotacao_euro;
12 float valor_dolar, valor_euro;
13
14 printf(Informe um valor para conversao (em reais): );
15 scanf(%f,&valor_reais);
16 printf(Cotacao do Dolar: );
17 scanf(%f,&cotacao_dolar);
18 printf(Cotacao do Euro: );
19 scanf(%f,&cotacao_euro);
20
21 //converso real para dlar
22 valor_dolar = valor_reais / cotacao_dolar;
23
24 //converso real para euro
25 valor_euro = valor_reais / cotacao_euro;
26
27 //resultado
28 printf(Valor em dolar = %.2f \n , valor_dolar);
29 printf(Valor em euro = %.2f \n, valor_euro);
30
31 return 0;
32 }
fim cdigo 31

Informe um valor para converso (em
reais): 100.00
Cotao do Dlar: 2.07
Cotao do Euro: 2.85
Valor em dlar = 48.31
Valor em euro = 35.09
6) Em matemtica, funes polinomiais, tambm conhecidas como polinmios, repre-

sentam uma classe importante de funes simples e infinitamente diferenciveis. Os
polinmios, devido a sua estrutura e a sua simples avaliao, so frequentemente em-
pregados em anlise numrica. Dentro desse contexto, escreva um programa na lin-
guagem C capaz de calcular o valor numrico do polinmio= P(x) x 3 7x 2 + 3x 4 .
O valor do elemento x dever ser informado pelo usurio.
cdigo 32
01 /*---------------------------------------------
02 *
03 * Exemplo de aplicao com o objetivo de calcular o valor de um
04 * polinmio.
05 *
07 *
08 *--------------------------------------------*/
09
10 /*----------------------------------------------
11 * BIBLIOTECAS
12 *--------------------------------------------*/
13 #include <stdio.h> //instrues de entrada e sada (printf e scanf)
14
15 /*---------------------------------------------*
16 * PROGRAMA PRINCIPAL
17 *--------------------------------------------*/
18 int main()
19 {
20 // declarao das variveis globais
21 float x;
22 float resultado;
23
24 printf(-------------------------------\n);
25 printf(| CALCULO DE POLINOMIO \n);
26 printf(-------------------------------\n);
27 printf(\n);
28 printf(Informe o valor de X: );
29 scanf(%f,&x);
30
31 resultado = (x*x*x)-(7*(x*x))+(3*x)-4;
32
33 printf(\nO resultado do calculo do polinomio eh = %0.2f \n,resultado);
34
35 return 0; // fim da aplicao
36 }
fim cdigo 32

Observe, na captura de tela a seguir, o resultado da execuo do programa no ambiente

de desenvolvimento. Neste caso, foi utilizado o ambiente Code::Blocks. No entanto, a sada ser
semelhante em outros ambientes, como, por exemplo, no NetBeans. Este resultado obtido
com a compilao e a execuo do cdigo-fonte apresentado no Cdigo 32.
7) Uma pessoa deseja emagrecer 25% do seu peso atual. Para isso, voc dever escrever
um programa na linguagem C capaz de calcular qual ser o peso dessa pessoa aps
emagrecer o percentual desejado. O programa dever solicitar pessoa seu peso atu-
al e exibir as informaes resultantes na tela.
cdigo 33
01 /*---------------------------------------------
02 *
03
* Exemplo de uma aplicao com o objetivo de calcular as condies de pagamento de um
04 * produto.
05 *
07 *
08 *-------------------------------------------*/
09
10 /*---------------------------------------------
11 * BIBLIOTECAS
12 *-------------------------------------------*/
14
15 /*--------------------------------------------*
17 *-------------------------------------------*/
18 int main()
19 {
21 float peso_atual;
22 float peso_novo;
23
24 printf(------------------------------\n);
25 printf(| CALCULO DO PESO \n);
26 printf(------------------------------\n);
27 printf(\n);
28 printf(Informe seu peso atual: );
29 scanf(%f,&peso_atual);
30
31 peso_novo = peso_atual-(peso_atual*0.25);
32
33 printf(\nO novo peso da pessoa apos emagrecer 25%% serah = %0.2f \n\n,peso_novo);
34
36 }
fim cdigo 33

8) Uma loja de departamentos est realizando uma grande promoo de seus produtos.
Seus clientes podero comprar qualquer item da promoo e pagar nas seguintes con-
dies:
a) vista, com 20% de desconto no valor do produto;
b) 1 + 1 sem juros, com 10% de desconto no valor do produto;
c) 1 + 2 sem juros, com 5% de desconto no valor do produto;
d) 1 + 3 sem juros, e sem desconto no valor do produto;
e) 1 + 4 sem juros, e sem desconto no valor do produto;
f) 1 + 5 sem juros, e sem desconto no valor do produto;

g) 1 + 6 sem juros, e sem desconto no valor do produto;

h) 1 + 7 sem juros, e sem desconto no valor do produto;
i) 1 + 8 sem juros, e sem desconto no valor do produto;
j) 1 + 9 sem juros, e sem desconto no valor do produto.
Escreva um programa na linguagem C que receba o valor do produto e apresente ao clien-
te as opes de pagamento. Os resultados devero ser apresentados para o cliente em funo
do valor de cada parcela.
cdigo 34
01 /*-------------------------------------------------
02 *
03 * Exemplo de aplicao com o objetivo de calcular o valor de um
04 * polinmio.
05 *
07 *
08 *-----------------------------------------------*/
09
10 /*-------------------------------------------------
11 * BIBLIOTECAS
12 *-----------------------------------------------*/
14
15 /*------------------------------------------------*
17 *-----------------------------------------------*/
18 int main()
19 {
21 float preco_produto;
22 float condicao_pagamento_01, condicao_pagamento_02;
27
28 printf(----------------------------------\n);
29 printf(| LOJA DE DEPARTAMENTOS \n);
30 printf(----------------------------------\n);
31 printf(\n); //pular uma linha
32 printf(Informe o preco total do produto: );
33 scanf(%f,&preco_produto);
34
35
36 // calculo das condies de pagamento
37
// a. vista com 20% de desconto no valor do produto
38
condicao_pagamento_01 = preco_produto-(preco_produto*0.20);
39
40
//b. 1 + 1 sem juros com 10% de desconto no valor do produto
41
condicao_pagamento_02 = (preco_produto- (preco_produto*0.10))/2;
42
43
//c. 1 + 2 sem juros com 5% de desconto no valor do produto
44
condicao_pagamento_03 = (preco_produto-(preco_produto*0.05))/3;
45
46
//d. 1 + 3 sem juros e sem desconto no valor do produto
47
condicao_pagamento_04 = (preco_produto/4);
48
49
//e. 1 + 4 sem juros e sem desconto no valor do produto
50 condicao_pagamento_05 = (preco_produto/5);
51
52 //f. 1 + 5 sem juros e sem desconto no valor do produto
54
55
//g. 1 + 6 sem juros e sem desconto no valor do produto
57
58
//h. 1 + 7 sem juros e sem desconto no valor do produto
60
61
//i. 1 + 8 sem juros e sem desconto no valor do produto
63
64
//j. 1 + 9 sem juros e sem desconto no valor do produto
66
67
68
69
//apresentao dos resultados do programa (sada)
72 printf(--------------------------------\n);
73
printf( >>> CONDICOES ESPECIAIS DE PAGAMENTO <<< \n);
74 printf(--------------------------------\n);
76 printf(>>>Condicao 01: \n);
77 printf(..............: A vista com 20%% de desconto = R$ %0.2f \n,condicao_
pagamento_01);
80 printf(..............: 1 + 1 sem juros com 10%% de desconto no valor do produto
\n);
81
printf(.......Entrada: 1x de R$ %0.2f \n, condicao_pagamento_02);
82
printf(......Restante: 1x de R$ %0.2f (uma parcela)\n, condicao_pagamento_02);
83
printf(\n); //pular uma linha
85 printf(..............: 1 + 2 sem juros com 5%% de desconto no valor do produto
\n);
86
87
printf(......Restante: 2x de R$ %0.2f (duas parcelas)\n, condicao_pagamento_03);
89
printf(..............: 1 + 3 sem juros e sem desconto no valor do produto \n);
90

91
printf(......Restante: 3x de R$ %0.2f (tres parcelas)\n, condicao_pagamento_04);
94
95
96 printf(......Restante: 4x de R$ %0.2f (quatro parcelas)\n, condicao_
pagamento_05);
99
100
101 printf(......Restante: 5x de R$ %0.2f (cinco parcelas)\n, condicao_
pagamento_06);
104
105
106
printf(......Restante: 6x de R$ %0.2f (seis parcelas)\n, condicao_pagamento_07);
109
110
111
printf(......Restante: 7x de R$ %0.2f (sete parcelas)\n, condicao_pagamento_08);
114
115
116
printf(......Restante: 8x de R$ %0.2f (oito parcelas)\n, condicao_pagamento_09);
119
120
121
printf(......Restante: 9x de R$ %0.2f (nove parcelas)\n, condicao_pagamento_10);
123
125
126 }
fim cdigo 34

com a compilao e a execuo do cdigo-fonte apresentado anteriormente.
9) As interfaces grficas facilitam a interao do usurio com as aplicaes. Essas inter-

faces, tambm conhecidas como Graphical User Interface, ou simplesmente GUI, re-
presentam um dos elementos mais importantes no desenvolvimento de um sistema
computacional. Aplicaes tradicionais baseadas em console, as quais so executadas
em modo texto, como, por exemplo, os programas desenvolvidos com a linguagem de
programao C ou Pascal, no possuem recursos muito sofisticados para a elaborao
de interfaces. Para facilitar a construo de interfaces para esses tipos de aplicaes,
os caracteres da tabela ASCII so comumente utilizados. Dentro desse contexto, es-
creva uma aplicao capaz de demonstrar alguns dos principais caracteres ASCII que
podem ser utilizados na construo de interfaces grficas.
cdigo 35
01 /*---------------------------------------------------
02 *
03 * Exemplo de uma aplicao capaz de construir interfaces grficas
04 * com o usurio utilizando os caracteres da tabela ASCII. Essa
05 * aplicao demonstra os principais caracteres utilizados
06 * na elaborao de interfaces grficas.
07 *
09 *
10 *-------------------------------------------------*/
11
12 /*---------------------------------------------------
13 * BIBLIOTECAS
14 *-------------------------------------------------*/
16
17 /*--------------------------------------------------*
19 *-------------------------------------------------*/

20 int main()
21 {
23
24
25 printf(------------------------------------\n);
26 printf(| INTERFACES GRFICAS COM A TABELA ASCII \n);
27 printf(----------------------------------------\n);
30 printf(>>>Caracteres para preenchimento\n);
31 printf(\n);
32 printf(Codigo da Tabela 176, caractere resultante %c \n, 176);
33 printf(......................Exemplo: %c%c%c%c%c \n\n,176,176,176,176,176);
38
40 printf(>>>Caracteres para construcao de janelas (simples)\n);
41 printf(\n);
53 printf(......................Exemplo: \n);
printf(\t\t\t %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c
54
\n,218,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,191);
55 printf(\t\t\t %c \t EXEMPLO %c\n,179,179);
56
\n,192,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,217);
58 printf(>>>Caracteres para construcao de janelas (duplo)\n);
59 printf(\n);

71 printf(......................Exemplo: \n);
72
\n,201,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,187);
73 printf(\t\t\t %c \t EXEMPLO %c\n,186,186);
74
\n,200,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,188);
75
77
78 }
fim cdigo 35


10) Considerando o conjunto de informaes apresentado no Quadro 15, escreva, na lin-

guagem de programao C, um programa capaz de apresentar esses dados de manei-
ra tabulada. Para isso, voc deve considerar a utilizao dos cdigos de barra inverti-
da. Alm disso, a aplicao demonstra a utilizao dos caracteres da tabela ASCII para
construo de interfaces grficas em programas do tipo console.
Quadro 15 Informaes Pessoais.

INFORMAES PESSOAIS
NOME DATA DE NASCIMENTO TELEFONE
Joo da Silva 03/04/1968 (11) 3323-2233
Carlos Antnio 08/10/1976 (12) 8342-4432
Francisco Jos 12/12/1982 (11) 3334-5533
Ana Maria 11/09/1980 (11) 2342-4336
cdigo 36
01 /*---------------------------------------------------
02 *
03 * Exemplo de aplicao com o objetivo de apresentar
04 * um conjunto de informaes na tela de maneira tabulada
05 * por meio dos cdigos de barra invertida
06 *
08 *
09 * Importante: Como a apresentao de informaes na
10 * tela em modo console (ou prompt de comando) no
11 * demonstra adequadamente os acentos da lngua
12 * portuguesa, TODAS as sadas e informaes textuais
13 * foram propositalmente codificadas SEM acento.
14 *----------------- ---------------------------------*/
15
16 /*-----------------------------------------------------
17 * BIBLIOTECAS
18 *---------------------------------------------------*/
20
21 /*----------------------------------------------------*
23 *---------------------------------------------------*/
24 int main()
25 {
27 char titulo_do_programa[30] = INFORMACOES PESSOAIS;
28
29 char pessoa1_nome[20] = Joao da Silva;
30 char pessoa1_datanascimento[20] = 03/04/1968;
31 char pessoa1_telefone[20] = (11) 3323-2233;
32
33 char pessoa2_nome[20] = Carlos Antonio;
36
37 char pessoa3_nome[20] = Francisco Jose;
40
41 char pessoa4_nome[20] = Ana Maria;


44
45 // APRESENTAO DAS INFORMAES NA TELA
// Construo de uma interface grfica utilizando cdigos da tabela ASCII e os
46
cdigos de barra invertida
47 printf(%c,201);
48 printf(%c%c%c%c%c%c%c%c%c,205,205,205,205,205,205,205,205,205,205);
53 printf(%c\n,187);
54 printf(%c %s\t\t\t %c\n,186,titulo_do_programa,186);
55 printf(%c,200);
61 printf(%c \n\n,188);
62
63
64 // Tabulao dos dados com os cdigos de barra invertida
65 printf(NOME \t \t DT.NASC. \t TELEFONE \n);
printf(%s \t %s \t %s \n, pessoa1_nome, pessoa1_datanascimento,pessoa1_
66
telefone);
67
telefone);
68
telefone);
69
telefone);
70
72 }
fim cdigo 36

11) Altere o programa anterior para que todas as informaes sejam apresentadas em
forma de tabela. Para isso, utilize os caracteres ASCII para separao dos dados.
cdigo 37
01 /*--------------------------------------------
02 *
03 * Exemplo de aplicao com o objetivo de apresentar
04 * um conjunto de informaes na tela de maneira tabulada
05 * por meio dos cdigos de barra invertida
06 *
08 *
09 * Importante: Como a apresentao de informaes na tela
10 * em modo console (ou prompt de comando) no
11 * demonstra adequadamente os acentos da lingua
12 * portuguesa, TODAS as sadas e informaes textuais
13 * foram propositalmente codificadas SEM acento.
14 *------------------------------------------*/
15
16 /*--------------------------------------------
17 * BIBLIOTECAS
18 *------------------------------------------*/
20
21 /*-------------------------------------------*
23 *------------------------------------------*/
24 int main()
25 {
27 char titulo_do_programa[30] = INFORMACOES PESSOAIS;
28

29 char pessoa1_nome[20] = Joao da Silva;

31 char pessoa1_telefone[20] = (11)3323-2233;
32
33 char pessoa2_nome[20] = Carlos Antonio;
36
37 char pessoa3_nome[20] = Francisco Jose;
40
41 char pessoa4_nome[20] = Ana Maria;
44
46 // Construo de uma interface grfica utilizando cdigos da tabela ASCII
47 printf(%c, 218);
54 printf(%c%c%c,196,196,196,196);
56 printf(%c %s\t\t\t\t\t %c\n,179,titulo_do_programa,179);
57 printf(%c,195);
64 printf(%c%c%c,196,196,196,196);
65 printf(%c \n,180);
66
67 // Tabulao dos dados com os cdigos de barra invertida
68 printf(%c NOME \t \t%c DT.NASC. \t%c TELEFONE \t %c \n,179,179,179,179);
69 printf(%c,195);
76 printf(%c%c%c,196,196,196,196);
77 printf(%c \n,180);
printf(%c %s \t%c %s \t%c %s %c \n,179, pessoa1_nome, 179, pessoa1_
78
datanascimento, 179,pessoa1_telefone,179);
79 printf(%c,195);
86 printf(%c%c%c,196,196,196,196);
87 printf(%c \n,180);
printf(%c %s \t%c %s \t%c %s %c \n,179, pessoa2_nome, 179, pessoa2_
88
datanascimento,179,pessoa2_telefone,179);
89 printf(%c,195);
96 printf(%c%c%c,196,196,196,196);
97 printf(%c \n,180);
printf(%c %s \t%c %s \t%c %s %c\n,179, pessoa3_nome, 179, pessoa3_
98
99 printf(%c,195);
106 printf(%c%c%c,196,196,196,196);
107 printf(%c \n,180);
printf(%c %s \t\t%c %s \t%c %s %c \n,179, pessoa4_nome, 179, pessoa4_
108
109 printf(%c,192);
116 printf(%c%c%c,196,196,196,196);
117 printf(%c \n,217);
118
120 }
fim cdigo 37


12) O Imposto sobre a Propriedade de Veculos Automotores, conhecido comumente

como IPVA, um tributo aplicado a todos os proprietrios de veculos automotores. A
alquota utilizada para o clculo do imposto determinada por cada governo estadual
com base em um critrio prprio. A base de clculo do imposto o valor venal do ve-
culo. Dentro desse contexto, escreva, na linguagem C, um programa capaz de calcular
o valor do IPVA de um veculo do tipo automvel. Para isso, o programa dever solici-
tar ao usurio o valor venal do veculo e em seguida a alquota do imposto. O imposto
pago dever ser calculado e apresentado na tela.
cdigo 38
01 /*---------------------------------------------------
02 *
03 * Exemplo de aplicao com o objetivo de calcular o valor do
04 * IPVA de uma automvel de passeio.
05 *
07 *
08 *-------------------------------------------------*/
09
10 /*---------------------------------------------------
11 * BIBLIOTECAS
12 *-------------------------------------------------*/
14
15 /*--------------------------------------------------*
17 *-------------------------------------------------*/
18 int main()
19 {
21 char titulo_do_programa[30] = CALCULO DO IPVA;
22 float valor_venal_veiculo;
23 float aliquota_ipva;
24 float total_imposto;
25
28 printf(%c,201);
35 printf(%c %s\t\t\t %c\n,186,titulo_do_programa,186);
36 printf(%c,200);
42 printf(%c \n\n,188);
43
44 printf(Informe o valor venal do veiculo: );
45 scanf(%f,&valor_venal_veiculo);
46
47 printf(Informe a aliquota do imposto (Exemplo 4% = 0.04): );
48 scanf(%f,&aliquota_ipva);
49
50 //calculo do imposto
51 total_imposto = valor_venal_veiculo*aliquota_ipva;
52
53
54 //apresentao dos resultados (sada na tela)
55 printf(\n\n>>> RESULTADO <<< \n);
56 printf(......Total de imposto a ser pago R$ %0.2f \n, total_imposto);
57
58
60
61 }
fim cdigo 38


13) Escreva um programa capaz de calcular e apresentar em metros por segundo o valor
da velocidade de um maratonista que tenha percorrido uma determinada distncia
em quilmetros em um determinado tempo, marcado em segundos. Para isso utilize
a seguinte frmula: Velocidade = (Distncia em quilmetros * 1000) / (Tempo em mi-
nutos * 60).
cdigo 39
01 /*---------------------------------------------------
02 *
03 * Exemplo de aplicao com o objetivo de calcular a velocidade
04 * de um maratonista em metros por segundo
05 *
07 *
08 *-------------------------------------------------*/
09
10 /*---------------------------------------------------
11 * BIBLIOTECAS
12 *-------------------------------------------------*/
14
15 /*--------------------------------------------------*
17 *-------------------------------------------------*/
18 int main()
19 {
21 char titulo_do_programa[30] = MARATONA;
22 float distancia_quilometros;
23 float distancia_metros;
24 float tempo_minutos;
25 float tempo_segundos;
26 float velocidade_maratonista;
27
printf(%c%c%c%c%c%c%c%c%c,178,178,178,178,178,178,
30
178,178,178,178);
31
178,178,178,178);
32
178,178,178,178);
34
35 printf(%c%c%c%c%c%c%c%c,176,176,176,176,176,176,176,176);
36 printf( %s ,titulo_do_programa);
37 printf(%c%c%c%c%c%c%c%c\n,176,176,176,176,176,176,176,176);
41 printf(%c\n\n,178);
42
43 printf(Informe a distancia em Km: );
44 scanf(%f,&distancia_quilometros);
45
46 printf(Informe o tempo em minutos: );
47 scanf(%f,&tempo_minutos);
48
49 //calculos necessrios
50 distancia_metros = distancia_quilometros*1000;
51 tempo_segundos = tempo_minutos*60;
52 velocidade_maratonista = distancia_metros/tempo_segundos;
53
54
55 //apresentao dos resultados (sada na tela)
56 printf(\n\n>>> RESULTADO <<< \n);
printf(......Velocidade do maratonista em Metros por segundo = %0.2f \n,
57
velocidade_maratonista);
58
59
61 }
fim cdigo 39



A elaborao de programas de computador envolve questes tericas e prticas. Por isso,
essencial que voc esteja sintonizado com os assuntos tericos e, principalmente, que saiba
como aplic-los em problemas prticos. As questes autoavaliativas dessa unidade abordam as-
pectos fundamentais da construo de programas. O conhecimento desses aspectos ser essen-
cial ao longo do estudo das outras unidades. Aproveite para realizar uma reviso. Bons estudos!
1) Relate a importncia de Dennis Ritchie no desenvolvimento de programas.
2) Qual a estrutura bsica de um programa na linguagem C?
3) Nos cdigos de programao, reflita sobre a utilidade da diretiva #include e do bloco main{ .... }.
4) Quais relaes podem ser definidas em uma anlise comparativa entre a estrutura bsica de algoritmos e pro-
gramas na linguagem C?
5) Considerando que os dados se dividem em tipos especficos em funo das caractersticas das informaes que
eles armazenam, explique os tipos de dados int, char, float e void.
6) O que uma varivel? Apresente um exemplo de declarao de uma varivel do tipo int, uma do tipo char, uma
do tipo float e uma do tipo void.
7) O que um operador de atribuio?
8) Refletindo sobre a sintaxe de um comando de atribuio, ilustre, por meio de um cdigo na linguagem C, a atri-
buio do valor 42 para uma varivel do tipo int.
9) Ilustre, por meio de um cdigo na linguagem C, a atribuio do valor 25.98 para uma varivel do tipo float.
10) Explique o que ocorre quando um valor do tipo 25.66 atribudo para uma varivel do tipo int.
11) Apresente um exemplo de um comentrio de uma nica linha e um exemplo de um comentrio com mltiplas
linhas.
12) Qual a utilidade da inicializao das variveis? E qual sua relao com o lixo de memria?
13) Pensando na definio de constantes, explique a sintaxe de declarao de uma constante.
14) Explique o conceito case-sensitite.

15) Os nomes utilizados para definir variveis e constantes so chamados de identificadores. Apresente pelo me-
nos cinco identificadores vlidos e cinco identificadores invlidos na linguagem C e explique o porqu de essa
linguagem ser chamada de case-sensitite.
16) O que so os comandos de entrada e os comandos de sada?
17) O que so especificadores de formato?
18) Qual a utilidade do especificador de formato %s?
19) Qual especificador de formato utilizado para o tipo de dados double?
20) Qual a utilidade do especificador de formato %x?
21) Qual especificador de formato utilizado para o tipo de dados int?
22) Qual especificador de formato utilizado para exibir endereos de memria?
23) Explique a sintaxe da instruo scanf e a utilidade do smbolo &.
24) Quais so os principais comandos que fazem parte da biblioteca stdio.h?
25) Qual a diferena entre as instrues getchar() e getch()?
26) Explique como uma varivel do tipo char pode ser utilizada para armazenar um conjunto de caracteres.
27) Declare uma varivel capaz de armazenar o nome completo de uma pessoa.
28) Declare uma varivel capaz de armazenar a idade de uma pessoa.
29) Declare uma varivel capaz de armazenar o salrio de uma pessoa.
30) Qual a utilidade do comando gets?
31) Qual a funo do cdigo de barra invertida \n e a funo do cdigo de barra invertida \t?
32) Qual cdigo de barra invertida, no comando printf, utilizado para exibir uma aspa dupla?
33) Qual cdigo de barra invertida, no comando printf, utilizado para exibir uma barra invertida?
34) Explique como realizado o controle de preciso nos comandos de sada.
35) Qual a utilidade dos comandos putchar e puts?
36) Quais so os principais operadores aritmticos da linguagem de programao C?
37) Qual a utilidade do operador ++ e a do operador --?
38) Qual a diferena entre operao pr-fixada e ps-fixada?
39) Explique qual a funo do operador +=.
40) Quais so os principais operadores de igualdade da linguagem de programao C?
41) Quais so os principais operadores relacionais da linguagem de programao C?
42) Quais so os principais operadores lgicos da linguagem de programao C?
43) Explique pelo menos trs funes da biblioteca matemtica math.h.
44) Explique pelo menos trs funes da biblioteca matemtica string.h.

13. CONSIDERAES
Enfim, terminamos o contedo da Unidade 2. Este o momento para treinarmos os con-
ceitos apresentados ao longo desta unidade. Por isso, importantssimo que voc estude os
exerccios resolvidos.

SCHILDT, H. C completo e total. So Paulo: Makron Books, 1997.
Estruturas de Controle
1. OBJETIVOS
Controlar o fluxo de execuo dos algoritmos por meio das estruturas condicionais.
Especificar blocos de comando por meio das estruturas de repetio.
2. CONTEDOS
Estruturas de controle.
Estruturas condicionais.
Estruturas de repetio.

guir:
1) Sugerimos a leitura da obra ASCENCIO, A. F. G. Fundamentos da programao de com-
putadores: algoritmos, Pascal e C/C++. So Paulo: Prentice Hall, 2002. Para o estudo
desta unidade, voc pode ler o captulo 3, Estrutura condicional, e o 4, Estrutura de
repetio.
2) Utilize o ambiente de desenvolvimento para implementar os programas disponveis
em "Exerccios Resolvidos". Alm disso, aproveite para comparar a sada da sua imple-
mentao com a sada de cada algoritmo. Essas implementaes sero fundamentais
para seu aprendizado.
3) Revise os conceitos estudados at o momento. Eles sero essenciais para compreen-

der o contedo desta unidade.
4. INTRODUO UNIDADE
Na unidade anterior, pudemos estudar os conceitos fundamentais para a construo de
programas, desde variveis at expresses lgicas e aritmticas. Nesta unidade, teremos a pos-
sibilidade de aprender recursos mais avanados para o desenvolvimento de programas, conhe-
cidos como estruturas de controle.
As estruturas de controle fornecem ao programador um mecanismo para controlar o fluxo
de execuo dos programas. Esses mecanismos so conhecidos como estruturas condicionais e
estruturas de repetio.
Uma estrutura condicional permite ao programador determinar, com base em uma ex-
presso lgica, se um trecho do programa deve ser executado. As estruturas condicionais da
linguagem C so: if, if-else e switch.
Com uma estrutura de repetio, voc pode observar que possvel definir que a execu-
o de um trecho do cdigo seja repetida por um determinado nmero de vezes. As estruturas
de repetio tambm so conhecidas como laos de repetio. Na linguagem C, h trs meca-
nismos de repetio: for, while e do-while.
Nesta unidade, aprenderemos como criar programas utilizando as estruturas de controle
(tanto as condicionais quanto as de repetio).
5. ESTRUTURA CONDICIONAL
Na linguagem de programao C, h trs tipos de estruturas condicionais:
estrutura condicional simples;
estrutura condicional composta;
estrutura seleo mltipla.
Essas estruturas possibilitam a definio do trecho do cdigo-fonte, que ser executado
com base em uma ou mais condies lgicas.
Vamos conhec-las melhor.
Estrutura condicional simples (if)

Na estrutura condicional simples, a execuo de um trecho do cdigo-fonte depende do
resultado de uma condio, a qual pode ser especificada utilizando as expresses aritmticas,
relacionais ou lgicas discutidas na unidade anterior.
Uma estrutura condicional simples possui a seguinte sintaxe:
1 if ( condicao )
2 {
3
//trecho do cdigo
4 }
U3 Estruturas de Controle 119
O trecho do cdigo ser executado sempre que a condio definida for verdadeira. Na lin-
guagem C, para que uma expresso lgica seja verdadeira, seu resultado deve ser diferente de
zero. As expresses lgicas com resultados iguais a zero so representadas como falsas.
Na sintaxe anterior, os smbolos { e } delimitam o trecho do cdigo que pertence a estru-
tura condicional.
O Cdigo 1 demonstra a utilizao da estrutura condicional simples associada aos opera-
dores de igualdade. Acompanhe-o atentamente.
cdigo 1
1 /*
2 * Programa para demonstrar a utilizao
3 * de estruturas condicionais simples
4 *
6 */
7
9
10 int main()
11 {
12 int a, b;
13
14 printf(Informe o valor de A: );
15 scanf(%i,&a);
16 printf(Informe o valor de B: );
17 scanf(%i,&b);
18
19 if ( a == b )
20 {
21 printf(A e igual a B \n);
22 }
23
24 if ( a != b )
25 {
26 printf(A e diferente de B \n);
27 }
28
29 return 0;
30 }
fim cdigo 1

Informe o valor de A: 10
Informe o valor de B: 20
A e diferente de B
No Cdigo 1, voc pode observar que as mensagens do comando de sada printf so exi-
bidas somente quando a condio da expresso lgica satisfeita.

No exemplo do Cdigo 2, a estrutura condicional simples empregada juntamente com

os operadores relacionais.
cdigo 2
1 /*
3 * de estruturas condicionais simples
4 *
6 */
7
9
10 int main()
11 {
12 int a, b;
13
14 printf(Informe o valor de A: );
15 scanf(%i,&a);
16 printf(Informe o valor de B: );
17 scanf(%i,&b);
18
19 if ( a > b )
20 {
21 printf(A e maior que B \n);
22 }
23
24 if ( a < b )
25 {
26 printf(A e menor que B \n);
27 }
28
29 if ( a >= b )
30 {
31 printf(A e maior ou igual a B \n);
32 }
33
34 if ( a <= b )
35 {
36 printf(A e menor ou igual a B \n);
37 }
38
39 return 0;
40 }
fim cdigo 2

A e menor que B
A e menor ou igual a B

A e maior que B
A e maior ou igual a B
Estrutura condicional composta (if-else)

Enquanto na estrutura condicional simples podemos especificar tomadas de deciso ape-
nas quando o resultado da expresso lgica verdadeiro, na estrutura condicional composta po-
demos definir como ser o comportamento do programa para condies verdadeiras ou falsas.
A sintaxe da estrutura condicional composta definida do seguinte modo:
1 if ( condicao )
2 {
3 // trecho do cdigo 1
4 }
5 else {
6 // trecho do cdigo 2
7 }
O trecho do Cdigo 1 (Linha 3) ser executado apenas quando o resultado da condio for
verdadeiro (diferente de zero), enquanto o trecho do Cdigo 2 (Linha 6) ser executado apenas
quando a condio for falsa (igual a zero).
No Cdigo 3 do programa a seguir, demonstrada a utilizao da estrutura condicional
composta. Este exemplo tem como objetivo calcular o peso ideal de uma pessoa. Para isso, o
programa deve receber sua altura e sexo, e, com base nas frmulas descritas a seguir, dever
determinar o peso ideal:
frmula do peso ideal para homens: (72,7 * altura) 58,0;
frmula do peso ideal para mulheres: (62,1 * altura) 44,7.
cdigo 3
1 /*
3 * de estruturas condicionais compostas
4 *
6 */
7

9 #include <ctype.h>
10
11 int main()
12 {
13 float altura, pesoideal;
14 char sexo;
15
16
17 printf(Informe a altura: );
18 scanf(%f,&altura);
19
20 fflush(stdin);
21 printf(Informe o sexo [m = masculino; f = feminino]: );
22 scanf(%c,&sexo);
23
24 //Converso do caractere de Minsculo para Maisculo
25 sexo = toupper(sexo);
26
27 //clculo do peso ideal
28 if ( sexo == M)
29 {
30 printf(\nMasculino\n);
31 pesoideal = (72.7 * altura) - 58.0;
32 }else{
33 printf(\nFeminino\n);
34 pesoideal = (62.1 * altura) - 44.7;
35 }
36
37 //resultado
38 printf(Seu peso ideal e = %.2f , pesoideal);
39
40 return 0;
41 }
fim cdigo 3

Informe a altura: 1.80
Informe o sexo [m = masculino; f =
feminino]: m
Masculino
Seu peso ideal e = 72.86
Veja que o Cdigo 3, no programa anterior, alm de exemplificar a utilizao da estrutura

condicional composta, demonstra dois recursos interessantes da linguagem C.
O primeiro o comando fflush(stdin), inserido na Linha 20, antes da leitura do caractere
referente ao sexo do usurio. Esse comando muito til, pois realiza a limpeza do buffer do te-
clado. O buffer do teclado contm todos os dados digitados pelo usurio. Assim, com o coman-
do que limpa os dados, ele estar vazio para a prxima leitura. Em alguns casos, sem a utilizao
do comando fflush, o programa pode no executar a instruo scanf(%c,&sexo), uma vez que
o buffer pode conter dados desnecessrios.
Outro recurso interessante a utilizao do comando toupper, responsvel pela conver-
so de um caractere minsculo para maisculo. Caso o usurio tenha digitado o sexo m, por
exemplo, o comando toupper realizar a converso desse caractere para maisculo, ou seja,
para M. Alm do comando toupper, h o comando tolower, que realiza o processo inverso,
converte um caractere maisculo para minsculo (M para m). Ambos esto disponveis na
biblioteca ctype.h. Se esse comando no fosse utilizado, precisaramos alterar a estrutura con-
dicional, conforme est demonstrado na Linha 28 a seguir.
28 if ( ( sexo == M) || ( sexo == m) )
Utilizando uma estrutura condicional composta, diversos testes condicionais podem ser
executados. Com isso, podemos avaliar sucessivamente vrias condies at que um determi-
nado trecho seja executado. Esse tipo de estrutura conhecido como condicional aninhada.
No Cdigo 4, o programa recebe como entrada o tipo do funcionrio e o valor do salrio
mensal. Os funcionrios do tipo Gerente (G), que atingirem um total de vendas superior a R$
100.000,00, devero ter um bnus de R$ 350,00 no salrio, caso contrrio, recebero apenas o
salrio. J os funcionrios do tipo Vendedor (V), que venderem acima de R$ 5.000,00 ganharo
uma comisso de 5% sobre o valor vendido, caso contrrio, a comisso de 2%.
cdigo 4
1 /*
3 * de estruturas condicionais compostas
4 * com if aninhado
5 *
7 */
8
11
12 int main()
13 {
14 float salario, cotavendas,totalvendas;
15 float novosalario;
16 char tipofuncionario;
17
18 //leitura das variveis
19 printf(Tipo funcionario [g=gerente; v=vendedor] : );
20 scanf(%c,&tipofuncionario);
21 printf(Salario: );
23
24 //Converso para Minsculo
25 tipofuncionario = tolower(tipofuncionario);

26
27 if ( tipofuncionario == g)
28 {
29 /*
30 * funcionrio = Gerente
31 */
32 printf(Cota de vendas: );
33 scanf(%f,&cotavendas);
34
35 if ( cotavendas >= 100000)
36 {
37 novosalario = salario + 350.00;
38
printf(Salario mensal do Gerente= %.2f\n, novosalario);
39 }else{
40 printf(Salario mensal do Gerente= %.2f \n, salario);
41 }
42
43 }else{
44
45 /*
46 * funcionrio = Vendedor
47 */
48
49 if ( tipofuncionario == f)
50 {
51 printf(Total vendido: );
52 scanf(%f,&totalvendas);
53
54 if ( totalvendas >= 5000)
55 {
56 // comisso de 5%
57 novosalario = salario + (salario * (5/100));
58 }else{
59 //comisso de 2%
60 novosalario = salario + (salario * (2/100));
61 }
62
63
printf(Salario mensal do Vendedor= %.2f\n, novosalario);
64
65 }else{
66 printf(Tipo de funcionario invlido.\n);
67 }
68 }
69
70 return 0;
71 }
fim cdigo 4

Tipo funcionario [g=gerente; v=vendedor] : G
Salario: 2500.00
Cota de vendas: 125000.00
Salario mensal do Gerente = 2850.00
O Cdigo 5 demonstra a utilizao da estrutura condicional composta combinada com

os operadores lgicos. Este programa tem como objetivo receber duas notas, calcular a mdia
aritmtica e exibir uma mensagem segundo o Quadro 1.
Quadro 1 Mensagens para o resultado da execuo do programa.

DADOS NECESSRIOS PARA A EXECUO DO PROGRAMA 5
MDIA ARITMTICA MENSAGEM
Maior ou igual a zero e menor que 2,0 Reprovado
Maior ou igual a 2,0 e menor que 5,0 Exame
Maior ou igual a 5,0 Aprovado
cdigo 5
1 /*
3 * de estruturas condicionais composta
4 * com os operadores lgicos
5 *
7 */
8
10
11 int main()
12 {
13 float nota1, nota2;
14 float media;
15
17 printf(Informe a 1a nota : );
18 scanf(%f,&nota1);
19 printf(Informe a 2a nota : );
21
22 //clculo da mdia
23 media = (nota1+nota2) /2;
24 printf(Media = %.1f \n, media);
25
26 if ( ( media >= 0 ) && ( media < 2 ) )
27 {
28
29 printf(Reprovado \n);
30
31 }else{

32
33 if ( ( media >= 2 ) && ( media < 5 ) ) {
34 printf(Exame \n);
35 }else{
36 printf(Aprovado \n);
37 }
38
39 }
40
41 return 0;
42 }
fim cdigo 5

Informe a 1a nota : 8.5
Informe a 2a nota : 6.4
Media = 7.4
Aprovado
Estrutura de seleo mltipla (switch)

A estrutura de mltipla escolha switch uma maneira alternativa de testar o valor de uma
varivel, segundo uma determinada condio. Essa estrutura pode ser empregada apenas para
variveis do tipo int ou char. Sua sintaxe definida a seguir.
1 switch( variavel )
2 {
3 case valor1:
4 // trecho do cdigo
5 break;
6
7 case valor2:
9 break;
10
11 case valor3:
13 break;
14
15 default:
17
18 }
Vamos conhecer o funcionamento da estrutura switch no programa descrito no Cdigo 6.

Neste exemplo, ser exibido na tela o cargo do funcionrio, com base no cdigo informado pelo
usurio. Veja os cargos disponveis especificados no Quadro 2.
Quadro 2 Cargos dos funcionrios.

CDIGOS DOS CARGOS DOS FUNCIONRIOS
CDIGO CARGO
1 Diretor
2 Gerente de projeto
3 Programador
4 Estagirio
cdigo 6
1 /*
3 * de estruturas de seleo mltipla
4 *
6 */
7
9
10 int main()
11 {
12 int codigo;
13
15 printf(Informe o tipo do funcionario: );
16 scanf(%i,&codigo);
17
18 switch(codigo)
19 {
20 case 1:
21 printf(Diretor \n);
22 break;
23
24 case 2:
25 printf(Gerente de Projeto \n);
26 break;
27
28 case 3:
29 printf(Programador \n);
30 break;
31
32 case 4:
33 printf(Estagiario \n);
34 break;
35
36 default:
37 printf(Tipo de funcionario invalido \n);
38 }
39

40 return 0;
41 }
fim cdigo 6

Informe o tipo do funcionario: 3
Programador
No exemplo anterior, no Cdigo 6, a estrutura switch analisa o valor da varivel cdigo e

compara com os valores definidos aps cada um dos casos (case). importante lembrar que o
tipo da varivel entre parnteses deve ser int ou char. Os casos possveis tambm devem ser do
tipo int ou char e sempre devem ser finalizados por dois pontos (:).
Ao final de cada caso, deve ser inserida a instruo break. Esse comando garante que ape-
nas aquele caso seja executado. Caso no se insira esse comando, o programa executar todos
os casos possveis da estrutura.
A estrutura switch possui, ainda, um caso especial rotulado como default. Esse caso ocor-
rer sempre que nenhum dos casos anteriores for executado. Entretanto, importante notar
que o caso default no obrigatrio.
6. ESTRUTURA DE REPETIO
Ao longo desta unidade, voc ter a oportunidade de estudar as estruturas de repetio.
Essas estruturas so utilizadas para solucionar muitos problemas encontrados na construo de
programas.
As estruturas de repetio, tambm conhecidas como laos, so utilizadas para indicar
trechos do cdigo-fonte que devero ser repetidos. Elas so muito empregadas no desenvolvi-
mento de programas, pois facilitam o trabalho do programador na elaborao do cdigo-fonte.
H, tambm, milhares de problemas computacionais que envolvem a repetio de trechos
do cdigo-fonte. Esses problemas podem ser facilmente solucionados por meio das estruturas
de repetio. A linguagem C possui trs tipos de estrutura de repetio:
for;
while;
do...while.
Estrutura de repetio for

Na estrutura de repetio for, o programador pode definir quantas vezes um determinado
trecho do cdigo-fonte deve ser repetido. Para isso, necessrio definir uma varivel especial
conhecida como contador. Essa varivel responsvel por contar o nmero de vezes que o tre-
cho do cdigo foi repetido.
Observe, a seguir, a sintaxe da estrutura for.
1
for ( <inicializao>; <condio_parada>; <incremento_decremento> )
2 {
3
5
6 }
O parmetro de inicializao da estrutura define o valor inicial que ser atribudo va-
rivel contador. A condio de parada determina qual valor dever ser atingido pela varivel
contadora (ou valor final). J o parmetro de incremento ou decremento especifica como ser o
comportamento do contador. Podemos definir um contador incremental (++), no qual seu valor
sempre ser acrescido, ou podemos especificar um contador decremental (--), em que seu valor
ser decrescido.
O Cdigo 7 demonstra a utilizao do comando for para exibir na tela nmeros entre 1 e
10. Neste exemplo, foi utilizado um contador incremental de um em um.
cdigo 7
1 /*
3 * da estrutura de repetio for
4 *
6 */
7
9
10 int main()
11 {
12 int contador;
13
14 for ( contador = 1; contador <= 10; contador++)
15 {
16 printf(%i \n, contador);
17 }
18
19 return 0;
20 }
fim cdigo 7

1
2
3
4
5
6
7
8
9
10

No prximo exemplo, no Cdigo 8, observe que o conjunto de nmeros que ser impresso
na tela determinado em funo dos valores informados pelo usurio. Nesse caso, a varivel
valor_inicial representa o valor inicial que ser atribudo ao contador, enquanto a varivel va-
lor_final determina a condio de parada da contagem.
cdigo 8
1 /*
3 * da estrutura de repetio for
4 *
6 */
7
9
10 int main()
11 {
12 int contador;
13 int valor_inicial, valor_final;
14
15 printf(Informe o valor inicial: );
16 scanf(%i,&valor_inicial);
17 printf(Informe o valor final: );
18 scanf(%i,&valor_final);
19
20
for (contador=valor_inicial; contador<=valor_final; contador++)
21 {
22 printf(%i \n, contador);
23 }
24
25 return 0;
26 }
fim cdigo 8

Informe o valor inicial: 18
Informe o valor final: 22
18
19
20
21
22
Veja que ainda temos mais uma situao em que muitos problemas computacionais en-
volvem estruturas de repetio e necessitam que o valor de uma determinada varivel seja
acumulado ao longo dos laos de repetio. Esse recurso de acumular o valor de uma varivel
conhecido como Acumulador.
Embora na maioria das vezes esse mecanismo seja empregado para acumular a soma de
uma varivel, tambm podemos utiliz-lo para acumular a subtrao, a multiplicao ou a divi-
so. Entretanto, importante observar que, para utilizarmos acumuladores, sempre necess-
rio inicializar a varivel utilizada como acumulador com o valor zero (exceto para multiplicao,
em que se deve ser inicializado com 1). Com isso, podemos garantir que nenhum valor prvio
afetar o processo do acumulador.
O programa a seguir (Cdigo 9) demonstra a utilizao do recurso de acumulador para
somar os nmeros entre 1 e 10.
cdigo 9
1 /*
3 * do acumulador
4 *
6 */
7
9
10 int main()
11 {
12 int i; // contador
13 int soma;
14
15 //inicializao do acumulador
16 soma = 0;
17
18 for( i = 1; i <= 10; i++)
19 {
20 //acumulador
21 soma += i;
22 }
23
24 printf(Soma = %i \n, soma);
25
26 return 0;
27 }
fim cdigo 9

Soma = 55
Veja que, no exemplo do programa apresentado no Cdigo 9, a varivel soma acumula os

valores: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 (Linha 21). E, por fim, o resultado apresentado na tela (Linha
24).
Estrutura de repetio while

A estrutura de repetio while permite ao programador definir um lao de repetio en-
quanto uma condio for verdadeira. Essa estrutura tem a mesma funcionalidade da estrutura

de repetio for. No entanto, a estrutura while pode ser utilizada em problemas em que no
sabemos o nmero de vezes que o lao de repetio ser repetido.
Dessa forma, a estrutura while pode ser empregada em laos de repetio com ou sem
contadores. A sintaxe da estrutura while sem contador definida como segue:
1 while ( <condicao> )
2 {
3 // trecho de cdigo
4 }
Na estrutura de repetio, o trecho de cdigo ser repetido enquanto a condio especi-

ficada for verdadeira. importante lembrar que a condio verdadeira significa que o resultado
deve ser diferente de zero.
Para uma estrutura while com contador, temos a seguinte sintaxe:
1 <inicializao>
2 while ( condicao )
3 {
4
5 <incremento ou decremento>
6 }
Quando utilizamos a estrutura de repetio com contador, devemos observar que a ini-
cializao da varivel contadora deve ser realizada antes da estrutura (Linha 1). Alm disso,
necessrio especificar o incremento ou decremento da varivel contadora (Linha 5).
O comparativo a seguir demonstra a utilizao das estruturas de repetio for e while na
resoluo de um mesmo problema. O objetivo exibir dez vezes o nome do usurio na tela.
Observe as duas estruturas.
Soluo utilizando for:
1 for ( i = 1; i <= 10; i++)

2 {
3 printf(%s \n, Joao da Silva);
4 }
Soluo utilizando while:
1 i = 1;
2 while ( i <= 10 )
3 {
4 printf(%s \n, Joao da Silva);
5 i++;
6 }
Alternativamente, podemos criar uma soluo em que o nmero de repeties indefini-

do. Nesse caso, o nome ser exibido na tela at que o usurio no deseje mais isso. Observe o
programa completo apresentado no Cdigo 10, a seguir.
cdigo 10
1 /*
2 * Programa para exemplificar a estrutura
3 * de repetio while sem contador.
4 *
6 */
7
9
10 int main()
11 {
12
13 char nome[20];
14 char continuar;
15
17 gets(nome);
18
19 continuar = s;
20
21 while ( continuar == s )
22 {
23 printf(\n%s \n, nome);
24
25 printf(Deseja continuar [S ou N]? );
26 continuar = getche();
27 }
28
29 return 0;
30 }
fim cdigo 10


Joao da Silva
Deseja continuar [S ou N]? s
Joao da Silva
Joao da Silva
Joao da Silva
Joao da Silva
Joao da Silva
Joao da Silva
Deseja continuar [S ou N]? n
Voc pode observar nesse exemplo que no existe uma varivel contadora. Ao contrrio,
a repetio da estrutura determinada pela varivel continuar. O usurio deve informar, a cada
repetio, se deseja (ou no) continuar com o lao.
No prximo exemplo, no Cdigo 11, utilizaremos a estrutura while para ler um conjunto
de notas das provas realizadas pelos alunos do Claretiano. O lao de repetio ser executa-
do sempre que uma nota vlida for informada. Uma nota vlida precisa, necessariamente, ser
maior ou igual a zero, e menor ou igual a dez. Ao final, o algoritmo exibir a quantidade de notas
vlidas lidas, alm da mdia das notas.
cdigo 11
1 /*
3 * da estrutura while
4 *
6 */
7
9
10 int main()
11 {
12 float nota = 0;
13 float soma = 0;
14 int totalnotas = 0;
15
16 while ( (nota >= 0) && (nota <= 10) )
17 {
18
19 printf(Nota: );
20 scanf(%f,&nota);
21
22 if ( (nota >= 0) && (nota <= 10) )
23 {
24 soma = soma + nota;

25 totalnotas++;
26 }
27
28 }
29
30 // exibir resultado
31 printf(Total de notas lidas: %i \n, totalnotas);
32 printf(Media das notas: %.1f \n, (soma/totalnotas) );
33
34 return 0;
35 }
fim cdigo 11
Nota: 5.5
Nota: 9.8
Nota: 6.2
Nota: 7.4
Nota: -1
Total de notas lidas: 4
Media das notas: 7.2
Observe que, no Cdigo 11 (exemplo anterior), a condio de parada da estrutura de repe-

tio a leitura de uma nota fora do intervalo, ou seja, uma nota menor que zero ou uma nota
maior que 10. Esse caso, tambm, um exemplo de como criar uma estrutura de repetio sem
a utilizao de contadores.
Estrutura de repetio do...while

A estrutura de repetio do...while outra maneira de produzir um lao de repetio em
um programa. Essa estrutura permite ao programador especificar a repetio de um trecho do
cdigo-fonte at que uma determinada condio se torne verdadeira.
Nessa estrutura, o teste da condio de parada realizado ao final do lao de repetio.
Essa a principal diferena em relao estrutura while. Veja a sintaxe da estrutura:
1 do{
2
3 //trecho do cdigo
4
5 }while ( <condicao> );
A condio de parada da estrutura do...while definida por meio de uma expresso lgi-
ca, que pode conter operadores lgicos e relacionais.
O prximo programa, descrito no Cdigo 12, demonstra a utilizao da estrutura de repe-
tio do...while. Este exemplo tem como objetivo exibir na tela os nmeros pares entre 1 e 10.

cdigo 12
1 /*
3 * da estrutura de repetio do...while
4 *
6 */
7
9
10 int main()
11 {
12 int i;
13
14 i = 1;
15
16 do{
17
18 if ( (i % 2) == 0 )
19 {
20 printf(%i \n,i);
21 }
22 i++;
23 }while ( i <= 10 );
24
25 return 0;
26 }
fim cdigo 12

2
4
6
8
10
O prximo exemplo, no Cdigo 13, demonstra a utilizao da estrutura do...while sem

contadores. Este programa tem como objetivo receber um conjunto indeterminado de idades
de pessoas e classific-las com base no Quadro 3. O usurio dever informar quando o conjunto
terminou.
Quadro 3 Faixa de idade das pessoas.

FAIXA ETRIA DAS PESSOAS
FAIXA IDADE
1 1 15 anos
2 16 30 anos
FAIXA ETRIA DAS PESSOAS

FAIXA IDADE
3 31 45 anos
4 45 60 anos
5 > 60 > 60 anos
cdigo 13
1 /*
3 * da estrutura do...while sem contadores
4 *
6 */
7
10
11 int main()
12 {
13 int idade;
14 int faixa1, faixa2, faixa3;
15 int faixa4, faixa5;
16 char continuar;
17
18 //inicializar contadores
19 faixa1 = 0;
20 faixa2 = 0;
21 faixa3 = 0;
22 faixa4 = 0;
23 faixa5 = 0;
24
25 do{
26 printf(\nIdade: );
27 scanf(%i,&idade);
28
29 if ((idade >=0) && (idade <=15)) {
30
31 faixa1++;
32
33 }else if ((idade >=16) && (idade <=30)) {
34
35 faixa2++;
36
38
39 faixa3++;
40
42
43 faixa4++;

44
45 }else if (idade > 60) {
46
47 faixa5++;
48
49 }
50
51 fflush(stdin);
52 printf(Deseja continuar (S ou N)? );
53 continuar = getche();
54
55
}while ( (continuar == S) || (continuar == s) );
56
57
printf(\n\nNumero pessoas 1 - 15 anos: %i \n, faixa1);
58
printf(Numero pessoas 16 - 30 anos: %i \n, faixa2);
59
60
61
printf(Numero pessoas > 60 anos: %i \n, faixa5);
62
63 return 0;
64 }
fim cdigo 13

Idade: 12
Deseja continuar (S ou N)?s
Idade: 25
Idade: 36
Idade: 49
Idade: 66
Deseja continuar (S ou N)?n
Numero pessoas 1 - 15 anos: 1

Numero pessoas > 60 anos: 1
As estruturas de controle fornecem um ferramental muito poderoso para construo de

programas. Dessa forma, fundamental que voc compreenda quais so os aspectos positivos
e negativos da utilizao das estruturas de controle no desenvolvimento de programas.
Os exerccios deste tpico foram selecionados de contedos preexitentes da disciplina Al-
goritmos e Programao, com o intuito de demonstrar como possvel transformar algoritmos
em programas.
1) Escreva um programa que receba o nome e o nmero de votos de trs candidatos da

eleio para presidente. Apresente na tela o nome do candidato que venceu a eleio.
Considere que no possvel haver empate.
cdigo 14
1 /*
2 * Programa Eleio de Candidatos
3 *
5 */
6
9
10 int main()
11 {
12 char nome1[20], nome2[20], nome3[20];
13 char nome_vencedor[20];
14 int votos1, votos2, votos3;
15 int votos_vencedor;
16
17 printf(Nome do 1o. candidato: );
18 gets(nome1);
19 printf(Numero de votos do 1o candidato: );
20 scanf(%i,&votos1);
21
22 fflush(stdin);
24 gets(nome2);
27
28 fflush(stdin);
30 gets(nome3);
33
34 strcpy(nome_vencedor, nome1);
35 votos_vencedor = votos1;
36
37 if ( votos2 > votos_vencedor )
38 {
41 }
42
43 if ( votos3 > votos_vencedor )
44 {

47 }
48
49 printf(O candidato %s venceu a eleicao com %i votos \n, nome_vencedor,votos_
vencedor);
50
51 return 0;
52 }
fim cdigo 14

Nome do 1o. candidato: Jose Antonio
Numero de votos do 1o candidato: 980
Nome do 2o. candidato: Carlos Francisco
Nome do 3o. candidato: Alfredo Santos
O candidato Jose Antonio venceu a eleicao com 980
votos
2) Escreva um programa que analise os dados de uma pesquisa realizada entre os habi-
tantes da cidade de Taboo do Norte. Os dados coletados foram: idade, sexo (M/F) e
salrio. O objetivo da pesquisa saber: (a) mdia do salrio dos habitantes; (b) maior
e menor idade do grupo; (c) quantidade de mulheres com salrios superiores a R$
600,00.
A execuo do programa deve terminar quando uma idade negativa for informada.
cdigo 15
1 /*
2 * Programa para analisar os dados
3 * de uma pesquisa
4 *
6 */
7
9
10 int main()
11 {
12 int idade, contador, feminino;
13 int maior, menor;
14 float salario,soma;
15 char sexo;
16
17 //inicializao das variveis
18 idade = 0;
19 soma = 0;
20 contador = 0;
21 feminino = 0;
22
23 while ( idade >= 0 )
24 {
25 // leitura das informaes

26 printf(Idade: );
27 scanf(%i,&idade);
28 fflush(stdin);
29 printf(Sexo (M ou F): );
30 scanf(%c,&sexo);
33
34 if ( idade >= 0 ) {
35
36 // soma dos salrios
37 soma += salario;
38
39 // primeira idade informada pelo usurio
40 if ( contador == 0 ) {
41
42 maior = idade;
43 menor = idade;
44
45 }else{
46
47 //determinar maior idade
48 if ( idade > maior ) {
49 maior = idade;
50 }
51 // determinar menor idade
52 if ( idade < menor) {
53 menor = idade;
54 }
55 }
56
57 if (((sexo==F) || (sexo==f)) && (salario>600)) {
58 feminino++;
59 }
60
61 contador++;
62 }
63
64 }
65
66 // resultados
67 printf(\nMedia dos salarios R$ %.2f \n, (soma/contador) );
68 printf(Maior idade = %i \n, maior);
69 printf(Menor idade = %i \n, menor);
70 printf(Pessoas do sexo F e salario > 600.00 = %i \n, feminino);
71
72 return 0;
73 }
fim cdigo 15


Idade: 22
Sexo (M ou F): f
Salario: 850.00
Idade: 25
Sexo (M ou F): m
Salario: 500.00
Idade: -1
Sexo (M ou F): m
Salario: 200.00
Media dos salarios R$ 675.00

Maior idade = 25
Menor idade = 22
Pessoas do sexo F e salario > 600.00 = 1
3) O Cdigo Americano para Troca de Informaes, conhecido comumente como ASCII, do in-
gls American Standard Code for Information Interchange, foi criado para representar um
conjunto de caracteres para utilizao em aplicaes. Inicialmente, esse conjunto contava
com um total de 127 cdigos diferentes, desde cdigos para o controle do fluxo de dados, at
os caracteres da lngua inglesa, tais como letras maisculas e minsculas de A at Z, bem
como os dgitos de 0 (zero) a 9 (nove), e os sinais grficos de pontuao.
Com o surgimento dos microcomputadores pessoais e a popularizao mundial das
aplicaes, foi necessrio representar caracteres acentuados, especialmente por conta
da diversidade de lnguas, como, por exemplo, o portugus. Com isso, o conjunto origi-
nal (contendo 127 caracteres) foi estendido para 256 caracteres codificados, contem-
plando com isso caracteres acentuados, alm de uma srie de sinais grficos.
Para demonstrar a diversidade da ASCII, construa uma aplicao capaz de apresentar
na tela os cdigos presentes na tabela, bem como o nmero decimal referente ao c-
digo.
cdigo 16
1 /*----------------------------------------------
2 *
3 * Exemplo de um programa capaz de apresentar na tela o conjunto
4 * de caracteres da tabela ASCII.
5 *
7 *
8 *--------------------------------------------*/
9
10 /*----------------------------------------------
11 * BIBLIOTECAS
12 *--------------------------------------------*/
14
15 /*---------------------------------------------*
17 *--------------------------------------------*/
18 int main()
19 {
21 int i = 0;
22
23
24 // SADA DE DADOS
25 for ( i = 0; i < 256; i++ )
26 {
27 printf(%i \t %c \n,i,i);
28 }
29
31 }
fim cdigo 16
Na captura de tela a seguir, observe o resultado da execuo do programa no ambiente

4) Altere o programa anterior para que o usurio seja capaz de informar o intervalo que
ele deseja visualizar da tabela ASCII. Para isso, o programa dever solicitar ao usurio
um valor inicial e um valor final, os quais representam o intervalo desejado.
cdigo 17
1 /*--------------------------------------------------
2 *
3 * Exemplo de um programa capaz de apresentar na tela o conjunto
4 * de caracteres da tabela ASCII.
5 *
7 *
8 *------------------------------------------------*/
9
10 /*--------------------------------------------------
11 * BIBLIOTECAS

12 *------------------------------------------------*/
14
15 /*-------------------------------------------------*
17 *------------------------------------------------*/
18 int main()
19 {
21 char titulo_do_programa[30] = Tabela ASCII;
22 int i = 0;
23 int valor_inicial;
24 int valor_final;
25
26 //TITULO DO PROGRAMA
27 printf(%c, 218);
34 printf(%c %s\t\t\t\t %c\n,179,titulo_do_programa,179);
35 printf(%c,192);
41 printf(%c \n\n,217);
42
43
44 // ENTRADA DE DADOS
45 printf(Informe o valor inicial: );
46 scanf(%i,&valor_inicial);
47 printf(Informe o valor final: );
48 scanf(%i,&valor_final);
49
50 printf(Caracteres do intervalo informado: \n\n);
51
52 // SADA DE DADOS
53 for ( i = valor_inicial; i <= valor_final; i++ )
54 {
55 printf(%i \t %c \n,i,i);
56 }
57
59 }
fim cdigo 17

5) Um banco deseja informatizar as movimentaes da conta corrente de seus clientes.

Para isso, voc dever elaborar um programa que seja capaz de simular as operaes
de saque e depsito em uma conta corrente. Dessa maneira, o sistema dever conter
um menu principal, onde o usurio poder:
a) informar o nome do titular da conta;
b) informar o nmero da conta;
c) informar o nmero da agncia;
d) inicializar o saldo com zero;
e) realizar uma operao de saque (essa operao dever atualizar o saldo);
f) realizar uma operao de depsito (essa operao dever atualizar o saldo);
g) exibir as informaes da conta na tela;
h) sair da aplicao.
Para facilitar o funcionamento da aplicao, construa um menu no qual o usurio poder

selecionar a operao desejada.
cdigo 18
1 /*-----------------------------------------------------
2 *
3 * Exemplo de aplicao com o objetivo de demonstrar as operaes
4 * de saque e depsito na conta corrente de um cliente
5 *
7 *
8 *---------------------------------------------------*/
9

10 /*-----------------------------------------------------
11 * BIBLIOTECAS
12 *---------------------------------------------------*/
14 #include <stdlib.h> //para utilizao da instruo system
15
16 /*----------------------------------------------------*
18 *---------------------------------------------------*/
19 int main()
20 {
22 char titulo_do_programa[30] = MOVIMENTACAO CONTA CORRENTE;
23
24 //informacoes do cliente
25 char cliente_nome_titular[30];
26 int cliente_numero_conta;
27 int cliente_numero_agencia;
28 float cliente_saldo = -1;
29
30 int opcao_desejada;
31 float valor_saque;
32 float valor_deposito;
33
34
35 do{
36 //
37 // MENU PRINCIPAL
38 //
39 system(cls); //limpar as informacoes da tela
40 printf(%c,218);
47 printf(%c >>> %-39s %c \n,179,titulo_do_programa,179);
48 printf(%c,192);
55
56 printf( [1] Cadastrar cliente \n);
57 printf( [2] Inicializar saldo do cliente \n);
58 printf( [3] Realizar Saque na conta corrente \n);
59 printf( [4] Realizar Deposito na conta corrente \n);
60 printf( [5] Exibir informacoes do cliente \n);

61 printf( [0] Sair do sistema \n\n);
62
63 printf( Selecione a opcao desejada: );
64 scanf(%i,&opcao_desejada);
65
66 switch(opcao_desejada){
67
68 case 1:
70 printf(\n\n%c%c%c%c>> CADASTRAR CLIENTE \n\n,195,196,196,196);
71 fflush(stdin);
72 printf(Informe o nome do titular da conta: );
73 gets(cliente_nome_titular);
74 printf(Informe o numero da conta: );
75 scanf(%i,&cliente_numero_conta);
76 printf(Informe o numero da agencia:);
77 scanf(%i,&cliente_numero_agencia);
78
79 fflush(stdin);
printf(\nOperacao realizada com SUCESSO! \n\nPressione <ENTER> para o
80
menu principal\n\n);
81 getchar();
82
83 break;
84
85 case 2:
87 printf(\n\n%c%c%c%c>> INICIALIZAR SALDO \n\n,195,196,196,196);
88
89 cliente_saldo = 0;
90
91 fflush(stdin);
92
93 getchar();
94
95 break;
96
97 case 3:
99 printf(\n\n%c%c%c%c>> SAQUE \n\n,195,196,196,196);
100 printf(Informe o valor do saque: );
101 scanf(%f,&valor_saque);
102
103 //verificar se o saque no ir estourar a conta
104 if ( (cliente_saldo-valor_saque) >= 0 ){
105 //atualizar saldo do cliente
106 cliente_saldo = cliente_saldo - valor_saque;
107 fflush(stdin);

printf(\nOperacao realizada com SUCESSO! \n\nPressione <ENTER>

108
para o menu principal\n\n);
109 getchar();
110 }else{
111 fflush(stdin);
printf(\nO saldo da conta NAO eh suficiente para o SAQUE. A
112 operacao NAO foi realizada. \n\nPressione <ENTER> para o
113 getchar();
114 }
115 break;
116
117 case 4:
119 printf(\n\n%c%c%c%c>> DEPOSITO \n\n,195,196,196,196);
120 printf(Informe o valor do deposito: );
121 scanf(%f,&valor_deposito);
122
123 //atualizar saldo da conta
124 cliente_saldo = cliente_saldo + valor_deposito;
125
126 fflush(stdin);
127
128 getchar();
129 break;
130
131 case 5:
133 printf(\n\n%c%c%c%c>> INFORMACOES DO CLIENTE \n\n,195,196,196,196);
134 printf(Nome.............: %s\n,cliente_nome_titular);
135 printf(Numero da Agencia: %i\n,cliente_numero_agencia);
136 printf(Numero da Conta..: %i\n,cliente_numero_conta);
137 printf(Saldo............: R$ %0.2f\n\n\n, cliente_saldo);
138
139 fflush(stdin);
140
141 getchar();
142 break;
143 }
144
145 }while(opcao_desejada != 0);
146
147
148 printf(\n\n\n\n); //pular linha
150 }
fim cdigo 18

6) Utilizando como base o exerccio anterior, crie uma aplicao para simular as opera-
es de movimentao de uma conta de poupana. Neste programa, podero ser ca-
dastrados os dados do cliente: nome do titular, nmero da conta e nmero da agncia,
bem como o saldo. Algumas funcionalidades que o sistema dever apresentar so: (I)
cadastrar um novo cliente; (II) inicializar o saldo do cliente; (III) realizar uma operao
de aplicao e atualizar o saldo; (IV) realizar uma operao de resgate e atualizar o
saldo; (V) atualizar o saldo da poupana em funo da porcentagem de rendimento
mensal; (VI) exibir informaes a respeito do cliente e (VII) finalizar a aplicao.
cdigo 19
1 /*------------------------------------------------------
2 *
3 * Exemplo de aplicao com o objetivo de simular a movimentao
4 * da conta de poupana de um cliente
5 *
7 *
8 *----------------------------------------------------*/
9
10 /*------------------------------------------------------
11 * BIBLIOTECAS
12 *----------------------------------------------------*/
15
16 /*-----------------------------------------------------*
18 *----------------------------------------------------*/
19 int main()
20 {


22 char titulo_do_programa[30] = MOVIMENTACAO CONTA POUPANCA;
23
24 //informacoes do cliente
25 char cliente_nome_titular[30];
26 int cliente_numero_conta;
27 int cliente_numero_agencia;
28 float cliente_saldo = -1;
29
31 float valor_aplicacao;
32 float valor_resgate;
33 float rendimento_mensal;
34
35
36 do{
37 //
39 //
41 printf(%c,218);
49 printf(%c,192);
56
57 printf( [1] Cadastrar cliente \n);
58 printf( [2] Inicializar saldo do cliente \n);
59 printf( [3] Realizar uma Aplicacao na conta de poupanca \n);
60 printf( [4] Realizar um Resgate na conta de poupanca \n);
61 printf( [5] Atualizar o saldo em funcao do rendimento mensal \n);
62 printf( [6] Exibir informacoes do cliente \n);
64
67
69
70 case 1:

72 printf(\n\n%c%c%c%c>> CADASTRAR CLIENTE \n\n,195,196,196,196);
73 fflush(stdin);
74 printf(Informe o nome do titular da conta: );
75 gets(cliente_nome_titular);
76 printf(Informe o numero da conta: );
77 scanf(%i,&cliente_numero_conta);
78 printf(Informe o numero da agencia: );
79 scanf(%i,&cliente_numero_agencia);
80
81 fflush(stdin);
82
83 getchar();
84
85 break;
86
87 case 2:
89 printf(\n\n%c%c%c%c>> INICIALIZAR SALDO \n\n,195,196,196,196);
90
91 cliente_saldo = 0;
92
93 fflush(stdin);
94
95 getchar();
96
97 break;
98
99 case 3:
101 printf(\n\n%c%c%c%c>> APLICACAO \n\n,195,196,196,196);
102 printf(Informe o valor do aplicacao:);
103 scanf(%f,&valor_aplicacao);
104
105 //atualizar saldo da conta
106 cliente_saldo = cliente_saldo + valor_aplicacao;
107
108 fflush(stdin);
109
110 getchar();
111 break;
112
113 case 4:
115 printf(\n\n%c%c%c%c>> RESGATE \n\n,195,196,196,196);
116 printf(Informe o valor da resgate: );
117 scanf(%f,&valor_resgate);
118

119 //verificar se o saque no ir estourar a conta

120 if ((cliente_saldo-valor_resgate) >= 0 ){
121 //atualizar saldo do cliente
122 cliente_saldo = cliente_saldo - valor_resgate;
123 fflush(stdin);
printf(\nOperacao realizada com SUCESSO! \n\nPressione <ENTER> para
124
o menu principal\n\n);
125 getchar();
126 }else{
127 fflush(stdin);
printf(\nO saldo da conta NAO eh suficiente para o RESGATE. A
128 operacao NAO foi realizada. \n\nPressione <ENTER> para o
129 getchar();
130 }
131 break;
132
133 case 5:
135 printf(\n\n%c%c%c%c>> RENDIMENTO MENSAL \n\n,195,196,196,196);
printf(Informe o a porcentagem de rendimento mensal da poupanca (0.65%%
136
= 0.0065): );
137 scanf(%f,&rendimento_mensal);
138
139 //atualizar o saldo da poupanca
140 cliente_saldo = cliente_saldo + (cliente_saldo*rendimento_mensal);
141
142 fflush(stdin);
143
144 getchar();
145 break;
146
147 case 6:
149 printf(\n\n%c%c%c%c>> INFORMACOES DO CLIENTE \n\n,195,196,196,196);
150 printf(Nome.............: %s\n,cliente_nome_titular);
151 printf(Numero da Agencia: %i\n,cliente_numero_agencia);
152 printf(Numero da Conta..: %i\n,cliente_numero_conta);
153 printf(Saldo............: R$ %0.2f\n\n\n, cliente_saldo);
154
155 fflush(stdin);
156
157 getchar();
158 break;
159 }
160
162
163

166 }
fim cdigo 19
Nas capturas de tela a seguir, observe o resultado da execuo do programa no ambiente


7) Para o prximo campeonato brasileiro, os clubes desejam armazenar informaes a

respeito do nmero de gols marcados por cada jogador. Para isso, ser necessrio ela-
borar um algoritmo que seja capaz de:
a) receber o clube (time) do jogador;
a) receber o nome do jogador;
b) receber o nmero de gols marcados;
c) exibir na tela o jogador que marcou o maior nmero de gols;
d) exibir na tela o jogador que marcou o menor nmero de gols;
e) exibir na tela a mdia de gols do campeonato por jogador.
cdigo 20
1 /*------------------------------------------------------
2 *
3 * Exemplo de aplicao com o objetivo de armazenar informacoes
4 * a respeito dos gols marcados pelos jogadores no campeonato

5 * brasileiro de futebol.
6 *
8 *
9 *----------------------------------------------------*/
10
11 /*------------------------------------------------------
12 * BIBLIOTECAS
13 *----------------------------------------------------*/
16 #include <string.h> //para instrucoes de manipulacao de string
17
18 /*-----------------------------------------------------*
20 *----------------------------------------------------*/
21 int main()
22 {
24 char titulo_do_programa[40] = CAMPEONATO BRASILEIRO DE FUTEBOL;
25
26 //informacoes do jogador
27 char jogador_nometime[30];
28 char jogador_nomecompleto[30];
29 int jogador_numerogols;
30
31 //informacoes estatisticas
32 int total_jogadores;
33 int total_golsmarcados;
34 float media_golsmarcados;
35
36 char jogador_maior_numero_gols_nometime[30];
37 char jogador_maior_numero_gols_nomecompleto[30];
38 int jogador_maior_numero_gols_numerogols;
39 char jogador_menor_numero_gols_nometime[30];
40 char jogador_menor_numero_gols_nomecompleto[30];
41 int jogador_menor_numero_gols_numerogols;
42
44
45
46 // INICIALIZAR VARIAVEIS
47 total_jogadores = 0;
48 total_golsmarcados = 0;
49
50
51 do{
52 //

54 //
56 printf(%c,218);
64 printf(%c,192);
71
72 printf( [1] Cadastrar jogador \n);
73 printf( [2] Exibir jogador com o maior numero de gols (artilheiro) \n);
74 printf( [3] Exibir jogador com o menor numero de gols \n);
75 printf( [4] Exibir a media de gols do campeonato (por jogador) \n);
77
80
82
83 case 1:
85 printf(\n\n%c%c%c%c>> CADASTRAR JOGADOR \n\n,195,196,196,196);
86 fflush(stdin);
87 printf(Informe o nome completo do jogador.: );
88 gets(jogador_nomecompleto);
89 fflush(stdin);
90 printf(Informe o nome do time do jogador..: );
91 gets(jogador_nometime);
92 printf(Informe o numero de gols do jogador: );
93 scanf(%i,&jogador_numerogols);
94
95 if ( total_jogadores == 0 ){
96 // como este eh o primeiro jogador devemos copiar suas informacoes
97 // pois ateh o momento ele eh o jogador com mais e menos gols
98
99 //maior numero de gols
100 strcpy(jogador_maior_numero_gols_nomecompleto,jogador_nomecompleto);
101 strcpy(jogador_maior_numero_gols_nometime,jogador_nometime);
102 jogador_maior_numero_gols_numerogols = jogador_numerogols;
103
104 //menor numero gols

105 strcpy(jogador_menor_numero_gols_nomecompleto,jogador_nomecompleto);
106 strcpy(jogador_menor_numero_gols_nometime,jogador_nometime);
107 jogador_menor_numero_gols_numerogols = jogador_numerogols;
108
109
110
111 }else{
112
113 //um novo artilheiro foi encontrado
114 if ( jogador_numerogols > jogador_maior_numero_gols_numerogols){
115 strcpy(jogador_maior_numero_gols_nomecompleto,jogador_nomecompleto);
116 strcpy(jogador_maior_numero_gols_nometime,jogador_nometime);
117 jogador_maior_numero_gols_numerogols = jogador_numerogols;
118 }
119
120 if ( jogador_numerogols < jogador_menor_numero_gols_numerogols){
121 strcpy(jogador_menor_numero_gols_nomecompleto,jogador_nomecompleto);
122 strcpy(jogador_menor_numero_gols_nometime,jogador_nometime);
123 jogador_menor_numero_gols_numerogols = jogador_numerogols;
124 }
125
126 }
127
128 // atualizar total de gols marcados no campeonato
129 total_golsmarcados = total_golsmarcados + jogador_numerogols;
130
131 //atualizar o numero total de jogados do campeonato
132 total_jogadores++;
133
134 fflush(stdin);
135
136 getchar();
137
138 break;
139
140 case 2:
142 printf(\n\n%c%c%c%c>> MAIOR NUMERO DE GOLS \n\n,195,196,196,196);
143
printf(Nome do jogador.....: %s \n, jogador_maior_numero_gols_
144
nomecompleto);
printf(Nome do time (clube): %s \n, jogador_maior_numero_gols_
145
nometime);
printf(Numero de gols......: %i \n, jogador_maior_numero_gols_
146
numerogols);
147
148 fflush(stdin);
149
150 getchar();

151
152 break;
153
154 case 3:
156 printf(\n\n%c%c%c%c>> MENOR NUMERO DE GOLS \n\n,195,196,196,196);
157
printf(Nome do jogador.....: %s \n, jogador_menor_numero_gols_
158
nomecompleto);
printf(Nome do time (clube): %s \n, jogador_menor_numero_gols_
159
nometime);
printf(Numero de gols......: %i \n, jogador_menor_numero_gols_
160
numerogols);
161
162 fflush(stdin);
163
164 getchar();
165 break;
166
167 case 4:
169 printf(\n\n%c%c%c%c>> MEDIA DE GOLS \n\n,195,196,196,196);
170
171 media_golsmarcados = ((float)total_golsmarcados/(float)total_jogadores);
printf(A media de gols no campeonato foi de %0.2f gols por jogador
172
\n,media_golsmarcados);
172
173 fflush(stdin);
174
175 getchar();
176 break;
177
178 }
179
181
182
183 printf(\n\n\n\n); //pular linhas
185 }
fim cdigo 20

8) Elabore um algoritmo que exiba na tela um grfico horizontal de barras em funo dos
valores informados pelo usurio. Como entrada, este algoritmo dever receber cinco
nmeros inteiros, cada nmero representando uma barra do grfico. O tamanho das
barras est vinculado ao valor especificado pelo usurio. Como exemplo, considere a
seguinte entrada:
a) nmero 1: 30;
b) nmero 2: 8;
c) nmero 3: 45;
d) nmero 4: 68;
e) nmero 5: 18.
Neste caso, o algoritmo dever apresentar a seguinte sada:

---------------------------------------------------------------------------------
Grfico de Barras
---------------------------------------------------------------------------------
[30] ..............................
[ 8] ........
[45] .............................................
[68] ....................................................................
[18] ..................
---------------------------------------------------------------------------------
O usurio poder criar um nmero indeterminado de grficos. Portanto, voc dever exibir
uma mensagem perguntando se ele deseja continuar a construo de grficos.
cdigo 21
1 /*-----------------------------------------------------------
2 *
3 * Exemplo de aplicao com o objetivo de gerar um grfico de barras
4 * na horizontal em funo de um conjunto de cinco valores numricos
5 * informados pelo usurio.
6 *
8 *
9 *---------------------------------------------------------*/
10
11 /*-----------------------------------------------------------
12 * BIBLIOTECAS
13 *---------------------------------------------------------*/
16 #include <ctype.h> //para utilizacao da instrucao toupper
17
18 /*----------------------------------------------------------*
20 *---------------------------------------------------------*/
21 int main()
22 {
24 char titulo_do_programa[50] = GRAFICO DE BARRAS - HORIZONTAL;
25
26 //valores do grafico
27 int barra_grafico_01,barra_grafico_02,barra_grafico_03,
28 barra_grafico_04,barra_grafico_05;
29
30 int i;
31 char opcao_desejada;
32
33 do{
34 //
36 //
38 printf(%c,218);
46 printf(%c,192);
53
54
55 printf(Informe o valor da 1a barra do grafico: );
56 scanf(%i,&barra_grafico_01);
65
66 printf(\n\n%c%c%c%c>> GRAFICO \n\n,195,196,196,196);
67
68 //gerar barra do grafico 01
69 for( i = 1; i <= barra_grafico_01; i++){
70 printf(.);
71 }
72 printf(\n);
75 printf(.);
76 }
77 printf(\n);


80 printf(.);
81 }
82 printf(\n);
85 printf(.);
86 }
87 printf(\n);
90 printf(.);
91 }
92 printf(\n);
93
94
95 fflush(stdin);
96 printf(\n\n\n);
97 printf( Deseja continuar [S] ou [N]? );
98 scanf(%c,&opcao_desejada);
99 //conversao da opcao desejada para maiusculo
100 opcao_desejada = toupper(opcao_desejada);
101
102 }while(opcao_desejada != N);
103
104
107 }
fim cdigo 21

A apresentao do grfico pode ser melhorada utilizando os caracteres da tabela ASCII.

Por exemplo, com os cdigos 176, 177, 178 ou 219. O Cdigo 22 apresenta as alteraes neces-
srias para a exibio das barras com um cdigo da tabela ASCII.
cdigo 22
1 /*---------------------------------------------------------
2 *
3 * Exemplo de aplicao com o objetivo de gerar grficos com
4 * caracteres simblicos da tabela ASCII
5 *
6 *
8 *
9 *-------------------------------------------------------*/
10
11 /*---------------------------------------------------------
12 * BIBLIOTECAS
13 *-------------------------------------------------------*/
17
18 /*--------------------------------------------------------*
20 *-------------------------------------------------------*/
21 int main()
22 {
25

29
30 int i;
32
33 do{
34 //
36 //
38 printf(%c,218);
46 printf(%c,192);
53
54
65
67

70 printf(%c,178);
71 }
72 printf(\n);
75 printf(%c,178);
76 }
77 printf(\n);
80 printf(%c,178);
81 }
82 printf(\n);
85 printf(%c,178);
86 }
87 printf(\n);
90 printf(%c,178);
91 }
92 printf(\n);
93
94
95 fflush(stdin);
96 printf(\n\n\n);
101
103
104
107 }
fim cdigo 22


9) Altere o algoritmo anterior de forma que o usurio seja capaz de escolher qual sm-
bolo deve ser colocado nas barras do grfico. Considerando as entradas do exerccio
anterior, por exemplo, sendo o smbolo informado igual a $, o grfico produzido ser:
---------------------------------------------------------------------------------
Grfico de Barras
---------------------------------------------------------------------------------
[30] $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
[ 8] $$$$$$$$
[45] $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
[68] $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
[18] $$$$$$$$$$$$$$$$$$
---------------------------------------------------------------------------------
Ao supor que o smbolo especificado pelo usurio foi igual a +, temos o seguinte grfico:
-------------------------------------------------------------------------------------
Grfico de Barras
-------------------------------------------------------------------------------------
[30] ++++++++++++++++++++++++++++++
[ 8] ++++++++
[45] +++++++++++++++++++++++++++++++++++++++++++++
[68] ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
[18] ++++++++++++++++++
-------------------------------------------------------------------------------------
cdigo 23
1 /*-------------------------------------------------
2 *
3 * Exemplo de aplicao com o objetivo de criar um grfico de
4 * barras em funo dos valores informado pelo usurio. Neste
5 * exemplo o usurio poder especificar qual o smbolo ser
6 * utilizado nas barras do grfico
7 *

9 *
10 *-----------------------------------------------*/
11
12 /*-------------------------------------------------
13 * BIBLIOTECAS
14 *-----------------------------------------------*/
18
19 /*------------------------------------------------*
21 *-----------------------------------------------*/
22 int main()
23 {
26
30
31 // smbolo do grfico
32 char simbolo;
33
34 int i;
36
37 do{
38 //
40 //
42 printf(%c,218);
50 printf(%c,192);
57

58 fflush(stdin);
59 printf(Informe o simbolo que sera utilizado nas barras do grafico: );
60 simbolo = getchar();
61
72
74
76 printf([%02i] ,barra_grafico_01);
78 printf(%c,simbolo);
79 }
80 printf(\n);
81
86 }
87 printf(\n);
88
93 }
94 printf(\n);
95
100 }
101 printf(\n);
106 }
107 printf(\n);
108
109
110 fflush(stdin);
111 printf(\n\n\n);
116
118
119
122 }
fim cdigo 23


10) Uma pizzaria deseja controlar as entregas de pizzas realizadas por seus entregadores.
Com isso, voc dever elaborar um programa na linguagem C, que atenda s seguintes
funcionalidades:
a) Cadastrar entrega dever ser informado o nome do entregador, o dia da sema-
na (segunda-feira, tera-feira, quarta-feira, quinta-feira, sexta-feira, sbado ou do-
mingo) e a quantidade de pizzas.
b) Total de pizzas entregues.
c) Total de pizzas por dia da semana.
d) Melhor dia da semana maior nmero de pizzas entregues.
e) Pior dia da semana menor nmero de pizzas entregues.
cdigo 24
1 /*-----------------------------------------------------------
2 *
3 * Exemplo de aplicao com o objetivo de cadastrar as entregas
4 * de pizzas realizadas por uma pizzaria. Alm disso, a aplicao
5 * dever informar alguns dados estatstico a respeito das entregas.
6 *
8 *
9 *---------------------------------------------------------*/
10
11 /*-----------------------------------------------------------
12 * BIBLIOTECAS
13 *---------------------------------------------------------*/
16 #include <string.h> //para utilizao da funo strcpy
17
18 /*----------------------------------------------------------*
20 *---------------------------------------------------------*/
21 int main()
22 {
24 char titulo_do_programa[50] = SISTEMA DE ENTREGAS - PIZZARIA;
25
26 //informacoes da entrega
27 char entrega_nomeentregador[40];
28 int entrega_diasemana;
29 int entrega_quantidadepizzas;
30 int entrega_quantidade_segunda;
31 int entrega_quantidade_terca;
32 int entrega_quantidade_quarta;
33 int entrega_quantidade_quinta;
34 int entrega_quantidade_sexta;
35 int entrega_quantidade_sabado;
36 int entrega_quantidade_domingo;
37
38 //variaveis auxiliares
40 int aux_quantidade_pizzas;
41 int aux_informacao_desejada;
42 char melhor_dia_da_semana[40];
43 char pior_dia_da_semana[40];
44
45
46 //INICIALIZAR VARIAVEIS
47 entrega_quantidadepizzas = 0;
48 entrega_quantidade_segunda = 0;
49 entrega_quantidade_terca = 0;
50 entrega_quantidade_quarta = 0;
51 entrega_quantidade_quinta = 0;
52 entrega_quantidade_sexta = 0;
53 entrega_quantidade_sabado = 0;
54 entrega_quantidade_domingo = 0;
55
56
57 do{
58 //
60 //
62 printf(%c,218);
70 printf(%c,192);

77 printf(\t[1] CADASTRAR NOVA ENTREGA \n);
78 printf(\t[2] INFORMACOES ESTATISTICAS \n);
79 printf(\t[0] SAIR DA APLICACAO \n);
80 fflush(stdin);
81 printf(\n\n);
82 printf(\tSelecione a opcao desejada: );
85 opcao_desejada = opcao_desejada;
86
88
89 case 1: // CADASTRAR NOVA ENTREGA
91 printf(\n\n%c%c%c%c>> CADASTRAR NOVA ENTREGA \n,195,196,196,196);
94
95 do{
96 fflush(stdin);
printf(%c%c%c%c%c%cInforme o nome do entregador:
97
,195,196,196,194,196,196);
98 gets(entrega_nomeentregador);
99
printf(%c%c%c%c%c%cInforme o dia da semana:
100
\n,195,196,196,197,196,196);
printf( %c%c%c%c%c%c%c%c%c%c%c%c%c%c[1] Domingo
101 \n,195,196,196,196,196,196,196,196,196,196,196,
196,196,196);
printf( %c%c%c%c%c%c%c%c%c%c%c%c%c%c[2] Segunda-feira
102 \n,195,196,196,196,196,196,196,196,196,
196,196,196,196,196);
printf( %c%c%c%c%c%c%c%c%c%c%c%c%c%c[3] Terca-feira
103 \n,195,196,196,196,196,196,196,196,196,196,
196,196,196,196);
printf( %c%c%c%c%c%c%c%c%c%c%c%c%c%c[4] Quarta-feira
104 \n,195,196,196,196,196,196,196,196,196,196,
196,196,196,196);
printf( %c%c%c%c%c%c%c%c%c%c%c%c%c%c[5] Quinta-feira
105 \n,195,196,196,196,196,196,196,196,196,196,
196,196,196,196);
printf( %c%c%c%c%c%c%c%c%c%c%c%c%c%c[6] Sexta-feira
106 \n,195,196,196,196,196,196,196,196,196,196,
196,196,196,196);
printf( %c%c%c%c%c%c%c%c%c%c%c%c%c%c[7] Sabado
107 \n,192,196,196,196,196,196,196,196,196,196,196,
196,196,196);
108 printf( \nSelecione o dia da semana desejado: );
109 scanf(%i,&entrega_diasemana);
110
111 printf(Informe a quantidade de pizzas: );
112 scanf(%i,&aux_quantidade_pizzas);
113
entrega_quantidadepizzas = entrega_quantidadepizzas + aux_
114
quantidade_pizzas;
115
116 if ( entrega_diasemana == 1 ){
entrega_quantidade_domingo = entrega_quantidade_domingo + aux_
117
quantidade_pizzas;
118 }else if ( entrega_diasemana == 2){
entrega_quantidade_segunda = entrega_quantidade_segunda + aux_
119
quantidade_pizzas;
entrega_quantidade_terca = entrega_quantidade_terca+ aux_
121
quantidade_pizzas;
entrega_quantidade_quarta = entrega_quantidade_quarta + aux_
123
quantidade_pizzas;
entrega_quantidade_quinta = entrega_quantidade_quinta + aux_
125
quantidade_pizzas;
entrega_quantidade_sexta = entrega_quantidade_sexta + aux_
127
quantidade_pizzas;
entrega_quantidade_sabado = entrega_quantidade_sabado + aux_
129
quantidade_pizzas;
130 }else{
131 fflush(stdin);
132 printf(\n\n);
133 printf(>>>>ERRO: O dia da semana informado nao eh valido!\n);
134 printf(\n\n);
135 getchar();
136 system(cls);
137 }
138 }while( entrega_diasemana < 1 || entrega_diasemana > 7);
139
140 fflush(stdin);
141 printf(\n\n);
142 printf(>>>>INFO: PIZZA cadastrada com SUCESSO!\n);
143 printf(\n\n);
144 getchar();
145
146 break;
147 case 2: // INFORMACOES ESTATISTICAS
149 printf(\n\n%c%c%c%c>> INFORMACOES ESTATISTICAS \n,195,196,196,196);
150 printf(%c\n,179);
151 printf(%c%c%c%c\n,195,196,196,191);
printf( %c%c%c%c%c%c%c%c%c%c%c%c%c%c[1] Total de pizzasentregues
152 \n,195,196,196,196,196,196,196,
196,196,196,196,196,196,196);
printf( %c%c%c%c%c%c%c%c%c%c%c%c%c%c[2] Total de pizzas por dia da
153 semana\n,195,196,196,196,196,
196,196,196,196,196,196,196,196,196);

printf( %c%c%c%c%c%c%c%c%c%c%c%c%c%c[3] Melhor dia da semana

154 \n,195,196,196,196,196,196,196,196,
196,196,196,196,196,196);
printf( %c%c%c%c%c%c%c%c%c%c%c%c%c%c[4] Pior dia da semana\
155 n\n,192,196,196,196,196,196,196,196,
196,196,196,196,196,196);
156 printf( Selecione o a informacao desejada: );
157 scanf(%i,&aux_informacao_desejada);
158
159 if ( aux_informacao_desejada == 1 ){
160 printf(\n\n); //pular linhas
printf(\t>>>Total de PIZZAS entregues: %i \n,entrega_
161
quantidadepizzas);
163 }else if ( aux_informacao_desejada == 2){
165 printf(\t>>>Total de PIZZAS entregues por dia da semana\n);
printf(...................................Domingo......: %i \n,entrega_quantidade_
166
domingo);
printf(....................................Segunda-Feira: %i \n,entrega_quantidade_
167
segunda);
printf(....................................Terca-Feira..: %i \n,entrega_quantidade_
168
terca);
printf(....................................Quarta-Feira.: %i \n,entrega_quantidade_
169
quarta);
printf(....................................Quinta-Feira.: %i \n,entrega_quantidade_
170
quinta);
printf(....................................Sexta-Feira..: %i \n,entrega_quantidade_
171
sexta);
printf(....................................Sabado-Feira.: %i \n,entrega_quantidade_
172
sabado);
175
176 //DETERMINAR MELHOR DIA DA SEMANA ==> MAIOR NUMERO DE ENTREGAS
177 if ( (entrega_quantidade_domingo >= entrega_quantidade_segunda ) &&
178 (entrega_quantidade_domingo >= entrega_quantidade_terca ) &&
179 (entrega_quantidade_domingo >= entrega_quantidade_quarta ) &&
180 (entrega_quantidade_domingo >= entrega_quantidade_quinta ) &&
181 (entrega_quantidade_domingo >= entrega_quantidade_sexta ) &&
182 (entrega_quantidade_domingo >= entrega_quantidade_sabado ) ){
183 strcpy(melhor_dia_da_semana,Domingo);
}else if ( (entrega_quantidade_segunda >= entrega_quantidade_domingo
184
) &&
185 (entrega_quantidade_segunda >= entrega_quantidade_terca ) &&
186 (entrega_quantidade_segunda >= entrega_quantidade_quarta ) &&
187 (entrega_quantidade_segunda >= entrega_quantidade_quinta ) &&
188 (entrega_quantidade_segunda >= entrega_quantidade_sexta ) &&
189 (entrega_quantidade_segunda >= entrega_quantidade_sabado ) ){
190 strcpy(melhor_dia_da_semana,Segunda-Feira);
}else if ( (entrega_quantidade_terca >= entrega_quantidade_segunda )
191
&&
192 (entrega_quantidade_terca >= entrega_quantidade_domingo ) &&
193 (entrega_quantidade_terca >= entrega_quantidade_quarta ) &&
194 (entrega_quantidade_terca >= entrega_quantidade_quinta ) &&
195 (entrega_quantidade_terca >= entrega_quantidade_sexta ) &&

196 (entrega_quantidade_terca >= entrega_quantidade_sabado ) ){
197 strcpy(melhor_dia_da_semana,Terca-Feira);
}else if ( (entrega_quantidade_quarta >= entrega_quantidade_segunda
198
) &&
199 (entrega_quantidade_quarta >= entrega_quantidade_terca ) &&
200 (entrega_quantidade_quarta >= entrega_quantidade_domingo ) &&
201 (entrega_quantidade_quarta >= entrega_quantidade_quinta ) &&
202 (entrega_quantidade_quarta >= entrega_quantidade_sexta ) &&
203 (entrega_quantidade_quarta >= entrega_quantidade_sabado ) ){
204 strcpy(melhor_dia_da_semana,Quarta-Feira);
}else if ( (entrega_quantidade_quinta >= entrega_quantidade_segunda
205
) &&
206 (entrega_quantidade_quinta >= entrega_quantidade_terca ) &&
207 (entrega_quantidade_quinta >= entrega_quantidade_quarta ) &&
208 (entrega_quantidade_quinta >= entrega_quantidade_domingo ) &&
209 (entrega_quantidade_quinta >= entrega_quantidade_sexta ) &&
210 (entrega_quantidade_quinta >= entrega_quantidade_sabado ) ){
211 strcpy(melhor_dia_da_semana,Quinta-Feira);
}else if ( (entrega_quantidade_sexta >= entrega_quantidade_segunda )
212
&&
213 (entrega_quantidade_sexta >= entrega_quantidade_terca ) &&
214 (entrega_quantidade_sexta >= entrega_quantidade_quarta ) &&
215 (entrega_quantidade_sexta >= entrega_quantidade_quinta ) &&
216 (entrega_quantidade_sexta >= entrega_quantidade_domingo ) &&
217 (entrega_quantidade_sexta >= entrega_quantidade_sabado ) ){
218 strcpy(melhor_dia_da_semana,Sexta-Feira);
}else if ( (entrega_quantidade_sabado >= entrega_quantidade_segunda
219
) &&
220 (entrega_quantidade_sabado >= entrega_quantidade_terca ) &&
221 (entrega_quantidade_sabado >= entrega_quantidade_quarta ) &&
222 (entrega_quantidade_sabado >= entrega_quantidade_quinta ) &&
223 (entrega_quantidade_sabado >= entrega_quantidade_sexta ) &&
224 (entrega_quantidade_sabado >= entrega_quantidade_domingo ) ){
225 strcpy(melhor_dia_da_semana,Sabado);
226 }
227
229 printf(\t>>>MELHOR dia da semana: %s \n,melhor_dia_da_semana);
231
232
234
235 //DETERMINAR PIOR DIA DA SEMANA ==> MENOR NUMERO DE ENTREGAS
236 if ( (entrega_quantidade_domingo <= entrega_quantidade_segunda ) &&
237 (entrega_quantidade_domingo <= entrega_quantidade_terca ) &&
238 (entrega_quantidade_domingo <= entrega_quantidade_quarta ) &&
239 (entrega_quantidade_domingo <= entrega_quantidade_quinta ) &&
240 (entrega_quantidade_domingo <= entrega_quantidade_sexta ) &&
241 (entrega_quantidade_domingo <= entrega_quantidade_sabado ) ){
242 strcpy(pior_dia_da_semana,Domingo);

}else if ( (entrega_quantidade_segunda <= entrega_quantidade_domingo

243
) &&
244 (entrega_quantidade_segunda <= entrega_quantidade_terca ) &&
245 (entrega_quantidade_segunda <= entrega_quantidade_quarta ) &&
246 (entrega_quantidade_segunda <= entrega_quantidade_quinta ) &&
247 (entrega_quantidade_segunda <= entrega_quantidade_sexta ) &&
248 (entrega_quantidade_segunda <= entrega_quantidade_sabado ) ){
249 strcpy(pior_dia_da_semana,Segunda-Feira);
}else if ( (entrega_quantidade_terca <= entrega_quantidade_segunda )
250
&&
251 (entrega_quantidade_terca <= entrega_quantidade_domingo ) &&
252 (entrega_quantidade_terca <= entrega_quantidade_quarta ) &&
253 (entrega_quantidade_terca <= entrega_quantidade_quinta ) &&
254 (entrega_quantidade_terca <= entrega_quantidade_sexta ) &&
255 (entrega_quantidade_terca <= entrega_quantidade_sabado ) ){
256 strcpy(pior_dia_da_semana,Terca-Feira);
}else if ( (entrega_quantidade_quarta <= entrega_quantidade_segunda
257
) &&
258 (entrega_quantidade_quarta <= entrega_quantidade_terca ) &&
259 (entrega_quantidade_quarta <= entrega_quantidade_domingo ) &&
260 (entrega_quantidade_quarta <= entrega_quantidade_quinta ) &&
261 (entrega_quantidade_quarta <= entrega_quantidade_sexta ) &&
262 (entrega_quantidade_quarta <= entrega_quantidade_sabado ) ){
263 strcpy(pior_dia_da_semana,Quarta-Feira);
}else if ( (entrega_quantidade_quinta <= entrega_quantidade_segunda
264
) &&
265 (entrega_quantidade_quinta <= entrega_quantidade_terca ) &&
266 (entrega_quantidade_quinta <= entrega_quantidade_quarta ) &&
267 (entrega_quantidade_quinta <= entrega_quantidade_domingo ) &&
268 (entrega_quantidade_quinta <= entrega_quantidade_sexta ) &&
269 (entrega_quantidade_quinta <= entrega_quantidade_sabado ) ){
270 strcpy(pior_dia_da_semana,Quinta-Feira);
}else if ( (entrega_quantidade_sexta <= entrega_quantidade_segunda )
271
&&
272 (entrega_quantidade_sexta <= entrega_quantidade_terca ) &&
273 (entrega_quantidade_sexta <= entrega_quantidade_quarta ) &&
274 (entrega_quantidade_sexta <= entrega_quantidade_quinta ) &&
275 (entrega_quantidade_sexta <= entrega_quantidade_domingo ) &&
276 (entrega_quantidade_sexta <= entrega_quantidade_sabado ) ){
277 strcpy(pior_dia_da_semana,Sexta-Feira);
}else if ( (entrega_quantidade_sabado <= entrega_quantidade_segunda
278
) &&
279 (entrega_quantidade_sabado <= entrega_quantidade_terca ) &&
280 (entrega_quantidade_sabado <= entrega_quantidade_quarta ) &&
281 (entrega_quantidade_sabado <= entrega_quantidade_quinta ) &&
282 (entrega_quantidade_sabado <= entrega_quantidade_sexta ) &&
283 (entrega_quantidade_sabado <= entrega_quantidade_domingo ) ){
284 strcpy(pior_dia_da_semana,Sabado);
285 }
286
288 printf(\t>>>PIOR dia da semana: %s \n,pior_dia_da_semana);

290
291 }
292
293 fflush(stdin);
294 printf(\n\n);
295 printf(>>>>Pressione <ENTER> para voltar ao menu principal\n);
296 printf(\n\n);
297 getchar();
298
299 break;
300
301 }
302
304
307 }
fim cdigo 24

com a compilao e execuo do cdigo-fonte apresentado no Cdigo 24.

Esta unidade abordou alguns dos conceitos primordiais na elaborao de programas. Es-
sas estruturas, tanto as condicionais quanto as de repetio, sero utilizadas por voc ao longo
de sua carreira profissional. Aproveite as questes autoavaliativas a seguir para testar seus co-
nhecimentos e consolidar seu aprendizado.
1) Explique a sintaxe bsica da estrutura condicional simples if e a sintaxe da estrutura condicional composta if...
else.
2) Reflita sobre a utilidade dos comandos fflush(stdin), toupper e tolower.
3) O que uma condicional aninhada?
4) Explique a sintaxe bsica da estrutura de seleo mltipla switch e a sintaxe bsica da estrutura de repetio for.
5) Como a estrutura de repetio for pode ser utilizada para exibir os nmeros pares entre 1 e 100?
6) Explique a sintaxe bsica da estrutura de repetio while e a sintaxe da estrutura de repetio do...while.
7) Observamos que o acumulador um recurso computacional utilizado para acumular os valores de uma deter-
minada varivel. Reflita sobre o seu funcionamento em uma aplicao.
8) Explique como uma estrutura de repetio pode ser utilizada para calcular a mdia de um conjunto de dez ele-
mentos do tipo float (ou double).
9) Explique como uma estrutura de repetio pode ser utilizada para contar quantos nmeros primos existem
entre 1 e 100.
10) Explique como realizado o processo para determinar o maior elemento de um conjunto por meio de uma es-
trutura de repetio. Voc pode considerar, por exemplo, que um usurio digitou um conjunto de vinte nmeros
do tipo inteiro e necessrio determinar qual o maior elemento desse conjunto.
11) Com base no item anterior, explique como possvel determinar o menor elemento de um conjunto.
9. CONSIDERAES
Terminamos o estudo de mais uma unidade, na qual voc teve a oportunidade de apren-
der sobre as estruturas de controle. Alm disso, voc pde perceber que essas estruturas so
utilizadas para determinar o fluxo de execuo dentro dos programas, e pde notar, tambm,

que existem dois grupos principais de estruturas de controle, que so: as estruturas condicionais
e as estruturas de repetio.
Na prxima unidade, voc ter contato com a criao e a manipulao de vetores e matri-
zes e de registros. Estudar, tambm, o conceito de ponteiros, aprendendo como estes podem
ajud-lo a acessar dados.
Vamos l?

ASCENCIO, A. F. G.; EDILENE, A. V.. Fundamentos da programao de computadores: algoritmos, Pascal e C/C++. So Paulo:
Prentice Hall, 2002.
MANZANO, J. A. N. G.. Algoritmos: lgica para desenvolvimento de programao. 2. ed. So Paulo: rica, 1996.
SALVETTI, D. D.; BARBOSA, L. M. Algoritmos. So Paulo: Makron Books, 1998.
Estrutura de Dados
e Ponteiros
1. OBJETIVOS
Criar e manipular vetores e matrizes.
Criar e manipular registros.
Compreender o conceito de ponteiros.
Acessar dados por meio dos ponteiros.
2. CONTEDOS
Estruturas de dados homogneas: vetores e matrizes.
Estruturas de dados heterogneas: registros.
Ponteiros.

guir:
1) Uma sugesto para leitura a obra ASCENCIO, A. F. G. Fundamentos da programao
de computadores: algoritmos, Pascal e C/C++. So Paulo: Prentice Hall, 2002. Para essa
unidade, voc poder ler o captulos 5, Vetores; o 6, Matrizes, e o 8, Registros.
2) Codifique os "Exerccios Resolvidos" em seu ambiente de desenvolvimento. Desse
modo, voc pode implementar os programas disponveis e comparar sua sada com a
sada de cada programa. Essa uma tima forma de colocar em prtica o que apren-
deu na unidade.
4. INTRODUO UNIDADE
Nesta unidade, teremos a oportunidade de estudar as metodologias essenciais para a ela-
borao de programas de computador. fundamental que voc atente para este estudo, pois
essas metodologias abrem um leque imenso de possibilidades na construo de programas e
podem tornar o desenvolvimento mais simples e profissional.
Inicialmente, aprenderemos as estruturas de dados, as quais fornecem ao programador
um ferramental para a organizao e a manipulao de grandes conjuntos de dados; as trs
principais estruturas so: vetores, matrizes e registros.
Alm disso, discutiremos o conceito de alocao dinmica de memria. Essa tcnica im-
portante para o desenvolvedor, pois permite que seja realizado o gerenciamento da quantidade
de memria utilizada pelo programa.
Fique atento a todo o contedo que ser apresentado nesta unidade.
5. VETORES
Quando construmos programas, comum manipularmos inmeras informaes na me-
mria. A utilizao de variveis pode ser uma soluo para esse problema. No entanto, no
uma maneira simples e prtica.
Com a utilizao de variveis, os programadores podem contar com os vetores, que so
capazes de organizar sequencialmente grandes conjuntos de dados na memria; alm disso, os
vetores fornecem um mecanismo simples para recuperao das informaes.
Os vetores so uma estrutura de dados homognea, ou seja, eles sempre manipulam da-
dos do mesmo tipo. Podemos criar, por exemplo, um vetor para armazenar um conjunto de
notas de alunos. Nesse caso, como as notas permitem casas decimais, devemos criar um vetor
do tipo float ou double. Tambm possvel criar vetores de outros tipos de dados, tais como
int, char etc.
Suponha que voc precise armazenar um conjunto de dados contendo os pesos de dez
pessoas e outro conjunto contendo suas alturas. Essas estruturas podem ser visualizadas por
meio das representaes a seguir:
vetor_de_pesos
86 72 78 64 74 59 62 88 61 82
0 1 2 3 4 5 6 7 8 9
vetor_de_alturas
1.78 1.82 1.90 1.85 1.74 1.83 1.62 1.82 1.65 1.66
0 1 2 3 4 5 6 7 8 9
U4 Estrutura de Dados e Ponteiros 183
Em decorrncia das caractersticas dos dados armazenados, os dois vetores podem ser
definidos pelo tipo float. Na linguagem C, a declarao dessas estruturas definida como se v
a seguir:
1 float vetor_de_pesos[10]
2 float vetor_de_alturas[10]
Veja que, na declarao dos vetores, sempre devemos especificar o tipo de dados que
ser manipulado; em seguida, o nome da estrutura; e, por fim, entre colchetes, a quantidade de
informaes que ser armazenada (nesse caso, dez pessoas).
O acesso s informaes nos vetores efetuado por meio das posies conhecidas como
ndices. Um ndice um nmero inteiro que representa a posio, dentro da estrutura do vetor,
em que uma determinada informao est armazenada.
Por exemplo, para armazenar o valor 86 na posio 0 do vetor_de_pesos, utilizamos o
seguinte comando:
1 vetor_de_pesos[0] = 86;
Da mesma forma, caso seja necessrio recuperar uma informao de uma determinada
posio do vetor, tambm utilizamos os ndices. Por exemplo, para escrevermos na tela o conte-
do da posio 6 do vetor_de_altura, utilizamos a seguinte instruo:
1 printf(Altura da posicao 6 = %.2f \n, vetor_de_altura[6]);
O programa descrito a seguir, no Cdigo 1, demonstra a utilizao da estrutura de dados

vetor. Nesse programa, os pesos e as alturas de dez pessoas so carregados, e, em seguida, so
determinados o valor do maior peso e o valor da maior altura. Por fim, os resultados so exibi-
dos na tela.
cdigo 1
1 /*
3 * da estrutura de dados Vetor
4 *
6 */
7
9
10
11 int main()
12 {
13 float vetor_de_pesos[10];
14 float vetor_de_alturas[10];
15 float maior_peso, maior_altura;
16 int idx; // ndice
17
18
19 // carregar dados nos vetores

20 for( idx = 0; idx < 10; idx++){

21
22 printf(Peso da pessoa %i: , idx);
23 scanf(%f,&vetor_de_pesos[idx]);
24
25 printf(Altura da pessoa %i: , idx);
26 scanf(%f,&vetor_de_alturas[idx]);
27
28 }
29
30 // determinar maior peso e maior altura
31 maior_peso = vetor_de_pesos[0];
32 maior_altura = vetor_de_alturas[0];
33
34 for ( idx = 0; idx < 10; idx++ ){
35
36 if ( vetor_de_pesos[idx] > maior_peso ){
37 maior_peso = vetor_de_pesos[idx];
38 }
39
40 if ( vetor_de_alturas[idx] > maior_altura ){
41 maior_altura = vetor_de_alturas[idx];
42 }
43
44 }
45
46 printf(\nMaior peso: %.2f \n, maior_peso);
47 printf(Maior altura: %.2f \n, maior_altura);
48
49 return 0;
50 }
fim cdigo 1
Peso da pessoa 0: 86
Altura da pessoa 0: 1.78
Maior peso: 88.00

Maior altura: 1.90
Como estudamos na Unidade 2, a estrutura de dados vetor pode ser utilizada para arma-
zenar conjuntos de caracteres, tambm conhecidos como strings. Dessa forma, a manipulao
de cada caractere presente na string efetuada por meio dos ndices.
O Cdigo 2 demonstra a utilizao de vetores de caracteres. No exemplo, uma string in-
formada pelo usurio armazenada no vetor nome. Em seguida, exibe-se na tela caractere por
caractere dessa string. Note que foi utilizada a funo strlen da biblioteca string.h. Essa biblio-
teca retorna o nmero de caracteres da string.
cdigo 2
1 /*
3 * da estrutura de dados Vetor com tipo de dados char
4 *
6 */
7
9
10
11 int main()
12 {
13 char nome[15];
14 int i;
15
17 gets(nome);
18
19 //Exibio caractere por caractere
20 for( i = 0 ; i < strlen(nome); i++ ){
21 printf(Caractere da posicao %i = %c \n,i,nome[i]);
22 }
23
24 return 0;
25 }
fim cdigo 2


Caractere da posicao 0 = J
Caractere da posicao 1 = o
Caractere da posicao 2 = a
Caractere da posicao 3 = o
Caractere da posicao 4 =
Caractere da posicao 5 = d
Caractere da posicao 7 =
Caractere da posicao 8 = S
Caractere da posicao 9 = i
Caractere da posicao 10 = l
Caractere da posicao 11 = v
6. MATRIZES
A matriz uma maneira alternativa de manipulao de dados homogneos. Por meio
dela, possvel armazenar e recuperar dados multidimensionais. O que significa que, ao con-
trrio dos vetores, que so estruturas de dados unidimensionais (uma linha e vrias colunas), as
matrizes podem conter vrias linhas e vrias colunas. Os dados armazenados em matrizes so
semelhantes s tabelas.
Tomando por base, por exemplo, o problema do tpico anterior, em que era necessrio
armazenar os pesos e as alturas de dez pessoas, podemos utilizar uma matriz contendo duas
linhas e dez colunas. Na primeira linha, podem ser armazenadas as informaes referentes aos
pesos e, na segunda linha, as informaes referentes s alturas. Visualmente, essa estrutura
representada da seguinte forma:
matriz_de_pessoas
86 72 78 64 74 59 62 88 61 82
1.78 1.82 1.90 1.85 1.74 1.83 1.62 1.82 1.65 1.66
0 1 2 3 4 5 6 7 8 9
Veja que, com as matrizes, podemos armazenar os dados em uma nica estrutura. Entre-
tanto, importante observar que isso s possvel uma vez que todos os dados so do mesmo
tipo.
A declarao de uma matriz segue o mesmo modelo da declarao de um vetor; no entan-
to, alm de definir o nmero de linhas, devemos especificar tambm o nmero de colunas. A
declarao da matriz para armazenar os pesos e as alturas de dez pessoas pode ser especificada
da seguinte maneira:
1 float matriz_de_pessoas[2][10];
Na declarao anterior, o valor 2, especificado no primeiro colchete, representa o nmero

de linhas da matriz, lembrando que a primeira linha ser utilizada para armazenar os pesos e a
segunda linha utilizada para armazenar as alturas. J o valor 10, especificado no segundo col-
chete, representa o nmero de colunas da matriz. O nmero 10 refere-se ao nmero de pessoas
que a matriz armazenar.
Para armazenarmos as informaes de peso e altura de uma pessoa na posio 0 da ma-
triz_de_pessoas, utilizamos as seguintes instrues:
1 matriz_de_pessoas[0][0] = 86; // peso

2 matriz_de_pessoas[1][0] = 1.78; // altura
Para exibirmos as informaes na tela, utilizamos o mesmo modelo, no qual o primeiro

ndice representa a linha e o segundo ndice a coluna. Por exemplo, para exibirmos o contedo
da posio 6 da matriz_de_pessoas, utilizamos o seguinte comando:
1 printf(Pessoa 0: peso = %.2f \n,matriz_de_pessoas[0][6]);

2 printf(Pessoa 0: altura = %.2f \n,matriz_de_pessoas[1][6]);
No Cdigo 3, os pesos e as alturas de dez pessoas so armazenados em uma estrutura de

dados do tipo matriz. Em seguida, o valor do maior peso e da maior altura determinado, e o
resultado exibido na tela.
cdigo 3
1 /*
3 * da estrutura de dados Matriz
4 *
6 */
7
9
10
11 int main()
12 {
13 float matriz_de_pessoas[2][10];
14 float maior_peso, maior_altura;
15 int idx;
16
17 //carregar dados na matriz
18 for ( idx = 0; idx < 10; idx++){
19
20 printf(Peso da pessoa %i: , idx);
21 scanf(%f,&matriz_de_pessoas[0][idx]);
22
23 printf(Altura da pessoa %i: , idx);
24 scanf(%f,&matriz_de_pessoas[1][idx]);
25 }
26
27 //determinar maior peso e altura

28 maior_peso = matriz_de_pessoas[0][0];
29 maior_altura = matriz_de_pessoas[1][0];
30
31 for ( idx = 0; idx < 10; idx++ ){
32
33 if ( matriz_de_pessoas[0][idx] > maior_peso ){
34 maior_peso = matriz_de_pessoas[0][idx];
35 }
36
37 if ( matriz_de_pessoas[1][idx] > maior_altura ){
38 maior_altura = matriz_de_pessoas[1][idx];
39 }
40
41 }
42
43 //exibir resultados na tela
44 printf(\nMaior peso: %.2f \n, maior_peso);
45 printf(Maior altura: %.2f \n, maior_altura);
46
47 return 0;
48 }
fim cdigo 3

Maior peso: 88.00

Maior altura: 1.90
Veja, no Cdigo 4, um exemplo da estrutura de dados matrizes que utilizada para calcu-
lar todos os valores possveis para tabuada de 1 a 10. Os resultados so armazenados em uma
matriz de 10 por 10 elementos. Neste exemplo, importante destacar a utilizao de duas estru-
turas de repetio aninhadas. Note que a estrutura de repetio for, da Linha 19, executada no
interior da estrutura for, que iniciou na Linha 18. A estrutura mais externa utilizada para varrer
as linhas da matriz, enquanto a estrutura mais interna varre as colunas.
cdigo 4
1 /*
3 * da estrutura de dados Matriz
4 *
6 */
7
9
10
11 int main()
12 {
13 int tabuada[10][10];
14 int lin; // ndice para linha
15 int col; // ndice para coluna
16
17 // calcular todas as tabuadas
18 for ( lin = 0; lin < 10; lin++ ){
19 for ( col = 0; col < 10; col++ ){
20 tabuada[lin][col] = (lin+1)*(col+1);
21 }
22 }
23
24 // escrever dados na tela em forma de tabela
25 for ( lin = 0; lin < 10; lin++ ){
26 printf([%2i] , lin+1);
27 for ( col = 0; col < 10; col++ ){
28 printf(%4i,tabuada[lin][col]);
29 }
30 printf(\n);
31 }
32
33 return 0;
34 }
fim cdigo 4


[ 1] 1 2 3 4 5 6 7 8 9 10
[ 2] 2 4 6 8 10 12 14 16 18 20
[ 3] 3 6 9 12 15 18 21 24 27 30
[ 4] 4 8 12 16 20 24 28 32 36 40
[ 5] 5 10 15 20 25 30 35 40 45 50
[ 6] 6 12 18 24 30 36 42 48 54 60
[ 7] 7 14 21 28 35 42 49 56 63 70
[ 8] 8 16 24 32 40 48 56 64 72 80
[ 9] 9 18 27 36 45 54 63 72 81 90
[10] 10 20 30 40 50 60 70 80 90 100
7. REGISTROS
Uma estrutura do tipo registro permite a manipulao de dados heterogneos, o que
significa que, em uma nica estrutura, podemos armazenar informaes de tipos de dados di-
ferentes.
Suponha que seja necessrio construir um programa para armazenar a idade (int), o sexo
(char) e a altura (float) de um conjunto de dez pessoas. A princpio, podemos pensar em uma
soluo utilizando vetores, na qual sero necessrios trs vetores, sendo um para cada informa-
o a ser manipulada: idade, sexo e altura.
Entretanto, se utilizarmos os registros, podemos agregar essas trs informaes em uma
nica estrutura. Assim, tornamos a manipulao dos dados mais simples. Com isso, o progra-
mador pode criar novos tipos de dados conforme sua necessidade. As informaes contidas em
uma estrutura so conhecidas como campos.
Na linguagem C, a definio de uma estrutura do tipo registro especificada da seguinte
forma:
1 struct tipopessoa{
2 int idade;
3 char sexo;
4 float altura;
5 };
A declarao anterior define um novo tipo de dados denominado struct tipopessoa. Em

toda definio de uma estrutura, necessrio utilizar a palavra reservada struct, seguida do
nome que ser atribudo ao novo tipo de dados.
Depois de definidas as informaes contidas na estrutura, necessrio criarmos uma vari-
vel, que ser do tipo struct tipopessoa. Para isso, utilizamos a instruo a seguir:
1 struct tipopessoa pessoa1;
H uma maneira simplificada de criar uma varivel associada a um determinado tipo de

estrutura. Para isso, utilizamos a seguinte declarao:
2 int idade;
3 char sexo;
4 float altura;
5 }pessoa1;
Note que, na declarao anterior, criamos uma varivel pessoa1 pertencendo estrutura
tipopessoa. Para atribuirmos valores a essa varivel, utilizamos o seguinte mecanismo:
1 pessoa1.idade = 22
2 pessoa1.sexo = M
3 pessoa1.altura = 1.68
Para armazenar ou recuperar os dados da estrutura, devemos utilizar o operador ponto

(.), tambm conhecido como operador de associao. Assim, para manipulao dos dados, uti-
lizamos a seguinte sintaxe:
<nome_da_estrutura>.<nome_do_campo>
O exemplo a seguir (Cdigo 5) demonstra a utilizao da estrutura registro. No programa,

uma estrutura registro definida contendo os campos nome, idade, sexo e altura. Alm disso,
duas variveis so associadas a essa estrutura. Aps a leitura das informaes, os dados so
exibidos na tela. Perceba que, no programa, os especificadores de formato so utilizados para
formatar corretamente a sada (caso tenha dvidas, consulte a Unidade 2, Tpico 5, onde o co-
mando printf explicado).
cdigo 5
1 /*
3 * da estrutura de dados Registro
4 *
6 */
7
9
10 int main()
11 {
13 char nome[20];
14 int idade;
15 char sexo;
16 float altura;
17 };
18
21
22 //leitura das informaes da pessoa 1
23 printf(Nome: );
24 gets(pessoa1.nome);
25 printf(Idade: );
26 scanf(%i, &pessoa1.idade);
27 fflush(stdin);
28 printf(Sexo: );
29 scanf(%c,&pessoa1.sexo);

30 printf(Altura: );
31 scanf(%f, &pessoa1.altura);
32
33
34 //leitura das informaes da pessoa 2
35 fflush(stdin);
36 printf(Nome: );
37 gets(pessoa2.nome);
38 printf(Idade: );
39 scanf(%i, &pessoa2.idade);
40 fflush(stdin);
41 printf(Sexo: );
42 scanf(%c,&pessoa2.sexo);
44 scanf(%f, &pessoa2.altura);
45
46 //exibir informaes na tela
47 printf( Pessoa1 Pessoa2 \n);
48 printf( Nome: %-10s %-10s \n, pessoa1.nome, pessoa2.nome);
49 printf( Idade: %-10i %-10i \n, pessoa1.idade,pessoa2.idade);
50 printf( Sexo: %-10c %-10c \n, pessoa1.sexo,pessoa2.sexo);
51 printf(Altura: %-10.2f %-10.2f \n, pessoa1.altura,pessoa2.altura);
52
53 return 0;
54 }
fim cdigo 5

Nome: Joao
Idade: 22
Sexo: M
Altura: 1.72
Nome: Ana
Idade: 23
Sexo: F
Altura: 1.66
Pessoa1 Pessoa2
Nome: Joao Ana
Idade: 22 23
Sexo: M F
Altura: 1.72 1.66
Observe que, da mesma forma que criamos vetores de qualquer tipo de dados, tambm
podemos criar vetores de estruturas. O prximo exemplo, no Cdigo 6, demonstra a utilizao
de um vetor de estruturas capaz de armazenar o nome, a idade, o sexo e a altura de um conjunto
de cinco pessoas. Para isso, ser utilizada a estrutura de registro juntamente com os vetores.
cdigo 6
1 /*
3 * da estrutura de dados Registro
4 *
6 */
7
9
10 //declarao da estrutura
11
12
13
14 int main()
15 {
17 char nome[20];
18 int idade;
19 char sexo;
20 float altura;
21 };
22
23 struct tipopessoa pessoa[5];
24 int i;
25
26 for ( i = 0; i<5; i++){
27 fflush(stdin);
28 printf(Nome: );
29 gets(pessoa[i].nome);
30 printf(Idade: );
31 scanf(%i, &pessoa[i].idade);
32 fflush(stdin);
33 printf(Sexo: );
34 scanf(%c,&pessoa[i].sexo);
36 scanf(%f, &pessoa[i].altura);
37 }
38
39 //exibir informaes na tela
40 for ( i = 0; i<5; i++){
41 printf(Pessoa %i \n, i);
42 printf(-Nome: %s \n, pessoa[i].nome);
43 printf(-Idade: %i \n, pessoa[i].idade);
44 printf(-Sexo: %c \n, pessoa[i].sexo);
45 printf(-Altura: %.2f \n, pessoa[i].altura);
46 }
47
48 return 0;
49 }
fim cdigo 6


Nome: Joao
Idade: 22
Sexo: M
Altura: 1.72
Nome: Ana
Idade: 23
Sexo: F
Altura: 1.66
Nome: Jose
Idade: 28
Sexo: M
Altura: 1.80
Nome: Maria
Idade: 26
Sexo: F
Altura: 1.68
Nome: Carlos
Idade: 23
Sexo: M
Altura: 1.82
Pessoa 0
-Nome: Joao
-Idade: 22
-Sexo: M
-Altura: 1.72
Pessoa 1
-Nome: Ana
-Idade: 23
-Sexo: F
-Altura: 1.66
Pessoa 2
-Nome: Jose
-Idade: 28
-Sexo: M
-Altura: 1.80
Pessoa 3
-Nome: Maria
-Idade: 26
-Sexo: F
-Altura: 1.68
Pessoa 4
-Nome: Carlos
-Idade: 23
-Sexo: M
-Altura: 1.82
8. PONTEIROS
Os ponteiros so um tipo de varivel que guarda um endereo de memria de outra varivel.
So considerados poderosos recursos da linguagem de programao C. Por meio deles, podemos
acessar o contedo de uma determinada varivel sem acess-la diretamente (MIZRAHI, 1990).
Quando definimos uma varivel do tipo ponteiro, necessrio especificar qual tipo de
dados est associado a ele. Por exemplo, se definirmos um ponteiro do tipo inteiro, este poder
fazer referncia (ou apontar) apenas para variveis do tipo inteiro (int). Da mesma maneira,
ponteiros do tipo float apontam apenas para variveis do tipo float, e assim sucessivamente.
Para voc declarar uma varivel do tipo ponteiro, basta inserir o smbolo de asterisco (*)
antes do nome da varivel. A declarao de ponteiros possui a seguinte sintaxe:
<tipo_de_dados> *<nome_da_variavel>
Exemplos:
1 int *pIdade;
// exemplo de ponteiro para int
2 char *pNome;
// exemplo de ponteiro para char
3 float *pValor; // exemplo de ponteiro para float
Depois de declarado um ponteiro, o prximo passo sua inicializao. Um ponteiro sem-

pre deve ser inicializado com o endereo de memria da varivel para o qual ele dever apontar.
Para isso, utilizamos o operador de endereo, representado pelo smbolo &. Por exemplo, con-
sidere o trecho de cdigo a seguir:
1 int idade;
2 int *pIdade;
3
4 idade = 22;
5 pIdade = &idade;
No cdigo apresentado, idade (Linha 1) uma varivel do tipo inteiro que, inicialmente,
recebeu o valor 22 (Linha 4). A varivel pIdade (Linha 2) uma varivel do tipo ponteiro que
pode ser apontada para uma varivel do tipo inteiro.
Utilizando o operador de endereamento, podemos fazer que o ponteiro pIdade faa uma
referncia para o endereo de memria da varivel idade, como ilustrado na Linha 5. Essa refe-
rncia lida como "pIdade aponta para varivel idade.
importante observar que uma varivel do tipo ponteiro guarda apenas os endereos de
memria das variveis e no os dados armazenados por elas.
O programa descrito no Cdigo 7 demonstra a utilizao do operador de endereamento.
Voc pode observar neste exemplo que o endereo de memria da varivel idade o mesmo
endereo apontado pela varivel pIdade.
cdigo 7
1 /*
3 * de Ponteiros
4 *
6 */
7
9
10 int main()
11 {
12 int idade;
13 int *pIdade;
14
15 idade = 22;
16 pIdade = &idade;

17
18 printf(Endereco da variavel idade: %u \n, &idade);
19 printf(Endereco apontado pela variavel pIdade: %u \n, pIdade);
20
21 return 0;
22 }
fim cdigo 7

Endereco da variavel idade: 2293572
Endereco apontado pela variavel pIdade: 2293572
Observe que, por meio dos ponteiros, podemos tambm modificar o valor de uma deter-
minada varivel. Para isso, utilizamos o operador indireto representado pelo smbolo asterisco
*. Esse operador pode ser empregado para atribuir um valor a uma varivel apontada por um
ponteiro, sem a necessidade de acessar a varivel diretamente.
O Quadro 1 apresenta resumidamente as principais operaes com ponteiros.
Quadro 1 Operadores com ponteiros.

PRINCIPAIS OPERADORES COM PONTEIRO
OPERADOR SMBOLO FUNO
Endereo & Retornar o endereo de memria da varivel apontada.
Indireto * Retornar o contedo da varivel apontada.
O Cdigo 8, a seguir, demonstra a utilizao do operador de endereo e do operador indi-

reto na manipulao de ponteiros. Note que a atribuio do valor 22 varivel idade realizada
por meio do operador indireto.
cdigo 8
1 /*
3 * de Ponteiros
4 *
6 */
7
9
10 int main()
11 {
12 int idade;
13 int *pIdade;
14
15 pIdade = &idade;
16 *pIdade = 22;
17
18 printf(Informacoes da variavel idade \n);
19 printf(--endereco: %u \n, &idade);
20 printf(--valor...: %i \n\n, idade);
21
22 printf(Informacoes da variavel pIdade \n);
23 printf(--endereco: %u \n, &pIdade);
24 printf(--valor...: %i \n, pIdade);
25 printf(--endereco apontado: %u \n, pIdade);
26 printf(--valor apontado...: %i \n\n, *pIdade);
27
28 return 0;
29 }
fim cdigo 8

Informacoes da variavel idade
--endereco: 2293572
--valor...: 22
Informacoes da variavel pIdade

--endereco: 2293568
--valor...: 2293572
--endereco apontado: 2293572
--valor apontado...: 22
O prximo exemplo (Cdigo 9) demonstra a utilizao de ponteiros com os principais tipos

de dados. Os resultados de cada trecho de cdigo so exibidos na tela.
cdigo 9
1 /*
3 * de Ponteiros
4 *
6 */
7
9
10 int main()
11 {
12 int valorInt;
13 int *pInt;
14
15 float valorFloat;
16 float *pFloat;
17
18 char valorChar;
19 char *pNome = Joao da Silva;
20 char *pChar;
21
22 int vetor[3];
23 int *pVetor1;
24 int *pVetor2;
25

26 printf(----------Operacoes com Ponteiros---------- \n\n);

27
28 printf(+ ponteiro com inteiros \n);
29 valorInt = 10;
30 pInt = &valorInt;
31 *pInt = 20;
32 printf(--valor inteiro: %i \n\n, valorInt);
33
34 printf(+ ponteiro com float \n);
35 valorFloat = 10.52;
36 pFloat = & valorFloat;
37 *pFloat = 8.66;
38 printf(--valor float: %.2f \n\n, valorFloat);
39
40 printf(+ ponteiro com char \n);
41 pChar = &pNome[0];
42 valorChar = *pChar;
43 printf(--valor char: %c \n, valorChar);
44
45 pChar = pNome;
46 printf(--valor char: %c \n, *pChar);
47 pChar++;
49 pChar++;
51 pChar++;
52 printf(--valor char: %c \n\n, *pChar);
53
54 printf(+ ponteiro com vetor \n);
55 vetor[0] = 10;
56 vetor[1] = 20;
57 vetor[2] = 30;
58 pVetor1 = vetor;
59 printf(--valor pVetor1: %i \n, *pVetor1);
60 pVetor2 = pVetor1 + 2;
61 printf(--valor pVetor2: %i \n, *pVetor2);
62
63 return 0;
64 }
fim cdigo 9

----------Operacoes com Ponteiros----------
+ ponteiro com inteiros

--valor inteiro: 20
+ ponteiro com float

--valor float: 8.66
+ ponteiro com char

--valor char: J
--valor char: J
--valor char: o
--valor char: a
--valor char: o
+ ponteiro com vetor

--valor pVetor1: 10
--valor pVetor2: 30
Veja que as variveis do tipo ponteiro tambm podem ser utilizadas com estruturas do
tipo registro. Da mesma forma que ponteiros so criados para tipos comuns como int, char ou
float, tambm possvel criar ponteiros para os registros.
No Cdigo 10, o programa demonstra a utilizao de ponteiros em estrutura do tipo regis-
tro. Note que a definio da estrutura segue os mesmos moldes especificados anteriormente,
de modo que a nica alterao est relacionada declarao da varivel ponteiro (Linha 19).
cdigo 10
1 /*
3 * de Ponteiros
4 *
6 */
7
9
10 int main()
11 {
12 struct tipoaluno{
13 char *nome[20];
14 char *curso[30];
15 int ra;
16 };
17
18 struct tipoaluno aluno;
19 struct tipoaluno *pAluno;
20
21
22 printf(Nome do aluno: );
23 gets(aluno.nome);
24 printf(Curso do aluno: );
25 gets(aluno.curso);

26 printf(RA do aluno: );
27 scanf(%i,&aluno.ra);
28
29 //pAluno aponta para a estrutura aluno
30 pAluno = &aluno;
31
32 /*
33 * exibio das informaes do aluno por meio
34 * do ponteiro pAluno
35 */
36 printf(Informacoes do aluno\n);
37 printf(--Nome.: %s \n, pAluno->nome);
38 printf(--Curso: %s \n, pAluno->curso);
39 printf(--RA...: %i \n\n, pAluno->ra);
40
41 //alterao do nome do curso
42 strcpy(pAluno->curso,Ciencia da Computacao);
43
44 /*
45 * exibio das informaes do aluno por meio
46 * da estrutura registro
47 */
48 printf(Informacoes do aluno\n);
49 printf(--Nome.: %s \n, aluno.nome);
50 printf(--Curso: %s \n, aluno.curso);
51 printf(--RA...: %i \n, aluno.ra);
52
53 return 0;
54 }
fim cdigo 10

Nome do aluno: Joao da Silva
Curso do aluno: Sistemas de Informacao
RA do aluno: 12345
Informacoes do aluno
--Nome.: Joao da Silva
--Curso: Sistemas de Informacao
--RA...: 12345
Informacoes do aluno
--Nome.: Joao da Silva
--Curso: Ciencia da Computacao
--RA...: 12345
Voc pode observar uma alterao importante nas linhas 37 a 39, que a utilizao do
operador seta ->. Esse operador empregado no acesso aos campos da estrutura registro, quan-
do trabalhamos com ponteiros. Por exemplo, para atribuirmos o RA 12345 estrutura definida
anteriormente, temos:
1 pAluno->ra = 54321;
Alternativamente, podemos utilizar a seguinte instruo (que produz o mesmo resultado):
1 (*pAluno).ra = 54321;
Vamos, agora, a mais uma sequncia de exerccios resolvidos.
No deixe de verificar todos os exerccios resolvidos, pois esse um momento importante
para fixar os contedos estudados e retirar as possveis dvidas.
Os exerccios 1, 2 e 3 foram selecionados de contedos preexistente da disciplina Algorit-
mos e Programao, com o intuito de demonstrar como possvel transformar algoritmos em
programas.
1) Elabore um algoritmo para controlar as notas dos alunos de uma escola. Esse algorit-
mo deve receber duas notas de cinco alunos e apresentar na tela as seguintes infor-
maes:
a) mdia de cada aluno;
b) mdia da turma;
c) maior mdia;
d) porcentagem de alunos aprovados (mdia >= 5);
e) porcentagem de alunos reprovados (mdia < 5).
cdigo 11
1 /*
2 * Programa para controlar as notas dos alunos
3 *
5 */
6
8
9 int main()
10 {
11
12 //declarao das variveis
13 float vet_media[5];
14 int i, totalalunos;
15 float nota1,nota2, soma, maior;
16 float aprovados,reprovados;
17
18
20 totalalunos = 5;
21 i = 0;
22 while ( i < totalalunos ) {
23 printf(Nota 1a prova: );

25 printf(Nota 2a prova: );
27
28 //calcular mdia
29 vet_media[i] = (nota1+nota2)/2;
30 printf(Media do aluno = %.1f \n, vet_media[i]);
31
32 i++;
33 }
34
35 soma = 0;
36 maior = vet_media[0];
37 aprovados = 0;
38 reprovados = 0;
39
40 for (i=0; i < totalalunos; i++){
41 //soma das mdias
42 soma += vet_media[i];
43
44 if ( vet_media[i] > maior ) {
45 maior = vet_media[i];
46 }
47
48 if ( vet_media[i] >= 5 ) {
49 aprovados++;
50 }else{
51 reprovados++;
52 }
53 }
54
55 printf(Media da turma: %.1f \n, (soma/totalalunos) );
56 printf(Maior media: %.1f \n, maior);
57 printf(Aprovados: %.1f%% \n, ((float)(aprovados/totalalunos)*100));
58 printf(Reprovados: %.1f%% \n, ((float)(reprovados/totalalunos)*100));
59
60
61 return 0;
62 }
fim cdigo 11
Resultado da execuo do algoritmo:

Nota 1a prova: 10
Nota 2a prova: 8
Mdia do aluno = 9
Nota 1a prova: 6.5

Nota 2a prova: 6
Mdia do aluno = 6.25
Nota 1a prova: 3.5

Nota 2a prova: 8
Mdia do aluno = 5.75
Nota 1a prova: 8
Nota 2a prova: 1
Mdia do aluno = 4.5
Nota 1a prova: 5
Nota 2a prova: 3
Mdia do aluno = 4
Mdia da turma: 5.9

Maior mdia: 9
Porcentagem de Aprovados = 60%
Porcentagem de Reprovados = 40%
2) Elabore um algoritmo que receba o cdigo, a descrio, o valor unitrio e a quantida-

de em estoque de cinquenta produtos comercializados por uma livraria. Esses dados
devem ser armazenados em um registro do tipo vetor.
Assim, crie um menu por meio do qual o usurio possa:
a) cadastrar novos produtos;
b) alterar produtos cadastrados;
c) exibir todos os produtos;
d) exibir produtos com estoque inferior a 5 unidades.
cdigo 12
1 /*
2 * Programa para controlar produtos.
3 *
5 */
6
8
9 int main()
10 {
11
12 struct tipoproduto{
13 int codigo;
14 char descricao[40];
15 float vlunit;
16 int qtde;
17 };
18

19 //vetor de 50 posies do tipo registro

20 struct tipoproduto produtos[50];
21
22 int opcao;
23 int total_produtos;
24 int cont_produtos;
25 int i, codigo, posicao;
26 int achou;
27
28
29 //total de produtos que podem ser cadastrados
30 total_produtos = 50;
31
32 //total de produtos j cadastrados no sistema
33 cont_produtos = 0;
34
35
36 do{
37 // menu de opes
38 printf(\n---------Menu de Opcoes---------\n);
39 printf([1] Cadastrar \n);
40 printf([2] Alterar \n);
41 printf([3] Exibir Todos \n);
42 printf([4] Exibir Estoque Baixo \n);
43 printf([5] Sair \n);
44 fflush(stdin);
45 scanf(%i,&opcao);
46
47 switch(opcao){
48 case 1: //cadastrar novos produtos
49
50 if ( cont_produtos < total_produtos) {
51 printf(Codigo: );
52 scanf(%i,&produtos[cont_produtos].codigo );
53 fflush(stdin);
54 printf(Descricao: );
55 gets(produtos[cont_produtos].descricao);
56 printf(Valor Unitario: );
57 scanf(%f,&produtos[cont_produtos].vlunit );
58 printf(Quantidade: );
59 scanf(%i,&produtos[cont_produtos].qtde );
60
61 printf(\nProduto cadastrado com sucesso!\n);
62
63 //incrementar produtos cadastrados
64 cont_produtos++;
65 }else{
66 printf(\nLimite atingido.\n);
67 }
68 break;
69
70 case 2: //alterar produtos j cadastrados
71
72 printf( \n Codigo do produto para alteracao: );
74
75 // verificar se o produto j foi cadastrado
76 achou = 0;
77 i = 0;
78 while ((i<total_produtos) && (achou==0)){
79
80 if (produtos[i].codigo==codigo) {
81 achou = 1;
82 //guardar a posio do produto
83 posicao = i;
84 }
85
86 i++;
87 }
88
89 if (achou != 0) {
90 printf(\n Alteracao do produto\n);
91 printf(Codigo : );
92 scanf(%i,&produtos[posicao].codigo );
93 fflush(stdin);
94 printf(Descricao: );
95 gets( produtos[posicao].descricao );
96 printf(Valor Unitario: );
97 scanf(%f,&produtos[posicao].vlunit );
98 printf(Quantidade: );
99 scanf(%i,&produtos[posicao].qtde );
100
101 printf(\nProduto alterado com sucesso!\n);
102
103 }else{
104 printf(\nProduto no encontrado.\n);
105 }
106 break;
107
108 case 3: //exibir todos os produtos
109
110 printf(Relatorio dos Produtos \n);
111 printf(Codigo----Descricao---------Vl Unit.--Qtde\n);
112 for (i = 0; i < cont_produtos; i++){
113 printf(%-10i, produtos[i].codigo);
114 printf(%-18s, produtos[i].descricao);
115 printf(%8.2f, produtos[i].vlunit);
116 printf(%6i\n, produtos[i].qtde);
117 }
118 break;

119 case 4: //exibir produtos com estoque baixo

120
121 printf(Produtos com Estoque Baixo \n);
122 printf(Codigo----Descricao---------Vl Unit.--Qtde\n);
123 for (i = 0; i < cont_produtos; i++){
124 if (produtos[i].qtde < 5) {
125 printf(%-10i, produtos[i].codigo);
126 printf(%-18s, produtos[i].descricao);
127 printf(%8.2f, produtos[i].vlunit);
128 printf(%6i\n, produtos[i].qtde);
129 }
130 }
131 break;
132 case 5:
133 printf(Programa finalizado \n);
134 break;
135
136 default:
137 printf(\nOpcao invalida.\n);
138 }
139 }while( opcao != 5 );
140
141 return 0;
142 }
fim cdigo 12
---------Menu de Opcoes---------
[1] Cadastrar
[2] Alterar
[3] Exibir Todos
[4] Exibir Estoque Baixo
[5] Sair
1
Codigo: 123
Descricao: Computador Core 2 Duo
Valor Unitario: 1350.00
Quantidade: 5
Produto cadastrado com sucesso!
---------Menu de Opcoes---------
[1] Cadastrar
[2] Alterar
[3] Exibir Todos
[4] Exibir Estoque Baixo
[5] Sair
5
Programa finalizado
3) Escreva um programa que inicialize todas as posies de um vetor de inteiros com

zero. Para isso, utilize um ponteiro para inteiro. Antes da inicializao, voc dever
exibir o contedo do vetor na tela.
cdigo 13
1 /*
2 * Programa inicializar os elementos de um vetor
3 * utilizando ponteiros
4 *
6 */
7
10
11 /*
12 * FUNO PRINCIPAL
13 */
14 int main()
15 {
16 int v[5];
17 int i;
18 int *p;
19
20 //exibir vetor
21 for ( i = 0; i < 5; i++){
22 printf(Posicao %i = %i \n,i,v[i]);
23 }
24
25 //inicializar vetor
26 p = &v; // ponteiro para primeira posio do vetor (0)
27
28 for ( i = 0; i < 5; i++){
29
30 // atribuir zero posio atual do vetor e incrementar
31 // o ndice
32 *p++ = 0;
33
34 }
35
36 //exibir vetor
37 for ( i = 0; i < 5; i++){
39 }
40
41 return 0;
42 }
fim cdigo 13


Posicao 0 = 1997087925
Posicao 1 = -64836606
Posicao 2 = -2
Posicao 3 = 1997025703
Posicao 4 = 1997356140
Posicao 0 = 0
Posicao 1 = 0
Posicao 2 = 0
Posicao 3 = 0
Posicao 4 = 0
4) Escreva um algoritmo capaz de receber um conjunto de 20 valores informados pelo

usurio e armazen-los em uma matriz de 5x4, ou seja, cinco linhas e quatro colunas.
Ateno: voc deve garantir que os valores recebidos sejam maiores ou iguais a zero e
menores que 100. Ao final, apresente as informaes na tela.
cdigo 14
1 /*------------------------------------------------
2 *
3 * Exemplo de uma aplicao capaz de ler um conjunto de dados e
4 * armazena-los em uma matriz.
5 *
7 *
8 *----------------------------------------------*/
9
10 /*------------------------------------------------
11 * BIBLIOTECAS
12 *----------------------------------------------*/
15
16 /*------------------------------------------------
17 * CONSTANTES
18 *----------------------------------------------*/
19 #define NUM_LINHAS 5
20 #define NUM_COLUNAS 4
21
22
23 /*-----------------------------------------------*
25 *----------------------------------------------*/
26 int main()
27 {
29 char titulo_do_programa[30] = MANIPULACAO DE MATRIZES;
30
31 //declaracao da matriz
32 int matriz[NUM_LINHAS][NUM_COLUNAS];
33 int linha;
34 int coluna;
35 int numero_valido;
36
37 //
39 //
41 printf(%c,218);
49 printf(%c,192);
56
57 for (linha = 0; linha < NUM_LINHAS; linha++){
58 for ( coluna = 0; coluna < NUM_COLUNAS; coluna++){
59 matriz[linha][coluna] = linha*coluna;
60 }
61 }
62
63 printf(>>>LEITURA dos dados da matriz\n\n);
66
67 do{
68 printf(Informe o valor da linha %i e coluna %i: ,linha,coluna);
69 scanf(%i,&matriz[linha][coluna]);
70
71 // garantir que os valores sejam validos e estejam dentro do
72 // intervalo desejado
73 if ( matriz[linha][coluna] >= 0 && matriz[linha][coluna] < 100 ){
74 numero_valido = 1;
75 }else{
77 printf( ***valor informado eh invalido!\n);
78 }
79 }while( numero_valido = 0 );
80

81
82 }
83 }
84
85 printf(\n\n);
86 printf(>>>APRESENTACAO dos dados da matriz\n\n);
87 printf(\t %c,218);
89 printf(%c%c%c%c%c%c%c%c%c%c,194,196,196,196,196,194,196,196,196,196,196);
printf(Linha %i %c %02i %c %02i %c %02i %c %02i %c\n,linha, 179,matriz[linha]
[0],179,
92
matriz[linha][1],179,matriz[linha][2],179,
matriz[linha][3],179);
93
94 if ( linha < NUM_LINHAS-1 ){
95 printf(\t %c,195);
printf(%c%c%c%c%c%c%c%c%c%c,197,196,196,196,
97
196,197,196,196,196,196,196);
99 }else{
100 printf(\t %c,192);
102
196,193,196,196,196,196,196);
103 printf(%c\n,217);
104 }
105 }
106
109 }
fim cdigo 14

5) Altere o algoritmo anterior (Cdigo 14) de maneira que os dados da matriz sejam
preenchidos com valores aleatrios. Em seguida, apresente essas informaes na tela.
cdigo 15
1 /*-------------------------------------------------
2 *
5 *
7 *
8 *-----------------------------------------------*/
9
10 /*-------------------------------------------------
11 * BIBLIOTECAS
12 *-----------------------------------------------*/
15 #include <iostream.h> //para utilizao da funo time dos numeros aleatorios
16
17 /*-------------------------------------------------
18 * CONSTANTES
19 *-----------------------------------------------*/
22
23
24 /*------------------------------------------------*

26 *-----------------------------------------------*/
27 int main()
28 {
30 char titulo_do_programa[30] = MANIPULACAO DE MATRIZES;
31
34 int linha;
35 int coluna;
37
38 //
40 //
42 printf(%c,218);
50 printf(%c,192);
57
60 matriz[linha][coluna] = linha*coluna;
61 }
62 }
63
64 //inicializar o gerador de numeros randomicos
65 srand(time(NULL));
66
67 printf(>>>LEITURA dos dados da matriz (aleatorios)\n\n);
70
71 do{
72
73 //
74 // GERACAO DE NUMEROS ALEATORIOS
75 //
76 //
77
78 // gera um nmero aleatrio entre 0 e
79 // 99 (inclusive)
80 int valor_aleatorio = rand() % 99 ;
81
printf(Informe o valor da linha %i e coluna %i:
82
%i\n,linha,coluna,valor_aleatorio);
83 matriz[linha][coluna] = valor_aleatorio;
84
85 // garantir que os valores sejam validos e estejam dentro do
86 // intervalo desejado
87 if ( matriz[linha][coluna] >= 0 && matriz[linha][coluna] < 100 ){
89 }else{
91 printf( ***valor informado eh invalido!\n);
92 }
93 }while( numero_valido = 0 );
94
95
96 }
97 }
98
99 printf(\n\n);
100 printf(>>>APRESENTACAO dos dados da matriz\n\n);
101 printf(\t %c,218);
103
196,194,196,196,196,196,196);
104 printf(%c\n,191);
printf(Linha %i %c %02i %c %02i %c %02i %c %02i %c\n,linha, 179,matriz[linha]
106 [0],179,
matriz[linha][1],179,matriz[linha][2],179,matriz[linha][3],179);
107
109 printf(\t %c,195);
111
196,197,196,196,196,196,196);
112 printf(%c\n,180);
113 }else{
114 printf(\t %c,192);
116
196,193,196,196,196,196,196);
117 printf(%c\n,217);
118 }
119 }
120

123 }
fim cdigo 15

6) Elabore um algoritmo que contenha uma matriz de 10x4 elementos. O usurio dever
informar qual valor ele deseja armazenar na matriz, que deve ser do tipo inteiro, bem
como a posio em que esse valor dever ser armazenado. Para garantir o correto fun-
cionamento do algoritmo, voc dever verificar se a posio informada pelo usurio
valida. Crie um menu para facilitar a utilizao da aplicao que tenha duas opes:
(i) adicionar elemento e (ii) listar elementos. Alm disso, uma opo deve ser utilizada
para finalizar a aplicao.
cdigo 16
1 /*-------------------------------------------------
2 *

5 *
7 *
8 *-----------------------------------------------*/
9
10 /*-------------------------------------------------
11 * BIBLIOTECAS
12 *-----------------------------------------------*/
15 #include <iostream.h> //para utilizao da funo time dos numeros aleatorios
16
17 /*-------------------------------------------------
18 * CONSTANTES
19 *-----------------------------------------------*/
22
23
24 /*------------------------------------------------*
26 *-----------------------------------------------*/
27 int main()
28 {
30 char titulo_do_programa[40] = MANIPULACAO DE MATRIZES COM INTEIROS;
31
34 int linha;
35 int coluna;
38
39 //INICIALIZAR MATRIZ COM ZEROS
42 matriz[linha][coluna] = 0;
43 }
44 }
45
46 //
48 //
49 do{
51 printf(%c,218);

59 printf(%c,192);
66
67 printf(\t[1] ADICIONAR ELEMENTO NA MATRIZ \n);
68 printf(\t[2] LISTAR ELEMENTOS \n);
70 fflush(stdin);
71 printf(\n\n);
74
75
76 if ( opcao_desejada == 1 ){
77
78 do{
80 printf(\n\n%c%c%c%c>> ADICIONAR ELEMENTO NA MATRIZ \n,195,196,196,196);
83 printf(%c%c%c%c%c%cInforme a linha...: ,195,196,196,194,196,196);
84 scanf(%i,&linha);
85 printf(%c%c%c%c%c%cInforme a coluna..: ,195,196,196,197,196,196);
86 scanf(%i,&coluna);
87
88 if ( !( linha >=0 && linha < NUM_LINHAS ) ) {
89 fflush(stdin);
90 printf(\n\n);
91 printf(>>>>ERRO: A linha informada nao eh valida!\n);
92 printf(\n\n);
93 getchar();
94 }else{
95 if ( !(coluna >=0 && coluna < NUM_COLUNAS) ) {
96 fflush(stdin);
97 printf(\n\n);
98 printf(>>>>ERRO: A coluna informada nao eh valido!\n);
99 printf(\n\n);
100 getchar();
101 }else{
102 fflush(stdin);
printf(%c%c%c%c%c%cInforme o elemento:
103
,192,196,196,193,196,196);
104 scanf(%i,&matriz[linha][coluna]);
105 }
106 }
107
}while ( !( linha >=0 && linha < NUM_LINHAS ) || !(coluna >=0 && coluna <
108
NUM_COLUNAS) );
109
110 fflush(stdin);
111 printf(\n\n);
112 printf(>>>>INFO: OPERACAO realizada com com SUCESSO!\n);
113 printf(\n\n);
114 getchar();
115
116 }else if ( opcao_desejada == 2 ){
118 printf(\n\n%c%c%c%c>> LISTAR ELEMENTOS DA MATRIZ \n,192,196,196,196);
119
120 printf(%c,218);
printf(%c%c%c%c%c%c%c%c%c%
121
cc,196,196,196,196,196,196,194,196,196,196,196,196);
printf(%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c,196,
122
196,194,196,196,196,196,196,196,194,196,196,196,196,196,196,196);
123 printf(%c\n,191);
125 printf(%c %04i %c %04i %c %04i %c %04i %c\n,179,matriz[linha][0],
179,matriz[linha][1], 179,matriz[linha][2], 179,matriz[linha]
126
[3],179);
128 printf(%c,195);
printf(%c%c%c%c%c%c%c%c%c%c
129
%c,196,196,196,196,196,196,197,196,196,196,196,196,196,196);
130
196,197,196,196,196,196,196,196,197,196,196,196,196,196);
131 printf(%c\n,180);
132 }else{
133 printf(%c,192);
printf(%c%c%c%c%c%c%c%c%c%c
134
%c,196,196,196,196,196,196,193,196,196,196,196,196,196,196);
135
196,193,196,196,196,196,196,196,193,196,196,196,196,196);
136 printf(%c\n,217);
137 }
138 }
139
140 fflush(stdin);
141 printf(\n\n);
143 printf(\n\n);
144 getchar();
145
146 }
148


151 }
fim cdigo 16


7) Escreva um algoritmo que receba duas matrizes de 3x3 elementos, some os valores
dessas matrizes e armazene em uma terceira matriz. Ao final, apresente os resultados
na tela.
cdigo 17
1 /*-------------------------------------------------
2 *
3 * Exemplo de uma aplicao capaz de ler duas matrizes de 3x3,
4 * realizar a soma entre elas e apresentar os resultados na tela.
5 *
7 *
8 *-----------------------------------------------*/
9
10 /*-------------------------------------------------
11 * BIBLIOTECAS
12 *-----------------------------------------------*/
15
16 /*-------------------------------------------------
17 * CONSTANTES
18 *-----------------------------------------------*/
21
22
23 /*------------------------------------------------*
25 *-----------------------------------------------*/

26 int main()
27 {
29 char titulo_do_programa[40] = SOMA DE MATRIZES;
30
32 int matrizA[NUM_LINHAS][NUM_COLUNAS];
33 int matrizB[NUM_LINHAS][NUM_COLUNAS];
34 int matrizC[NUM_LINHAS][NUM_COLUNAS];
35 int linha;
36 int coluna;
37
39
40 //INICIALIZAR MATRIZES COM ZERO
43 matrizA[linha][coluna] = 0;
44 matrizB[linha][coluna] = 0;
45 matrizC[linha][coluna] = 0;
46 }
47 }
48
49 //
51 //
52 do{
54 printf(%c,218);
62 printf(%c,192);
69
70 printf(\t[1] LEITURA DA MATRIZ A \n);
71 printf(\t[2] LEITURA DA MATRIZ B \n);
72 printf(\t[3] SOMA DAS MATRIZES (A+B) \n);
74 fflush(stdin);
75 printf(\n\n);

78
79
81
83 printf(\n\n%c%c%c%c%c%c LEITURA DA MATRIZ A \n,195,196,196,196,175,175);
84 printf(\n);
85 printf(\n);
86
printf(Informe o valor do elemento da linha %i e coluna %i da
89
matriz A: ,linha,coluna);
90 scanf(%i,&matrizA[linha][coluna]);
91 }
92 }
93
94 fflush(stdin);
95 printf(\n\n);
97 printf(\n\n);
98 getchar();
99
101
103 printf(\n\n%c%c%c%c%c%c LEITURA DA MATRIZ B \n,195,196,196,196,175,175);
104 printf(\n);
105 printf(\n);
106
printf(Informe o valor do elemento da linha %i e coluna %i da
109
matriz B: ,linha,coluna);
110 scanf(%i,&matrizB[linha][coluna]);
111 }
112 }
113
114 fflush(stdin);
115 printf(\n\n);
117 printf(\n\n);
118 getchar();
119
120
122

printf(\n\n%c%c%c%c%c%c SOMA DAS MATRIZES (A+B)

124
\n,195,196,196,196,175,175);
125 printf(\n);
126 printf(\n);
127
128 //SOMAR OS ELEMENTOS DA MATRIZ E ARMAZENA-LOS NA MATRIZ C
matrizC[linha][coluna] = matrizA[linha][coluna]+matrizB[linha]
131
[coluna];
132 }
133 }
134
135 //APRESENTAR RESULTADOS NA TELA
136 printf(%c,218);
137 printf(%c%c%c%c%c%c%c%c%c,196,196,196,196,196,194,196,196,196);
printf(%c%c%c%c%c%c%c%c,196,196,194,196,196,
138
196,196);
139 printf(%c\n,191);
141 printf(%c %03i %c %03i %c %03i %c \n,179,matrizC[linha][0],
142 179,matrizC[linha][1], 179,matrizC[linha][2], 179);
143
145 printf(%c,195);
printf(%c%c%c%c%c%c%c%c
146
%c,196,196,196,196,196,197,196,196,196,196,196,196);
printf(%c%c%c%c%c%c%c%c,196,196,197,196,196,
147
196,196,196);
148 printf(%c\n,180);
149 }else{
150 printf(%c,192);
printf(%c%c%c%c%c%c%c%c
151
%c,196,196,196,196,196,193,196,196,196,196,196,196);
printf(%c%c%c%c%c%c%c%c,196,196,193,196,196,
152
196,196,196);
153 printf(%c\n,217);
154 }
155 }
156
157 fflush(stdin);
158 printf(\n\n);
160 printf(\n\n);
161 getchar();
162
163 }
165
168 }
fim cdigo 17


8) Um consultrio odontolgico deseja armazenar informaes a respeito de seus clien-

tes. Para isso, voc dever elaborar um sistema computacional que seja capaz de:
a) cadastrar novos clientes, contendo as seguintes informaes: cdigo, nome, en-
dereo completo, data de nascimento, telefone e ativo. O campo ativo ser uti-
lizado para determinar se um cliente est visitando regularmente o consultrio
ou no;
b) alterar dados cadastrais deve ser possvel, por meio do cdigo do paciente, alte-
rar as informaes cadastradas;
c) alterar status do paciente deve ser possvel ativar ou desativar um paciente.
Para isso, necessrio informar o cdigo desse paciente;
d) pesquisa por cdigo informando o cdigo do paciente, todas as suas informa-
es devero ser apresentadas;
e) pesquisa por nome a partir do nome completo do paciente, todas as suas infor-
maes so exibidas;
f) relatrio por cdigo devero ser exibidas na tela todas as informaes dos pa-
cientes ordenadas a partir do cdigo;
g) relatrio por nome devero ser exibidas na tela todas as informaes dos pa-
cientes ordenadas a partir do nome.
O sistema dever ser capaz de armazenar at cem pacientes e todas as informaes de-
vem ser armazenadas em uma estrutura do tipo registro.
cdigo 18
1 /*-------------------------------------------------
2 *
3 * Exemplo de uma aplicao capaz controlar os pacientes de um
4 * consultrio odontolgico
5 *
7 *
8 *-----------------------------------------------*/
9
10 /*-------------------------------------------------
11 * BIBLIOTECAS
12 *-----------------------------------------------*/
15 #include <string.h> //para manipulao de strings
16
17 /*-------------------------------------------------
18 * CONSTANTES
19 *-----------------------------------------------*/
20 #define TOTAL_PACIENTES 5
21
22 /*-------------------------------------------------
23 * ESTRUTURA DO TIPO REGISTRO
24 *-----------------------------------------------*/
25 struct tipo_data{
26 int dia;
27 int mes;
28 int ano;
29 };
30
31 struct tipo_paciente{
32 int codigo;
33 char nome[60];
34 char endereco[80];
35 struct tipo_data data;
36 char telefone[14];
37 int ativo; // 0 = inativo e 1 = ativo;
38 };
39
40
41
42 /*------------------------------------------------*
44 *-----------------------------------------------*/
45 int main()
46 {


48 char titulo_do_programa[40] = CONSULTORIO ODONTOLOGICO;
49
50 //declaracao do vetor de registro de pacientes
51 struct tipo_paciente pacientes[TOTAL_PACIENTES];
52 int paciente_atual;
53
54 //variveis auxiliares
55 int codigo_paciente_pesquisar;
56 char nome_paciente_pesquisar[60];
57 int posicao;
58 int paciente_status;
59 bool paciente_encontrado = false;
60
62
63 //INICIALIZAR VARIAVEIS
64 paciente_atual = 0;
65 for( posicao = 0; posicao < TOTAL_PACIENTES; posicao++){
66 pacientes[posicao].codigo = -1;
67 strcpy(pacientes[posicao].nome,);
68 strcpy(pacientes[posicao].endereco,);
69 pacientes[posicao].data.dia = -1;
70 pacientes[posicao].data.mes = -1;
71 pacientes[posicao].data.ano = -1;
72 strcpy(pacientes[posicao].telefone,);
73 pacientes[posicao].ativo = 0;
74 }
75
76 //
78 //
79 do{
81 printf(%c,218);
88 printf(%c %c%c %-40s %c \n,179,175,175,titulo_do_programa,179);
89 printf(%c,195);
96 printf(%c %c%c %-40s %c \n,179,175,175,MENU PRINCIPAL,179);
97 printf(%c %-43s %c \n,179, ,179);

98 printf(%c %-40s %c \n,179, [1] CADASTRAR NOVO PACIENTE ,179);
99 printf(%c %-40s %c \n,179, [2] ALTERAR DADOS CADASTRAIS ,179);
100 printf(%c %-40s %c \n,179, [3] ALTERAR STATUS DO PACIENTE ,179);
101 printf(%c %-40s %c \n,179, [4] PESQUISAR PACIENTE POR CODIGO ,179);
102 printf(%c %-40s %c \n,179, [5] PESQUISAR PACIENTE POR NOME ,179);
103 printf(%c %-40s %c \n,179, [6] RELATORIO DE PACIENTES POR CODIGO ,179);
104 printf(%c %-40s %c \n,179, [7] RELATORIO DE PACIENTES POR NOME ,179);
105 printf(%c %-43s %c \n,179, ,179);
106 printf(%c %-40s %c \n,179, [0] SAIR DA APLICACAO ,179);
107 printf(%c,192);
113 printf(%c\n,217);
114
115 fflush(stdin);
116 printf(\n\n);
117 printf( %s ,Selecione a opcao desejada: );
119
120
122
124 printf(%c,218);
130 printf(%c\n,191);
132 printf(%c,192);
138 printf(%c\n,217);
139 printf( %c\n,179);
140 printf( %c%c%c%c>>> CADASTRAR NOVO PACIENTE\n,192,196,196,196,175);
141 printf(\n\n);
142
143
144 if ( paciente_atual < TOTAL_PACIENTES ){
145 printf( %c Codigo............: ,219);
146 scanf(%i,&pacientes[paciente_atual].codigo);

147
148 fflush(stdin);
149 printf( %c Nome..............: ,219);
150 gets(pacientes[paciente_atual].nome);
151
152 fflush(stdin);
153 printf( %c Endereco..........: ,219);
154 gets(pacientes[paciente_atual].endereco);
155
156 fflush(stdin);
157 printf( %c Data de Nascimento: \n,219);
printf( %c ...........Dia: ,219);
158
scanf(%i,&pacientes[paciente_atual].data.dia);
printf( %c ...........Mes: ,219);
159
scanf(%i,&pacientes[paciente_atual].data.mes);
printf( %c ...........Ano: ,219);
160
scanf(%i,&pacientes[paciente_atual].data.ano);
161
162 fflush(stdin);
163 printf( %c Telefone..........: ,219);
164 gets(pacientes[paciente_atual].telefone);
165
166 //DETERMINAR STATUS DO PACIENTE
167 pacientes[paciente_atual].ativo = 1;
168
169
170 //INCREMENTAR TOTAL DE PACIENTE
171 paciente_atual++;
172
173 fflush(stdin);
174 printf(\n\n);
176 printf(\n\n);
177 getchar();
178
179 }else{
180 fflush(stdin);
181 printf(\n\n);
printf(>>>>ERRO: O total de %i pacientes jah foi atingido\n, TOTAL_
182
PACIENTES);
183 printf(\n\n);
184 getchar();
185 }
186
187
188
190
192 printf(%c,218);
198 printf(%c\n,191);
200 printf(%c,192);
206 printf(%c\n,217);
207 printf( %c\n,179);
208 printf( %c%c%c%c>>> ALTERAR DADOS CADASTRAIS\n,192,196,196,196,175);
209 printf(\n\n);
210
211
212 printf( %c Informe o codigo do paciente: ,219);
213 scanf(%i,&codigo_paciente_pesquisar);
214
215 //PESQUISAR SE O PACIENTE EXISTE NO SISTEMA
216 paciente_encontrado = false;
217 posicao = 0;
218 while ( paciente_encontrado == false && posicao < TOTAL_PACIENTES ){
219 if ( pacientes[posicao].codigo == codigo_paciente_pesquisar ){
220 paciente_encontrado = true;
221 }else{
222 posicao++;
223 }
224 }
225
226 if ( paciente_encontrado == true ){
227
228 printf(\n);
229 printf( %c INFORME OS NOVOS DADOS DO PACIENTE \n,219);
230 printf( %c Codigo............: ,219);
231 scanf(%i,&pacientes[posicao].codigo);
232
233 fflush(stdin);
234 printf( %c Nome..............: ,219);
235 gets(pacientes[posicao].nome);
236
237 fflush(stdin);
239 gets(pacientes[posicao].endereco);
240
241 fflush(stdin);
printf( %c ...........Dia: ,219);
243
scanf(%i,&pacientes[posicao].data.dia);

printf( %c ...........Mes: ,219);

244
scanf(%i,&pacientes[posicao].data.mes);
printf( %c ...........Ano: ,219);
245
scanf(%i,&pacientes[posicao].data.ano);
246
247 fflush(stdin);
249 gets(pacientes[posicao].telefone);
250
252 pacientes[posicao].ativo = 1;
253
254 fflush(stdin);
255 printf(\n\n);
257 printf(\n\n);
258 getchar();
259
260
261 }else{
262 fflush(stdin);
263 printf(\n\n);
printf(>>>>INFO: O paciente com o codigo informado NAO foi
264
encontrado.\n);
265 printf(\n\n);
266 getchar();
267 }
269
271 printf(%c,218);
277 printf(%c\n,191);
279 printf(%c,192);
285 printf(%c\n,217);
286 printf( %c\n,179);
287 printf( %c%c%c%c>>> ALTERAR STATUS DO PACIENTE\n,192,196,196,196,175);
288 printf(\n\n);
289
290
293
296 posicao = 0;
300 }else{
301 posicao++;
302 }
303 }
304
306 printf(\n);
printf( %c INFORME O NOVO STATUS DO PACIENTE....: [1] ATIVO
307
\n,219);
308 printf( %c .................: [2] INATIVO \n,219);
309 printf( %c ......Selecione o status desejado: ,219);
310 scanf(%i,&paciente_status);
311
312 if ( paciente_status == 2){
313 paciente_status = 0; // inativo
314 }
315
316 pacientes[posicao].ativo = paciente_status;
317
318 fflush(stdin);
319 printf(\n\n);
321 printf(\n\n);
322 getchar();
323
324 }else{
325 fflush(stdin);
326 printf(\n\n);
327
encontrado.\n);
328 printf(\n\n);
329 getchar();
330 }
332
334 printf(%c,218);
340 printf(%c\n,191);


342 printf(%c,192);
348 printf(%c\n,217);
349 printf( %c\n,179);
printf( %c%c%c%c>>> PESQUISAR PACIENTE POR CODIGO
350
\n,192,196,196,196,175);
351 printf(\n\n);
352
353
356
359 posicao = 0;
363 }else{
364 posicao++;
365 }
366 }
367
369
370 printf(\n);
printf( %c Codigo............: %i \n,219,pacientes[posicao].
371
codigo);
372 printf( %c Nome..............: %s \n,219,pacientes[posicao].nome);
printf( %c Endereco..........: %s \n,219,pacientes[posicao].
373
endereco);
printf( %c ...........Dia: %i \n,219, pacientes[posicao].data.
375
dia);
printf( %c ...........Mes: %i \n,219, pacientes[posicao].data.
376
mes);
printf( %c ...........Ano: %i \n,219, pacientes[posicao].data.
377
ano);
printf( %c Telefone..........: %s \n,219, pacientes[posicao].
378
telefone);
379
380 if ( pacientes[posicao].ativo == 1 ){
381 printf( %c Status............: %s \n,219, ATIVO);
382 }else{
383 printf( %c Status............: %s \n,219, INATIVO);
384 }
385 fflush(stdin);
386 printf(\n\n);

388 printf(\n\n);
389 getchar();
390
391 }else{
392 fflush(stdin);
393 printf(\n\n);
394
encontrado.\n);
395 printf(\n\n);
396 getchar();
397 }
398
399
401
403 printf(%c,218);
409 printf(%c\n,191);
411 printf(%c,192);
417 printf(%c\n,217);
418 printf( %c\n,179);
printf( %c%c%c%c>>> PESQUISAR PACIENTE POR NOME
419
\n,192,196,196,196,175);
420 printf(\n\n);
421
422 fflush(stdin);
423 printf( %c Informe o nome do paciente: ,219);
424 gets(nome_paciente_pesquisar);
425
428 posicao = 0;
430 //DICA:
431 // Se voc tentar criar duas strings com o mesmo contedo e compar-las
// como faria como nmeros, ver que elas no so iguais. Isso ocorre
432
porque,
// na verdade, o que est sendo comparado so os endereos de memria
433
onde esto

// guardadas as strings. Para comparar o contedo de duas strings, voc

434
deve usar
435 // a funo strcmp (ou suas variantes):
436 //
// strcmp = compara duas strings com distino de maisculas e
437
minsculas
// strncmp = compara apenas os n primeiros caracteres das duas
438
strings,sendo n um terceiro argumento.
// stricmp = compara duas strings sem distino entre maisculas e
439
minsculas. A sintaxe igual de strcmp
440 if ( strcmp(nome_paciente_pesquisar,pacientes[posicao].nome) == 0 ){
442 }else{
443 posicao++;
444 }
445 }
446
448
449 printf(\n);
printf( %c Codigo............: %i \n,219,pacientes[posicao].
450
codigo);
451 printf( %c Nome..............: %s \n,219,pacientes[posicao].nome);
printf( %c Endereco..........: %s \n,219,pacientes[posicao].
452
endereco);
printf( %c ...........Dia: %i \n,219, pacientes[posicao].data.
454
dia);
printf( %c ...........Mes: %i \n,219, pacientes[posicao].data.
455
mes);
printf( %c ...........Ano: %i \n,219, pacientes[posicao].data.
456
ano);
printf( %c Telefone..........: %s \n,219, pacientes[posicao].
457
telefone);
458
459 if ( pacientes[posicao].ativo == 1 ){
461 }else{
463 }
464 fflush(stdin);
465 printf(\n\n);
467 printf(\n\n);
468 getchar();
469
470 }else{
471 fflush(stdin);
472 printf(\n\n);
printf(>>>>INFO: O paciente com o nome informado NAO foi
473
encontrado.\n);
474 printf(\n\n);
475 getchar();
476 }
477
479
481 printf(%c,218);
487 printf(%c\n,191);
489 printf(%c,192);
495 printf(%c\n,217);
496 printf( %c\n,179);
printf( %c%c%c%c>>> RELATORIO DE PACIENTES POR CODIGO
497
\n,192,196,196,196,175);
498 printf(\n\n);
499
500
501 //
502 // ORDENACAO DOS PACIENTES UTILIZANDO O METODO POR SELECAO
503 //
504 // Informao
505 // O selection sort (do ingls, ordenao por seleo) um
506 // algoritmo de ordenao baseado em se passar sempre o menor
507 // valor do vetor para a primeira posio (ou o maior dependendo
508 // da ordem requerida), depois o de segundo menor valor para a
509 // segunda posio, e assim feito sucessivamente com os (n-1)
510 // elementos restantes, at os ltimos dois elementos.
511 //
512 // Fonte: http://pt.wikipedia.org/wiki/Selection_sort
513
514 int i, j, min;
515 struct tipo_paciente tmp[TOTAL_PACIENTES];
516 struct tipo_paciente aux;
517
518 //COPIAR PACIENTES PARA UMA ESTRUTURA TEMPORARIA
520 tmp[posicao] = pacientes[posicao];
521 }
522
523 for ( i = 0; i < TOTAL_PACIENTES; i++){
524 min = i;
525 for ( j = i+1; j < TOTAL_PACIENTES; j++){
526 if ( tmp[j].codigo < tmp[min].codigo ){

527 min = j;
528 }
529 }
530 if ( i != min ){
531 // TROCAR
532 aux = tmp[i];
533 tmp[i] = tmp[min];
534 tmp[min] = aux;
535 }
536 }
537
538 //EXIBIR DADOS NA TELA
539 for ( posicao = 0; posicao < TOTAL_PACIENTES; posicao++){
540
541 if ( tmp[posicao].codigo != -1 ){
542 printf( %c Codigo............: %i \n,219, tmp[posicao].codigo);
543 printf( %c Nome..............: %s \n,219, tmp[posicao].nome);
printf( %c Endereco..........: %s \n,219, tmp[posicao].
544
endereco);
printf( %c ...........Dia: %i \n,219, tmp[posicao].data.
546
dia);
printf( %c ...........Mes: %i \n,219, tmp[posicao].data.
547
mes);
printf( %c ...........Ano: %i \n,219, tmp[posicao].data.
548
ano);
printf( %c Telefone..........: %s \n,219, tmp[posicao].
549
telefone);
550
551 if ( tmp[posicao].ativo == 1 ){
552 printf( %c Status............: %s \n\n,219, ATIVO);
553 }else{
554 printf( %c Status............: %s \n\n,219, INATIVO);
555 }
556 }
557
558 }
559
560 fflush(stdin);
561 printf(\n\n);
563 printf(\n\n);
564 getchar();
565
566
568
570 printf(%c,218);
576 printf(%c\n,191);
578 printf(%c,192);
584 printf(%c\n,217);
585 printf( %c\n,179);
printf( %c%c%c%c>>> RELATORIO DE PACIENTES POR NOME
586
\n,192,196,196,196,175);
587 printf(\n\n);
588
589
590 //
591 // ORDENACAO DOS PACIENTES UTILIZANDO O METODO POR SELECAO
592 //
593 int i, j, min;
594 struct tipo_paciente tmp[TOTAL_PACIENTES];
595 struct tipo_paciente aux;
596
597 //COPIAR PACIENTES PARA UMA ESTRUTURA TEMPORARIA
599 tmp[posicao] = pacientes[posicao];
600 }
601
602 for ( i = 0; i < TOTAL_PACIENTES; i++){
603 min = i;
604 for ( j = i+1; j < TOTAL_PACIENTES; j++){
605 if ( strcmpi(tmp[min].nome,tmp[j].nome) > 0 ){
606 min = j;
607 }
608 }
609 if ( i != min ){
610 // TROCAR
611 aux = tmp[i];
613 tmp[min] = aux;
614 }
615 }
616
618 for ( posicao = 0; posicao < TOTAL_PACIENTES; posicao++){
619


623
endereco);
625
dia);
626
mes);
627
ano);
628
telefone);
629
632 }else{
634 }
635 }
636
637 }
638
639 fflush(stdin);
640 printf(\n\n);
642 printf(\n\n);
643 getchar();
644
645 }
646
648
651 }
fim cdigo 18


9) Quando construmos aplicaes para manipulao de grandes conjuntos de dados,

fundamental que a quantidade de memria alocada pela aplicao seja gerenciada
adequadamente. No exerccio anterior, apesar de todos os requisitos e funcionalida-
des do sistema serem atendidos perfeitamente, h uma deficincia importante, rela-
cionada quantidade de memria que utilizada pela aplicao. A estrutura de dados
utilizada para armazenamento das informaes foi um vetor contendo cem posies,
sendo que cada posio contm uma estrutura do tipo registro. Uma maneira de im-
plementar esse programa a utilizao de ponteiros. Com eles, possvel controlar
de maneira eficiente a quantidade de memria utilizada. O objetivo deste exerccio
realizar as alteraes necessrias no exerccio anterior para que ele utilize ponteiros
para gerenciar os dados que esto na memria. O resultado apresentado no Cdigo
19. fundamental para seu aprendizado comparar as duas abordagens, uma vez que
as modificaes demonstram claramente a implementao de sistemas comerciais.
Alm disso, para complementar o estudo, os cdigos devem ser compilados e execu-
tados.
cdigo 19
1 /*-------------------------------------------------
2 * >>> IMPORTANTE
3 * Este exercicio foi implementado com PONTEIROS, cujo objetivo
4 * principal gerenciar adequadamente a quantidade de memria
5 * utilizada pela aplicao.
6 *
7 *-----------------------------------------------*/
8
9 /*-------------------------------------------------
10 *
11 * Exemplo de uma aplicao capaz de controlar informacoes a
12 * respeito dos pacientes de um consultorio odontologico.
13 *
15 *
16 *-----------------------------------------------*/
17
18 /*-------------------------------------------------
19 * BIBLIOTECAS
20 *-----------------------------------------------*/
23 #include <string.h> //para manipulacao de strings
24
25 /*-------------------------------------------------
27 *-----------------------------------------------*/
29 int dia;
30 int mes;
31 int ano;
32 };
33
35 int codigo;
36 char nome[60];
41
42 // ponteiro para o prximo paciente
43 struct tipo_paciente *proximo;
44 };
45
46 struct conjunto_pacientes{
47 struct tipo_paciente *inicio;
48 struct tipo_paciente *fim;
49 int total_pacientes;

50 };
51
52
53
54 /*------------------------------------------------*
56 *-----------------------------------------------*/
57 int main()
58 {
61
62 //declaracao da estrutura de ponteiros que armazenar
63 //os pacientes
64 struct conjunto_pacientes pacientes;
65
66 //declaracao de uma estrutura temporria que ser utilizada
67 //em diversas operaes ao longo da aplicao
68 struct tipo_paciente *aux;
69
70 // int paciente_atual;
71
73 int codigo_paciente_pesquisar;
75 int posicao;
77 bool paciente_encontrado = false;
78
80
81 //INICIALIZAR ESTRUTURA DE PONTEIROS
82 pacientes.inicio = NULL;
83 pacientes.fim = NULL;
84 pacientes.total_pacientes = 0;
85
86 //
88 //
89 do{
91 printf(%c,218);
99 printf(%c,195);
105 printf(%c\n,180);
107 printf(%c %-43s %c \n,179, ,179);
115 printf(%c %-43s %c \n,179, ,179);
117 printf(%c,192);
123 printf(%c\n,217);
124
125 fflush(stdin);
126 printf(\n\n);
129
130
132
134 printf(%c,218);
140 printf(%c\n,191);
142 printf(%c,192);
148 printf(%c\n,217);
149 printf( %c\n,179);

150 printf( %c%c%c%c>>> CADASTRAR NOVO PACIENTE\n,192,196,196,196,175);

151 printf(\n\n);
152
153 //
154 // Criacao de um novo registro do tipo paciente
155 //
156 // Dica: A funo malloc utilizada para alocao dinmica de memria
157 //
158 struct tipo_paciente *novo;
159 novo=(struct tipo_paciente *) malloc (sizeof(struct tipo_paciente));
160
161 printf( %c Codigo............: ,219);
162 scanf(%i,&novo->codigo);
163
164 fflush(stdin);
165 printf( %c Nome..............: ,219);
166 gets(novo->nome);
167
168 fflush(stdin);
170 gets(novo->endereco);
171
172 fflush(stdin);
174 printf( %c ...........Dia: ,219); scanf(%i,&novo->data.dia);
175 printf( %c ...........Mes: ,219); scanf(%i,&novo->data.mes);
176 printf( %c ...........Ano: ,219); scanf(%i,&novo->data.ano);
177
178 fflush(stdin);
180 gets(novo->telefone);
181
183 novo->ativo = 1;
184
185 // ESPECIFICAR O PONTEIRO PARA O PRXIMO ELEMENTO
186 novo->proximo = NULL;
187
188 //
189 // ADICIONAR NOVO ELEMENTO A LISTA DE PACIENTES
190 //
191 if ( pacientes.inicio == NULL ){
192 pacientes.inicio = novo;
193 pacientes.fim = novo;
194 }else{
195 pacientes.fim->proximo = novo;
196 pacientes.fim = pacientes.fim->proximo;
197
198 }
199
200 // INCREMENTAR O TOTAL DE PACIENTES

201 pacientes.total_pacientes++;
202
203 fflush(stdin);
204 printf(\n\n);
206 printf(\n\n);
207 getchar();
208
209
211
213 printf(%c,218);
219 printf(%c\n,191);
221 printf(%c,192);
227 printf(%c\n,217);
228 printf( %c\n,179);
229 printf( %c%c%c%c>>> ALTERAR DADOS CADASTRAIS\n,192,196,196,196,175);
230 printf(\n\n);
231
232
233
236
240 aux = pacientes.inicio;
241 while ( paciente_encontrado == false && aux != NULL ){
242 if ( aux->codigo == codigo_paciente_pesquisar ){
244 }else{
245 aux = aux->proximo;
246 }
247 }
248

250
251 printf(\n);
253 printf( %c Codigo............: ,219);
254 scanf(%i,&aux->codigo);
255
256 fflush(stdin);
257 printf( %c Nome..............: ,219);
258 gets(aux->nome);
259
260 fflush(stdin);
262 gets(aux->endereco);
263
264 fflush(stdin);
266 printf( %c ...........Dia: ,219); scanf(%i,&aux->data.dia);
267 printf( %c ...........Mes: ,219); scanf(%i,&aux->data.mes);
268 printf( %c ...........Ano: ,219); scanf(%i,&aux->data.ano);
269
270 fflush(stdin);
272 gets(aux->telefone);
273
275 aux->ativo = 1;
276
277 fflush(stdin);
278 printf(\n\n);
280 printf(\n\n);
281 getchar();
282
283 }else{
284 fflush(stdin);
285 printf(\n\n);
286
encontrado.\n);
287 printf(\n\n);
288 getchar();
289 }
291
293 printf(%c,218);
299 printf(%c\n,191);

301 printf(%c,192);
307 printf(%c\n,217);
308 printf( %c\n,179);
309 printf( %c%c%c%c>>> ALTERAR STATUS DO PACIENTE\n,192,196,196,196,175);
310 printf(\n\n);
311
312
315
323 }else{
325 }
326 }
327
329 printf(\n);
330
\n,219);
331 printf( %c ..........................: [2] INATIVO \n,219);
334
337 }
338
339 //Alterar o status do paciente
340 aux->ativo = paciente_status;
341
342 fflush(stdin);
343 printf(\n\n);
345 printf(\n\n);
346 getchar();
347
348 }else{
349 fflush(stdin);

350 printf(\n\n);
351
encontrado.\n);
352 printf(\n\n);
353 getchar();
354 }
356
358 printf(%c,218);
364 printf(%c\n,191);
366 printf(%c,192);
372 printf(%c\n,217);
373 printf( %c\n,179);
printf( %c%c%c%c>>> PESQUISAR PACIENTE POR CODIGO
374
\n,192,196,196,196,175);
375 printf(\n\n);
376
377
380
388 }else{
390 }
391 }
392
394
395 printf(\n);
396 printf( %c Codigo............: %i \n,219, aux->codigo);
397 printf( %c Nome..............: %s \n,219, aux->nome);
398 printf( %c Endereco..........: %s \n,219, aux->endereco);

400 printf( %c ...........Dia: %i \n,219, aux->data.dia);
401 printf( %c ...........Mes: %i \n,219, aux->data.mes);
402 printf( %c ...........Ano: %i \n,219, aux->data.ano);
403 printf( %c Telefone..........: %s \n,219, aux->telefone);
404
405 if ( aux->ativo == 1 ){
407 }else{
409 }
410
411 fflush(stdin);
412 printf(\n\n);
414 printf(\n\n);
415 getchar();
416
417 }else{
418 fflush(stdin);
419 printf(\n\n);
420
encontrado.\n);
421 printf(\n\n);
422 getchar();
423 }
424
425
427
429 printf(%c,218);
435 printf(%c\n,191);
437 printf(%c,192);
443 printf(%c\n,217);
444 printf( %c\n,179);
printf( %c%c%c%c>>> PESQUISAR PACIENTE POR NOME
445
\n,192,196,196,196,175);
446 printf(\n\n);
447

448 fflush(stdin);
451
457 if ( strcmp(nome_paciente_pesquisar,aux->nome) == 0 ){
459 }else{
461 }
462 }
463
465
466 printf(\n);
467 printf( %c Codigo............: %i \n,219, aux->codigo);
468 printf( %c Nome..............: %s \n,219, aux->nome);
469 printf( %c Endereco..........: %s \n,219, aux->endereco);
471 printf( %c ...........Dia: %i \n,219, aux->data.dia);
472 printf( %c ...........Mes: %i \n,219, aux->data.mes);
473 printf( %c ...........Ano: %i \n,219, aux->data.ano);
474 printf( %c Telefone..........: %s \n,219, aux->telefone);
475
476 if ( aux->ativo == 1 ){
478 }else{
480 }
481
482 fflush(stdin);
483 printf(\n\n);
485 printf(\n\n);
486 getchar();
487
488 }else{
489 fflush(stdin);
490 printf(\n\n);
printf(>>>>INFO: O paciente com o nome informado NAO foi
491
encontrado.\n);
492 printf(\n\n);
493 getchar();
494 }
495
497

499 printf(%c,218);
505 printf(%c\n,191);
507 printf(%c,192);
513 printf(%c\n,217);
514 printf( %c\n,179);
printf( %c%c%c%c>>> RELATORIO DE PACIENTES POR CODIGO
515
\n,192,196,196,196,175);
516 printf(\n\n);
517
518 //Estrutura temporria utilizada para ordenao dos elementos
519 struct tipo_paciente *tmp;
tmp = (struct tipo_paciente *) malloc (pacientes.total_pacientes *
520
sizeof(struct tipo_paciente));
521
522 struct tipo_paciente str;
523 int i=0,j=0, min=0;
524
525
526 //COPIAR OS DADOS DA ESTRUTURA DINMICA PARA UMA ESTRUTURA TEMPORRIA
528 while ( aux != NULL ){
529 tmp[i].codigo = aux->codigo;
530 strcpy(tmp[i].nome,aux->nome);
531 strcpy(tmp[i].endereco,aux->endereco);
532 tmp[i].data.dia = aux->data.dia;
533 tmp[i].data.mes = aux->data.dia;
534 tmp[i].data.ano = aux->data.mes;
535 strcpy(tmp[i].telefone,aux->telefone);
536 tmp[i].ativo = aux->ativo;
537
539 i++;
540 }
541
542
543 //Ordenao dos elementos por Seleo
544 for ( i = 0; i < pacientes.total_pacientes ; i++){
545 min = i;
546 for ( j = i+1; j < pacientes.total_pacientes; j++){

547 if ( tmp[j].codigo < tmp[min].codigo ){

548 min = j;
549 }
550 }
551 if ( i != min ){
552 // TROCAR elementos
553 str = tmp[i];
555 tmp[min] = str;
556 }
557 }
558
559
561 for ( posicao = 0; posicao < pacientes.total_pacientes; posicao++){
562
566
endereco);
568
dia);
569
mes);
570
ano);
571
telefone);
572
575 }else{
577 }
578 }
579
580 }
581
582 fflush(stdin);
583 printf(\n\n);
585 printf(\n\n);
586 getchar();
587
588
590
592 printf(%c,218);
598 printf(%c\n,191);
600 printf(%c,192);
606 printf(%c\n,217);
607 printf( %c\n,179);
printf( %c%c%c%c>>> RELATORIO DE PACIENTES POR NOME
608
\n,192,196,196,196,175);
609 printf(\n\n);
610
611
613 struct tipo_paciente *tmp;
tmp = (struct tipo_paciente *) malloc (pacientes.total_pacientes *
614
sizeof(struct tipo_paciente));
615
616 struct tipo_paciente str;
617 int i=0,j=0, min=0;
618
619
631
633 i++;
634 }
635
636
638 for ( i = 0; i < pacientes.total_pacientes ; i++){
639 min = i;
640 for ( j = i+1; j < pacientes.total_pacientes; j++){
641 if ( strcmpi(tmp[min].nome,tmp[j].nome) > 0 ){
642 min = j;

643 }
644 }
645 if ( i != min ){
646 // TROCAR elementos
647 str = tmp[i];
649 tmp[min] = str;
650 }
651 }
652
655
659
endereco);
661
dia);
662
mes);
663
ano);
664
telefone);
665
668 }else{
670 }
671 }
672
673 }
674
675 fflush(stdin);
676 printf(\n\n);
678 printf(\n\n);
679 getchar();
680
681 }
682
684
687 }
fim cdigo 19

de desenvolvimento. Neste caso, foi utilizado o ambiente Code::Blocks. No entanto, a sada
ser semelhante em outros ambientes, como, por exemplo, no NetBeans. Este resultado
obtido com a compilao e a execuo do cdigo-fonte apresentado anteriormente.

As informaes de um programa so manipuladas por meio das variveis, as quais sempre
esto associadas a tipos de dados como int, float, char, dentre outros. No entanto, quando a
quantidade de informaes armazenadas pelos programas aumenta, temos que utilizar as es-
truturas de dados. Essas estruturas so divididas em estruturas de dados homogneas vetores
e matrizes e estruturas de dados heterogneas registros. Esses conceitos so fundamentais
na elaborao de algoritmos. As questes autoavaliativas dessa unidade abordam esses aspec-
tos. Confira seu desempenho.

1) Descreva a diferena entre as estruturas de dados homogneas e as estruturas de dados heterogneas.
2) Explique a sintaxe bsica de declarao de um vetor na linguagem C.
3) Dentro do contexto de vetores, explique o conceito de ndices.
4) Explique a sintaxe bsica de declarao de uma matriz na linguagem C.
5) Quantos ndices so utilizados na manipulao de uma matriz?
6) O que so registros? Explique a sintaxe bsica de declarao de um registro na linguagem C.
7) Declare um registro para armazenar informaes a respeito de um funcionrio de uma empresa.
8) Declare um registro para armazenar informaes a respeito de um cliente de uma loja de departamentos.
9) Qual operador utilizado para armazenar ou recuperar dados de uma estrutura do tipo registro?
10) O que so ponteiros? Explique a sintaxe bsica de declarao de um ponteiro.
11) Qual a utilidade do operador de ponteiro representado pelo smbolo *?
12) Qual operador de ponteiro tem como funo o retorno do endereo de memria da varivel apontada?
13) Ilustre, por meio de um cdigo na linguagem C, como possvel apresentar na tela o contedo de uma varivel
apontada por um ponteiro.
14) Ilustre, por meio de um cdigo na linguagem C, como possvel apresentar na tela o endereo de uma varivel
apontada por um ponteiro.
11. CONSIDERAES
Nesta unidade, voc teve a oportunidade de aprender os principais conceitos de estrutu-
ras de dados e ponteiros. Nas estruturas de dados, estudamos como possvel manipul-los por
meio de vetores e matrizes. Alm disso, aprendemos que os registros podem organizar informa-
es de maneira heterognea. Em ponteiros, compreendemos seu conceito e como eles podem
ser utilizados na construo de programas.
Na Unidade 5, voc aprender a desenvolver programas utilizando os conceitos de pro-
gramao modular. Alm disso, a partir de seu estudo, poder reconhecer e construir funes
recursivas.
At l!

MIZRAHI, V. V. Treinamento em linguagem C. So Paulo: Prentice Hall, 1990.
Programao Modular
1. OBJETIVOS
Desenvolver programas utilizando os conceitos de programao modular.
Reconhecer e construir funes recursivas.
2. CONTEDOS
Programao modular (funes).
Passagem de parmetros por valor.
Passagem de parmetros por referncia.
Recursividade.

guir:
1) Uma sugesto para leitura a obra:
2) ASCENCIO, A. F. G. Fundamentos da programao de computadores: algoritmos, Pas-
cal e C/C++. So Paulo: Prentice Hall, 2002. Para o auxiliar no estudo desta unidade,
voc poder ler o captulo 10, Sub-Rotinas.
3) Aproveite para implementar os exerccios disponveis na seo Exerccios Resolvi-
dos. Esses exerccios sero essenciais para complementar seu aprendizado.

4. INTRODUO UNIDADE
Na unidade anterior, voc aprendeu a utilizar estruturas de dados na construo de pro-
gramas. Nesta unidade, voc ser convidado a estudar o modo como possvel utilizar os con-
ceitos de programao modular para a elaborao de programas na linguagem C.
Voc ver que a programao modular uma tcnica importante para a reutilizao do
cdigo-fonte, e que tem como objetivo a diviso do cdigo em pequenas partes, chamadas de
funes.
Aprender, ainda, que uma funo tem as mesmas caractersticas das sub-rotinas utiliza-
das nos algoritmos, ou seja, a modularizao do cdigo para a realizao de uma tarefa espec-
fica. Quando construmos algoritmos, a linguagem de programao C permite a criao de dois
tipos de mdulos: procedimentos e funes.
Nesse sentido, podemos, ento, construir funes que no retornam valores, que so
equivalentes aos procedimentos nos algoritmos, e, tambm, construir funes que retornam
valores, que so iguais s funes dos algoritmos.
Bom estudo!
5. FUNES
Todos os programas escritos na linguagem de programao C utilizam o conceito de fun-
es. Desse modo, para um programa funcionar corretamente, essencial que ele possua ao
menos uma funo, denominada main. Essa funo determina o local em que a execuo do
programa deve comear.
Ao longo do estudo das unidades, voc utilizou diversas funes disponveis na linguagem
C, como, por exemplo: sqrt (para o clculo da raiz quadrada), strcpy (para copiar contedos en-
tre strings), printf (para exibir informaes na tela), dentre outras.
Veja como , de maneira geral, a sintaxe da estrutura de uma funo na linguagem C:
1 <tipo_de_retorno> <nome_da_funcao>( <lista_de_parametros> ){
2
3 //declarao das variveis locais
4
5 /*
6 * bloco de comandos
7 */
8
9 }
Na sintaxe apresentada anteriormente, o tipo de retorno (<tipo_de_retorno>) determi-

na o comportamento da funo. Entretanto, uma funo pode possuir dois tipos de comporta-
mento:
Funes que no retornam valores: o retorno o tipo de dados void. Esse tipo de
funo utilizado para executar um determinado conjunto de instrues e no retorna
valores para a funo principal (main).
U5 Programao Modular 259
Funes que retornam valores: o objetivo realizar algum tipo de tarefa e retornar
valores funo principal. Esse tipo de funo pode retornar qualquer tipo de dados
da linguagem C, tais como: int, char, float, double etc.
O nome da funo (<nome_da_funcao>) um identificador, que deve seguir os mesmos
critrios utilizados para definio de nomes de variveis e utilizado para chamar a funo em
determinadas partes do programa.
A lista de parmetros (<lista_de_parametros>) especifica um conjunto de informaes
que podem ser passadas para as funes. Os parmetros podem ser utilizados para passar da-
dos de uma funo para outra, bem como para retornar dados das funes. Esse conceito ser
descrito no decorrer do estudo desta unidade.
A declarao das variveis locais (Linha 3) define um conjunto de variveis que funciona-
ro apenas dentro da funo. Essas variveis no podem ser acessadas fora do bloco da funo,
que est delimitado pelos smbolos de abre chaves { e fecha chaves }. importante salientar que
variveis declaradas dentro da funo principal (main) podem ser acessadas em qualquer parte
do cdigo inclusive dentro de qualquer funo.
O bloco de comandos especifica quais tarefas devero ser executadas pela funo. Qual-
quer comando da linguagem C pode ser utilizado dentro do bloco.
O exemplo a seguir (Cdigo 1) demonstra a utilizao do conceito de funes na constru-
o de programas em que foram utilizadas apenas funes que no retornam valores.
cdigo 1
1 /*
2 * Programa para demonstrar a utilizao de funes
3 *
5 */
6
7
10
11 //assinaturas das funes
12 void soma(int a, int b);
13 void multiplicacao(int a, int b);
14
15
16 /*
17 * FUNO PRINCIPAL
18 */
19 int main()
20 {
21
22 int num1;
23 int num2;
24
25 num1 = 10;
26 num2 = 20;

27 soma(num1,num2); //chamada da funo

28 multiplicacao(num1,num2); //chamada da funo
29
30 num1 = 3;
31 num2 = 2;
32 soma(num1,num2); //chamada da funo
33 multiplicacao(num1,num2); //chamada da funo
34
35 return 0;
36 }
37
38 //FUNO soma
39 void soma(int a, int b){
40
42 int resultado;
43
44 //clculo da soma
45 resultado = a + b;
46
47 //exibir resultado na tela
48 printf(Soma de %i e %i = %i \n, a,b,resultado);
49
50 }
51
52 //FUNO multiplicao
53 void multiplicacao(int a, int b){
54
56 int resultado;
57
58 //clculo da soma
59 resultado = a * b;
60
61 //exibir resultado na tela
62 printf(Multiplicacao de %i e %i = %i \n, a,b,resultado);
63
64 }
fim cdigo 1

Soma de 10 e 20 = 30
Multiplicacao de 10 e 20 = 200
Soma de 3 e 2 = 5
No Cdigo 1, as linhas em destaque demonstram os locais em que foram utilizados os

conceitos relacionados s funes.
As Linhas 12 e 13 definem as assinaturas das funes, que so utilizadas para informar
quais funes adicionais foram definidas pelo programador. A omisso da assinatura impossi-
bilita a utilizao das funes ao longo do programa. A assinatura de uma funo sempre deve
ser terminada pelo smbolo de ponto e vrgula. Alm disso, as assinaturas das funes definidas
pelo programador devem ser inseridas antes da funo principal (main) do programa.
J as Linhas 27, 28, 32 e 33 demonstram como deve ser realizada a chamada de uma
funo que no retorna valores. Para esse tipo especfico de funo, a chamada ser realizada
apenas informando os parmetros (quando houver).
Por fim, as linhas de 39 a 50 definem a funo soma. Note que essa funo recebe as infor-
maes da funo principal por meio dos parmetros a e b. O resultado da execuo da funo
exibido na tela por meio do comando printf (Linha 48). O mesmo ocorre para as linhas de 53 a
64, que definem a funo multiplicao.
O programa a seguir (Cdigo 2) tem as mesmas funcionalidades do programa anterior. A
alterao principal est no comportamento das funes. Observe que neste programa as fun-
es retornam valores.
cdigo 2
1 /*
2 * Programa para demonstrar a utilizao de funes com retorno
3 *
5 */
6
7
10
12 int soma(int a, int b);
13 int multiplicacao(int a, int b);
14
15
16 /*
17 * FUNO PRINCIPAL
18 */
19 int main()
20 {
21
22 int num1;
23 int num2;
24 int resultado;
25
26 num1 = 10;
27 num2 = 20;
28

29 resultado = soma(num1,num2); //chamada da funo

30 printf(Soma de %i e %i = %i \n, num1,num2 , resultado);
31
32 resultado = multiplicacao(num1,num2); //chamada da funo
33 printf(Multiplicacao de %i e %i=%i\n,num1,num2,resultado);
34
35 num1 = 3;
36 num2 = 2;
37 //chamada da funo e exibio do resultado na tela
38 printf(Soma de %i e %i = %i\n, num1,num2,soma(num1,num2));
39 //chamada da funo e exibio do resultado na tela
40 printf(Multiplicacao de %i e %i=%i\n,num1,num2,multiplicacao(num1,num2));
41
42 return 0;
43 }
44
45 //FUNO soma
46 int soma(int a, int b){
47
49 int resultado;
50
51 //clculo da soma
52 resultado = a + b;
53
54 //retornar resultado
55 return resultado;
56
57 }
58
59 //FUNO multiplicao
60 int multiplicacao(int a, int b){
61
63 int resultado;
64
65 //clculo da soma
66 resultado = a * b;
67
68 //retornar resultado
69 return resultado;
70
71 }
fim cdigo 2

Soma de 10 e 20 = 30
Soma de 3 e 2 = 5
No exemplo anterior, as Linhas 12 e 13 definem as assinaturas das funes. A nica dife-

rena para o programa descrito no Cdigo 1 que o tipo de retorno das funes agora so int,
em vez de void, o que significa que as funes devero executar algum tipo de processamento
e retornar um valor do tipo int.
As Linhas 29 e 32 realizam as chamadas das funes denominadas, respectivamente, de
soma e multiplicao. Note que, como as funes retornam um tipo de dados int, declaramos,
obrigatoriamente, uma varivel (do mesmo tipo) para receber o resultado do processamento da
funo.
J as Linhas 38 e 40 demonstram uma utilizao alternativa para as funes soma e multi-
plicao. Nesse caso, em vez de utilizarmos uma varivel para receber o resultado do processa-
mento, os valores retornados pela funo so exibidos diretamente na tela por meio da funo
printf.
Finalmente, as linhas de 46 a 57 definem a funo soma. Veja que essa funo muito
semelhante funo soma definida no programa anterior, porm apresenta algumas mudanas.
As principais mudanas so: o tipo de retorno que antes era void e agora foi definido como int
e a utilizao da instruo return. Toda funo que retorna valores deve possuir a instruo
return, que utilizada justamente para retornar o resultado do processamento da funo.
6. PASSAGEM DE PARMETROS
A lista de parmetros um recurso utilizado para passar informaes para as funes.
Nessa lista, devemos informar o tipo de dados e o nome do parmetro. Quando definimos uma
lista contendo mais de um parmetro, esses parmetros devem ser separados por vrgula.
A passagem de parmetro para uma funo pode ser realizada de duas maneiras:
Passagem de parmetro por valor: qualquer tipo de alterao realizada nos parme-
tros (ao longo das instrues da funo) no propagado para a funo principal. Em
outras palavras, caso o valor do parmetro dentro da funo seja alterado, o valor no
ser enviado para fora da funo (quando a funo terminar).
Passagem de parmetro por referncia: as alteraes ocorridas no interior da funo
so propagadas para a funo principal. Para que isso ocorra, devemos transformar
os parmetros em ponteiros. Assim, qualquer tipo de alterao no parmetro afetar
diretamente a posio de memria da varivel original.
importante observar que a passagem de parmetros por valor ou por referncia pode
ser utilizada em funes que retornam e que no retornam valores.
O Cdigo 3 demonstra a passagem de parmetros por valor.

cdigo 3
1 /*
2 * Programa para demonstrar a passagem de parmetros por valor
3 *
5 */
6
7
10
12 void exibirvalor(int valor);
13
14
15 /*
16 * FUNO PRINCIPAL
17 */
18 int main()
19 {
20 int numero;
21
22 numero = 10;
23
24 //valor da varivel ANTES da funo
25 printf(Numero = %i \n, numero);
26
27 //chamada da funo
28 exibirvalor(numero);
29
30 //valor da varivel APS a funo
32
33 return 0;
34 }
35
36 void exibirvalor(int valor){
37
38 // atribuir valor 20 ao parmetro
39 valor = 20;
40
41 //valor da varivel no INTERIOR da funo
42 printf(Numero = %i \n, valor);
43
44 }
fim cdigo 3

Numero = 10
Numero = 20
Numero = 10
No programa, para demonstrar a passagem de parmetros por valor, voc pode observar
que a varivel numero foi inicializada com o valor 10 (Linha 22), o que pode ser demonstrado
pela exibio do seu valor na tela (Linha 25).
A varivel numero passada como parmetro para funo exibirvalor, o nome do pa-
rmetro que faz referncia a essa varivel valor. Dentro da funo, esse parmetro recebe o
valor 20 (Linha 39) e o resultado exibido na tela (Linha 42).
Ao final da execuo da funo, o valor da varivel numero novamente exibido na tela.
Entretanto, como possvel observar no resultado da execuo do programa, seu valor no foi
alterado para o valor 20. Como resultado, temos a exibio na tela do valor original da varivel
definido antes da chamada da funo.
Esse programa demonstra que, apesar de alterarmos o valor de um parmetro no interior
de uma funo, essa alterao no propagada para fora da funo. Dessa forma, voc acabou
de conhecer a principal caracterstica da passagem de parmetros por valor.
A seguir, o Cdigo 4 demonstra um programa com a passagem de parmetros por refern-
cia.
cdigo 4
1 /*
2 * Programa para demonstrar a passagem de parmetro por referncia
3 *
5 */
6
7
10
12 void exibirvalor(int *valor);
13
14
15 /*
16 * FUNO PRINCIPAL
17 */
18 int main()
19 {
20 int numero;
21
22 numero = 10;

23
24 //valor da varivel ANTES da funo
26
27 //chamada da funo
28 exibirvalor(&numero);
29
30 //valor da varivel APS a funo
32
33 return 0;
34 }
35
36 void exibirvalor(int *valor){
37
38 // atribuir valor 20 ao parmetro
39 *valor = 20;
40
41 //valor da varivel no INTERIOR da funo
42 printf(Numero = %i \n, *valor);
43
44 }
fim cdigo 4

Numero = 10
Numero = 20
Numero = 20
Para a passagem de parmetros por referncia, precisamos transformar os parmetros da

funo em ponteiros. Essa alterao pode ser notada na assinatura da funo (Linha 12). Dessa
forma, os nomes dos parmetros do tipo ponteiros devem ser precedidos do smbolo de asteris-
co (*). A utilizao do smbolo de asterisco com ponteiros indica um operador indireto, utilizado
para manipular o contedo da varivel apontada pelo ponteiro.
Outra alterao importante na chamada da funo (Linha 28), em que todos os parme-
tros do tipo ponteiro devem ser passados com o smbolo &. Com isso, em vez de passar o con-
tedo da varivel como parmetro, passado o endereo de memria da varivel. A utilizao
do smbolo & com ponteiros indica um operador de endereo. Esse operador utilizado para
referenciar um endereo de memria.
Como resultado da execuo do programa, voc pode notar que a alterao realizada den-
tro da funo exibivalor (Linha 39) refletida para a funo principal. Assim, o contedo original
da varivel numero alterado.
As estruturas de dados de vetores e matrizes tambm podem ser passadas como parme-
tros. O prximo exemplo, no Cdigo 5, demonstra essa utilizao:
cdigo 5
1 /*
2 * Programa para demonstrar a passagem de vetores como parmetro
3 *
5 */
6
9
11 void carregarVetor(int v[], int num);
12 void imprimirVetor(int v[], int num);
13 float mediaVetor(int v[], int num);
14
15 /*
16 * FUNO PRINCIPAL
17 */
18 int main()
19 {
20 int vetor[5];
21 float media;
22
23 carregarVetor(vetor,5);
24 imprimirVetor(vetor,5);
25
26 media = mediaVetor(vetor,5);
27 printf(Media dos elementos = %.2f \n,media);
28
29 return 0;
30 }
31
32 void carregarVetor(int v[], int num){
33
34 int i;
35
36 for ( i = 0; i < num; i++ ){
37 printf(Valor da posicao %i = ,i);
38 scanf(%i,&v[i]);
39 }
40
41 }
42
43 void imprimirVetor(int v[], int num){
44
45 int i;
46
47 printf(\nValores do vetor \n);
48 for ( i = 0; i < num; i++ ){

50 }
51
52 }
53
54
55 float mediaVetor(int v[], int num){
56
57 int i;
58 float soma = 0;
59
60 for ( i = 0; i < num; i++ ){
61 soma += v[i];
62 }
63
64 return (float)soma/num;
65
66 }
fim cdigo 5

Valor da posicao 0 = 1
Valores do vetor
Posicao 0 = 1
Posicao 1 = 2
Posicao 2 = 3
Posicao 3 = 4
Posicao 4 = 5
Media dos elementos = 3.00
O Cdigo 6 demonstra a passagem de estruturas do tipo registro como parmetros para

funes.
cdigo 6
1 /*
2 * Programa para demonstrar a passagem de registros como parmetro
3 *
5 */
10 //definio da estrutura
11 struct tipodata{
12 int dia;
13 int mes;
14 int ano;
15 };
16
18 void lerData(struct tipodata *data);
19 int ano(struct tipodata data);
20
21 /*
22 * FUNO PRINCIPAL
23 */
24 int main()
25 {
26 struct tipodata hoje;
27
28 lerData(&hoje);
29
30 printf(Ano atual = %i \n, hoje.ano);
31 return 0;
32 }
33
34
35 //FUNO para carregar uma data
36 void lerData(struct tipodata *data){
37
38 printf(Dia: );
39 scanf(%i,&data->dia);
40 printf(Mes: );
41 scanf(%i,&data->mes);
42 printf(Ano: );

43 scanf(%i,&data->ano);
44
45 }
46
47 //FUNO para retornar o ano de uma data
48 int ano(struct tipodata data){
49 return data.ano;
50 }
fim cdigo 6

Dia: 01
Mes: 05
Ano: 2009
Ano atual = 2009
Faa uma reflexo sobre as vantagens e desvantagens da programao modular no desen-

volvimento dos programas. Pense sobre como a programao modular pode facilitar (ou no) o
trabalho do programador.
7. RECURSIVIDADE
A recursividade uma tcnica utilizada na elaborao de funes, na qual uma funo
pode realizar uma chamada de si mesma. Para exemplificar a utilizao do conceito de recursi-
vidade, considere o problema de somar todos os elementos de um vetor. Uma possvel soluo
sequencial para esse problema est apresentada no Cdigo 7.
cdigo 7
1 /*
2 * Programa para somar os elementos de um vetor sequencialmente
3 *
5 */
6
9
11 int somarVetor(int v[], int num);
12
13 /*
14 * FUNO PRINCIPAL
15 */
16 int main()
17 {
18 int vetor[] = {10,20,30,40,50};
19 int resultado;
20
21 resultado = somarVetor(vetor,5);
22 printf(Soma do vetor = %i \n, resultado);
23
24 return 0;
25 }
26
27 int somarVetor(int v[], int num){
28
29 int i;
30 int soma = 0;
31
32 for( i = 0; i < num; i++){
33 soma += v[i];
34 }
35
36 return soma;
37
38 }
fim cdigo 7

Soma do vetor = 150
A principal funcionalidade do programa demonstrada nas Linhas 32, 33 e 34, que rea-
lizam o somatrio dos elementos do vetor. Para que essa soma seja possvel, foi utilizada uma
estrutura de repetio.
Verifique no programa a seguir, descrito no Cdigo 8, o mesmo problema apresentado no
Cdigo 7, agora implementado de forma recursiva. A principal alterao que esse programa
no utiliza estruturas de repetio. O fato de no utilizar laos de repetio na resoluo de pro-
blemas uma caracterstica essencial das funes recursivas.
cdigo 8
1 /*
2 * Programa para somar elementos de um vetor com recursivamente
3 *
5 */
6
9
11 int somarVetor(int v[], int num);

12
13 /*
14 * FUNO PRINCIPAL
15 */
16 int main()
17 {
18 int vetor[] = {10,20,30,40,50};
19 int resultado;
20
21 resultado = somarVetor(vetor,4);
22 printf(Soma do vetor = %i \n, resultado);
23
24 return 0;
25 }
26
27 int somarVetor(int v[], int num){
28
29 if ( num == 0 ){
30 return v[0];
31 }else{
32 return v[num] + somarVetor(v,num-1);
33 }
34 }
fim cdigo 8

Soma do vetor = 150
Analisando o Cdigo 8, voc pode observar que a soma dos elementos do vetor foi reali-
zada sem a utilizao de laos de repetio. O problema foi solucionado apenas com chamadas
recursivas da prpria funo (somarVetor).
No Cdigo 9 do programa a seguir, veja uma soluo recursiva para calcular o fatorial de
um nmero.
cdigo 9
1 /*
2 * Programa para calcular o fatorial de um nmero
3 * de maneira recursiva
4 *
6 */
7
10
12 int fatorial(int num);
13
14 /*
15 * FUNO PRINCIPAL
16 */
17 int main()
18 {
19 int numero;
20
22 scanf(%i,&numero);
23
24 printf(Fatorial de %i = %i \n,numero,fatorial(numero));
25
26 return 0;
27 }
28
29 int fatorial(int num){
30
31 if ( num <= 1 ){
32 return 1;
33 }else{
34 return num * fatorial(num-1);
35 }
36
37 }
fim cdigo 9

Fatorial de 5 = 120
Confira a implementao dos programas desenvolvidos. Neste tpico, voc encontrar as
solues escritas na linguagem de programao C. Essa uma tima forma para fixar os conte-
dos.
1) Construa um programa capaz de gerenciar o peso e a altura de um conjunto de cin-
quenta pessoas. Para isso, voc deve utilizar um vetor definido a partir de uma es-
trutura de dados do tipo registro. Crie uma funo para cadastrar as pessoas e uma
funo para exibir o ndice de Massa Corprea (IMC = peso/altura2). O clculo do IMC,
tambm, deve ser realizado por meio de uma funo.
cdigo 10
1 /*
2 * Programa para calcular o IMC de um conjunto
3 * de pessoas
4 *


6 */
7
10
#define TOTALPESSOAS 50 // a instruo define especifica uma constante denominada TOTALPES-
11
SOAS com o valor 50. Tem a mesma utilizao da palavra reservada const.
12
13 //declarao da estrutura
15 char nome[20];
16 float altura;
17 float peso;
18 };
19
21 void cadastrar(struct tipopessoa p[], int *pos);
22 void exibirIMC(struct tipopessoa p[], int pos);
23 float imc(float peso, float altura);
24
25
26 /*
27 * FUNO PRINCIPAL
28 */
29 int main()
30 {
31 struct tipopessoa pessoas[TOTALPESSOAS];
32 int posicao, opcao;
33
34 posicao = 0;
35
36 do{
37 printf(-------Menu-------\n);
38 printf([1] cadastrar \n);
39 printf([2] calcular IMC \n);
40 printf([3] sair \n\n);
41 printf(Opcao desejada: );
43
44 switch(opcao){
45
46 case 1: //cadastrar novas pessoas
47 cadastrar(pessoas,&posicao);
48 break;
49
50 case 2: // calcular e exibir IMC das pessoas
51 exibirIMC(pessoas,posicao);
52 break;
53
54 case 3:
55 printf(\nPrograma finalizado.\n);
56 break;
57
58 default:
59 printf(Opcao invalida.);
60 break;
61
62 }
63
64 }while ( opcao != 3 );
65
66 return 0;
67 }
68
69
70 //FUNO para adicionar uma nova pessoa ao vetor
71 void cadastrar(struct tipopessoa p[], int *pos){
72
73 if ( *pos < TOTALPESSOAS ){
74
75 fflush(stdin);
76 printf(Nome: );
77 gets(p[*pos].nome);
78 printf(Peso: );
79 scanf(%f,&p[*pos].peso);
81 scanf(%f,&p[*pos].altura);
82
83 *pos = *pos + 1;
84
85 }else{
86 printf(\no limite de pessoas foi atingido\n);
87 }
88 }
89
90 //FUNO para exibir o IMC das pessoas
91 void exibirIMC(struct tipopessoa p[], int pos){
92
93 int i;
94 float valor;
95
96 for ( i = 0; i < pos; i++){
97 //chamada da funo para clculo do IMC
98 valor = imc(p[i].peso,p[i].altura);
99
100 printf(Nome: %s \n, p[i].nome);
101 printf(IMC.: %.2f \n\n,valor);
102 }
103
104 }

105
106 //FUNO para calcular o IMC de uma pessoa
107 float imc(float peso, float altura){
108 return peso/(altura*altura);
109 }
Fim cdigo 10
-------Menu-------
[1] cadastrar
[2] calcular IMC
[3] sair
Opcao desejada: 1
Nome: Joao da Silva
Peso: 74
Altura: 1.80
-------Menu-------
[1] cadastrar
[2] calcular IMC
[3] sair
Opcao desejada: 1
Nome: Ana Maria
Peso: 60
Altura: 1.69
-------Menu-------
[1] cadastrar
[2] calcular IMC
[3] sair
Opcao desejada: 2
Nome: Joao da Silva
IMC.: 22.84
Nome: Ana Maria
IMC.: 21.01
-------Menu-------
[1] cadastrar
[2] calcular IMC
[3] sair
Opcao desejada: 3
Programa finalizado.

2) Escreva um programa capaz de calcular potenciao (um nmero elevado ao outro).
Para isso, voc dever criar uma funo recursiva, que receba como parmetro a base
e o expoente, e retorne o resultado.
cdigo 11
1 /*
2 * Programa para calcular a potncia de um nmero
3 * de maneira recursiva
4 *
6 */
7
10
12 int potencia( int b, int e);

13
14 /*
15 * FUNO PRINCIPAL
16 */
17 int main()
18 {
19 int base, expoente;
20 int resultado;
21
22 printf(Base: );
23 scanf(%i,&base);
24 printf(Expoente: );
25 scanf(%i,&expoente);
26
27 resultado = potencia(base,expoente);
28
29 printf(%i elevado a %i = %i \n,base,expoente,resultado);
30
31 return 0;
32 }
33
34 //FUNO para calcular a potncia de um nmero
35 int potencia( int b, int e){
36
37 if ( e == 0 ){
38 return 1;
39 }else{
40 return b * potencia(b,e-1);
41 }
42
43 }
fim cdigo 11

Base: 2
Expoente: 3
2 elevado a 3 = 8
3) Uma universidade deseja informatizar o processo de correo de gabaritos do vesti-

bular. Para isso, voc foi contratado para construir um sistema computacional que seja
capaz de:
a) Ler o gabarito oficial esse gabarito constitudo pelo nmero de questes do
vestibular, bem como pelas respostas corretas para cada questo. A prova do ves-
tibular formada por um total de vinte questes.
b) Ler os gabaritos dos candidatos do vestibular como um nmero indeterminado
de candidatos pode realizar a inscrio no vestibular, os dados devero ser arma-
zenados dinamicamente com ponteiros. Alm das respostas de cada candidato,
tambm desejvel armazenar (para cada candidato): o nmero da inscrio, o
nmero do RG e o nome completo.
c) Emitir um relatrio a respeito do desempenho dos candidatos no qual ser apre-

sentado o nmero de questes que cada candidato acertou.
Devido complexidade da aplicao, este programa dever ser implementado utilizando
os conceitos de programao modular. Alm disso, importante destacar que os dados dos
gabaritos dos candidatos devem ser armazenados em uma estrutura dinmica com ponteiros.
cdigo 12
1 /*-------------------------------------------------
2 *
3 * Exemplo de uma aplicao capaz de corrigir automaticamente
4 * os gabaritos dos candidatos de um vestibular.
5 *
7 *
8 *-----------------------------------------------*/
9
10 /*-------------------------------------------------
11 * BIBLIOTECAS
12 *-----------------------------------------------*/
15 #include <ctype.h> //para utilizao da funo toupper
17
18 /*-------------------------------------------------
20 *-----------------------------------------------*/
21
22 #define NUM_QUESTOES 5
23
24 struct tipo_alternativas{
25 char correta;
26 };
27
28 struct tipo_gabarito_candidato{
29 int num_inscricao;
30 char num_rg[12]; //XX.XXX.XXX-X
31 char nome[40];
32 struct tipo_alternativas alternativas[NUM_QUESTOES];
33 int total_corretas;
34 struct tipo_gabarito_candidato *proximo;
35 };
36 typedef tipo_gabarito_candidato candidato;
37
38 struct tipo_candidatos{
39 candidato *inicio;
40 candidato *fim;
41 int total_candidatos;
42 };
43

44 //Gabaritos
45 typedef tipo_alternativas gabarito_oficial[NUM_QUESTOES];
46 typedef tipo_candidatos gabarito_candidatos;
47
48 /*------------------------------------------------*
49 * ASSINATURAS DOS MTODOS (MDULOS)
50 *-----------------------------------------------*/
51 void menu_principal(char *titulo_do_programa, int *opcao_desejada);
52 void menu_secundario(char *titulo_do_programa,char *subtitulo_do_programa);
53 void mensagem(char *msg);
54 void ler_gabarito_oficial(gabarito_oficial g);
55 void ler_gabarito_candidatos(gabarito_candidatos *g);
56 void gabarito_correcao(gabarito_oficial go,gabarito_candidatos *gc);
57 void exibir_resultados_candidatos(gabarito_candidatos *gc);
58
59
60
61 /*------------------------------------------------*
63 *-----------------------------------------------*/
64 int main()
65 {
67 char titulo_do_programa[40] = SISTEMA GAB@ARITOS;
68
69 gabarito_oficial oficial;
70 gabarito_candidatos candidatos;
71 char continua;
72
73 //Inicializar variveis
74 candidatos.inicio = NULL;
75 candidatos.fim = NULL;
76 candidatos.total_candidatos = 0;
77
79
80 do{
81 menu_principal(titulo_do_programa,&opcao_desejada);
82
84 case 1:
85 menu_secundario(titulo_do_programa,LER GABARITO OFICIAL);
86 ler_gabarito_oficial(oficial);
87 mensagem(OPERACAO realizada com SUCESSO!);
88 break;
89 case 2:
90 do{
91 menu_secundario(titulo_do_programa,LER GABARITOS DOS CANDIDATOS);
92 ler_gabarito_candidatos(&candidatos);
93 fflush(stdin);
printf(\n Deseja digitar o gabarito de outro aluno [S] ou [N]?

94
);
95 continua = toupper(getchar());
96 }while(continua == S);
97
98
99 break;
100 case 3:
menu_secundario(titulo_do_programa,
101
RELATORIO DOS CANDIDATOS);
102 gabarito_correcao(oficial,&candidatos);
103 exibir_resultados_candidatos(&candidatos);
104
106 break;
107
108 }
109
111
114 }
115
116
117 /*------------------------------------------------*
118 * IMPLEMENTAO DOS MTODOS (MDULOS)
119 *-----------------------------------------------*/
120 void menu_principal(char *titulo_do_programa, int *opcao_desejada)
121 {
123 printf(%c,201);
129 printf(%c\n,187);
131 printf(%c %-40s %c \n,186,Correcao automatica de gabaritos,186);
132 printf(%c,204);
138 printf(%c\n,185);
140 printf(%c %-43s %c \n,186, ,186);
141 printf(%c %-40s %c \n,186, [1] LER GABARITO OFICIAL ,186);
142 printf(%c %-40s %c \n,186, [2] LER GABARITOS DOS CANDIDATOS ,186);

143 printf(%c %-40s %c \n,186, [3] RELATORIO DOS CANDIDATOS ,186);

144 printf(%c %-43s %c \n,186, ,186);
146 printf(%c,200);
152 printf(%c\n,188);
153
154 fflush(stdin);
155 printf(\n\n);
157 scanf(%i,&*opcao_desejada);
158 }
159
160 void menu_secundario(char *titulo_do_programa,char *subtitulo_do_programa)
161 {
163 printf(%c,201);
169 printf(%c\n,187);
171 printf(%c,200);
177 printf(%c\n,188);
178 printf( %c\n,186);
179 printf( %c%c%c%c>>> %s\n,200,205,205,205,subtitulo_do_programa);
180 printf(\n\n);
181 }
182
183 //-------------------------------------------------
184 //FUNO: mensagem
185 // Exibe uma mensagem na tela
186 void mensagem(char *msg)
187 {
188 fflush(stdin);
189 printf(\n\n);
190 printf(>>>>INFO: %s\n,msg);
191 printf(\n\n);
192 getchar();
193 }
194 //-------------------------------------------------
195 //FUNO: ler_gabarito_oficial
196 // Realize a leitura do gabarito oficial da prova.
197 void ler_gabarito_oficial(gabarito_oficial g)
198 {
199 int i = 0;
200 printf( %c INFORMACOES SOBRE A PROVA \n,219);
201 printf( %c Total de questoes %i\n, 219, NUM_QUESTOES);
202 printf( %c\n,219);
203 printf( %c Leitura das respostas corretas\n,219);
204 for( i = 0; i < NUM_QUESTOES; i++)
205 {
206 fflush(stdin);
207 printf( %c Questao [%02i]: ,219,i+1);
208 //Leitura da resposta correta
209 //A alternativa convertida para maiscula para facilitar
210 //a correo.
211 g[i].correta = toupper(getchar());
212 }
213
214 }
215
216 //-------------------------------------------------
217 //FUNO: ler_gabarito_candidatos
218 // Realiza a leitura dos gabaritos dos candidatos
219 // Essa funo manipula uma instruo de dados dinmica com ponteiros
220 void ler_gabarito_candidatos(gabarito_candidatos *g)
221 {
223 printf( %c Total de questoes ......: %i\n, 219, NUM_QUESTOES);
224 printf( %c Total de gabaritos lidos: %i\n, 219, g->total_candidatos);
225 printf( %c\n,219);
226
227 //Alocar memria para leitura de um novo gabarito
228 candidato *novo;
229 novo=(candidato *) malloc (sizeof(candidato));
230
231 printf( %c Num Inscricao: ,219);
232 scanf(%i,&novo->num_inscricao);
233
234 fflush(stdin);
235 printf( %c Num RG.......: ,219);
236 gets(novo->num_rg);
237
238 fflush(stdin);
239 printf( %c Nome.........: ,219);
241
242 printf( %c\n,219);


244 for(int i = 0; i < NUM_QUESTOES; i++){
245 fflush(stdin);
246 printf( %c Questao [%02i]: ,219,i+1);
247 novo->alternativas[i].correta = toupper(getchar());
248 }
249
251
252 if (g->inicio == NULL ){
253 g->inicio = novo;
254 g->fim = novo;
255 }else{
256 g->fim->proximo = novo;
257 g->fim = g->fim->proximo;
258 }
259 g->total_candidatos++;
260 }
261
262 //-------------------------------------------------
263 //FUNO: gabarito_correcao
264 // Correcao automtica dos gabaritos
265 void gabarito_correcao(gabarito_oficial go,gabarito_candidatos *gc)
266 {
267 int total;
268 candidato *aux = gc->inicio;
269 while (aux != NULL){
270 total = 0;
271 //Comparar gabarito do candidato com gabarito oficial
272 for(int j = 0; j < NUM_QUESTOES; j++){
273 if ( aux->alternativas[j].correta == go[j].correta){
274 total++;
275 }
276 }
277 //atualizar o nmero de questes corretas
278 aux->total_corretas = total;
280 }
281
282 }
283
284 //----------------------------------------------------------------
285 //FUNO: exibir_resultados_candidatos
286 // Apresenta na tela o desempenho de cada candidato, bem como, o
287 // nmero de questes corretas, alm da porcentagem de acerto.
288 void exibir_resultados_candidatos(gabarito_candidatos *gc)
289 {
290 float porcentagem_corretas;
printf( %c %-4s %-30s %-10s %-10s \n,219,# INSCR,CANDIDATO,# ACER-
291
TOS,% ACERTO);

294 porcentagem_corretas = ((float)aux >total_corretas/(float)NUM_QUESTOES)*100;
printf( %c %05i %-34s %02i \t %0.2f %%\n,219,aux->num_inscricao,aux
295
->nome,aux->total_corretas,porcentagem_corretas);
297 }
298
299 }
fim cdigo 12

Para testar a aplicao, foi considerado um gabarito contendo apenas cinco questes.

4) Nos exerccios resolvidos da Unidade 4, foi implementado um programa completo

para gerenciamento de dados de um consultrio odontolgico. Esse programa foi ela-
borado sequencialmente, sem a utilizao das tcnicas de modularizao. Para de-
monstrar como a modularizao uma tcnica eficiente para construo de aplica-
es, especialmente em aplicaes com um grande nmero de linhas de cdigo, a
aplicao do consultrio odontolgico foi modularizada. O programa apresentado
no Cdigo 13, e utiliza a abordagem baseada em ponteiros para manipulao das in-
formaes. muito importante notar os mdulos que foram implementados, bem
como as passagens de parmetros tanto por valor quanto por referncia.
cdigo 13
1 /*-------------------------------------------------
2 *
3 * Exemplo de uma aplicao capaz de controlar informacoes a
4 * respeito dos pacientes de um consultorio odontologico.
5 *
6 * >>>IMPORTANTE: ESSA IMPLEMENTAO UTILIZA PROGRAMAO MODULAR!
7 *
9 *
10 *-----------------------------------------------*/
11
12 /*-------------------------------------------------
13 * BIBLIOTECAS
14 *-----------------------------------------------*/
18
19 /*-------------------------------------------------
21 *-----------------------------------------------*/
23 int dia;
24 int mes;
25 int ano;
26 };
27
29 int codigo;
30 char nome[60];
35
36 // ponteiro para o prximo paciente
37 struct tipo_paciente *proximo;
38 };
39
40 struct conjunto_pacientes{
41 struct tipo_paciente *inicio;
42 struct tipo_paciente *fim;
43 int total_pacientes;
44 };
45
46 typedef struct tipo_paciente paciente;
47
48 /*------------------------------------------------*
49 * ASSINATURAS DOS MDULOS
50 *-----------------------------------------------*/
51 int menu_principal(char *titulo_do_programa, int *opcao_desejada);
54 void paciente_cadastrar(struct conjunto_pacientes *p);
55 paciente* pesquisar_paciente_codigo(struct conjunto_pacientes *p);
56 paciente* pesquisar_paciente_nome(struct conjunto_pacientes *p);
57 void paciente_exibir(paciente *p);
58 paciente* paciente_ordenar(struct conjunto_pacientes *p, int tipo);

59
60
61 /*------------------------------------------------*
63 *-----------------------------------------------*/
64 int main()
65 {
68
69 //declaracao da estrutura de ponteiros que armazenar
70 //os pacientes
71 struct conjunto_pacientes pacientes;
72
73 paciente *aux;
74
75 //Variveis auxiliares
76 int posicao;
79
80 //INICIALIZAR ESTRUTURA DE PONTEIROS
81 pacientes.inicio = NULL;
82 pacientes.fim = NULL;
83 pacientes.total_pacientes = 0;
84
85 //
87 //
88 do{
90
92
93 menu_secundario(titulo_do_programa,CADASTRAR NOVO PACIENTE);
94 paciente_cadastrar(&pacientes);
95 mensagem(OPERACAO realizada com com SUCESSO!);
96
98
menu_secundario(titulo_do_programa,ALTERAR DADOS CADASTRAIS NOVO
99
PACIENTE);
100 paciente *aux = pesquisar_paciente_codigo(&pacientes);
101
102 if ( aux != NULL ){
103 printf(\n);
105 printf( %c Codigo............: ,219);
106 scanf(%i,&aux->codigo);
107
108 fflush(stdin);
109 printf( %c Nome..............: ,219);

110 gets(aux->nome);
111
112 fflush(stdin);
114 gets(aux->endereco);
115
116 fflush(stdin);
printf( %c ...........Dia: ,219); scanf(%i,&aux->data.
118
dia);
printf( %c ...........Mes: ,219); scanf(%i,&aux->data.
119
mes);
printf( %c ...........Ano: ,219); scanf(%i,&aux->data.
120
ano);
121
122 fflush(stdin);
124 gets(aux->telefone);
125 aux->ativo = 1; //DETERMINAR STATUS DO PACIENTE
127
128 }else{
129 mensagem(O paciente com o codigo informado NAO foi encontrado.);
130 }
131
133
134 menu_secundario(titulo_do_programa,ALTERAR STATUS DO PACIENTE);
136
137 if ( aux != NULL ){
138 printf(\n);
139
\n,219);
printf( %c .................................: [2] INATIVO
140
\n,219);
143
146 }
147 aux->ativo = paciente_status; //Alterar o status do paciente
149
150 }else{
152 }
153
155

156 menu_secundario(titulo_do_programa,PESQUISAR PACIENTE POR CODIGO);

158
159 if ( aux != NULL ){
160 paciente_exibir(aux);
162 }else{
164 }
165
167
168 menu_secundario(titulo_do_programa,PESQUISAR PACIENTE POR NOME);
169 paciente *aux = pesquisar_paciente_nome(&pacientes);
170
171 if ( aux != NULL ){
172 paciente_exibir(aux);
174 }else{
175 mensagem(O paciente com o nome informado NAO foi encontrado.);
176 }
177
179
menu_secundario(titulo_do_programa,
180
RELATORIO DE PACIENTES POR CODIGO);
181 paciente *tmp = paciente_ordenar(&pacientes,1);
182
185 paciente_exibir(&tmp[posicao]);
186 }
188
190
menu_secundario(titulo_do_programa,RELATORIO DE PACIENTES POR
191
NOME);
192 paciente *tmp = paciente_ordenar(&pacientes,2);
193
195 paciente_exibir(&tmp[posicao]);
196 }
198 }
199
201
204 }
205
206 /*------------------------------------------------*
207 * IMPLEMENTAO DAS FUNES
208 *-----------------------------------------------*/
209
210 //-------------------------------------------------
211 //FUNO: menuprincipal
212 // Exibe o menu principal da aplicao e recebe a opo desejada
213 // pelo usurio.
214 int menu_principal(char *titulo_do_programa, int *opcao_desejada)
215 {
217 printf(%c,218);
223 printf(%c\n,191);
225 printf(%c,195);
231 printf(%c\n,180);
233 printf(%c %-43s %c \n,179, ,179);
241 printf(%c %-43s %c \n,179, ,179);
243 printf(%c,192);
249 printf(%c\n,217);
250
251 fflush(stdin);
252 printf(\n\n);

255 }
256
257 //-------------------------------------------------
258 //FUNO: menu_secundario
259 // Desenha na tela os menus secundrios da aplicao
261 {
263 printf(%c,218);
269 printf(%c\n,191);
271 printf(%c,192);
277 printf(%c\n,217);
278 printf( %c\n,179);
280 printf(\n\n);
281 }
282
283 //-------------------------------------------------
287 {
288 fflush(stdin);
289 printf(\n\n);
291 printf(\n\n);
292 getchar();
293 }
294
295 //-------------------------------------------------
296 //FUNO: paciente_cadastrar
297 // Cadastra um novo paciente na aplicao
298 void paciente_cadastrar(struct conjunto_pacientes *p)
299 {
300 paciente *novo;
301 novo=(paciente *) malloc (sizeof(paciente));
302
303 printf( %c Codigo............: ,219);
304 scanf(%i,&novo->codigo);
305
306 fflush(stdin);
307 printf( %c Nome..............: ,219);
309
310 fflush(stdin);
312 gets(novo->endereco);
313
314 fflush(stdin);
316 printf( %c ...........Dia: ,219); scanf(%i,&novo->data.dia);
317 printf( %c ...........Mes: ,219); scanf(%i,&novo->data.mes);
318 printf( %c ...........Ano: ,219); scanf(%i,&novo->data.ano);
319
320 fflush(stdin);
322 gets(novo->telefone);
323
325 novo->ativo = 1;
326
327 // ESPECIFICAR O PONTEIRO PARA O PRXIMO ELEMENTO
329
330 // ADICIONAR NOVO ELEMENTO A LISTA DE PACIENTES
331 if ( p->inicio == NULL ){
332 p->inicio = novo;
333 p->fim = novo;
334 }else{
335 p->fim->proximo = novo;
336 p->fim = p->fim->proximo;
337 }
338
339 // INCREMENTAR O TOTAL DE PACIENTES
340 p->total_pacientes++;
341 }
342
343 //-------------------------------------------------
344 //FUNO: pesquisar_paciente
345 // Pesquisa se o paciente j foi cadastrado, retornando um valor
346 // verdadeiro (true) ou falso (false).
347 // Essa pesquisa realizada por CDIGO
348 paciente* pesquisar_paciente_codigo(struct conjunto_pacientes *p)
349 {
350 int chave;
351
353 scanf(%i,&chave);
354


356 paciente *aux;
357 aux = p->inicio;
359 if ( aux->codigo == chave ){
360 //paciente encontrado
361 return aux;
362 }else{
364 }
365 }
366 //paciente no encontrado
367 return NULL;
368 }
369
370 //-------------------------------------------------
371 //FUNO: pesquisar_paciente
372 // Pesquisa se o paciente j foi cadastrado, retornando um valor
373 // verdadeiro (true) ou falso (false).
374 // Essa pesquisa realizada por NOME
375 paciente* pesquisar_paciente_nome(struct conjunto_pacientes *p)
376 {
378 fflush(stdin);
381
386 if ( strcmp(nome_paciente_pesquisar,aux->nome) == 0 ){
387 return aux;
388 }else{
390 }
391 }
392 return NULL;
393 }
394 //-------------------------------------------------
395 //FUNO: paciente_exibir
396 // Exibe na tela as informaes de um paciente
397 void paciente_exibir(paciente *p)
398 {
399 printf(\n);
400 printf( %c Codigo............: %i \n,219, p->codigo);
401 printf( %c Nome..............: %s \n,219, p->nome);
402 printf( %c Endereco..........: %s \n,219, p->endereco);
404 printf( %c ...........Dia: %i \n,219, p->data.dia);
405 printf( %c ...........Mes: %i \n,219, p->data.mes);

406 printf( %c ...........Ano: %i \n,219, p->data.ano);
407 printf( %c Telefone..........: %s \n,219, p->telefone);
408
409 if ( p->ativo == 1 ){
411 }else{
413 }
414 }
415
416 //----------------------------------------------------------------
417 //FUNO: paciente_ordenar
418 // Ordenar os dados dos pacientes
419 // Tipo = 1 ==> ordenao por nome
420 // Tipo = 2 ==> ordenao por cdigo
421 paciente* paciente_ordenar(struct conjunto_pacientes *p, int tipo)
422 {
424 paciente *aux;
425 paciente *tmp;
426 tmp = (paciente *) malloc (p->total_pacientes * sizeof(paciente));
427
428 paciente str;
429 int i=0,j=0, min=0;
430
431
443
445 i++;
446 }
447
448
450 for ( i = 0; i < p->total_pacientes ; i++){
451 min = i;
452 for ( j = i+1; j < p->total_pacientes; j++){
453 if ( tipo == 1 ){
454 if ( tmp[j].codigo < tmp[min].codigo )

455 min = j;
456 }else if ( tipo == 2 ){
457 if ( strcmpi(tmp[min].nome,tmp[j].nome) > 0 )
458 min = j;
459 }
460 }
461 if ( i != min ){ // TROCAR elementos
462 str = tmp[i];
464 tmp[min] = str;
465 }
466 }
467
468 return tmp;
469 }
fim cdigo 13


As questes autoavaliativas desta unidade foram elaboradas com base nos conceitos de
programao modular. Estes fundamentos so aplicados na elaborao dos mais variados tipos
de programas e so essenciais para a organizao do cdigo-fonte, bem como para sua reutiliza-
o. Aproveite as questes para realizar uma reviso desses conceitos.
1) Explique a estrutura geral de uma funo na linguagem C.
2) Descreva as diferenas entre as funes que retornam valores e as funes que no retornam valores.
3) Apresente a declarao (em linguagem C) de uma funo que retorna valor e de uma funo que no retorna
valor.
4) As assinaturas das funes so utilizadas para informar quais funes adicionais foram definidas pelo programa-
dor, em qual parte do programa devem ser declaradas essas assinaturas?
5) Explique a utilidade da passagem de parmetros no desenvolvimento das funes e diferencie a passagem de

parmetro por valor da passagem de parmetro por referncia.
6) Qual a relao entre ponteiros e a passagem de parmetro por referncia?
7) O que recursividade?
10. CONSIDERAES
Nesta unidade, foram apresentados os principais conceitos para modularizao de progra-
mas. Alm de aprender que, na linguagem C, os programas podem ser modularizados utilizando
funes, voc pde aprender, tambm, a definir e utilizar funes, bem como os tipos de passa-
gem de parmetros por valor e referncia. Alm disso, teve a oportunidade de construir funes
recursivas e transformar funes sequenciais em recursivas.
Agora, convidamos voc a estudar a ltima unidade. Vamos l!

MIZRAHI, V. V. Treinamento em Linguagem C. So Paulo: Prentice Hall, 1990.
SCHILDT, H. C Completo e Total. So Paulo: Makron Books, 1997.

Arquivos
1. OBJETIVO
Construir programas para armazenar dados em arquivos.
2. CONTEDO
Manipulao de arquivos.

guir:
1) No decorrer da unidade, sero apresentados alguns modos de abertura de arquivos.
Para conhecer outras formas de abertura, pesquise na obra de SCHILDT, H. C completo
e total. So Paulo: Makron Books, 1997.
2) Uma sugesto para leitura a obra:
ASCENCIO, A. F. G. Fundamentos da programao de computadores: algoritmos, Pas-
cal e C/C++. So Paulo: Prentice Hall, 2002. Para esta unidade, voc poder ler o cap-
tulo 9, Arquivos.
3) Aproveite para implementar os exerccios disponveis na seo "Exerccios Resolvi-
dos". Essas implementaes sero fundamentais para seu aprendizado.
4. INTRODUO UNIDADE
Ao longo do estudo das unidades anteriores, voc teve a oportunidade de aprender como
manipular informaes por meio de variveis, vetores, matrizes e registros. Essas estruturas so
essenciais para a construo de programas. No entanto, h um problema crucial: quando o pro-
grama finalizado, todos os dados armazenados nessas estruturas so perdidos.
Nesta unidade, vamos aprender uma nova estrutura para manipulao de informaes,
em que os dados podem ser armazenados permanentemente. Essa estrutura conhecida como
arquivo. Voc aprender como criar, ler e escrever (gravar) informaes em arquivos.
Bom estudo!
5. ESTRUTURA BSICA PARA MANIPULAO DE ARQUIVOS

Na linguagem de programao C, os arquivos so formados por uma sequncia de bytes
denominada fluxo (do ingls stream). Dessa forma, qualquer tipo de informao pode ser arma-
zenada no arquivo, pois tudo considerado uma sequncia de bytes.
A grande dificuldade de manipulao de arquivos que a sequncia de bytes no possui
uma organizao lgica. Para facilitar a manipulao, os arquivos so comumente organizados
em registros.
Quando trabalhamos com arquivos, o procedimento inicial a criao de uma varivel do
tipo ponteiro para arquivo. Os arquivos possuem um tipo especfico de dados, denominado FILE,
que associa um ponteiro a um arquivo armazenado no disco. A instruo a seguir demonstra a
criao de um ponteiro para arquivo:
1 FILE *pArquivo;
Depois de criado o ponteiro para o arquivo, o prximo passo realizar a abertura do ar-
quivo. Esse processo executado pela funo fopen. O trecho da instruo a seguir ilustra a
abertura de um arquivo denominado teste.txt.
1 FILE *pArquivo
2 pArquivo = fopen(teste.txt,w)
Na funo fopen, dois parmetros devem ser informados: o nome do arquivo (teste.txt) e
o modo de abertura, que define quais operaes podero ser efetuadas no arquivo. Essas ope-
raes so especificadas no Quadro 1.
Quadro 1 Modos de abertura dos arquivos.

MODOS DE ABERTURA DOS ARQUIVOS
MODO UTILIZAO
r Abre um arquivo texto e permite apenas a leitura de informaes.
r+ Abre um arquivo texto e permite a leitura e a escrita de informaes
w Cria um novo arquivo texto e permite apenas a escrita de informaes.
w+ Cria um novo arquivo texto e permite a leitura e a escrita de informaes.
Fonte: adaptado de Schildt (1997, p. 158).
U6 - Arquivos 301
importante observar que no modo w ou w+, se o arquivo j existir, o contedo desse

arquivo ser substitudo por um novo arquivo vazio, e, assim, todos os dados anteriores sero
perdidos. J os modos r ou r+ preservam os dados j existentes no arquivo (caso ele j exista).
Dessa forma, o contedo no perdido.
Para garantir que um arquivo tenha sido aberto corretamente, devemos verificar se o
ponteiro para arquivo est realmente associado a um arquivo no disco. Essa verificao pode ser
realizada por meio do trecho de cdigo a seguir:
1 FILE *pArquivo;
2 pArquivo = fopen(teste.txt,w);
3
4 if ( pArquivo == NULL ){
5 printf(Erro na abertura do arquivo.\n);
6 exit(1);
7 }
8
9 // operaes de leitura e escrita
10
Analisando o trecho da instruo anterior, veja que a condio avaliada na Linha 4 verifica
se o arquivo foi aberto corretamente. Quando o arquivo no pode ser aberto, a funo fopen
retorna NULL. Com isso, exibida a mensagem de erro da Linha 5. Alm disso, a instruo exit(1)
finaliza imediatamente a execuo do programa. Para utilizar a funo exit, necessrio incluir
a biblioteca stdlib.h.
Para concluir a estrutura bsica para manipulao de um arquivo, devemos realizar uma
chamada funo fclose, que responsvel pelo fechamento de um arquivo aberto. A utilizao
da funo simples. Veja a demonstrao no trecho a seguir:
1 FILE *pArquivo;
2 pArquivo = fopen(teste.txt,w);
3
6 exit(1);
7 }
8
9 // operaes de leitura e escrita
10
11 fclose(pArquivo);
12
Agora que voc j estudou os comandos bsicos para abertura e fechamento do arquivo,
vamos aprender como escrever e ler seus dados. O Quadro 2 apresenta os principais comandos.
Considere que pArquivo um ponteiro para o tipo file.
Quadro 2 Funes para escrita e leitura de dados no arquivo.

FUNES E SUAS UTILIZAES
FUNO UTILIZAO
fputc Escreve um caractere no arquivo.

FUNES E SUAS UTILIZAES

FUNO UTILIZAO
fgetc Realiza a leitura de um caractere do arquivo.
fputs Escreve um conjunto de caracteres (string) no arquivo.
fgets Realiza a leitura de um conjunto de caracteres do arquivo.
fwrite Escreve qualquer tipo de dados no arquivo.
fread Realiza a leitura de qualquer tipo de dados no arquivo.
O programa a seguir (Cdigo 1) demonstra a utilizao dos comandos fputc e fgetc para
leitura e escrita de caracteres no arquivo.
cdigo 1
1 /*
2 * Programa capaz de realizar a leitura e escrita de
3 * caracteres (char) em um arquivo texto
4 *
6 */
7
10 #include <stdlib.h>
11
12 /*
13 * FUNO PRINCIPAL
14 */
15 int main()
16 {
17
18 FILE *pArquivo;
19 char c;
20
21 pArquivo = fopen(caracteres.txt,w+);
22
25 exit(1);
26 }
27
28 /*
29 * ESCREVER CARACTERES NO ARQUIVO
30 */
31 do{
32 fflush(stdin);
33 printf(Digite um caractere (ou @ para sair): );
34 scanf(%c, &c);
35
36 //escrevendo caractere no arquivo
37 fputc(c,pArquivo);
38
39 }while (c != @);
U6 - Arquivos 303
40
41 /*
42 * LER CARACTERES NO ARQUIVO
43 */
44 printf(\nLeitura dos Caracteres do Arquivo\n);
45 rewind(pArquivo);
46
47 while ( !feof(pArquivo) ){
48
49 c = fgetc(pArquivo);
50 printf(Caractere: %c \n, c);
51
52 };
53
55
56 return 0;
57 }
fim cdigo 1

Digite um caractere (ou @ para sair): a
Digite um caractere (ou @ para sair): 2
Digite um caractere (ou @ para sair): k
Digite um caractere (ou @ para sair): 9
Digite um caractere (ou @ para sair): $
Digite um caractere (ou @ para sair): y
Digite um caractere (ou @ para sair): @
Leitura dos Caracteres do Arquivo
Caractere: a
Caractere: 2
Caractere: k
Caractere: 9
Caractere: $
Caractere: y
Caractere: @
Caractere:

Note que, no Cdigo 1, os caracteres so escritos (ou gravados) no arquivo por meio
do comando fputc (Linha 37). Para terminar a leitura dos caracteres, o smbolo @ deve ser
informado.
Na Linha 45, o comando rewind foi utilizado para reposicionar o indicador de posio
do arquivo no incio. Esse procedimento necessrio para que a leitura dos caracteres seja
realizada do incio para o fim. Na Linha 47, utilizado o comando feof, que uma maneira de
verificar se a leitura do arquivo chegou ao fim. Todo arquivo possui um caractere especial que
representa seu fim, comumente conhecido como EOF (End-Of-File). A funo feof realiza um
teste para determinar se o final do arquivo foi atingido.
J na Linha 49, o comando fgetc utilizado para ler caractere por caractere do arquivo.
Esse comando est dentro do lao de repetio while, que s termina quando o final do arquivo
(EOF) encontrado.
O prximo exemplo (Cdigo 2) demonstra a utilizao dos comandos fputs e fgets para
leitura e escrita de conjunto de caracteres (strings) no arquivo.
cdigo 2
1 /*
3 * caracteres (char) em um arquivo texto
4 *
6 */
7
12
13 /*
14 * FUNO PRINCIPAL
15 */
16 int main()
17 {
18
19 FILE *pArquivo;
20 char texto[20];
21
22 pArquivo = fopen(strings.txt,w+);
23
26 exit(1);
27 }
28
29
30 /*
31 * ESCREVER CARACTERES NO ARQUIVO
32 */
33 do{
34 fflush(stdin);
U6 - Arquivos 305
35 printf(Digite uma string (ou @ para sair): );

36 gets(texto);
37
38 //adiciona o caractere de nova linha
39 strcat(texto,\n);
40
41 //escrevendo caractere no arquivo
42 fputs(texto,pArquivo);
43
44 }while (*texto != @);
45
46
47 fflush(pArquivo);
48 /*
49 * LER CARACTERES NO ARQUIVO
50 */
51 printf(\nLeitura das Strings do Arquivo\n);
53
55
56 fgets(texto,19,pArquivo);
57
58 if ( *texto != @){
59 printf(String: %s, texto);
60 }
61
62 };
63
65
66 return 0;
67 }
fim cdigo 2


Digite uma string (ou @ para sair):
Brasil

Argentina

Chile

Estados Unidos

Inglaterra
Digite uma string (ou @ para sair): @
Leitura das Strings do Arquivo
String: Brasil
String: Argentina
String: Chile
String: Estados Unidos
String: Inglaterra
Dessa forma, a Linha 42 realiza a escrita das informaes no arquivo, por meio da funo
fputs. Esse comando escreve uma string no arquivo.
Na Linha 56, os dados contidos no arquivo so carregados por meio do comando fgets.
Para leitura da string, necessrio informar uma varivel que receber a string carregada (texto),
o nmero de caracteres que deve ser lido (19) e, tambm, o ponteiro para o arquivo (pArquivo).
Os caracteres sero lidos do arquivo at o tamanho especificado (19) ou at que um caractere
de nova linha (\n) seja encontrado.
O prximo programa, descrito no Cdigo 3, demonstra a utilizao dos comandos fwrite e
fread. Esses comandos so utilizados para escrita e leitura de qualquer tipo de dados no arquivo.
Os arquivos que armazenam qualquer tipo de dados so chamados de arquivos binrios.
cdigo 3
1 /*
3 * registros em um arquivo
4 *
6 */
U6 - Arquivos 307
13
14 //definio da estrutura registro
16 char nome[30];
17 int idade;
18 }pessoa;
19
20 int main()
21 {
22 FILE *pArquivo;
23 char continuar;
24
25 //cria um novo arquivo binrio para leitura e escrita
26 pArquivo = fopen(pessoas.dat,w+b);
27
28 if ( pArquivo == NULL){
30 exit(1);
31 }
32
33
34 printf(---Salvar registros no arquivo---);
35 do{
36 fflush(stdin);
37 printf(\nNome.: );
38 gets(pessoa.nome);
39 printf(Idade: );
40 scanf(%i,&pessoa.idade);
41
42 //salvar registro no disco
43 fwrite(&pessoa,sizeof(pessoa),1,pArquivo);
44
45 printf(Deseja continuar [S] ou [N])? );
46 continuar = toupper( getche() );
47 }while( continuar == S);
48
49
50 printf(\n\n---Carregar registros do arquivo---\n);
51 rewind(pArquivo); //posicionar no incio do arquivo
52

54
55 //ler registro do disco
56 fread(&pessoa,sizeof(pessoa),1,pArquivo);
57
58 if ( !feof(pArquivo) ){
59 printf(Nome.: %s\n, pessoa.nome);
60 printf(Idade: %i\n, pessoa.idade);
61 }
62 }
63
65
66 return 0;
67 }
fim cdigo 3

---Salvar registros no arquivo---
Nome.: Joao da Silva
Idade: 23
Deseja continuar [S] ou [N])? s
Nome.: Carlos Antonio
Idade: 42
Deseja continuar [S] ou [N])? s
Nome.: Ana Maria
Idade: 29
Deseja continuar [S] ou [N])? n
---Carregar registros do arquivo---
Nome.: Joao da Silva
Idade: 23
Nome.: Carlos Antonio
Idade: 42
Nome.: Ana Maria
Idade: 29
U6 - Arquivos 309
Veja que a Linha 43 utiliza o comando fwrite para escrever os dados no arquivo, enquanto
a Linha 56 utiliza o comando fread para realizar a leitura dos dados do arquivo.
1) Utilizando o conceito de arquivos, crie um programa para controlar os dados dos fun-
cionrios de uma empresa. Esse programa dever ser capaz de inserir, remover e listar
os funcionrios, e, alm disso, de salvar e carregar os funcionrios cadastrados no
disco.
cdigo 4
1 /*
3 * registros em um arquivo
4 *
6 */
7
12
13 //nmero total de funcionrios
14 #define TOTALFUNC 5
15
16 //definio da estrutura registro
17 struct tipofuncionario{
18 int codigo; //cdigo do funcionrio
19 char nome[30]; // nome do funcionrio
20 float salario; // salrio do funcionrio
21 int ativo; // 1 = ativo; 0 = inativo
22 };
23
25 void inicializar(struct tipofuncionario f[]);
26 void listar(struct tipofuncionario f[]);
27 void inserir(struct tipofuncionario f[]);
28 void remover(struct tipofuncionario f[]);
29 void salvar(struct tipofuncionario f[]);
30 void carregar(struct tipofuncionario f[]);
31
32 /*
33 * FUNO PRINCIPAL
34 */
35 int main()
36 {
37 int opcao;
38 struct tipofuncionario func[TOTALFUNC];
39
40 inicializar(func); //inicializar vetor
41

42 do{
43 printf(------Controle de Funcionarios------\n);
44 printf( [1] Inserir \n);
45 printf( [2] Remover \n);
46 printf( [3] Listar \n);
47 printf( [4] Carregar (arquivo)\n);
48 printf( [5] Salvar (arquivo)\n);
49 printf( [6] Sair \n\n);
50 printf(Opcao desejada: );
52
53 switch(opcao){
54 case 1: inserir(func);
55 break;
56 case 2: remover(func);
57 break;
58 case 3: listar(func);
59 break;
60 case 4: inicializar(func);
61 carregar(func);
62 break;
63 case 5: salvar(func);
64 break;
65
66 case 6: printf(\nPrograma finalizado\n);
67 break;
68 default: printf(\nOpcao invalida.\n);
69 }
70 }while ( opcao != 6 );
71
72 return 0;
73 }
74
75 //------------------------------------------
76 //FUNO para inicializar todas as posies do vetor
77 //------------------------------------------
78 void inicializar(struct tipofuncionario f[]){
79 int i;
80 for ( i = 0; i < TOTALFUNC; i++){
81 f[i].codigo = 0;
82 strcpy(f[i].nome,);
83 f[i].salario = 0.0;
84 f[i].ativo = 0;
85 }
86 }
87 //------------------------------------------
88 //FUNO para exibir na tela os funcionrios ativos
89 //------------------------------------------
90 void listar(struct tipofuncionario f[]){
91 int i = 0;
92 while ( i < TOTALFUNC ){
93 if ( f[i].ativo != 0 ){ // exibir funcionrios ativos
U6 - Arquivos 311
94 printf(Codigo: %i \n,f[i].codigo);
95 printf(Nome: %s \n,f[i].nome);
96 printf(Salario: %.2f \n\n,f[i].salario);
97 }
98 i++;
99 }
100 }
101 //------------------------------------------
102 //FUNO para inserir um funcionrio
103 //------------------------------------------
104 void inserir(struct tipofuncionario f[]){
105 int i, pos;
106 printf(\n--Inserir funcionario--\n);
107
108 //procurar uma posio para inserir o funcionrio
109 i = 0;
110 pos = -1;
111 while ( (i < TOTALFUNC) && (pos == -1) ){
112 if ( f[i].ativo == 0 ){
113 pos = i;
114 }
115 i++;
116 }
117
118 if ( pos != -1 ){
119 printf(Codigo.: );
120 scanf(%i,&f[pos].codigo);
121 fflush(stdin);
122 printf(Nome...: );
123 gets(f[pos].nome);
125 scanf(%f,&f[pos].salario);
126 f[pos].ativo = 1;
127 printf(\nFuncionario inserido com sucesso.\n);
128 }else{
129 printf(\nTodas as posicoes da lista estao ocupadas\n);
130 }
131 }
132 //------------------------------------------
133 //FUNO para remover um funcionrio
134 //------------------------------------------
135 void remover(struct tipofuncionario f[]){
136 int codigo, i, pos;
137
138 printf(\nInforme o codigo do funcionario: );
140
141 //procurar funcionrio
142 i = 0;
143 pos = -1;
144 while ( (i < TOTALFUNC) && (pos == -1) ){
145 if ( f[i].codigo == codigo ){

146 f[i].ativo = 0; //remover funcionrio

147 printf(\nFuncionario removido com sucesso.\n);
148 pos = i;
149 }
150 i++;
151 }
152 if ( pos == -1 ){
153 printf(\nFuncionario nao encontrado\n);
154 }
155 }
156 //------------------------------------------
157 //FUNO salvar todos os funcionrios em um arquivo no disco
158 //------------------------------------------
159 void salvar(struct tipofuncionario f[]){
160 int i;
161 FILE *pArquivo;
162
163 pArquivo = fopen(funcionarios.dat,wb);
164
167 return;
168 }
169
170 //gravar dados no arquivo
171 for( i = 0; i < TOTALFUNC; i++){
172 fwrite(&f[i], sizeof(f[i]), 1, pArquivo);
173 }
175 printf(\nInformacoes gravadas com sucesso\n);
176 }
177 //------------------------------------------
178 //FUNO carregar todos os funcionrios armazenados no disco
179 //------------------------------------------
180 void carregar(struct tipofuncionario f[]){
181 int i;
182 FILE *pArquivo;
183
184 pArquivo = fopen(funcionarios.dat,rb);
185
188 return;
189 }
190
191 //carregar dados do arquivo
192 for( i = 0; i < TOTALFUNC; i++){
193 fread(&f[i], sizeof(f[i]), 1, pArquivo);
194 }
196 printf(\nInformacoes carregadas com sucesso\n);
197 }
U6 - Arquivos 313
fim cdigo 4
2) Um arquivo denominado CSV, do ingls Comma-Separeted Values, muito utilizado

para armazenamento de dados tabelados e pode ser carregado nas mais variadas apli-
caes. Esse tipo de arquivo uma implementao particular de um arquivo texto. No
entanto, a principal diferena que este tipo de arquivo possui um caractere especial
denominado delimitador, que o separa dos valores presentes no arquivo. Considere a
planilha do Excel, na Figura 1, com algumas informaes.
Figura 1 Dados em uma planilha do Excel.
Esses dados podem ser facilmente exportados para o formato CSV no Excel. Para isso, uti-
lize a opo Salvar Como e, em Tipo, selecione CSV (separado por vrgula) (*.csv). O resultado
pode ser visualizado no bloco de notas e apresentado na Figura 2.
Figura 2 Resultado dos dados exportados para o formato CSV.
O objetivo deste exerccio o desenvolvimento de uma aplicao que seja capaz de car-
regar um arquivo do tipo CSV e apresentar os dados na tela. Para isso, utilize os comandos da
linguagem C para manipulao de arquivos.
cdigo 5

1 /*---------------------------------------------
2 *
3 * Exemplo de uma aplicao capaz de carregar um arquivo do tipo
4 * CSV e apresentar as informaes na tela.
5 *
7 *
8 *-------------------------------------------*/
9
10 /*---------------------------------------------
11 * BIBLIOTECAS
12 *-------------------------------------------*/
15 #include <string.h> //para utilizao da funo strtok
16
17 /*---------------------------------------------
19 *-------------------------------------------*/
20
21 struct tipo_arquivo_csv{
22 int codigo;
23 char nome[40];
24 float nota1;
25 float nota2;
26
27 struct tipo_arquivo_csv *proximo;
28 };
29
30 typedef struct tipo_arquivo_csv csv;
31
32 /*---------------------------------------------
33 * ASSINATURAS DOS MTODOS (OU MDULOS)
34 *-------------------------------------------*/
35 void trocar_caractere(char *str, char de, char para);
36 int ler_arquivo_csv(char *nomearquivo, csv reg[], int *n);
37 void exibir_dados(csv reg[], int n);
38
39
40 /*--------------------------------------------*
42 *-------------------------------------------*/
43 int main()
44 {
45 int total_linhas=0;
46 csv registros[100];
47
48 ler_arquivo_csv(dados.csv,registros,&total_linhas);
49 exibir_dados(registros,total_linhas);
50
53 }
U6 - Arquivos 315
54
55
56
57 //---------------------------------------------
58 //FUNO: trocar_caractere
59 // Troca um caractere de uma string por outro
60 void trocar_caractere(char *str, char de, char para)
61 {
62 char *pos = strchr(str,de);
63 str[(pos-str)] = para;
64 }
65
66 //---------------------------------------------
67 //FUNO: ler_arquivo_csv
68 // Carrega o contedo de um arquivo do tipo CSV e armazena em um
69 // vetor de registros
70 int ler_arquivo_csv(char *nomearquivo, csv reg[], int *n)
71 {
72 FILE *pArquivo; // ponteiro para o arquivo CSV
73
74 //Abertura do arquivo
75 pArquivo = fopen(nomearquivo,r);
76
77 //Verificar se o arquivo foi realmente aberto
80 return 0;
81 }
82
83 //leitura do arquivo
char tmp[4096]; // varivel temporrio que armazenar 1 (uma) linha inteira do
84
arquivo
85 char campo[200]; // varivel que armazenar apenas 1 (um) campo
86
87 //leitura do cabealho do arquivo
88 fgets(tmp,4096,pArquivo);
89
90 while ( !feof(pArquivo) )
91 {
92 fgets(tmp,4096,pArquivo);
93
94 //DICA
95 // ---> atoi = converte uma string em um valor inteiro
96 // ---> atof = converte uma string em um valor float
97 // ---> strtok = divide uma string em partes em funo
98 // do caractere desejado. Neste caso vamos
99 // dividir a string sempre que encontrarmos
100 // o delimitador (;)
101
102
103 //== leitura do campo cdigo (RA)
104 strcpy(campo,strtok(tmp,;\r\n));
105 reg[*n].codigo = atoi(campo); //converter para inteiro

106
107 //== leitura do campo nome
108 strcpy(campo,strtok(NULL,;\r\n));
109 strcpy(reg[*n].nome,campo);
110
111 //== leitura do campo nota 1
113 trocar_caractere(campo,,,.);
114 reg[*n].nota1 = atof( campo );
115
116 //== leitura do campo nota 2
118 trocar_caractere(campo,,,.);
119 reg[*n].nota2 = atof( campo );
120
121
122 //incrementar o nmero de linhas
123 *n = *n + 1;
124 }
125
127
128 }
129
130 //---------------------------------------------
131 //FUNO: exibir_dados
132 // Apresenta na tela o contedo do vetor de registros
133 void exibir_dados(csv reg[], int n)
134 {
135 int i = 0;
136
137 for ( i = 0; i < n; i++)
138 {
139 printf(Codigo (RA).: %i \n, reg[i].codigo);
140 printf(Nome........: %s \n, reg[i].nome);
141 printf(Nota Prova 1: %0.2f \n, reg[i].nota1);
142 printf(Nota Prova 2: %0.2f \n, reg[i].nota2);
143 printf(Media.......: %0.2f \n\n, (reg[i].nota1+reg[i].nota2)/2);
144 }
145
146 printf(Total de registros no arquivo: %i \n,n);
147
148 }
fim cdigo 5

de desenvolvimento. Neste caso foi utilizado o ambiente CodeBlocks, no entanto, a sada ser
semelhante em outros ambientes, como por exemplo, no NetBeans. Este resultado obtido
com a compilao e execuo do cdigo-fonte apresentado anteriormente.
U6 - Arquivos 317
1) Resultado da execuo do programa:

3) Nos exerccios resolvidos da unidade anterior foi desenvolvido um programa capaz de
corrigir automaticamente gabaritos de uma prova de vestibular. O programa elabora-
do permite a leitura do gabarito oficial da prova, bem como os gabaritos dos candida-
tos. No entanto, para o correto funcionamento da aplicao necessrio que todos
os dados (dos gabaritos) sejam digitados. Para melhorar a usabilidade do programa,
vamos construir uma nova verso em que as informaes dos gabaritos sero carrega-
das a partir de dois arquivos texto:
a) gabarito_oficial.csv: contm o gabarito oficial da prova, em que as alternativas
corretas de cada questo so definidas;
b) gabaritos_candidados.csv: contm o gabarito de cada candidato da prova. Lem-
brando que alm das alternativas corretas, o gabarito de cada candidato contm
o nmero de inscrio, o nmero do RG e o nome completo do candidato.
Para demonstrar o funcionamento do programa, considere o seguinte arquivo para o ga-
barito oficial, em que a primeira informao representa o nmero da prova.
gabarito_oficial.csv
44321; d; a; b; c; b; c; a; d; d; b; e; a; e; b; e; a; d; e; a; c;
O contedo do arquivo sobre os gabaritos dos candidatos apresentado como se segue. O

primeiro campo representa o nmero da inscrio, seguido pelo nmero do RG, e nome comple-
to do candidato. Os prximos campos representam as alternativas assinaladas pelos candidatos.

gabaritos_candidatos.csv
101;23568956;Joao da Silva;c;b;e;e;e;d;d;c;a;d;a;e;b;e;d;a;b;d;a;c
102;23802312;Carlos Antonio;c;d;c;e;d;a;d;b;b;a;c;a;a;a;a;c;d;c;e;e
103;24035668;Ana Maria;c;b;b;b;c;d;b;d;a;e;b;a;b;a;d;e;d;b;c;e
104;24269024;Marcos Felipe;b;c;d;c;a;d;d;d;a;a;d;e;c;a;a;b;e;d;d;d
105;24502380;Andre dos Santos;c;e;d;a;b;c;b;e;d;e;e;b;a;a;d;e;d;c;c;c
106;24735736;Sandro Mendes;d;b;b;d;e;b;c;b;a;b;a;b;d;c;d;e;c;d;e;b
107;24969092;Vitor Carlos;a;d;b;b;c;a;d;a;c;d;c;e;e;e;e;e;b;c;e;d
108;25202448;Barbara Lopes;c;d;b;b;e;a;b;c;d;e;c;a;c;c;e;d;e;b;b;e
109;25435804;Thiago Silva;a;c;a;d;c;a;d;e;d;c;d;b;b;a;e;e;c;e;a;c
110;25669160;Tiago Antonio;e;d;a;a;b;b;a;a;b;b;d;b;b;b;b;b;e;b;e;b
111;25902516;Joao dos Santos;e;b;d;a;b;d;b;d;a;d;b;e;e;d;a;c;b;e;a;b
112;26135872;Carlos Felipe;b;e;d;d;e;c;b;b;e;e;b;e;d;c;c;e;a;b;c;e
113;26369228;Maco Antonio;a;e;c;d;c;a;c;b;d;d;a;c;c;e;a;d;d;b;a;c
114;26602584;Mario Andrade;d;d;d;e;b;a;e;e;b;b;a;d;e;e;a;b;d;b;b;b
115;26835940;Fabio Santos;c;d;d;c;c;b;b;a;b;b;c;b;c;c;e;d;c;c;e;c
116;27069296;Felipe Mello;c;d;a;e;c;e;d;e;b;d;a;c;a;a;d;d;d;e;a;d
117;27302652;Catia Maria;a;b;b;e;a;d;d;d;d;a;b;c;d;c;d;d;e;c;e;b
118;27536008;Amanda Aparecida;b;e;e;b;d;b;c;a;a;e;d;e;e;b;a;d;e;b;d;d
119;27769364;Helena Silva;b;d;a;a;d;e;a;e;d;e;b;b;d;e;a;b;d;c;b;a
120;28002720;Silvia dos Santos;a;e;c;e;a;b;c;c;c;c;c;a;a;a;c;e;d;e;c;a
121;28236076;Rogerio Jose;d;c;c;c;a;b;b;c;b;d;b;c;e;a;a;b;b;b;d;e
122;28469432;Jose Carlos;c;c;e;e;b;b;b;a;a;d;e;b;c;b;b;e;b;d;a;d
123;28702788;Jose Silva;a;c;b;a;b;d;a;a;b;d;d;a;d;a;b;c;e;c;d;a
124;28936144;Roberto Carlos;a;d;b;c;a;b;b;c;e;a;b;c;e;e;e;b;d;b;b;b
125;29169500;Thais Silva;a;b;b;c;c;b;e;a;a;c;d;d;c;e;d;b;b;c;d;d
126;29402856;Salete Rosa;c;c;e;b;d;e;c;e;c;a;a;a;d;b;d;b;c;d;d;a
127;29636212;Rosana dos Santos;e;d;a;a;c;a;c;b;a;e;b;c;c;b;a;d;e;b;d;d
128;29869568;Antonio Andrade;b;b;b;b;e;e;c;b;a;c;b;a;d;c;a;c;e;e;a;e
129;30102924;Felipe Jose;b;c;a;e;a;c;a;d;a;b;e;b;a;e;d;c;e;b;a;d
130;30336280;Roselito Antonio;a;c;b;d;c;c;d;c;b;d;d;c;b;b;a;d;a;c;b;e
cdigo 6
1 /*---------------------------------------------
2 *
3 * Exemplo de uma aplicao capaz de corrigir automaticamente
U6 - Arquivos 319
4 * os gabaritos dos candidatos de um vestibular.

5 *
6 * Este exemplo carregas as informaes dos gabaritos a partir
7 * de arquivos do tipo CSV.
8 *
10 *
11 *-------------------------------------------*/
12
13 /*---------------------------------------------
14 * BIBLIOTECAS
15 *-------------------------------------------*/
18 #include <ctype.h> //para utilizao da funo toupper
20
21 /*---------------------------------------------
23 *-------------------------------------------*/
24
25 #define NUM_QUESTOES 20
26
27 //==ALTERNATIVAS ------------------------------
28 //Estrutura utilizada para armazenar as alternativas corretas a qual
29 //poder ser utilizada tanto no gabarito oficial quanto no gabarito
30 //dos candidates
31 struct tipo_alternativas{
32 char correta;
33 };
34
35
36 //==GABARITO OFICIAL --------------------------
37 //Estrutura que armazena o nmero da prova, e a alternativa correta
38 //de cada uma das questes da prova
39 struct tipo_gabarito_oficial{
40 int numeroprova;
42 };
43 typedef tipo_gabarito_oficial gabarito_oficial[NUM_QUESTOES];
44 //---------------------------------------------
45
46
47 //==GABARITO DOS CANDIDATOS -------------------
48 //Estrutura que armazena o nmero da inscrio, o nmero do RG e o
49 //nome completo do candidato. Alm disso, so armazenas as alternativas
50 //que foram assinalidas pelo candidato.
51 //Um campo especfico armazena o nmero total de alternativas que
52 //foram acertadas pelo candidato.
53 struct tipo_gabarito_candidato{
54 int num_inscricao;
55 char num_rg[12]; //XX.XXX.XXX-X
56 char nome[40];


58 int total_corretas;
59 struct tipo_gabarito_candidato *proximo;
60 };
61 typedef tipo_gabarito_candidato candidato;
62
63 struct tipo_candidatos{
64 candidato *inicio;
65 candidato *fim;
66 int total_candidatos;
67 };
68
69 typedef tipo_candidatos gabarito_candidatos; //Gabaritos
70 //---------------------------------------------
71
72 /*--------------------------------------------*
73 * ASSINATURAS DOS MTODOS (MDULOS)
74 *-------------------------------------------*/
75 void menu_principal(char *titulo_do_programa, int *opcao_desejada);
78 void ler_gabarito_oficial(gabarito_oficial g);
79 void ler_gabarito_candidatos(gabarito_candidatos *g);
80 void gabarito_correcao(gabarito_oficial go,gabarito_candidatos *gc);
81 void exibir_resultados_candidatos(gabarito_candidatos *gc);
82
83 /*--------------------------------------------*
85 *---------------------------------------------------------------*/
86 int main()
87 {
89 char titulo_do_programa[40] = SISTEMA GAB@ARITOS;
90
91 gabarito_oficial oficial;
92 gabarito_candidatos candidatos;
93 char continua;
94
95 //Inicializar variveis
96 candidatos.inicio = NULL;
97 candidatos.fim = NULL;
98 candidatos.total_candidatos = 0;
99
101
102 do{
104
106 case 1:
107 menu_secundario(titulo_do_programa,LER GABARITO OFICIAL);
108 ler_gabarito_oficial(oficial);
U6 - Arquivos 321
110 break;
111 case 2:
112 menu_secundario(titulo_do_programa,LER GABARITOS DOS CANDIDATOS);
113 ler_gabarito_candidatos(&candidatos);
115 break;
116 case 3:
117 menu_secundario(titulo_do_programa,RELATORIO DOS CANDIDATOS);
118 gabarito_correcao(oficial,&candidatos);
119 exibir_resultados_candidatos(&candidatos);
121 break;
122 }
123
125
128 }
129
130 /*--------------------------------------------*
131 * IMPLEMENTAO DOS MTODOS (MDULOS)
132 *-------------------------------------------*/
133 void menu_principal(char *titulo_do_programa, int *opcao_desejada)
134 {
136 printf(%c,201);
142 printf(%c\n,187);
144 printf(%c %-40s %c \n,186,Correcao automatica de gabaritos,186);
145 printf(%c,204);
151 printf(%c\n,185);
153 printf(%c %-43s %c \n,186, ,186);
154 printf(%c %-40s %c \n,186, [1] LER GABARITO OFICIAL ,186);
155 printf(%c %-40s %c \n,186, [2] LER GABARITOS DOS CANDIDATOS ,186);
156 printf(%c %-40s %c \n,186, [3] RELATORIO DOS CANDIDATOS ,186);
157 printf(%c %-43s %c \n,186, ,186);
159 printf(%c,200);

165 printf(%c\n,188);
166
167 fflush(stdin);
168 printf(\n\n);
171 }
172
174 {
176 printf(%c,201);
182 printf(%c\n,187);
184 printf(%c,200);
190 printf(%c\n,188);
191 printf( %c\n,186);
193 printf(\n\n);
194 }
195
196 //---------------------------------------------
200 {
201 fflush(stdin);
202 printf(\n\n);
204 printf(\n\n);
205 getchar();
206 }
207 //---------------------------------------------
208 //FUNO: ler_gabarito_oficial
209 // Realize a leitura do gabarito oficial da prova.
210 void ler_gabarito_oficial(gabarito_oficial g)
211 {
212
213 //==CARREGAR ARQUIVO CONTENDO O GABARITO OFICIAL
215 pArquivo = fopen(gabarito_oficial.csv,r); //Abertura do arquivo
U6 - Arquivos 323
216
218 mensagem(Erro na abertura do arquivo.\n);
219 }else{
char linha[4096]; // varivel temporria que armazenar 1 (uma) linha do
221
arquivo
223 int numeroprova;
224
225 //leitura da linha contendo o gabarito oficial
226 fgets(linha,4096,pArquivo);
227
//Carregar o nmero da prova e
228
armazenar na varivel numeroprova
//A informao do nmero da prova est
229
armazenada no primeiro campo
230 //do arquivo.
231 strcpy(campo,strtok(linha,;\r\n));
232 numeroprova = atoi(campo); //converter para inteiro
233
235 printf( %c Numero da prova....: %i\n, 219, numeroprova);
236 printf( %c Total de questoes..: %i\n, 219, NUM_QUESTOES);
237 printf( %c\n,219);
239
240 //Leitura das questes corretas armazenadas no arquivo
241 for( int i = 0; i < NUM_QUESTOES; i++)
242 {
244 g[0].alternativas[i].correta = *campo;
printf( %c Questao [%02i]: %c \n,219,i+1,g[0].alternativas[i].
245
correta);
246 }
247 }
248
249 }
250
251 //---------------------------------------------
252 //FUNO: ler_gabarito_candidatos
253 // Realiza a leitura dos gabaritos dos candidatos
254 // Essa funo manipula uma instruo de dados dinmica com ponteiros
255 void ler_gabarito_candidatos(gabarito_candidatos *g)
256 {
258 printf( %c Total de questoes ......: %i\n, 219, NUM_QUESTOES);
259
260
261 //==CARREGAR ARQUIVO CONTENDO O GABARITO DOS CANDIDATOS
263 pArquivo = fopen(gabaritos_candidatos.csv,r); //Abertura do arquivo
264

266 mensagem(Erro na abertura do arquivo.\n);

267 }else{
char linha[4096]; // varivel temporria que armazenar 1 (uma) linha do
268
arquivo
270
271 //Contar o nmero de candidatos no arquivo
272 int i = 0;
274 {
276 //incrementar o nmero de linhas do arquivo
277 i++;
278 }
279 //exibir o nmero total de candidatos, em funo do nmero de linhas
280 //armazenadas no arquivo.
281 printf( %c Total de gabaritos lidos: %i\n, 219, i);
282 printf( %c\n,219);
283
286 {
288
289 //Alocar memria para leitura de um novo gabarito
290 candidato *novo;
291 novo=(candidato *) malloc (sizeof(candidato));
292
293 //Nmero de inscrio do candidato
294 strcpy(campo,strtok(linha,;\r\n));
295 novo->num_inscricao = atoi(campo); //converter para inteiro
296
297 //Nmero do RG do candidato
299 strcpy(novo->num_rg,campo);
300
301 //Nome do candidato
303 strcpy(novo->nome,campo);
304
305 //Exibir informaes na tela para o usurio
306 printf( %c \n,219);
307 printf( %c Numero de Inscricao: %i \n,219,novo->num_inscricao);
308 printf( %c Numero do RG.......: %s \n,219,novo->num_rg);
309 printf( %c Nome...............: %s \n,219,novo->nome);
310
311 //Preencher o gabarito do candidato com as alternativas
312 for( int i = 0; i < NUM_QUESTOES; i++)
313 {
315 novo->alternativas[i].correta = *campo;
316 //Caso seja necessrio possvel exibir na tela as alternativas
317 //assinaladas pelo candidato
U6 - Arquivos 325
//printf( %c Questao [%02i]: %c \n,219,i+1,novo->alternativas[i].

318
correta);
319 }
320
322
323 //Uma estrutura dinmica baseada em ponteiros foi utilizada
324 if (g->inicio == NULL ){
325 g->inicio = novo;
326 g->fim = novo;
327 }else{
328 g->fim->proximo = novo;
329 g->fim = g->fim->proximo;
330 }
331 //Incrementar o nmero total de candidatos
332 g->total_candidatos++;
333
334 }
335
336 }
337
338 }
339
340 //---------------------------------------------
341 //FUNO: gabarito_correcao
342 // Correcao automtica dos gabaritos
343 void gabarito_correcao(gabarito_oficial go,gabarito_candidatos *gc)
344 {
345 int total;
348 total = 0;
349 //Comparar gabarito do candidato com gabarito oficial
350 for(int j = 0; j < NUM_QUESTOES; j++){
351 if ( aux->alternativas[j].correta == go[0].alternativas[j].correta){
352 //incremental o nmero total de questes corretas
353 total++;
354 }
355 }
356 //atualizar o nmero de questes corretas
357 aux->total_corretas = total;
359 }
360
361 }
362
363 //---------------------------------------------
364 //FUNO: exibir_resultados_candidatos
365 // Apresenta na tela o desempenho de cada candidato, bem como, o
366 // nmero de questes corretas, alm da porcentagem de acerto.
367 void exibir_resultados_candidatos(gabarito_candidatos *gc)
368 {
369 float porcentagem_corretas;

printf( %c %-4s %-30s %-10s %-10s \n,219,# INSCR,CANDIDATO,# ACERTOS,%

370
ACERTO);
373 //calcular a porcentagem de questes corretas
374 porcentagem_corretas = ((float)aux->total_corretas/(float)NUM_QUESTOES)*100;
375 //exibir as informaes na tela.
printf( %c %05i %-34s %02i \t %0.2f %%\n,219,aux->num_inscricao,aux-
376
>nome,aux->total_corretas,porcentagem_corretas);
378 }
379
380 }
fim cdigo 6


U6 - Arquivos 327

Os arquivos representam uma das primeiras maneiras de armazenamento persistente de
informaes nos computadores. Esse recurso precursor dos bancos de dados, e hoje em dia
ainda amplamente utilizado na elaborao de programas. As questes autoavaliativas desta
unidade foram elaboradas com base nos conceitos de arquivos. Aproveite as questes para ava-
liar seus conhecimentos.
1) Explique o termo fluxo ou stream.
2) Como declarado um arquivo na linguagem de programao C?
3) Qual a utilidade do comando fopen?
4) Reflita sobre os modos de abertura de arquivo r, r+, w e w+.
5) Apresente quais comandos so utilizados para escrita e quais so utilizados para leitura de informaes em
arquivos.
8. CONSIDERAES
Chegamos ao fim do estudo desta unidade. Voc teve a oportunidade de aprender como
manipular arquivos utilizando a linguagem C. Alm disso, os exemplos demonstraram como
possvel salvar informaes em arquivos texto e binrios, bem como ler os dados armazenados.
Esse conceito importantssimo para a construo de programas.
U6 - Arquivos 329
Com isso, conclumos o estudo de Laboratrio de Programao. Ao longo deste estudo,

voc teve a oportunidade de aprender os principais conceitos relativos construo de progra-
mas de computador.
SCHILDT, H. C completo e total. So Paulo: Makron Books, 1997.


CRC

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

CRC

Încărcat de

Drepturi de autor:

Formate disponibile

LABORATRIO DE PROGRAMAO

CURSOS DE GRADUAO EAD

Laboratrio de Programao Prof. Dr. Rodrigo de Oliveira Plotze.

Fazemos parte do Claretiano - Rede de Educao

Corpo Tcnico Editorial do Material Didtico Mediacional

Claretiano - Centro Universitrio

Fazemos parte do Claretiano - Rede de Educao

CADERNO DE REFERNCIA DE CONTEDO

Unidade1 INTRODUO PROGRAMAO DE COMPUTADORES

Unidade2 FUNDAMENTOS DA LINGUAGEM DE PROGRAMAO C

Unidade3 ESTRUTURAS DE CONTROLE

Unidade4 ESTRUTURA DE DADOS E PONTEIROS

Unidade5 PROGRAMAO MODULAR

2. ORIENTAES PARA ESTUDO

e os digitalizadores. Por outro lado, a funcionalidade de apresentao de dados por meio do

Claretiano - Centro Universitrio

ou sistemas operacionais baseados em Linux, ser possvel utilizar um ambiente totalmente

Fundamentos da linguagem de programao C

Claretiano - Centro Universitrio

#include <stdio.h> //biblioteca do programa

//entrada de dados da varivel a

//entrada de dados da varivel b

//clculo matemtico que resulta na soma de a e b

A linguagem de programao C possui um recurso interessante, denominado cdigos de

Claretiano - Centro Universitrio

Estrutura de Dados e Ponteiros

Claretiano - Centro Universitrio

Esquema dos Conceitos-chave

printf e scanf Estrutura de

Figura 1 Esquema dos Conceitos-chave de Laboratrio de Programao.

Claretiano - Centro Universitrio

O Esquema dos Conceitos-chave mais um dos recursos de aprendizagem que vem se

Figuras (ilustraes, quadros...)

Claretiano - Centro Universitrio

3. ORIENTAES PARA O ESTUDO DA UNIDADE

3) Tenha sempre mo o significado dos conceitos explicitados no Glossrio e suas li-

Figura 1 Representao dos principais componentes de um computador.

Claretiano - Centro Universitrio

Figura 2 Sistema Operacional Microsoft Windows Vista.

A famlia de sistemas operacionais Microsoft Windows possui uma gama de programas

Figura 3 Sistema Operacional Linux, distribuio Suse.

Ultimamente, os sistemas operacionais Linux vm ganhando mercado, especialmente

Figura 4 Sistema Operacional Mac OS.

Quadro 1 Principais sistemas operacionais para uso domstico.

Claretiano - Centro Universitrio

Figura 5 Sistema operacional Solaris.

O Quadro 2 apresenta os principais sistemas operacionais para servidores e seus respecti-

Quadro 2 Principais sistemas operacionais para servidores.

0100 1111 1010 0110

A instruo anterior poderia representar, por exemplo, a leitura de uma informao do

Figura 6 Execuo do programa Debug.

Claretiano - Centro Universitrio

Em seguida, digite o comando:

O resultado da execuo do programa Debug o demonstrado na captura de tela a seguir.

cdigos de mquina em hexadecimal.

Em seguida, pressione a tecla q (quit), e depois enter, para sair do programa.

Certamente, o cdigo em linguagem montadora muito mais simples do que os cdigos

Os programas de computador escritos em linguagem de alto-nvel so comumente cha-

Figura 7 Processo de compilao de um cdigo-fonte.

Na linguagem de programao C, por exemplo, o cdigo-fonte de um programa possui a

Claretiano - Centro Universitrio

Figura 8 Processo de compilao de um cdigo-fonte na linguagem de programao C.

Algumas linguagens de programao no executam o processo de compilao em seus c-