Linguagem de Programacao e Estruturas de

LINGUAGEM DE PROGRAMACA~ O E
ESTRUTURAS DE DADOS
BENEDITO MELO ACIO LY
VOLUME I
FTC 2001
2
Conteudo
1 INTRODUCA~ O:SOBRE LINGUAGEM DE PROGRAMACA~ O 5
1.1 Processamento de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Organizac~ao de um computador . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3 Sistema de programac~ao de apoio . . . . . . . . . . . . . . . . . . . . . . . 14
1.4 Construca~o de programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2 ALGUNS ALGORITMOS SIMPLES 21
2.1 Problemas usando o tipo abstrato de dados inteiro . . . . . . . . . . . . . . 21
2.2 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.3 Algoritmos estruturados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3 COMANDOS ESTRUTURADOS 45
3.1 Estruturas de decis~ao de selec~ao ou de alternativas . . . . . . . . . . . . . 58
3.2 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4 ALTERNATIVAS MU LTIPLAS 79
4.1 Selec~ao multipla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
4.2 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
5 PROGRAMACA~ O MODULAR 97
5.1 Procedimentos e func~oes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.2 Procedimentos e func~oes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
5.3 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
6 DADOS ESTRUTURADOS 119
6.1 Introduc~ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
6.2 Tipos abstratos de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
6.3 Tipos de dados basicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
6.4 O tipo matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
6.5 Variaveis e literais de string . . . . . . . . . . . . . . . . . . . . . . . . . . 141
6.6 Registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
3
4
CONTEUDO
6.7 Arquivos(File) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
6.8 Aplicac~oes de matrizes e registros . . . . . . . . . . . . . . . . . . . . . . . 153
6.9 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
Bibliograa 174
Captulo 1
INTRODUCA~ O:SOBRE
LINGUAGEM DE
PROGRAMACA~ O
O computador e um instrumento imprescindvel ao comercio, a industria e a pesquisa
cientca. Ele e um autômato que executa processos computacionais segundo regras pre-
1
cisamente estabelecidas. O computador possui um repertorio limitado de instruc~oes ele-

mentares que ele \entende" e e capaz de obedecer. Essas instruc~oes s~ao, porem, executadas
com rapidez e conabilidade extraordinarias. A utilidade do computador provem de sua
capacidade de executar sequências extremamente longas de instruc~oes, que se traduzem
em inumeras aco~es elementares. O ato de agrupar tais sequências de instruc~oes em \re-
ceitas" representando certa classe de processos computacionais e chamado programaca~o.
As ideias basicas sobre as quais se apoia a construc~ao de programas podem ser explicadas
e compreendidas sem qualquer referência ao computador.
A seguir apresentaremos algumas noc~oes basicas de programac~ao. Como elas s~ao
fundamentais, n~ao podem ser denidas formalmente em termos de outros conceitos. Ser~ao,
apenas, explicadas e ilustradas por meios de exemplos.
Ac~ao
Podemos dizer de uma aca~o que:
tem durac~ao nita;
tem um efeito esperado e bem denido;
1 Chamamos de automac~ao o processo em que uma tarefa deixa de ser desenvolvida pelo homem e
passa a ser realizada por uma maquina.
5
6 CAPITULO 1. INTRODUCAO:SOBRE
~ ~
LINGUAGEM DE PROGRAMACAO
subentende a existência de objetos sobre os quais ela e executada e cujo efeito e
reconhecido como mudancas de estado desses objetos;
pode ser descrita em termos de uma linguagem ou sistema de formulas;
sua descric~ao e chamada comando;
pode ser simples ou composta. Uma ac~ao composta e tambem chamada processo
2
ou computa
ca~o.
Se for possvel executar as partes de uma ac~ao composta em ordem cronologica ri-
gorosa, de modo que duas quaisquer delas nunca sejam executadas simultaneamente, o
processo e chamado sequencial.
Portanto, um programa e um comando que descreve um processo composto. Em outras
palavras, um programa e um conjunto de comandos cuja ordem em que s~ao escritos pode
n~ao coincidir com a ordem cronologica das ac~oes correspondentes.
Podemos dizer de um processador que
ele e a forca motriz que realmente executa as ac~oes, segundo comandos especcos;
ele pode ser um ser um humano ou um autômato.
Toda ac~ao requer uma certa quantidade de trabalho, dependendo do processador. Essa
quantidade pode ser expressa em termos do tempo gasto pelo processador para executar
a ac~ao. Esse intervalo de tempo, por sua vez, traduz-se mais ou menos diretamente em
uma medida de custo.Portanto, e importante conhecer o processador disponvel e, com
base nessa informac~ao, procurar a soluc~ao de menor custo.
Exemplo 1 (Multiplicac~ao)
Considere o comando:
multiplique os dois numeros naturais x e y;
denote seu produto por z: (1.1)
Se o processador disponvel entende este comando, isto e, ele sabe o que se quer
dizer por \numero natural" e por \multiplicac~ao", ent~ao qualquer elaborac~ao ulterior e
desnecessaria.
Suponha, porem, que o processador disponvel
1. n~ao entende sentencas em linguagem natural, e
2 Uma ac~ao e composta se ela puder ser decomposta em partes.
7
2. n~ao sabe multiplicar, mas, apenas, somar.
Um programa para manipular numeros(ou letras) usa nomes gerais representando
objetos variaveis. Esses nomes s~ao denominados variaveis. No incio de cada processo,
os valores especcos(2 ou 'a', por exemplo) s~ao atribudos a essas variaveis. Essa ac~ao de
atribui ao
c~ e fundamental nos processos computacionais executadodos por computador.
Uma variavel e comparavel a um quadro-negro: seu valor pode ser inspecionado(\lido")
tantas vezes quanto desejadas, ou pode ser apagado e reescrito. A ac~ao de reescrever, no
entanto, causa a perda do valor anteriormente escrito. A atribuic~ao de um valor k a uma
variavel v, sera denotado, de ora em diante, por
v k (1.2)
O smbolo e chamado operador de atribuic~ao.
O comando 1.1 pode, agora, ser denido formalmente por
z xy (1.3)
Se este comando for decomposto numa sequência de ac~oes que se sucedem cronolo-
gicamente, ent~ao a aca~o de multiplicac~ao torna-se um processo sequencial e o comando
1.3 toma a forma de um programa. Informalmente, descreveremos esse programa como
3
segue:
Passo 1 : z 0;
u x;
Passo 2 : repita as instruc~oes
z z+y
u u 1
ate que u=0.
Quando forem dados valores determinados a x e a y, o processo correspondente pode

ser visualizado registrando-se os valores atribudos as variaveis u e v, a propoc~ao que o
processo transcorre no tempo. Com x = 5 e y = 13, obtemos a tabela(de rastreio) a
seguir.
3 Por informalmente queremos signicar que n~ao estamos usando uma linguagem de programac~ao para
descrever esse programa.
~ ~
Passo valor de z valor de u
1 0 5
2 13 4
2 26 3
2 39 2
2 52 1
2 65 0
Pelo passo 2, o processo termina assim que u = 0. Neste instante, z assume o valor
nal 65 = 5 13. 4
Exemplo 2 (Divis~ao)
Considere as seguintes instruco~es:
1. divida o numero natural x pelo numero natural y;
2. denote o quociente inteiro por q e o resto por r.
A instruc~ao (2) pode ser expressa pelas seguintes relac~oes:
x=qy+r e 0r <y (1.4)

Introduzindo o operador de divis~ao div, a computac~ao pode ser descrita pelo seguinte
comando formal de atribuic~ao.
(q; r) x div y (1.5)

Novamente, para mostrar a possibilidade da transformac~ao do comando(constitudo
das duas instruc~oes acima) em programa, suponhamos que ele e destinado a um proces-
sador incapaz de dividir, isto e, sem o operador div. Vamos supor que o processador e
capaz de efetuar subtrac~oes. Portanto, divis~oes devem ser decompostas em sequências de
subtrac~oes.
Passo 1 : q 0;
r x;
Passo 2 : enquanto r y repita
q q+1
r r y
4Os objetos desta computac~ao s~ao numeros. Para se executar operac~oes sobre determinados numeros,
e necessario representa-los com uma notac~ao especca.
9
x e y denotam constantes que representam valores xados de antem~ao. Com x = 100
e y = 15 obtemos a seguinte tabela.
Passo valor de q valor de r
1 0 100
2 1 85
2 2 70
2 3 55
2 4 40
2 5 25
2 6 10
Ao se chegar a r < y o processo termina. Os resultados obtidos s~ao q = 6 e r = 10,
satisfazendo as relaco~es 1.4:
100 = 6 15 + 10 e 0 10 < 15 (1.6)
Os exemplos 1 e 2, descritos acima, s~ao processos sequenciais nos quais as atribuic~oes

s~ao feitas em estrita ordem cronologica. Nestas notas, assim como no curso de linguagem
de programac~ao 1, so discutiremos processos sequenciais, portanto, a palavra processo
signicara, para nos, processo sequencial.
Os exemplos que apresentamos mostram que todo programa descreve uma sequência
de mudancas de estados, do conjunto de suas variaveis. Se o programa for seguido duas
vezes, com diferentes valores de x e y, n~ao seria correto armar que os dois processos ou
computac~oes s~ao idênticos. No entanto, eles s~ao regidos pelo mesmo padr~ao de compor-
tamento. A descric~ao desse padr~ao de comportamento, indepentemente do processador
particular, e normalmente denominada algoritmo. O termo programa e mais apropriado
para aqueles algoritmos, t~ao elaborados, que podem ser seguidos ou executados por um
tipo particular de processador.
Para construir programas executaveis por computadores automaticos, o programador
deve possuir algum conhecimento do processador(computador). Quanto mais preciso for
o conhecimento que tiver do processador, melhor podera converter algoritmos em progra-
mas que utilizem as caracterscas partibulares desse processador. Por outro lado, quanto
mais ajustado e \sintonizado" ao processador for o algoritmo, maior o esforco dispendido
na elaborac~ao do programa. Embora n~ao pretendamos que o aluno sai conhecendo com
profundidade um computador, e fundamental que ele conheca as caracterstcas mais im-
portantes e comuns a maioria dos computadores. A seguir descreveremos o que vem a ser
o conceito de processamento de dados e a estrutura basica dos computares.
~ ~
1.1 Processamento de dados
Assim como a ideia de ac~ao, o conceito de informac~ao e primitivo. Entendemos que
5
uma informac~ao e capaz de transmitir um conhecimento. Para que haja transmiss~ao de

conhecimento, isto e, para que haja informac~ao, e necessario um emissor e um receptor.
O emissor emite os dados, enquanto o receptor recebe os dados, interpretando-os para
transforma-los em informac~ao. Os dados s~ao o suporte da informac~ao e representados por
meio de uma codicac~ao. Entretanto, para que haja informac~ao e preciso que o receptor
seja capaz de interpretar os dados atraves de uma decodicac~ao. A tarefa do computa-
dor e executar operac~oes com os dados, como, por exemplo, copiar, alterar, gravar, etc.
Dizemos, ent~ao, que o computac~ao executa processamento de dados.
Um computador digital e capaz de representar dois tipos de dados basicos: os numeros
e as letras de algum alfabeto(caracteres). Podemos citar como exemplos de processamento
de dados por um computador os seguintes.
Exemplo 3 1. Imprimir uma relac~ao de nomes em ordem alfabetica.
2. Elaborar uma folha de pagamento.
3. Achar a soluc~ao de uma equac~ao de 2o grau.
4. Imprimir os 50 primeiros numeros pares.
1.2 Organizac~ao de um computador

As partes principais de um computador s~ao o processador (tambem conhecida como uni-
6
dade logica-aritmetica) e a unidade memoria.
Memoria e Processador
partes principais do computador
Podemos armar que
1. a memoria abriga, em forma codicada, os objetos que ser~ao manipulados. Esses
objetos s~ao chamados dados. O desempenho da memoria e medido pela sua ca-
pacidade(tamanho) e pela velocidade como os dados s~ao nela armazenados e dela
retirados. A memoria tem sempre capacidade nita.
Um conceito e primitivo se ele n~ao pode ser explicado em termos de outros mais simples.
5
O processador e mais conhecido como unidade central de processamento(CPU-Central Processing
6
Unit) MEMORIA E CPU .

partes principais do computador
~ DE UM COMPUTADOR
1.2. ORGANIZACAO 11
2. O processador(unidade logica-aritmetica) executa adic~oes, multiplicac~oes, compa-
rac~oes, etc. Os dados s~ao buscados(lidos) na memoria para o processamento e, uma
vez obtido o resultado pela unidade logica-artimetica, armazenado novamente na
memoria(escritos).
O processador possui seus proprios elementos de memoria, chamados registradores.
Em cada instante eles contem, apenas, os dados a serem imediatamente processados.
Todos os outros dados s~ao deixados na memoria que, desse modo desempenha um papel
analogo ao de uma geladeira.
Para ilustrar como funciona o processamento na CPU, apresentaremos o calculo de
uma express~ao aritmetica, com varios operandos e resultados intermediarios.
Exemplo 4 Calcular a express~ao aritmetica
a b + c d: (1.7)
Para calcular essa express~ao usaremos, mais uma vez, a tecnica de decompo-
sic~ao de uma tarefa complicada em uma sequência de tarefas mais simples.
Usando essa tecnica, cada operac~ao aritmetica e efetuada sobre operandos to-
mados dos registradores do processador, com a subsequente substituic~ao, nos
registros, dos resultados. Assim
R1 a
R2 b
R1 R1 R2
z R1
R1 c
R2 d
R1 R1 R2
R2 z
R1 R1 + R2
onde R1 e R2 denotam registros do processador e z designa um resultado intermediario,
temporariamente depositado na memoria. O resultado nal esta no registro R1.
Desse modo, o calculo da express~ao foi transformado em um programa, consistindo de
três especies de instruc~oes ou comandos:
1. intruc~oes que buscam os operandos na memoria;
2. operaco~es(aritmeticas) atuando exclusivamente sobre os registros do processador;
~ ~
3. instruc~oes que depositam resultados na memoria.
Este exemplo mostra a necessidade de uma ntima conecc~ao entre o processador e a
memoria, pois e sempre muito grande o uxo de informac~oes entre essas duas unidades.
A memoria contem objetos acessveis atraves de nomes distintos(a, b, c, ...). Por isso
e preciso um criterio de disposic~ao dos elementos da memoria, parecido ao conjunto de
caixas de correspondência. Portanto, os objetos devem estar em um conjunto de posic~oes
de memoria identicados de modo unico, cada um deles possuindo um endereco. Todo
acesso a memoria deve ser acompanhado da especicac~ao do endereco da posic~ao de
memoria desejada.
As posic~oes de memoria tem como nalidade conter e preservar os objetos(dados). A
capacidade da memoria do computador de preservar dados n~ao e baseada no fato de que
ela abriga sicamente o objeto, mas porque certa codicac~ao do mesmo e representada
pelo o estado da posic~ao de memoria. Portanto, cada posic~ao de memoria deve ser capaz
de assumir um certo numero de estados. Nos computadores digitais os elementos de
memoria possuem somente dois estados distintos e, por isso, s~ao chamados elementos de
memoria binarios. Se um conjunto de n elementos de memoria binarios for agrupados, ele
podera assumir 2n diferentes combinac~oes de estados. Se este grupo for considerado como
uma unidade, ent~ao ela representara uma posic~ao de memoria com 2n estados possveis.
Exemplo 5 Codicac~ao de objetos em grupos de dgitos binarios.
Seja
x = bn :::b b
1 1 0 (1.8)
um numero binario qualquer, com n dgitos, na representac~ao posicional.7
A regra de codicaca~o desses numeros(iclusive o 0) e dada por
x = b + 2b + ::: + 2n bn
0 1
1
1 (1.9)
Esta regra n~ao e a unica possvel, mas, em muitos aspectos, e a mais adequada.
Ela e a mesma em que se baseia a representac~ao decimal desses numeros, isto
e, se
x = dm :::d d
1 1 0 (1.10)
Por exemplo, 1324 e um numero natural decimal representado na forma posicional. Aqui, o dgito
7
3, como ocupa a segunda posic~ao, da esquerda para a direita a contar de 0(portanto, a terceira posic~ao
contanto de zero), representa o valor 300.
~ DE UM COMPUTADOR
1.2. ORGANIZACAO 13
ent~ao,
x = d + 10 d + 10 d + ::: + 10m dm
0 1
2
2
1
1 (1.11)
Exemplo 6 Alguns numeros codicados em binario e decimal.
Binaria Decimal
1101 13
10101 21
111111 63
1101011 107
Podemos observar deste exemplo que posic~oes de memorias nitas, isto e, posic~oes de
memorias capazes de assumir somente um numero nito de estados diferentes, têm a pos-
sibilidade de armazenar somente numeros pertencentes a um intervalo nito de valores.
O numero de elementos binarios de memoria, reunidos sob uma unica posic~ao de memoria
enderecavel(palavra), e conhecido como comprimento de palavra do computador. Os va-
lores mais comuns de comprimentos de palavras s~ao: 8, 16, 32, 32 e 64, que correspondem
a conjuntos de 2n valores distintos, com n o comprimento da palavra.
Para que o computador tivesse um acesso \facil" a um programa, para poder segui-lo,
Jonh von Neumann teve a ideia de armazena-lo na memoria. Portanto, a memoria e usada
tanto para guardar os objetos(dados), como a \receita" do processo computacional(o
programa).
Como consequência do conceito de computador de programa armazenado, as instruc~oes
precisam tambem ser codicadas. No exemplo, 4 cada instruc~ao e representavel por
um codigo de operaca~o e em alguns casos por um operando. Se os operandos forem
8
representados por enderecos na posic~ao de memoria e se os enderecos forem numeros

inteiros 0, 1, 2, 3, ..., ent~ao o programa da codicac~ao de programas estara essencialemente
resolvido: todo programa sera representado por uma sequência de numeros(ou grupos de
numeros) e podera, portanto, ser depositado na memoria do computador.
Outra consequência do conceito de programa armazenado e que todo programa ocu-
para certo numero de posico~es de memoria, isto e, tomara certa porc~ao de memoria. O
numero de posic~oes de memoria ocupadas, e que n~ao estar~ao disponveis para armazena-
mento de dados, e proporcional ao comprimento do programa. Portanto, e importante ter
em vista que e \melhor" aquele programa, dentre os programas que executam a mesma
ac~ao, que seja mais conciso.
A seguir apresentaremos um resumo das func~oes de um computador que e baseado no
conceito de compartilhamento entre dados e programa.
8Para especicar o tipo de tarefa a ser executada, como leitura ou armazenamento de dados na
memoria, adic~ao, multiplicac~ao, etc.
~ ~
1. Assim que termina a execuc~ao de um programa P , um novo programa Q pode ser
aceito na memoria para subsequente execuc~ao( exibilida e vasta aplicabilidade).
2. Um computador pode gerar(segundo um certo programa) uma sequência de numeros
que ele subsequentemente considerara e interpretara como instruc~oes codicadas. Os
dados gerados na primeira etapa formam um programa a ser seguido na segunda.
3. Podemos instruir um computador X para considerar sequências de numeros repre-
sentando programas como se fossem dados, a serem transformados(segundo a algum
programa tradutor) em sequências de numeros representando programas codicados
para um outro computador Y.
Os dados, provinientes de um meio externo, s~ao \fornecidos" ao computador e arma-
zenados na memoria atraves dos dispositivos de entradas.
Os dados s~ao transmitidos da menoria para algum meio externo atraves dos disposi-
tivos de sada.
ENTRADAS
MEMORIA
/
E CPU SAIDAS
/
Alguns disposivos de entradas: teclado,disk driver.

Aguns dispositivos de sadas: monitor de vdeo, disk driver, impressora.
1.3 Sistema de programac~ao de apoio

Ate a decada de 60, programar consistia em fazer codicac~ao de longas sequências de
instruco~es. Inicialmente, estas codicac~oes eram escritas em alguma notac~ao simbolica,
como os numeros na forma binaria, octal ou hexadecimal. Hoje esse tipo de atividade
e denominada codicac~ao, para distinguir de programac~ao que abrange a tarefa mais
difcil de construc~ao de algoritmos. Com o aparecimento dos computadores mais rapidos
cou evidente as deciências desse processo de codicac~ao, dentre outras, pelas seguintes
raz~oes.
1. O codicador era forcado a ajustar o programa as caractrsticas particulares do
computador de que dispunha. Portanto, ele tinha que levar em conta todos os por-
menores da maquina, inclusive da organizac~ao de seu processador e de seu conjunto
de instruc~oes. O intercâmbio de programas entre diferentes maquinas era impossvel.
Por isso, grande parte do conhecimento dos metodos de codicac~ao para uma dada
maquina era praticamente inutil quando se passava para outro computador. Desse
modo, cada instituic~ao construia seus proprios programas e era forcada a desfazer-se
dos mesmo, e codicar novos, sempre que um novo computador tomava lugar do
antigo. Por tudo isso, cou evidente que a adaptac~ao e ajuste de algoritmos as
~ DE APOIO
1.3. SISTEMA DE PROGRAMACAO 15
caracterscas particulares de um computador especco representava um mal inves-
timento da inteligência humana.
2. A subordinac~ao do programador as peculiariddes de um tipo de computador possi-
bilitou e ate estimulou a invenc~ao e aplicac~ao de toda sorte de truques para obter o
maximo de desempenho da maquina. Enquanto essa \trucologia" estava em moda, o
programador dispendia um tempo apreciavel na construc~ao de programas \otimos",
cuja vericac~ao era geralmente muito difcil. Era praticamente impossvel descobrir
os princpios gerais de um programa construdo por outra pessoa. Muitas vezes,
era igualmente difcil explicar a estrutura de seus proprios programas. Esta arte
da codicac~ao perdeu atualmente quase toda a importância. O programador expe-
rimentado evita conscientemente o uso de truques, escolhemos, em contrapartida,
soluc~oes claras e sistematicas.
3. O chamado codigo de maquina continha, apenas, um mnimo de redundâncias a
base das quais erros formais de codicac~ao poderiam ser detectados. Consequente-
mente, mesmo os erros de digitac~ao, que poderiam ter efeitos desastrosos quando
da execuc~ao do programa, eram difceis de ser descobertos.
4. A representac~ao de um programa complexo como uma sequência linear n~ao estru-
turada de comandos e uma forma muito inadequada de uma pessoa descrever ou
compreender um processo complicado. A estruturac~ao do programa foi o primeiro
passo a ajudar o programador a sintetizar sistematicamente e a manter uma vis~ao
de conjunto de programas complicados.
Essas deciências levaram ao desenvolvimento das chamadas linguagens de progra-
mac~ao de \alto" nvel. Essas linguagens possilitaram os meios de instruir computador
imaginario, hipotetico, que e projetado n~ao segundo as limitac~oes da tecnologia atual,
mas, de acordo com os habitos e possibilidades de o homem expressar seus pensamentos.
Atualmente dispomos, ent~ao do seguinte cenario:
- de um lado, temos uma maquina A, que e economicamente exequvel, mas, cujo uso
n~ao e conveniente nem estimulante,
- de outro, um computador B que e adequado as necessidades humanas, mas existe,
apenas, no papel.
A ponte entre esses dois extremos e feita, atualmente, por uma entidade chamada (em
inglês)software (programac~ao de apoio). Em contrapartida, a maquina fsica e chamada
hardware. Um sistema de programa c~ao de apoio(sistema de softtware) e um programa
C, que, quando executado pela maquina real A, capacita A a traduzir programas escritos
para um computador hipotetico B, em programas para a maquina A. O programa C e
~ ~
chamado tradutor ou compilador. Ele permite que tudo se passe como se A fosse o
computador ideal B.
A utilizac~ao do compilador C alivia, assim, o programador da preocupac~ao de ter
sempre que levar em conta, em seus mnimos detalhes, as caractersticas particulares de seu
computador A. Isto n~ao libera da obrigac~ao do programador de estar permanentemente
consciente de que e a maquina A que, anal, executara os programas e, que ela tem
limitac~oes bem denidas, impostas por sua velocidade e capacidade de memoria nitas.
Normalmente, um sistema combinado de \hardware" e \software" processa um progra-
ma P em duas etapas distintas, que se sucedem cronologicamente. Na primeira etapa, P
e traduzido pelo compilador C numa forma interpretavel por A. Na segunda, o programa
traduzido e executado.
A esta ultima etapa chamamos execuc~ao e a primeira compilac~ao.
Compilac~ao: programa = compilador C
dados de entrada = programa P em linguagem B
dados de sada(resultados) = programa P na linguagem A.
Execuc~ao: programa = P na linguagem A
dados de entrada = argumentos X da computac~ao
dados de sada(resultados) = resultados Y da computac~ao.
1.4 Construc~ao de programas

Ja sabemos que
o processamento de dados e feito pela execuc~ao de programas e,
um programa e uma sequência de instruc~oes codicadas em uma linguagem de
programac~ao que,
para serem executadas precisam ser armazenadas na memoria de um computador.
Portanto, a seguinte pergunta: para que serve um programa?
A resposta seria, para resolver um problema. Esta resposta, por sua vez, suscita uma
outra pergunta: o que e um problema? Existem muitas pesquisas para tentar responder o
que um problema e. No nosso caso, estamos interessados em problemas computacionais,
aqueles relacionados com a manipulac~ao de informac~ooes.
Poderamos dizer que um problema envolve \uma pergunta de carater geral a ser
respondida". Segundo alguns autores, um problema e descrito quando especicamos a
entrada(quais s~ao os possveis dados) e as condic~oes(ou relac~oes) que a sada deve satisfazer
para uma determinada entrada.
Uma instância de um problema e obtida quando xamos determinados valores para
os dados de entradas.
~ DE PROGRAMAS
1.4. CONSTRUCAO 17
Os dados envolvidos em um problema pertencem a um determinado conjunto de valo-
res, que podem ser organizados de formas diferentes. A resoluc~ao do problema, em geral,
exige que sejam efetuadas operac~oes sobre os dados ou que sejam vericadas relac~oes entre
esses valores.
Essas considerac~oes nos permitem dizer que temos um tipo abstrato de dados
quando:
especicamos um conjunto de valores munidos de algumas operac~oes e relac~oes,
enfatizando o comportamento dos elementos desse tipo e,
desprezando os detalhes de representac~ao. 9
Ja sabemos que um programa de computador e descrito por uma linguagem de pro-
gramaca~o. Cada linguagem de programac~ao tem seus proprios tipos de dados, isto e,
conjunto de valores, operac~oes e relac~oes ja implementadas(disponveis para uso). Na
implementaca~o surge o conceito de domnio, isto e, da limitac~ao do conjunto de valores
dos elementos representados.
Os tipos de dados existentes nas linguagens de programac~ao podem representar el-
mente ou n~ao os dados idealizados(tipos abstratos de dados). Por isso, faremos distinc~ao
entre os tipos de dados abstratos, relacionados diretamente com o problema, e os tipos
de dados no nvel concreto, quando representamos as abstrac~oes na linguagem de progra-
mac~ao utilizada.
Durante a execuca~o do programa os dados s~ao armazenados na memoria do computa-
dor. As localizac~oes de memoria em que esses dados s~ao armazenados s~ao denominadas
estruturas de dados. As estruturas de dados s~ao organizadas conforme os tipos de da-
dos disponveis na linguagem de programac~ao, de forma que elas representem, o mais
elemente possvel, os tipos abstratos de dados em considerac~ao.
Tecnicas de programac~ao
Quando estamos elaborando algoritmos complexos precisamos utilizar metodos sistematicos
de programac~ao para obter programas conaveis, exveis e ecientes.
Uma proposta de metodologia estabelece os seguintes passos:
1. Analise do problema.
2. Projeto do programa: algoritmo e estrutura de dados.
3. Implementac~ao(codicac~ao) e teste do programa.
9 com isto queremos signicar que n~ao importa o nome do elemento nem sua representac~ao na memoria,
feita por uma linguagem de programac~ao.
~ ~
4. Vericac~ao do programa.
A seguir analisaremos, sucintamente, cada um desses itens propostos. E claro que cada
um desses itens se desdobram em um ou mais cursos. Por exemplo, o primeiro item pode
ser aprofundado num curso de analise de algoritmos, o item 2 em cursos como construc~ao
de programas e estruturas de dados, e assim por diante.
Analise do problema
Esta e a fase inicial na elaborac~ao de programas. Nesta fase procuramos
nos certicar que compreendemos o problema corretamente, sem ambiguidades,
nos assegurar que entendemos completamente as especicac~oes das entradas e das
sadas.
Para realizar esta fase precisamos seguir os seguintes passos:
1. escolher uma amostra signicativa dos dados e denir as especicac~oes de entrada;
2. determinar a sada desejada correspondente aos dados de entrada, denindo as es-
pecicac~oes de sada.
E bom observar que a escolha da amostra de entrada conrma a compreens~ao correta
do enunciado do problema.
Projeto do programa
Esta e a fase mais importante no desenvolvimento de programas. Aqui estudamos metodos
de resoluc~ao de problemas e estabelecemos estrategias para suas soluc~oes.
A partir da estrategia de resoluc~ao do problema desenvolvemos um algoritmo e de-
nimos as estruturas de dados que ser~ao utilizadas tendo em vista otimizar o binômio
espaco-tempo, isto e, visando obter um programa que apresente um tempo de execuc~ao
mnimo e com o melhor aproveitamento de espaco da memoria.
Como o algoritmo e um elemento importante nessa fase, a seguir apresentaremos
algumas de suas caractersticas e estrategias de construc~ao, necessarias neste estagio de
nosso estudo.
Algoritmo - intuitivamente, e uma sequência nita de instruc~oes ou operac~oes basicas 10
cuja execuc~ao, em tempo nito, resolve um problema computacional, qualquer que

seja sua instância. 11
10Estas operac~oes devem ser denidas sem ambiguidade e executaveis em tempo nito dispondo-se,
apenas, de lapis e papel.
11A ordena c~ao da sequência de instruc~oes do algoritmo e apoiada na estrategia estabelecida durante
a analise do problema. O desenvolvimento do algoritmo n~ao pode perder de vista os tipos de dados
considerados e a sua representac~ao.
~ DE PROGRAMAS
1.4. CONSTRUCAO 19
Desenvolvimento top-down - esta tecnica consiste em dividir o problema em varios
subproblemas de resoluc~ao mais simples. Para isso e preciso identicar partes ou
etapas na estrategia de resoluc~ao do problema, elaborando inicialmente um esboco
da resoluc~ao. Em seguida, e detalhada sucessivamente cada etapa, renando o
processo de resoluc~ao, ate chegar a uma sequência de operac~oes basicas sobre os
tipos de dados considerados.
Descri ao - um algoritmo pode ser descrito quer atrav
c~ es de um pseudocodigo(linguagem
algortmica) quer atraves de uxogramas. No uxograma, cada operac~ao basica(instruc~ao)
12
e representada por um desenho. Na linguagem algortmica cada operac~ao basica e

escrita em uma linguagem semelhante a linguagem natural, com algumas regras
comuns as linguagens de programac~ao.
Implementac~ao
Denominamos implementac~ao de um algoritmo a sua codicac~ao em uma linguagem de
programac~ao.
O algoritmo pode ser implementado em qualquer linguagem de programac~ao. Essa
implementaca~o pode ser muito \facil", consistindo, em geral, numa transcric~ao de ope-
rac~oes basicas. A implementac~ao se torna mais trabalhosa dependendo das caractersticas
da linguagem escolhida e dos tipos de dados nela denidos.
Vericac~ao de Programas
A vericac~ao de um programa tem como objetivo demonstrar que o algoritmo realmente
resolve o problema proposto, qualquer que seja sua instância. Este topico e considera-
do bastante mais avancado, requerendo do aluno muita maturidade, assim como base
matematica e logica.
12Os uxogramas s~ao preferveis nos casos onde e preciso uma visualizaca~o global do processo de
resoluc~ao e de suas partes. Por outro lado, a linguagem algortmica apresenta outras vantagens: em
geral, e mais facil escrever do que desenhar e a codicac~ao em uma linguagem de programa acaba se
tornando uma simples transcric~ao de palavras-chave.
~ ~
Captulo 2
ALGUNS ALGORITMOS SIMPLES
Introduc~ao
Ja sabemos que um programa deve consistir de comandos formulados em notac~ao que
o computador \entenda". Embora n~ao saibamos ainda que especies de comandos ou
formulas uma linguagem de programac~ao deva possuir, certamente sabemos que esses
comando especicar~ao as ac~oes pretendidas. Essa necessidade de precis~ao provalemente
constitui o traco mais caracterstico que distingue a comunicac~ao entre seres humanos da
comunicac~ao com maquinas. Lidar com computadores exige precis~ao e clareza. Incerteza
e ambiguidade s~ao abosolutamente proibidos.
Nesta parte das notas de aula, desenvolveremos algoritmos onde procuraremos seguir,
na medida de nossa base matematica, as etapas recomendadas na construc~ao de programas
visto em outra parte. Na etapa da implementac~ao poderamos usar qualquer linguagem
1
de programac~ao, mais amplamenente utilizada, como C, C++ ou Java. Usaremos o C++,

sem, no entanto, explicar neste texto as caractersticas desta linguagem. O aluno deve
seguir um outro texto de linguagem C++ ou ja conhecer esta linguagem para tirar proveito
da fase de implementac~ao. Caso o aluno n~ao conheca C++ ou n~ao esteja interessado em
conhece-la pode, simplesmente, pular a fase de implementac~ao.
2.1 Problemas usando o tipo abstrato de dados in-

teiro
Nesta sec~ao so consideraremos problemas sobre a estruturas dos numeros inteiros, pro-
blemas com outros tipos ser~ao considerados mais adiante. A seguir apresentaremos uma
1N~ao abordaremos certos aspectos do desenvolvimentos de algoritmos como, por exemplo, vericac~ao
e analise de eciência(complexidade). Como so abordaremos problemas muito simples, a fase de projeto
ca muito simplicada, parecendo ate desnecessaria.
21
22 CAPITULO 2. ALGUNS ALGORITMOS SIMPLES
Tipo abstrato inteiro
Objetos: numeros inteiros
Operac~oes/Notac~ao: adic~ao +
subtrac~ao -
multiplicac~ao
quociente inteiro div
resto da divis~ao mod
Relac~oes/Notac~ao menor <
maior >
diferente 6=
menor ou igual
maior ou igual
Objetos constantes numerais inteiros com
ou sem sinal por exemplo,
-34, 13, 0
Figura 2.1: Tipo abstrato inteiro
tabela do tipo abstrado numero inteiro, com suas operac~oes e relac~oes.
Exemplo 7 Enunciado do problema: Calcular a soma de dois numeros in-

teiros.
1. Analise(do problema): lembramos que na fase de analise do problema
devemos especicar a entrada, a sada e, uma relac~ao entre a entrada
e a sada, a qual chamaremos de metodo. Observe que a analise do
problema consiste da sua especicac~ao, segundo a denic~ao que apre-
sentamos na primeira parte. E bom observar que exitem varios formas
de especicac~ao: informal(usando linguagem natural e, quando muito,
matematica), temos a especicac~ao formal, usando logica ou algebras es-
peccas, ou podemos usar uma linguagem(executavel pelo computador)
de especicac~ao. Esta fora de proposito, aqui, uma especicac~ao que n~ao
seja informal, caso contrario teramos de fazer um curso de especcac~ao.
(i) Entrada: um par de numeros inteiros.
(ii) Sada: um numero inteiro.
(iii) Metodo: recebe um par de inteiros e devolve um inteiro.
2. Projeto: Lembramos que na fase do projeto devemos quebrar, tanto
quanto possvel, o problema em problemas \menores" cuja soluc~ao seja
2.1. PROBLEMAS USANDO O TIPO ABSTRATO DE DADOS INTEIRO 23
absolutamente obvia. Embora esse problema seja muito simples, ele pode
ser quebrado em três subproblemas ainda mais simples e basicos.
(1) Leia dois numeros inteiros. Leitura de dados.
(2) Some dois numeros inteiros. Soma dos valores lidos.
(3) Devolva o resultado. Por exemplo, imprima o resultado, ou apresente
o resultado no visor, etc.
3. Implementaca~o: Codicar na linguagem C++.
E claro que para chegarmos na fase de implementac~ao devemos desenvolver comple-
tamente o algoritmo, de modo que esta fase seja uma simples transcric~ao da linguagem
algortica para a linguagem de programac~ao. Na medida em que formos desenvolvendo a
fase de projeto iremos apresentando a nossa linguagem algortmica. Somente quando o
algoritmo estiver completamente projetado voltaremos a fase 3, de implementac~ao.
Continuando o projeto, para ler dois numeros, de (1), precisamos de duas variaveis
A e B , onde colocar os dois valores lidos. A ac~ao de colocar(atraves da leitura) os dois
inteiros nas variaveis A e B sera denotado por
leia(A,B)
Usaremos a variavel \soma" para colocar o resultado da adic~ao. Como estamos usando
o smbolo para denotar atribuic~ao, o item (2), do projeto tem a seguinte descric~ao:
soma A + B
Finalmente, para representar a sada de informac~oes, correspondente ao item (3) do
projeto, utilizaremos a instruc~ao de sada:
imprima(soma)
Essas três instruc~oes, escritas sequencialmente, nessa ordem, descrevem o projeto do
2
algoritmo de resoluca~o do problema proposto. Podemos escrevê-las na mesma linha, como

a seguir, ou em linhas diferentes, com a separac~ao entre uma instruc~ao e a seguinte sendo
feita por um ponto e vrgula:
2Do ponto de vista logico, um algoritmo e constitudo por três estruturas logicas: sequenciamen-
to(sequencial), repetic~ao(repetitiva) e selec~ao(seletiva). Portanto, um algoritmo pode ser constitudo por
qualquer combinac~ao dessas três estruturas. O algoritmo que estamos considerando tem uma estrutura
sequencial, as ac~oes que resolvem o problema, s~ao efetuadas em ordem sequencial, e na ordem em que
aparecem no algoritmo. Mais adiante veremos algoritmos com estruturas logicas alem da sequencial.
N~ao confundir sequencial, enquanto estrutura logica do algoritmo, com o conceito, visto noutra parte, de
algoritmo sequencial, em contrapartida a algoritmo paralelo.
leia(A,B); soma(A,B); imprima(A,B);
ou
leia(A,B);
soma(A,B);
imprima(soma)
A rigor, ao descrever um algoritmo, devemos especicar o seu objetivo, quais s~ao os
dados de entradae/ou sada, alem das instruc~oes que o comp~oem. Devemos, tambem,
dar um nome que identique o algoritmo. Finalmente, o nosso algoritmo deve tomar a
seguinte forma:
Algoritmo adic~ao
Objetivo: dados dois numeros inteiros, calcular sua soma.
Entrada: A, B(inteiros).
Sada: soma(Inteiro)
Adic~ao();
leia(A,B);
soma A + B ;
imprima(soma);
Apos o nome adica~o, que identica o algoritmo, colocamos uma par de parênteses.
Mais adiante, colocaremos parâmetros entre esses parênteses.
Finalmente, apresentamos a implementac~ao.
Implementac~ao
#include <iostream.h>
void main()
{
int A, B, soma;
cin >> A >> B ;
cout << soma = A + B << endl;

}
2.1. PROBLEMAS USANDO O TIPO ABSTRATO DE DADOS INTEIRO 25
Exemplo 8 Enunciado: Dado um numero inteiro obter seu ultimo algarismo
da direita.
1. Analise:
Entrada : Um numero entre 0 e 9999.
Metodo: Escrevendo o numero no sistema decimal, o ultimo algaris-
mo da direita representa as unidades. Para obter esta unidade basta
dividir o numero por 10. Logo, o metodo e: calcule o resto da divis~ao
do numero por 10.
Sada: O resto da divis~ao de um numero por 10.
2. projeto: O problema e divido nos seguintes subproblemas.
leia um numero inteiro A, entre 0 e 9999.
calcule A mod 10.
imprima o resultado.
Portanto, temos o seguinte algorimo.
Algoritmo ultimo
Objetivo: Obter o ultimo algarismo de um numeero dado.
Entrada: A(inteiros).
Sada: ultimo(Inteiro)
ultimo();
leia(A);
unidade A + B ;
imprima(unidade);
Implementa
c~ao.
void main()
{
int A, unidade;
cin >> A;
unidade = A % 10;
cout << unidade << endl;

}
Em cada um dos execcicios, abaixo, fazer analise do problema, o projeto do algoritmo

e a implementac~ao em C++.
2.2 Exerccios
1. Dado um numero inteiro de três algarismos, inverter a ordem de seus algarismos.
Os três algarismos do numero dado s~ao diferentes.
2. Dado um numero de três algarismo construir outro numero de quatro algarismo de
acordo com a seguinte regra:
(a) os três primeiros algarismos, contados da esquerda para a direita, s~ao iguais ao
do numero dado;
(b) o quarto algarismo e um dgito de controle calculado da seguinte forma: pri-
meiro algarismo + segundo algarismo 3 + terceiro algarismo 5; o dgito de
controle e igual ao resto da divis~ao dessa soma por 7.
3. Dado um numero inteiro de segundos, determinar o seu valor equivalente em graus,
mimutos e segundos. Se a quantidade de segundos for insuciente para dar o valor
em graus, o valor em graus deve ser zero. A mesma observac~ao continua valida em
relac~ao a minutos e segundos. Por exemplo, 3.600 segundos = 1 grau, 0 minutos, 0
segundos; 3500 segundos = 0 graus, 58 minutos, 20 segundos.
4. Dadas duas frac~oes ordinarias a=b e c=d, determinar a sua soma e o seu produto.
5. Dado um numero inteiro que representa um numero binario de cinco dgitos, deter-
minar o seu equivalente decimal
6. Dado o primeiro termo e a raz~ao de uma prograss~ao aritmetica, determinar a soma
de seus primeiros cinco termos.
2.3 Algoritmos estruturados

Express~oes e comandos
Uma express~ao e uma combinac~ao de variaveis, constantes e operadores que, uma vez
avaliada, resulta um valor. Por exemplo,
2.3. ALGORITMOS ESTRUTURADOS 27
(b h) :
2
Portanto, uma express~ao consiste de operandos e operadores. Os operandos s~ao ou
constante(por exemplo, numeros), ou variaveis, ou valores gerados por func~oes. Usual-
mente, os operadores se classicam como unarios, como -, e binarios, como + e . A
linguagem C++ possui um operador ternario, ?:. Sua sintaxe , em geral, possui a seguinte
3
construc~ao: expr1 ? : expr2 : expr3. A semântica desse operador e a seguinte: A expr1 e

4
avaliada primeiro. Se seu valor for diferente de zero(verdadeiro), a expr2 e avaliada e seu
resultado sera o valor da express~ao condicional toda. Se expr1 for zero(falsa), a expr3
sera avaliada e seu valor sera o valor da express~ao condicional como um todo.
Se varios operadores ocorrem em uma express~ao, e preciso ser especicada uma or-
dem de execuc~ao, ou pelo emprego explcito de parênteses, ou por regras implcitas na
linguagem. Na maioria das linguagens, os operadores binarios se subdividem em aditivos
e multiplicativos. Aos ultimos e atribuda prioridade mais alta. Suporemos, tambem, que
os operadores de igual prioridade ser~ao sempre executados da esquerda para a direita.
Estas regras simples s~ao ilustradas nos exemplos a seguir:
x+y+z = (x + y) + z
xy+z = (x y) + z
x+yz = x + (y z)
x y z w = (x (y z)) w
x y z w = (x y) (z w)
x + y=z = ( x) + (y=z)
x y=z = (x y)=z
x=y z = (x=y) z
Quanto ao tipo de dados dos operandos, as express~oes podem ser:
aritmeticas: quando os operandos s~ao aritmeticos(inteiros ou reais).
logicos: quando os operandos s~ao valores verdades, falso ou verdadeiro.
literais: quando os operandos s~ao letras ou palavras. Por exemplo, a express~ao
constituda do operador de concatenac~ao(+) e as palavras \sonha" e \dor" . \sonha"
+ \dor" resulta \sonhador". 5
3 Chamamos sintaxe a forma como comandos e express~oes na linguagem devem ser escritos a m de
que possam ser entendidos pelos tradutores de programas(interpretadores e copiladores.)
4 A semântica de um programa e o seu signicado, isto e, o conjunto de ac~oes efetuadas pelo compu-
tador duranto a execuc~ao do referido programa.
5 Mais detalhes, sobre operadores, express~
oes logicas e literais, ver o livro de Viviane, captulo 2, sobre
operadores.
A forma mais elementar de comando e o comando de atribuic~ao. Ele e representado
por
V E
onde V denota uma variavel e E , uma express~ao. Este comando indica que E deve
ser calculado e, ent~ao, seu valor atribudo a V . Sempre que a express~ao E assumir um
valor o camando tem um efeito.
Ja observamos que o comando fundamental de qualquer programa e o comando de
atribuic~ao. Ou seja, o efeito do comando de atribuic~ao e uma ac~ao simples, precisamente
o de tornar o valor da variavel V igual ao valor da express~ao E . Outras dois comandos
basicos s~ao: o comando de leitura de dados, por exemplo, leia(A), no exemplo 24, e o
comando de sada de dados, por exemplo, imprima(soma), no exemplo 24.
As ac~oes compostas, que s~ao efeitos de comandos compostos, podem ser classicadas
em três tipos basicas: sequenciais, repetivas e alternativas. Os comandos correspon-
tes(sequenciais, repetitivos e condicionais) s~ao conhecidos como comandos estruturados. 6
Existes seis formas basicas desses comandos estruturados: uma forma sequencial, duas
repetitivas ou formas de laco(para e enquanto) e três na forma alternativa( se ...ent~ao
...; se ...ent~ao ..., sen~ao ... e caso i de L1:S1; ...;ln:Sn ). A seguir estudaremos cada um
desses como comando, procurando ilustra-los com exemplos.
Estrutura sequencial
Na estrutura sequencial cada comando e executado somente apos o termino do comando
anterior. Ele tem a forma
In
cio
comando1;
comando2;
:
:
:
comandoN ;
fim
O separador \;" e um operador de continuac~ao. Ele ocasiona a execuc~ao do comando

subsequente, porem, somente apos terminada a execuc~ao do comando precedente. As
6 Esses comandos s~ao tambem conhecidos como controle de uxo de execuc~ao.
palavras incio e fim est~ao representando, aqui, o comeco de um bloco de comandos,
que e uma nova unidade ou comando composto. Comandos compostos podem, as ve-
7
zes, se constituir de um grande numero de comando basicos ou elementares, assumindo

tamanho consideravel. E , por isso, aconselhavel que se destaque, visivelmente, os coman-
dos parênteses(incio e fim), para, assim, se visualizar os agrupamentos de comandos
constituintes do comando composto.
Os exemplos 24 e 25, vistos anteriormente, s~ao exemplos de estruturas sequeciais.
Alias, qualquer programa que estudaremos, como ja observamos na primeira parte destas
notas, e uma estrutura sequencial. O que distingue os dois exemplos citados e que eles eles
somente s~ao constitudos por um uxo de controle sequencial, isto e, n~ao existe nenhum
comando na sequência, que por sua vez, tenha uma estrutura repetitiva ou alternativa,
como teremos oportunida de observar em outros programas, mais adiante.
Estruturas de repetic~ao(lacos ou loops)

A estrutura de laco repete um trecho de programa um certo numeros de vezes. Essa
estrutura se subdivide em dois tipos:
1. Estrutura de la
co com vari
avel de controle e,
2. Estruturas de la
cos condicionais.
Procuraremos entender essas duas estruturas atraves de exemplos.

Repetic~ao com variavel de controle
Sintaxe:
para < var > de <incio> ate < final > repita
< comando composto >;
fim-para
Semântica: deveremos ter o seguinte entendimento desse trecho de programa.

Dê um valor inicial a variavel < var >, no incio;
dê um valor nal a variavel < var >;
enquanto a variavel < var > percorrer do valor inicial ate o valor nal(inclusive o
valores inicial e nal) execute o bloco < comando composto >. 8
7Existe outras formas de indicar o incio e o m de um bloco ou corpo de comandos, como veremos
mais adiante. Esses duas palavras tambem s~ao conhecidas como comandos-parênteses.
8E claro que o comando < comando composto > pode ser constitudo de um unico comando basico.
Exemplo 9 Enunciado: Obter a soma dos n primeiros numeros pares posi-
tivos.
Analise: Os exemplos abaixo nos ajuda a entender o enunciado do problema:
n = 6 ! 2 + 4 + 6 + 8 + 10 = 42
n = 3 ! 2 + 4 + 6 = 12
n=2 !2+4=6
Obs: Todo numero par inteiro positivo pode ser escrito na forma 2i, onde
i 2 N = f1; 2; 3; :::g e a soma dos n primeiros numeros pares pode ser obitido
pela formula:
X
n
S= 2i
i=1
Para calcular essa soma basta guardar cada resultado parcial obtido e somar
este ultimo resultado acumulado ao numero par seguinte, repetindo esta ope-
rac~ao ate o ultimo numero. Portanto, podemos dizer que
Entrada: um numero natural positivo, n;
Sada: um numero natural positivo, o resulto da soma;
Metodo: A cada numero natural positivo devolve um numero natural po-
sitivo.
Projeto:
As estruturas presentes neste algoritmo s~ao, ent~ao, a sequencial e a repetitiva.
Um esboco do algoritmo seria
Esbo
co do algoritmo
entrada de dados(valor de n)
repetir n vezes calcular um numero par
acumular numa soma
sada do resultado
Podemos detalhar a estrategia:
para cada valor de i 2 f1; 2; 3:::; ng, calculamos o numero par. t, corres-
pondente e,
adicionamos o valor da soma S , previamente denida com valor zero.
Ou seja, devemos repetir n vezes as duas operac~oes:
calcular o numero par t, pela formula t = 2i e,
somar t em S .
Vamos representar essa operac~ao de repetic~ao por
para i de 1 ate n repita < bloco >

onde bloco e uma sequência de uma ou mais instruc~oes: e o laco desse coman-
do de repetic~ao. Dizemos que essa instruc~ao(operac~ao basica) e uma instruc~ao
de repetic~ao controlada por variavel.
Finalmente, o algoritmo tem a seguinte redac~ao:
Algoritmo somaDePares()
Objetivo: Dado um numero n, calcular a soma dos n primeiros numeros
pares.
Entrada: n(inteiro).
Sada: S (inteiro).
somaDePares()
leia(n);
S 0;
para i de 1 n ate repita tS 2S+i;t;
imprima(S );
A instruca~o de repetica~o, presente neste algoritmo, e controlodada pela variavel

i que e denominada variavel de controle da instruc~ao. A variavel i recebe o
valor inicial 1 e e incrementada de uma unidade ate atingir o valor nal n.
Enquanto o valor de i for maior ou igual que o valor de n, as instruc~oes
contidas no bloco s~ao executadas sucessivamente. Para cada valor atribudo
a i, se esse valor n~ao superar n, as instruc~oes do bloco s~ao executadas e,
em seguida, o valor de i e incrementado de uma unidade. As instruc~oes que
constituem o bloco fazem o \loop"(laco, malha, anel) da instruc~ao.
O numero de repetic~oes no laco esta previamente determinado pelo valor ini-
cial e pelo valor nal da variavel de controle. Nesse exemplo, o laco e execu-
tado
valor final valor inicial = n 1 + 1 = n vezes

Implementa
ca~o.
void main()
{
int i, n, t, S; // declara as vari
aveis.
cout << `Èntre com um valor n" << endl;
cin >> n;
for(i=1; i<=n; i++)

{
t = 2*i;
S= S + t;
}
cout << S << endl;

}
Exerccios
1. Calcular o fatorial de n (n!).
2. Mesmo problema naterior, porem, agora n! = n (n 1) ::: 2 1:
3. (i) Ache a soma de 10 numeros fornecidos pelo usuario.
(ii) Imprima os numeros pares entre 20 e 50.
Exemplo 10 Enunciado: Imprimir os n primeiros numeros mpares positi-
vos.
An
alise
Este problema e analogo ao anterior.

Sada: um numero natural positivo mpar;
Metodo: A cada numero natural positivo de entrada devolve um numero
mpar impresso(no visor).
Projeto
Cada numero mpar pode ser escrito pela formula 2i 1, com i=1,2,3,... Para
que cada numero mpar calculado seja impresso, o laco deve conter a instruc~ao
de sada. A seguir apresentamos um esboco do algoritmo.
Esbo
co do algoritmo
entrada de dados(valor de n)
repetir n vezes calcular um numero mpar t
imprimir t
Finalmente, o algoritmo tem a seguinte redac~ao:

Algoritmo imprimeImpares
Objetivo: Dado um numero n, imprimir os n primeiros numeros mpares.
Sada: t(inteiro).
imprime
Impares()
leia(n);
2 i 1;
para i de 1 ate n repita timprima (t);
Implementa
c~ao.
void main()
{
int i, n, t; // declara as vari
aveis.
cin >> n;
for(i=1; i<=n; i++)

{
t = 2*i-1;
cout << t << endl;
}
}
Exemplo 11 Enunciado: Imprimir os n primeiros numeros mpares em or-

dem oposta.
An
alise
Analogo o problema anterior, pois isso deixamos de apresentar.
Projeto
Geramos os numeros mpares desde o n-esimo ate o primeiro. A medida que

eles s~ao gerados, eles s~ao impressos. Utilizaremos a instruc~ao para-repita
com acressimo unitario negativo para descrever um laco em que a variavel de
controle assume valores na ordem decrescente.
n; n 1; :::; 3; 2; 1
Vamos indicar essa ordem escrevendo passo -1, antes da palavra repita:
para i de n ate 1 passo 1 repita < bloco >
A vers~ao nal do algoritmo pode escrito como segue.
Algoritmo imprimeImparesInvertidos
Objetivo: Dado um numero n, imprimir os n primeiros numeros mpares na
ordem oposta.
Sada: t(inteiro).
imprime
ImparesInvertidos()
leia(n);
2 i 1;
para i de n ate 1 repita timprima (t);
Implementa
c~ao.
void main()
{
int i, n, t; // declara as vari
aveis.
cin >> n;
for(i=n; i>=1; i--)

{
t = 2*i-1;
cout << t << endl;
}
}
Exemplo 12 Enunciado: Imprimir os n primeiros termos da sequência
yk = yk + 2; :::; com y = 1
+1 1
An
alise

Sada: uma sequência de numeros naturais;
Metodo: A cada numero natural positivo n, de entrada, devolve uma
sequência de numeros naturais.
Vejamos para n = 5. O primeiro termo e denido pela condic~ao inicial e os
demais s~ao calculados pela relac~ao de recorrência dada:
y1 =1
y2 =y 1 +2=3
y3 =y 2 +2=5
y4 =y 3 +5=7
y5 =y 4 +7=9
Projeto:
Cada termo da sequência e igual a soma do termo anterior com a constante 2.

O primeiro termo e dado e todos os demais s~ao calculados a partir dessa regra.
No exemplo acima, desejavamos obter os cinco primeiros termos da sequência.
Por isso, calculamos quatro valores y2; y3; y4 e y5 porque o primeiro termo, y1 ,
da sequência e dado e n~ao calculado.
Todos os 5 termos devem ser impressos. Portanto, assim que um elemento
for obtido ele deve ser impresso.
De uma forma geral, para imprimir os n primeiros termos, devemos imprimir
o primeiro, que e dado, e depois calcular e imprimir os n 1 termos seguintes,
conforme ilustramos no seguinte esboco do algoritmo:
Esbo
co do algoritmo
leia n
dena o primeiro elemento
imprima o primeiro elemento
para i de 1 ate n-1 repita calcule o elemento seguinte
imprima esse elemento
Observe que n~ao e necessario guardar todos os elementos da sequência. Po-

demos calcular cada um deles pela relac~ao de recorrência dada e imprimir o
valor calculado. A mesma variavel y que armazena o primeiro termo pode
ser utilizada para todos os demais, tendo o seu valor sucessivamente alterado
atraves da instruc~ao y y + 2.
A vers~ao nal do algoritmo e portanto:
Algoritmo numerosImpares
Objetivo: Imprimir os n primeiros termos da sequência
yk = yk + 2; k = 1; 2; 3; :::; com y = 1
+1 1
Sada: y (inteiro).
umeros
n Impares()
leia(n);
y 1; imprima(y);
para i de 1 ate n 1 repita yimprima
y + 2;
(y);
Observe que a sequência denida pela relac~ao de recorrência dada, dene em

yk o k-esimo numero mpar. Desse modo, atraves dessa relac~ao de recorrência
podemos gerar os n primeiros numeros mpares.
Implementa
c~ao.
void main()
{
int i, y, n; // declara as vari
aveis.
cin >> n;
y = 1;
cout << y << endl;
for(i=1; i<=n-1; i++)

{
Tipo abstrato real
Objetos: numeros racionais
Operac~oes/Notac~ao: adic~ao +
subtrac~ao -
multiplicac~ao
divis~ao /
Relac~oes/Notac~ao menor <
maior >
diferente 6 =
menor ou igual
maior ou igual
Objetos constantes numerais racionais ponto xo(13.5, 45.0)
ou em ponto utuante com ou sem sinal
6.023E54, -1.23E-2
Figura 2.2: Tipo abstrato real
y=y+2;
cout << y << endl;
}
}
Denic~ao 1 Dizemos que dois algoritmos s~ao equivalentes quando para uma mesma en-
trada produzem a mesma sada.
Observe que os algoritmos 18 e 21 s~ao equivalentes, segundo essa denic~ao.
Tipo abstrato de dados real
A implementac~ao do tipo inteiro, assim como do tipo real, em uma linguagem de

programac~ao exige a denica~o de um domnio, isto e, um conjunto nito de inteiros ou
racionais, no caso de racionais escritos com uma quantidade nita de algarismos sig-
nicativos. Consequentemente, durante a computac~ao pode haver estouro(over ow) e,
portanto, aproximac~ao dos valores exatos dos resultados.
Exemplo 13 Enunciado: A sequência9
Um processo iterativo e denido por uma relac~ao de recorrência que relaciona dois ou mais valores
9
consecutivos. Os valores calculados pela formula de recorrência chamam-se valores iterados. O processo
iterativo, denido pela formula de recorrência do exemplo 22, e umapaplicac~ao do metodo de Newton-
Raphson para o calculo de valores aproximados das razes de f(x) = x.
xn = 12 (x + xA ); x = 1; n 2 N
+1 0
n
converge para a raz quadrada de A, sendo A > 0. Calcule um valor aproxi-
mado da raz quadrada de A, atraves de 5 iterac~oes.
An
alise
Entrada: um numero real positivo, A;

Sada: um numero real positivo que represente um numero real aproxi-
mado da raz quadrada de A;
Metodo: A cada entra da um numero real positivo A, devolve um numero
real.
Vamos ilustrar o processo para A = 2, considerando-se os racionais escritos

com ate 10 algarismos signicativos:
x 0=1
x 1= (x + x0 )=2 = 1; 5
0
2
x 2= (x + x1 )=2 = 1; 416 666 667

1
2
x 3= (x + x2 )=2 = 1; 414 215 686

2
2
x 4= (x + x3 )=2 = 1; 414 213 562

3
2
x 5= (x + x4 )=2 = 1; 414 213 562

4
2
O valor da raz quadrada de 2, obtido atraves da quinta iterac~ao do processo

iterativo denido pela relac~ao de recorrência anterior, e 1; 414 213 562:
Esbo
co do algoritmo
entrada de dados(valor de A)
denic~ao do valor inicial de x
para i de 1 ate 5 repita calcular x
sada do resultado
Observe que somente o ultimo valor calculado deve ser impresso, por isso a
instruc~ao de sada deve ser colocada fora do laco. A variavel identicada por
x devera assumir, sucessivamente, o valor dos cinco primeiros elementos da
sequência gerada pela relac~ao de recorrência dada.
Portanto, o algoritmo tem o seguinte aspecto.
Algoritmo razQuadrada
Objetivo: Calcular um valor aproximado da raz quadrada de um
numero real dado.
Entrada: A(real).
Sada: x(real).
ra
zQuadrada()
leia(A);
x 1;
para i de 1 ate 5 repita x (x + Ax )=2
imprima(x)
Implementa
c~ao.
void main()
{
int x, A; // declara as vari
aveis.
cout << `Èntre com um valor para A " << endl;
cin >> A;
x = 1;
for(i=1; i<=5; i++)

{
y= (x+A/x)/2;
}
cout << x << endl;
}
Exemplo 14 Enunciado: Usando a relac~ao a relac~ao de recorrência denida

no exemplo 22, anterior, obter uma tabela de razes quadradas dos numeros
inteiros de dois 2 a 10. O valor aproximado de cada raz deve ser obtido
atraves de 5 iterac~oes.
An
alise
Entrada: valores inteiros de A de 2 a 10;
Sada: uma tabela de numeros reais positivos que representam numeros
reais aproximados da razes quadradas de A, de 1 a 10;
Metodo: A entrada dos numeros inteiros positivos A de 1 a 10, devolve
uma tabela de numeros realis.
Projeto:
Esbo
co do algoritmo
calcule a aproximac~ao x da raz quadrada de A

para i de 2 ate 10 repita sada do resultado
Algoritmo tabelaDeRazQuadrada
Objetivo: Obter uma tabela de raz quadrada dos numeros inteiros
de 2 a 10.
Entrada: Os dados de entrada s~ao gerado pelo proprio algoritmo,
sendo armazenado em A.
Sada: (inteiro), x(real).
tabelaDeRa
zQuadrada()
x 1;
para i de 2 ate 10 repita para i de 1 ate 5 repita x (x + A )=2;
2
imprima(A; x);
Exerccios
Em cada um dos exerccios proposto deve ser feita a analise do problema, o projeto do
algoritmo e a implementac~ao.
1. Considere a progress~ao geometica(PG) 1, 2, 4, 8, 16, 32,..., e um inteiro positivo n.
Pedimos que:
a) Imprima os n primeiros termos.
b) Calcule e imprima a soma dos n primeiros termos da PG sem utilizar a formula
da soma.
2. Imprimir os n primeiros termos das sequências denidas pelas relac~oes de recorrência:
(a) yk +1 = yk + k; k = 1; 2; 3; :::; y = 11
(b) yk +1 = yk + (2k + 1); k = 0; 1; 2; :::; y = 1 0
(c) yk+1 = yk + 3k + 3k + 1; k = 0; 1; 2; 3; :::; y = 1

2
0
(d) yk +1 = 2yk ; k = 1; 2; 3; :::; y = 1

1
3. Calcular as somas:
P P P
a) S = k b) T = k k 2k c) U = k k
20
=1
50
=5
2 100
=0
4. Partindo-se de um unico casal de coelhos lhotes recem-nascidos e supondo que um

casal de coelhos se torna fertil apos dois meses de vida e, a partir de ent~ao, produz
um novo casal a cada mês e que os coelhos nunca morrem, a quantidade de casal de
coelhos apos n meses e dado pelo n-esimo termo da seguinte sequência:
Fn = Fn + Fn ; n 2
2 1
F = 1;
0
F =11
Essa sequência chama-se sequência de Fibonacci.

a) Mostre como os termos dessa serie correspondem a soluc~ao do problema propos-
to.
b) Redija um algoritmo para calcular a quantidade de casais de coelhos apos n
meses.
5. Tabelar n! para n variando de 0 ate 10. Por denic~ao k! = k(k 1)(k 2):::3:2:1
para k 2 N e 0! = 1.
6. Dado um inteiro n tabelar n k para k variando de 1 ate n. Por denic~ao, x k =
( ) ( )
x(x 1)(x 2):::(x k + 1); x 2 R; k 2 N e x = 1:

0
Se x = n = k; n n = n(n 1)(n 2):::(n n + 1) = n!

( )
7. Em um campeonato de futebol cada time tem uma lista ocial de 23 jogadores.

Cada time prepara uma relac~ao contendo o peso e a idade de cada um de seus
jogadores. Os 40 times que participam do torneio enviam listas para o CPD da
confederc~ao. Pede-se a seguinte informac~ao:
a) o peso medio e a idade para cada um dos times.
b) o peso e a idade media de todos os participantes.
8. Desenvolver um algoritmo para calcular a soma:
1 1=2 + 1=4 1=6 + 1=8 ::: + 1=200

Captulo 3
COMANDOS ESTRUTURADOS
Lacos condicionais-A construc~ao enquanto
Sintaxe:
enquanto < condic~ao > repita
< comando composto >
fim-enquanto
Semântica:
Temos o seguinte entendimento dessa unidade de programa:
primeiro e testada a < condic~ao >, que e um valor verdadeiro ou falso;
se < condic~ao > for verdadeira, executar o corpo < comando composto >;
volta a testar < condic~ao >, se ela for verdadeira, executar o corpo < comando
composto >;
volta a testar .....
ate que < condic~ao > seja falsa, quando, ent~ao sera executada a proxima instruc~ao
apos fim-enquanto, isto e, o controle sai do laco \enquanto";
A seguir apresentaremos alguns exemplos da construc~ao \enquanto".
Exemplo 15 Enunciado: Dado um conjunto de numeros inteiros positivos,
determinar os seus quadrados.
45
46 CAPITULO 3. COMANDOS ESTRUTURADOS
An
alise
A entrada consiste de uma lista de numeros para os quais desejamos calcular

os seus quadrados. Assim, por exemplo, se os dados de entrada forem 3, 8, 4 e
10 a sada deve ser 9, 64, 16 e 100. Se a entrada for a relac~ao de numeros 12,
13, 17 pretendemos que a sada seja 144, 169, 289. Se a entrada for somente
o numero 11, desejamos obter a sada 121. Logo, para cada numero A dado,
basta calcular o seu quadrado por meio de t = A A e imprimir o resultado.
Portanto,
Entrada: Um lista de numeros inteiros positivos.
Sada: uma listas de inteiros positivos.
Metodo: Recebe como entrada uma lista de inteiros positivos e devolve
uma lista de numeros inteiro positivos.
Projeto:
O problema e dividido nos seguintes subproblemas.

repetir para cada elemento da lista
- leia um numero inteiro positivo A;
- calcule A A;
- imprima o resultado.
As estruturas presentes neste algoritmo s~ao, ent~ao, a sequencial e a repetitiva.
Um esboco do algoritmo seria
Esbo
co do algoritmo
Ler um numero A
repetir para cada elemento da lista Calcular A A
imprimir o resultado
O problema no projeto desse algoritmo e saber quantas vezes executar a repe-

tic~ao. Isto se da porque:
47
A lista de dados de entrada e constituda por um numero desconhecido de
elementos, isto e, n~ao faz parte da entrada a informac~ao sobre quantos
numeros existem na lista.
O que queremos e repetir o bloco(leitura, calculo, sada), enquanto existir
um numero na lista de entrada dos dados.1
Para resolver esse problema introduzimos o conceito de
Sentinela
A estrategia para vericar o m dos dados e utilizar um \sinal" de m de
dados, o qual denominaremos sentinela. Portanto, acrescentaremos no nal
da lista de numeros dados um valor que, reconhecidamente, n~ao pertenca a
lista de valores possveis dos dados de entrada.
No nosso exemplo, os dados s~ao numeros inteiros positivos, isto e, a lista de
valores permitidos para a entrada e
1; 2; 3; 4; :::
Logo, podemos usar como sentinela qualquer numero que n~ao seja positivo.
Por exemplo, o numero zero ou o numero -1.
Desse modo, a entrada do algoritmo passa a ser a lista de numeros acrescida
do valor sentinela.
Com essa estrategia, podemos apresentar o seguinte esboco do algoritmo.
Esbo
co do algoritmo
Ler o primeiro numeros da lista
Calcular o quadrado
enquanto o numero for positivo repetir imprimir
ler o proximo numero
Observe que o numero de vezes em que laco sera repetido depende do teste
de uma condic~ao. Por isso dizemos que a repetic~ao e controlada por uma
condic~ao.
1Observe que a existência e mais facil de ser vericada que o contrario. Como seria possvel vericar
que n~ao existe nenhum numero inteiro positivo na entrada de dados?
Na nossa linguagem algortmica representaremos essa estrutura de repetic~ao
atraves de uma das duas instruc~oes: enquanto-faca ou repita-ate-que.
As duas instruco~es s~ao equivalentes no sentido de que representam a repetic~ao
controlada por condic~ao. Uma condic~ao e o que chamamos uma
Express~ao booleana
Em nosso problema a condic~ao e expressa por A > 0.
Uma condic~ao e expressa utilizando-se os operadores de relac~ao:
<; >; =; ; e 6=
A express~ao que obteremos relacionando entre si variaveis e/ou constantes
por meio de operadores de relac~ao denominamos express~ao booleana. Uma
express~ao booleano assume somente um de dois valores mutuamente exclusivos:
verdadeiro(true) ou falso(false).
A instruc~ao enquanto-faca tem o seguinte formato
enquanto < condic~ao > faca < bloco >

Nesta instruc~ao, < bloco > somente sera executado se < condic~ao > for
verdadeira. < bloco > representara uma ou mais instruc~oes e constitui o laco.
Antes de ser executado pela primeira vez e necessario que a condic~ao esteja
denida. Se a primeira vez em que a < condic~ao > for testada ela for falsa,
o laco n~ao sera executado nenhuma vez. Dentro do laco deve existir uma
instruc~ao que altere o valor da < condic~ao >, caso contrario o laco pode se
tornar de execuca~o innita(n~ao parar).
Em nosso problema a < condic~ao > para que as operac~oes de calculo e im-
press~ao sejam executadas e que o numero dado seja positivo. Cada numero da
entrada, inclusive a sentinela, sera lida em uma mesma variavel. Chamemos
de A essa variavel. Podemos, nalmente, apresentar o projeto do algoritmo
como a seguir:
Algoritmo quadrados
Objetivo: Calcular os quadrados de uma lista de inteiros positivos,
terminada com 0.
49
Entrada: A(inteiro).
Sada: A; t(inteiro).
quadrados()
leia(A);
enquanto A > 0 faca tleia(AA); A; imprima(A; t);
Observe que o algoritmo quadrados \funcionara" mesmo que seja colocado

outro valor como sentinela, desde que n~ao seja um numero positivo.
Implementa
c~ao.
void main()
{
int A, t; // declara as vari
aveis.
cout << `Èntre com um lista de n

umeros inteiros positivos,
<< quando quiser terminar entre 0" << endl;
cin >> A;
while( A > 0 )
{
t = A*A;
cout << A << t;
cin >> A;
}
}
Apresentaremos, tambem, o projeto desse algoritmo, assim como sua imple-

mentac~ao, para o caso da instruc~ao ser repita-ate-que.
Essa outra instruc~ao de repetic~ao em que a repetic~ao e controlado por instruc~ao
e
repita < bloco > ate que < condic~ao >

Nesta instruc~ao < bloco > sera executado pelo menos uma vez porque somente
apos a sua execuc~ao a < condic~ao > e testada. Dentre as instruc~oes de laco
deve existir pelo menos uma que altere o valor de < condic~ao >. Utilizando
essa instruca~o na resoluc~ao do problema, obteremos o seguinte algoritmo.
quadrados1()
leia(A);
repita
t AA
imprima(A; t)
leia(A)
ate que A 0
Observe que a primeira estrutura de repetic~ao (enquanto-faca) e mais conve-

niente para resolver o problema proposto. Se a sequência de entrada for vazia
e o primeiro valor lido for o valor sentinela, ocorrera indevidamente impress~ao
na tabela e a execuca~o cara interrompida por falta de dados na execuc~ao de
quadrados1().
Do ponto de vista de formato, o laco de repita-ate-que n~ao precisa do dese-
nho de bloco mesmo quando for constitudo por uma sequência de instruc~oes,
segundo a descric~ao acima. Isso porque as proprias palavras-chave repita e
at e que servem de delimitadores de bloco.
Para um mesmo problema as condic~oes de controle dos comandos enaquanto-
faca e repita-ate-que s~ao complementares. Observe que a negac~ao de A > 0 e
A 0 e vice-versa.
Implementa
c~ao de quadrados1().
void main()
{
int A, t; // declara as vari
aveis.
cout << `Èntre com um lista de n

umeros inteiros positivos,
51
<< quando quiser terminar entre 0" << endl;
cin >> A;
do
{
t = A*A;
cout << A << t;
cin >> A;
} while(A>0);
}
Exemplo 16 Enunciado: Suponha que no ano N a populac~ao americana seja

maior que a brasileira. Sabendo-se que os Estados Unidos possuem um cres-
cimento anual de 2% na sua populac~ao e que o Brasil tem um crescimento
anual de 4%, determinar o ano em que as duas populac~oes ser~ao iguais(em
quantidade). S~ao dados os numeros de habitantes dos Estados Unidos e do
Brasil no ano N .
An
alise
A entrada consiste de três numeros: ano, populac~ao brasileira e populac~ao

americana. Portanto, a sada deve ser um numero que corresponde ao ano
em que as duas populaco~es se igualam. Assim,
Entrada: Um lista de três numeros inteiros positivos.
Sada: um numero inteiro.
Metodo: Recebe como entrada três numeros positivos e devolve um numero
inteiro positivo.
Projeto:
Devemos corrigir os valores das duas populac~oes para cada ano, a partir de
um ano dado, ate que o valor corrigido da populac~ao brasileira seja igual ou
maior que o valor corrigido da populac~ao americana. Portanto, o problema
deve ser subdividido nos seguintes subproblemas:
- corrigir a populaca~o brasileira (aumento 4%);
- corrigir a populaca~o americana (aumento 2%);
- passar para o ano seguinte.
Repetir isto ate que as duas populac~oes estejam iguais. Logo, a condic~ao que
controla a repetic~ao e a comparac~ao entre as duas populac~oes.2
Podemos, agora, apresentar o seguinte esboco para o algoritmo.
Esbo
co do algoritmo
leitura dos dados
corrigir popBras
repetir corrigir popUsa
incrementar ano
ate que popBras popUsa
sada do resultado
A correc~ao do valor da populac~ao e feita somando-se ao valor existente o valor

do acressimo, que e igual a taxa populac~ao:
Brasil: popBras + 0,04 popBras
Usa : popUsa + 0,02 popUsa
Podemos, agora, apresentar o algoritmo na sua vers~ao nal.
Algoritmo popIguais
Objetivo: Determinar o ano em que a populac~ao brasileira
supera ou iguala a americana.
Entrada: N (inteiro, Br; Usa(real).
Sada: N (inteiro).
popIguais1()
leia(N,Br,Usa);
repita
Br Br + 0:04 Br;
Usa Usa + 0:02 Usa;
N N + 1;
ate que Br Usa;
imprima(\Ano",N)
Vamos usar a instruc~ao repita-ate-que porque as duas populac~oes, primeiro, sofre um acressimo de 4%
2
e 2%, respectivamente, e somente, ent~ao, o teste da condic~ao sera executado. Esta instruc~ao e a indicada
porque sabemos, inicialmente, que a populac~ao americana e maior que a brasileira. Caso contrario, se
esses valores fossem desconhecidos, a instruc~ao enquanto-faca seria mais adequada, pois primeiro o teste
da condic~ao seria efetuado e conforme seu resultado o bloco seria executado ou n~ao.
53
Se usarmos a instruca~o enquanto-faca, a condic~ao que controla o laco sera a
negaca~o da condica~o usada na instruc~ao epita-ate-que.
popIguais2()
leia(N; Br; Usa);
Br 0:04 Br;
enquanto Br < Usa faca Usa 0:02 Usa;
N N + 1;
imprima(\Ano"; N );
Na instruca~o de sada acrescentamos uma mensagem que esclarece o signi-

cado do valor de N . As mensagens que devem ser escritas s~ao colocadas sob
aspas. A mensagem e o valor de N ser~ao impressos.3
Implementa
c~ao.
void main()
{
int N;
float Br, Usa;
cout << "Entre com o ano, a popula

cao brasileira e a americana" << endl;
cin >> N >> Br >> Usa;
while (Br < Usa )

{
Br <-- Br + 0.04 * Br;
Usa<-- Usa + 0.02 * Usa;
N <-- N + 1;
}
cout << "O ano e" << N;
}
3 Observe que o valor de N informa o ano em que ocorrera o empate, porem ate o nal do ano N a
populac~ao brasileira podera ter superada a populac~ao americana. Durante o ano N a populac~ao brasileira
sofre um aumento de 4%, enquanto a americana de, apenas, 2%. Logo, chegara um momento, nesse ano,
em que as populac~oes(brasileira e americana) se igualam.
Exemplo 17 Enunciado: Determinar o maximo divisor comum entre dois
numeros inteiros positivos.
An
alise
Para determinar o mdc usaremos o algoritmo das divis~oes sucessivas(algoritmo

de Euclides) que ilustraremos abaixo.
6 3 3
126 20 6 2 = mdc(126,20)
6 2 0
Na linha superior do dispositivo pratico registramos os quocientes obtidos, na

linha do meio os numeros que s~ao divididos(dividendo e divisor) e na linha
inferior, os restos das divis~oes:
quociente 6 3 3
dividendo/divisor 126 20 6 2
resto 6 2 0
Podemos armar que

Entrada: Dois numeros inteiros positivos.
Sada: um inteiro positivo.
Metodo: Para cada par de numeros inteiros positivos de entrada
devolve seu mdc.
Projeto:
Na primeira divis~ao um dos dividendos e um dos numeros dados e o divisor

e o outro. Nas divis~oes sucessivas o dividendo e substitudo pelo divisor e o
divisor pelo resto. A ultima divis~ao ocorre quando o respectivo resto for zero.
O valor de mdc e o valor do ultimo divisor:
55
dividendo divisor quociente resto
126 20 6 6
20 6 3 2
6 2 3 0
Portanto, o problema e dividido nos seguintes subproblemas.

- calcular o resto
- denir proximo dividendo
- denir proximo divisor
Resolver o problema consiste em repetir esses três subproblemas(nesta ordem)
ate que o resto seja zero.
O novo valor de dividendo e o divisor anterior e o novo do divisor e o resto
anterior. Portanto, quando o resto for igual a zero, o novo valor do dividendo
e o valor do ultimo divisor da sequência de divis~oes, isto e, e o valor do mdc.
Podemos apresentar o seginte esboco do algoritmo
esbo
co do algoritmo
leitura dos dados
denic~ao dos valores iniciais de dividendo e divisor
calcula o resto
repita as operac~oes substitui o dividendo pelo divisor
substitui o divisor pelo resto
ate que resto = 0
o valor do mdc e o valor do ultimo dividendo
impress~ao do mdc
Tendo em vista que a operac~ao mod fornece o resto da divis~ao entre dois
numeros inteiros, podemos nalmente apresenta o algoritmo que calcula o mdc
de dois numeros inteiros positivos.
Algoritmo mdc
Objetivo: Calcular o maximo divisor comum entre dois numeros intei-
ros positivos.
Entrada: M; N (inteiros).
Sada: mdc(inteiro).
mdc()
leia(M,N);
dividendo M ; divisor N ;
repita
resto dividendo mod divisor;
dividendo divisor;
divisor resto;
ate que resto = 0
imprima(mdc)
Observe que o algoritmo funciona mesmo que M < N . Por exemplo, se

M = 20 e N = 126, o resultado de mdc(20,126) e 2.
Implementa
c~ao.
void main()
{
int M, N;
cout << "Entre dois inteiros positivos" << endl;
cin >> N >> M;
dividendo <-- M;
divisor <-- N;
while (resto /= 0 )
{
resto <-- dividendo mod divisor;
dividendo <-- divisor;
divisor <-- resto;
}
mdc <-- dividendo
cout << mdc << endl;;
}
57
Exerccios
Em cada um dos exerccios abaixo, fazer a analise do problema, o projeto e implementac~ao
do algoritmo.
1. Dados os lados de quadrados, determinar suas areas. Parar quando for informado
de que lado=0.
2. Determinar o numero de alunos de uma turma qualquer.
3. Fazer um programa para validar notas, que v~ao de 0 ate 10, de alunos de uma
instituica~o de ensino.
4. O departamento de markting de uma editora esta com o problema de calcular o
ponto de equilbrio para qualquer livro que se prop~oe a publicar. Isto e, deve
estabelecer o valor do preco de venda que cobre os custos de produc~ao. Os custos
de produca~o consistem em um custo xo mais um custo de copia que depende do
numero de copias produzidas e do numero de paginas do livro.
custo de produca~o = custo xo + (num de copias) (num de pags.) 0; 031

Para cada livro que se pretenda publicar e feita uma pesquisa de campo para se
determinar o numero provavel de vendas. Esse numero e utilizado como o numero
de copias.
Em seguida e organizado uma lista dos livros que se pretende publicar contendo as
seguintes informaco~es: numero de identicac~ao do livro, previs~ao de vendas, custo
xo e numero de paginas.
Desenvolva um programa que, a partir dos dados dessa lista, emita um relatorio
contendo o numero de identicac~ao do livro, as vendas previstas e o preco de venda
do livro que cobre os custos de produc~ao. Para a leitura da lista e preciso utilizar
uma sentinela.
5. Dados dois numeros inteiros positivos determinar quantas vezes o primeiro divide
exatamente o segundo. Se o primeiro n~ao divide o segundo o numero de vezes e
zero.
6. Dados dois numeros inteiros positivos determinar o valor da maior potência do
primeiro que divide o segundo. Se o primeiro n~ao divide o segundo, a maior potência
e denida como sendo igual a 1.
7. Dados dois numeros reais positivos determinar o quociente inteiro do primeiro pelo
segundo usando, apenas, os operadores aritmeticos reais.
8. Dado um numero real positivo determinar sua parte inteira e sua parte fracinaria
usando, apenas os operadores aritmeticos reais.
9. Dado um numero binario inteiro positivo determinar a sua convers~ao para decimal.
3.1 Estruturas de decis~ao de selec~ao ou de alternati-

vas
Nas estruturas de dicis~ao(de selec~ao ou alternativa) o uxo de intruc~oes a ser seguido e
escolhido em funca~o do resultado da avaliac~ao de uma mais condic~oes(express~ao booleana
ou logica). Podemos classicar as estruturas de decis~ao, quando ao numero de condic~oes
em
uma condic~ao(condic~ao simples) - se;
varias condico~es(condic~oes multiplas) - escolha(caso).
Estruturas de decis~ao do tipo \se"
Sintaxe:
se <condic~ao> ent~ao
<comando-composto1>
sen~
ao
<comando-composto2>
m-se
Semântica:
Devemos ter o seguinte entendimento deste tipo de comando de decis~ao:
1. Testar a condic~ao <condic~ao>, se ela for verdadeira
2. executar o comando <comando-composto1>, caso contrario, isto e, se <condic~ao>
for falsa,
3. executar <comando-composto2>.
Exemplo 18 Enunciado: Dados dois numeros A e B distintos, determinar
maior.
An
alise
Podemos de incio identicar a seguinte estrutura sequencial do algoritmo:

~ DE SELECAO
3.1. ESTRUTURAS DE DECISAO ~ OU DE ALTERNATIVAS 59
leitura dos dados(A,B)
determinar o maior
sada do resultado(maior)
Portanto,
Entrada: Dois numeros inteiros A; B .
Sada: Um numero inteiro, o maior dos dois.
Metodo: Recebe como entrada dois numeros inteiros e devolve como sada
o maior dos dois.
Projeto
Para determinar o maior dos dois numeros A e B , e preciso comparar A com

B e, em func~ao do resultado dessa comparac~ao, o maior sera denido como o
valor de A ou o valor de B :
leia(A,B)
compare A com B , denindo o maior
imprima(maior)
Para efetuar a comparaca~o, podemos testar a condic~ao A > B . Se for verda-
deira, o maior deve receber valor de A, caso contrario, o maior deve receber
o valor de B . Isto signica que existem duas alternativas apos o teste e que
somente uma das duas sera executada:
A > B ? sim ! o maior e A
n~ao ! o maior e B
Da descric~ao do algoritmo essa instruc~ao e descrita por:
se A > B ent~ao
maior A
sen~ao
maior B
Essa instruc~ao e denominada instruc~ao de selec~ao de dois ramos porque a sua
execuc~ao, efetivamente, seleciona uma das duas alternativas: ou o ramo ent~ao
ou o ramo sen~ao, conforme o valor da condic~ao seja verdadeiro ou falso.
Algoritmo maior
Objetivo: Determinar o maior de dois numeros distintos.
Entrada: A; B (real).
Sada: Uma max(inteiro.
maior1()
leia(A,B);
se (A>B ) ent~ao
max A;
sen~ao
max B;
imprima(max);
Vejamos que modicac~ao deve sofrer o algoritmo maior1() se os numeros A e

B n~ao forem necessariamente distintos. Antes vamos estabelecer que no caso
de igualdade desejamos que que a sada seja uma mensagem, por exemplo,
\Valores iguais".
Com esta modicac~ao a condic~ao a ser testada inicialmente e a igualdade dos
dois numeros dados. Conforme o valor dessa condic~ao devemos imprimir uma
mensagem ou ent~ao determinar o maior e imprim-lo.
esbo
co do algoritmo
leitura dos dados
se A = B ent~ao
imprimir mensagem
sen~ao determinar o maior
imprimir o maior
O ramo sen~ao(<bloco2>) dessa instruc~ao nada mais e que o algoritmo ante-

rior, sem a instruca~o de leitura. Portanto, temos o seguinte algoritmo:
~ DE SELECAO
maior2()
leia(A,B);
se A = B ent~ao
imprimir(\Valores iguais');
se A > B ent~ao
maior A;
sen~ao sen~ao
maior B ;
imprimir(\maior=",maior);
Implementa
c~ao: maior1()
void main()
{
float max, A, B;
cout << "Digite dois n

umeros reais " << endl;
cin >> A >> B;
if (A > B )
max = A;
else
max = B;
cout << `` Maior = " << max << endl;
}
Implementa
c~ao: maior2()
void main()
{
float maior, A, B;
cout << "Digite dois n

umeros reais " << endl;
cin >> A >> B;
if (A = B )
cout << ``Valores iguais" << endl;
else
{
if (A > B )
maior = A;
else
maior = B;
cout << ``Maior" << maior << endl;
}
}
Exemplo 19 Enunciado: Determinar se uma pessoa e maior ou menor de

idade.
An
alise
A entrada consiste de um numero que e a idade alguem, enquanto a sada deve

ser uma a cadeia constante \Maior de idade" ou \Menor de idade".
Entrada: Um numero inteiro positivo.
Sada: Uma cadeia constante.
Metodo: Tem como entrada um inteiro positivo e devolve uma cadeia
constante, \Maior de idade" ou \Menor de idade"
Projeto:
Este problema e t~ao simples que escreveremos o algoritmo sem passar pela fase
de esboco.
Algoritmo maiorIdade
Objetivo: Vericar se alguem e de maior idade, isto e,
tem idade maior ou igual a 18 anos.
Entrada: N (inteiro).
Sada: Uma cadeia constante.
~ DE SELECAO
maiorIdade()
leia(idade);
se (idade18 )
imprima(\ Maior de idade");
sen~ao
imprima(\Menor de idade");
Implementa
c~ao.
void main()
{
int idade;
cout << "Digite a idade" << endl;
cin >> idade;
if (idade >= 18 )
cout << "Maior de idade" << endl;
else
cout << "Menor de idade" << endl;
}
Exemplo 20 Enunciado: Numa pequena empresa, cada funcionario recebe

mensalmente o ordenado mais um prêmio referente a comiss~oes. S~ao dados os
seguintes valores: salario bruto e prêmio, alem dos valores de base do INPS,
base do imposto de renda e respectivas taxas(INPS E IR). Deseja-se emitir
o demonstrativo do pagamento(contracheque) de um funcionario, contendo os
valores do salario bruto, prêmio, rendimento, desconto de IR e salario lquido.
Esclarecimento: O rendimento do funcionario e a soma do salario bruto com
o prêmio; o desconto do INPS somente incide se o rendimento for maior do
que a base do INPS e o desconto do imposto de renda, somente se a diferenca
entre os valores do rendimento e o valor do desconto do INPS for maior do
que a base do Imposto de Renda.
An
alise
Vamos examinar um exemplo para conrmar nossa compreens~ao do problema.
Suponha que a entrada de valores numericos sejam as seguintes:
Salario bruto = 2000
prêmio = 1000
base INPS = 1500
base IR = 2800
taxa IR = 15%
Inicialmente calculamos o rendimento atraves de:
rendimento = salario bruto + prêmio,
Obtendo rendimento = 2000 + 1000 = 3000
Logo a seguir vericaremos se incide a taxa INPS sobre esse rendimento:

base INPS = 1500 ! rendimento > base INPS
rendimento = 3000
Como rendimento>base do INPS devemos calcular o desconto do INPS, que
e igual a 10% do rendimento:
desconto INPS = 0; 10 3000 = 300

Em seguida para vericar se existe rentenc~ao de IR na fonte, subtraimos o
desconto do INPS do valor do rendimento e comparamos essa diferenca com
o valor base IR:
3000 300 = 2700 ! diferenca < base IR
base IR = 2800
Como diferenca e menor do que a base IR, n~ao existe desconto de IR, isto e,
o desconto de IR e nulo. Finalmente temos:
salario lquido = rendimento desconto INPS desconto IR
salario lquido = 3000 300 0 = 2700

Os valores de sada s~ao:
~ DE SELECAO
salario bruto = 2000
prêmio = 1000
rendimento = 3000
INPS = 300
IR = 0
salario lquido = 2700
Portanto,
Entrada: Seis numeros reais, que s~ao sBruto, prêmio, baseINPS, ba-
seIR, taxaINPS, taxaIR.
Sada: Seis numeros reais, que s~ao Sbruto, prêmio,
R(salario total), INPS, IR, sLquido
Metodo: Tem como entrada esses seis reais e devolve como seis numeros
reais.
Projeto:
Analisando o processo executado observamos que o desconto do INPS so ocorre

se o rendimento for maior que a base do INPS. Do mesmo modo, o desconto
do IR so e calculado se a diferenca(rendimento-desconto INPS) for maior que
a base IR.
Isto signica que o calculo dos descontos depende do valor da condic~ao, mas
n~ao existem duas alternativas: se a condic~ao for verdadeira o calculo deve ser
efetuado, mas se acondic~ao for falsa nenhum calculo deve e ser executado:

rendimento > base INPS? sim : calculo do desconto
n~ao :nada a fazer
Na descric~ao do algoritmo essa instruc~ao e descrita por:
se <condic~ao> ent~ao
<bloco>
Essa intruc~ao e denominada instruc~ao de selec~ao de um ramo porque a exe-
cuc~ao faz com que apenas uma unica alternativa seja executada ou n~ao. Apos
o teste do valor da condic~ao, o bloco somente e executado se o valor do teste
for verdadeiro.
Observe que os dois testes devem ser feitos em sequência, isto e, apos ve-
ricar a condica~o \rendimento > base INPS" deve ser vericada a condic~ao
\(rendimento-desconto INPS)> base IR"independemente do resultado do teste
anterior:
O algoritmo, portanto, apresenta a seguinte estrutura logica:
esbo
co do algoritmo
entrada de dados
calcular rendimento
calcular desconto de INPS, se incidir
calcular desconto IR, se incidir
calcular salario lquido
sada do resultado
Para identicar os valores de entrada usaremos as variaveis: sBruto, prêmio,
baseINPS, baseIR, taxaINPS, e para os valores de sada as variaveis: R,
sLquido, INPS e IR. O renamento do esboco anterior e o seguinte:
refinamento do esbo
co
leitura dos dados
R sBruto + prêmio
se(R >INPS) ent~ao INPS taxaINPSR
se(R>baseINPS) ent~ao IR taxaIr(R-INPS)
sLquido R-INPS-R
sada do resultado
Observe que na penultima instruc~ao em que e calculado o sLquido, a exe-
cuc~ao so podera ser feita se as parcelas do INPS e IR estiverem com valores
denidos. Se as condic~oes que denem INPS e IR forem falsas nenhum valor
sera atribudo a essas variaveis. Portanto, antes de testar as condic~oes deve-
mos atribuir para essas variaveis valores iniciais iguais a zero. Esses valores
somente ser~ao modicados se as condic~oes que os denem forem verdadeiras.
Finalmente, podemos escrever o algoritmo,
Algoritmo contraCheque
Objetivo: Calcular o rendimento, os decontos de INPS, de IR e
imprimir o respectivo demonstrativo, de funcinario
que recebe salario e prêmio.
Entrada: sBruto, prêmio, baseINPS, baseIR, taxaINPS, taxaIR(reaL).
~ DE SELECAO
Sada: sBruto, prêmio, R, INPS, IR, sLquido(real)
contraCheque()
leia(sBruto,prêmio);
leia(baseINPS,baseIR,taxaINPS,taxaIR);
INPS 0; IR 0;
R sBruto+prêmio;
se R>baseINPS ent~ao
INPS taxaINPS R;
se R-INPS>baseIR ent~ao
IR taxaIR (R INPS );
sLquido R-INPS-IR;
imprima(sBruto,prêmio,R,INPS,IR,sLquido);
Implementa
c~ao.
void main()
{
float sBruto, pr^
emio;
float baseINPS, baseIR, taxaINPS, taxaIR, R, sL
quido;
cout << "Digite sal

ario bruto e pr^
emio" << endl;
cin >> sBruto >> pr^

emio;
INPS = 0;
IR = 0;
if (R>baseINPS)
INPS = taxaIR*R;
if (R-INPS>baseIR)
IR = taxaIR*(R-INPS);
sL
quido = R - INPS - IR;
cout << sBruto << pr^

emio << R
<< INPS << IR << sLquido << endl;
}
Tipos de dados booleano e caracteres

A seguir apresentarem os tipos booleanos e caracteres necessarios para os problemas a
seguir.
Tipos de dados booleano(l

ogico)
Elementos : os valores logicos verdadeiro(true) e falso(false)
Operac~oes/Notaca~o : negac~ao n~ao
: onjunc~ao e
: disjunc~ao ou
Relac~oes/Notac~ao : igualdade =
: desgualdade 6 =
Constantes : T e F, representando os valores true e false, resp.
Denic~ao das operac~oes logicas pela tabela verdade
n~ao e F T ou F T
F T F F F F F T
T F T F T T T T
Tipos de dados caractere

Elementos : os caracteres alfanumericos
(letras latinas maiusculas, letras latinas minusculas, algarismos
decimais arabicos, sinais de pontuac~ao e smbolos especiais)
Operac~oes/Notac~ao : n~ao ha
Relac~oes/Notac~ao : igualdade =
: desigualdade = 6
Constantes : caractere alfanumericos sob aspas simples, por exemplo À',
`2', `.', `<'
A implementac~ao do tipo caractere numa liguagem de programac~ao representara os

caracteres em sistema de codicac~ao. O mais comum, principalmente, para os microcom-
putadores e o sistema ASCII(American Standard code for Interchase Information). Nesse
sistema e introduzido uma relac~ao de ordem(<; ; > e ) entre os caracteres por meio
da ordem associada a cada um dos 256 caracteres codicados. Essa relac~ao de ordem
preserva a ordem alfabetica e estabelece que os algarismos precedem as letras maiusculas
e estas, as minusculas.
~ DE SELECAO
Exemplo 21 Enunciado: E dado o gabarito de uma prova que consta de três
quest~oes, cujas respostas podem ser qualquer uma de três alternativas À', `B'
ou `C'. S~ao dadas tambem as respostas para as três quest~oes fornecidadas por
um estudante que se submeteu a prova.
Desenvolver um algoritmo para imprimir o gabarito e a mensagem \elimina-
do", caso estudante tenha errado todas as quest~oes, ou o gabarito e o numero
das quest~oes certas, caso o estudante tenha acertado alguma quest~ao.
An
alise
Os dados consistem de três letras que constituem o gabarito das três quest~oes,
e três que formam a resposta do estudante.
Exemplo de entrada e sadas:
entrada: (gabarito)B A C
(resposta)B A A
sada: gabarito: B A C
quest~ao 1, quest~ao 2
entrada: (gabarito)B B B
(resposta)A B B
sada: gabarito: B B B
quest~ao 2, quest~ao 3
Observe que o gabarito sera impresso independentemente de acertos ou erros,
isto e, imediatamente apos a entrada dos dados. Em seguida existem somen-
te duas possibilidades: ou a sada consiste da mensagem \eliminado" ou ou
consiste nos numeros das quest~oes certas. O que condiciona uma das duas
alternativas e o valor da condic~ao \errou as quest~oes":

errou as 3 quest~oes? sim ! eliminado
n~ao ! verique quais as certas
Temos, ent~ao a seguinte estrutura logica:
esbo
co do algoritmo
entrada de dados
imprimir gabarito
se errou as 3 quest~oes ent~ao
imprimir mensagem \ELIMINADO"
sen~ao
vericar quais as certas e imprimir os respectivos numeros
Para vericar quais as certas e imprimir os respectivos numeros, basta com-
parar o gabarito com a resposta quest~ao por quest~ao, imprimindo o numero da
quest~oes somente se o valor do gabarito for igual ao valor da resposta. Apos
vericar a quest~ao 1, devemos vericar a quest~ao 2(n~ao importa se houve acer-
to ou erro no teste da quest~ao 1)e em seguida, a quest~ao 3(idependentemente
do resultado das quest~oes 1 e 2).
Portanto, a estrutura logica desse bloco e uma sequência de três instruc~oes de
selec~ao de um ramos, ou seja:
refinamento do ebo
co
entrada de dados
imprimir gabarito
se errou as 3 quest~oes ent~ao
imprimir mensagem \ELIMINADO"
sen~ao
imprimir \ACERTOU"
se acertou a quest~ao 1 ent~ao
imprimir \quest~ao 1"
se acertou quest~ao 2 ent~ao
se acertou quest~ao 3 ent~ao
Sejam G1, G2 e G3 as variaveis que representam o gabarito e R1, R2 e R3

as variaveis que representam as respostas do estudante. Essas variaves s~ao do
tipo caractere.
A condica~o \errou as três quest~oes" representa três testes:
R16=G1 e R26=G2 e R36=G3
Finamente, podemos apresentar o algoritmo
Algoritmo exameFinal
Objetivo: Dados os gabaritos de três quest~oes e as resposta de um estudante
imprimir o gabarito e
a mensagem \ELIMINADO" ou a mensagem \ACERTOU" e os numeros
~ DE SELECAO
da quest~oes certas, conforme o estudante tenha errado todas
quest~oes ou n~ao.
Entrada: G1, G2, G2, R1, R2, R3(caractere).
Sada: G1, G2, G3(caractere), mensagem(cadeia de caractere).
exameFinal()
leia(G1,G2,G3,R1,R2,R3);
imprimir(\gabarito: ", G1,G2,G3);
se(R1neqG1) e (R2= 6 G2) e (R36=G3) ent~ao
imprima(\Eliminado");
sen~ao
imprima(\Acertou: ");
se R1=G1 ent~ao
imprima(\quest~ao 1");
se R2=G2 ent~ao
imprima(\quest~ao 2");
se R3=G3 ent~ao
imprim(\quest~ao 3");
A condic~ao utilizada na instruc~ao de selec~ao de dois ramos e uma condic~ao

composta porque e formada por condic~oes simples(escritas com operadores re-
lacionais) que s~ao conectados pelo operador logico \e".
Implementa
c~ao.
void main()
{
char G1,G2,G3,R1,R2,R3;
cout << "Digite os gabaritos G1, G2, G3: " << endl;
cout << "Digite as respostas R1, R2, R2: " << endl;
cin >> G1 >> G2 >> G3;
cin >> R1 >> R2 >> R3;

cout << G1 << G2 << G3 << \endl;
if (R1 /= G1 && R2 /= G2 && R3 /= G3)

cout << "Eliminado" << endl;
else
cout << "Acertou" << endl;
if(R1=G1)
cout << "quest~
ao 1" << endl;
if(R2=G2)
cout << "quest~
ao 2" << endl;
if(R3=G3)
cout << "quest~
ao 3" << endl;
}
Exemplo 22 Enunciado: Suponha que em vez da resposta de um unico estu-

dante se tenha uma lista de respostas de n estudantes, dado o valor de n.
Para repetir o processo acima n vezes e preciso utilizar uma instruc~ao de

repetic~ao. Como essa repetic~ao deve ocorrer n vezes, a instruc~ao adequada e
a repetic~ao controlada por variaveis:
para aluno de 1 ate n repita processo aluno
Como o gabarito e o mesmo para todos os estudantes, a leitura e a impress~ao

do gabarito deve preceder a instruc~ao de repetic~ao e o bloco \processa aluno"
e o algoritmo exameFinal tendo como entrada de dados apenas as respostas
de cada aluno.
~ DE SELECAO
exameFinal1()
leia(n);
leia(G1,G2,G3);
imprima(\gabarito: ");
imprima(G1,G2,G3);
para aluno de 1 ate n repita
leia(R1,R2,R3);
se (R16=G1)e(R26=G2)e(R36=G3) ent~ao
imprima(\Eliminado");
sen~ao
imprima(\Acertou: ");
se R1=G1 ent~ao
imprima(`Q1');
se R2=G2 ent~ao
imprima(`Q2');
se R3=G3 ent~ao
imprima(`Q');
Implementa
c~ao.
void main()
{
char G1,G2,G3,R1,R2,R3;
int n, aluno;
cout << ``Digite o numero de alunos: " << endl;
cin >> n;
cout << "Digite os gabaritos G1, G2, G3: " << endl;
cin >> G1 >> G2 >> G3;
cout << G1 << G2 << G3 << \endl;
for (aluno=1; aluno<=n;aluno++)
{
cout << "Digite as respostas R1, R2, R2: " << endl;
cin >> R1 >> R2 >> R3;
if (R1 /= G1 && R2 /= G2 && R3 /= G3)

cout << "Eliminado" << endl;
else
{
cout << "Acertou" << endl;
if(R1=G1)
cout << "quest~
ao 1" << endl;
if(R2=G2)
cout << "quest~
ao 2" << endl;
if(R3=G3)
cout << "quest~
ao 3" << endl;
}
}
Fuc~oes de bibliotecas
Alem das operaco~es denidas sobre os elementos do tipo inteiro e real, vamos considerar,
a partir de agora, que temos disponvel uma biblioteca de func~oes. Isto signica que num
programa que for preciso usar uma ou mais dessas func~oes tudo que e preciso fazer e for-
necer os nomes das func~oes com os argumentos correspontes. Chamemos essa biblioteca
de bibliFunc e para que ela, efetivamente, funcione devemos colocar a instruc~ao inclua
biblifunc antes do programa \principal"(no preâmbulo) e as expecicac~oes das func~oes
que est~ao sendo usadas antes do programa. Vamos supor que essa biblioteca contem
as func~oes elementares da matematica, como, por exemplo, abs()(func~ao valor absolu-
to), sqrt()(funca~o raz quadrada), ln()(logaritmo na base natural), exp()(exponencial),
sin()(seno), cos()(coseno) etc. Podemos usar qualquer uma dessas func~oes elementares
na biblioteca, mas, alem de incluir a biblioteca no preâmbulo, e preciso especicar a
func~ao que esta sendo usada. Por exemplo, suponha que pretendemos usar a func~ao raz
quadrada, para isso devemos uncluir a sua especicac~ao(prototipo) sqrt : R ! R. + 4
Exemplo 23 Enunciado: Dados três numeros reais correspondentes, respec-

tivamente, aos coecientes de uma equac~ao do segundo grau, ax2 + bxx + c = 0,
determinar e imprimir suas razes nos seguintes casos: razes reais distintas,
razes reais iguais e razes complexas(complexas conjungadas). Imprimir men-
sagem se a equac~ao n~ao for do segundo grau(a=0). Considerar disponveis em
biblioteca as func~oes srt()(razQuadrada()) e abs()(valorAbsoluto()).
O programa nal que, deixaremos como exerccio, teria o seguinte aspecto
incluir biblifunc
As func~oes dinponveis, de fato, dependem da sua implementac~ao numa linguagem de programac~ao

4
e fazem parte da biblioteca da linguagem.
3.2. EXERCICIOS 75
razQuadrada()
.............
3.2 Exerccios
Em cada um dos exerccios abaixo apresentar a analise do problema, o projeto do algoritmo
e a implementac~ao em C++.
1. Dada uma sequência de resultados da LOTO, identicar se cada numero e par,
mpar, multiplos de 3, multiplos de 5 ou multiplos de 7. Por exemplo,
Entrada: 27,16,42,30,10
Sada: 27 e mpar, multiplo de 3
16 e par
42 e par, multiplo de 3, multiplo de 7
30 e par, multiplo de 3, multiplo de 5
10 e par, multiplo de 5
2. Uma empresa decidiu dar uma graticac~ao de Natal a seus funcionarios, baseada no
numero de horas extras e no numero de horas que o empregado faltou ao trabalho.
O valor do prêmio e obtido pela consulta a tabela I, em que H e o numero de horas-
extras subtrado de dois tercos do numero de horas-faltas.
tabela I
H(horas) Prêmios(R$)
(40,100] 100,00
(30,40] 80,00
(20,30] 60,00
(10,20] 40,00
(0,10] 20,00
Dados os numeros de identicac~ao dos funcionarios, o numero de horas extras e o
numero de horas-faltas, imprimir uma relac~ao com duas colunas, a primeira con-
tendo o numero de funcionario e a segunda o valor do prêmio a que faz jus.
3. O departamente do meio ambiente tem uma relac~ao de três industrias altamente
poluentes, em constante estado de alerta. O ndice de poluic~ao e determinado regu-
larmente na regi~ao e e considerado normal o valor do ndice entre 0,05 e 0,25. Se o
ndice da poluica~o atingir 0,25 a situac~ao e de alerta. Se atingir 0,30, a primei-
ra industria da relac~ao e chamada a suspender as atividades, se o ndice atingir
0,40, a segunda industria tambem deve ser chamada a suspender as atividades
e se o ndice exceder 0,50, a terceira industria tambem deve ser noticada. As
industrias s~ao identicadas pelas letras A, B, C.
Fazer um programa para ler o ndice de poluic~ao e emitir relatorio noticando
as industrias, caso seja necessario. Deve constar do relatorio a situac~ao ocorri-
da(abaixo do normal, norma ou alerta).
4. Em um curso de ciência da computac~ao a nota do estudante e calculada a partir de
três notas atribudas, respectivamente, a um trabalho de laboratorio, a uma avaliac~ao
semestral e a um exame nal. As notas variam de 0 a 10 e a nota nal e a media
ponderada das três notas mencionadas. A tabela abaixo fornece os pesos:
laboratorio peso 2
avaliac~ao semestral peso 3
exame nal peso 5
Dada uma relac~ao de n estudantes, cada um com o respectivo numero de matrcula

e as três notas acima mencionadas, faca um programa para calcular a nota nal e
a classicac~ao de cada estudante. A classicac~ao e dada conforme a tabela abaixo.
Imprimir a lista dos n estudantes, com o seu numero, nota nal e classicac~ao.
Nota nal Classicac~ao

[8; 10] A
[7; 8) B
[6; 7) C
[5; 6) D
[0; 5) R
5. Cacular xn , supondo x um numero qualquer e n um inteiro n~ao negativo. Considerar

n~ao disponvel em biblioteca a func~ao de potenciac~ao.
6. Dados três numeros inteiros correspondentes, respectivamente, ao dia, mês e ano do
nascimento de uma pesssoa e três outros numeros correspondentes, respectivamente,
ao dia, mês e ano corrente(por exemplo, dada de hoje), determinar e imprimir
a idade em anos completos(excluir meses e dias). Se a data do nascimento for
posterior a data corrente, deve ser impressa a mensagem alusiva.
7. S~ao dados um numero n e quatro outros, a; b; c; d, correspondentes, respectivamente,
as extremidades dos intervalos [a; b] e [c; d], sendo a < b, c < d e a < c. Determinar
se n pertence somente ao intervalo [a; b] ou somente ao intervalo [c; d] ou, se n
pertence a ambos ou se n n~ao pertence a nenhum dos dois. Em cada caso imprimir
uma mensagem conveniente.
3.2. EXERCICIOS 77
8. Durante os 31 dias do mês de julho foram tomadas as temperaturas medias diarias
da cidade de Conquista. Determinar o numero de dias desse mês com temperaturas
menores ou iguais a 15 graus centgrados e o numero de dias com temperaturas
maiores que 15 graus centgrados.
9. Uma loja de calcados anota diariamente a quantidade de pares vendidos. Determi-
nar em que dia do mês de marco ocorreu a maior venda e qual foi a quantidade
vendida nesse dia.
10. Dados dois numeros inteiros e positivos, i e j , determinar e imprimir os n primeiros
multiplos de i ou de j ou de ambos.
11. Um numero inteiro positivo e triangular se ele e o produto de três numeros naturais
consecutivos. Por exemplo, o numero 120 e triangular porque 120 = 4 5 6.
Dado um numero inteiro e positivo vericar se ele e ou n~ao triangular, imprimindo
mensagem.
12. O governa da Republica das Bananas instituiu um controle de precos e salarios
logo apos sua eleic~ao. Uma previs~ao, baseada nas tendências atuais, revela que os
salarios v~ao aumentar anualmente de 5%, o custo de vida 10% e os impostos de
15%. Por outro lado, existe uma previs~ao de que, se os impostos mais o custo de
vida consumirem mais do que 70% do salario anual para um numero signicativo
de cidad~aos, o partido eleito tera problemas na proxima eleic~ao(em quatro anos), e
se atingir 80% certamente n~ao sera vitorioso.
A SIB(Secretaria de Informatica de Bananas) coletou os dados de uma amostra de
seus eleitores, referente a salario, imposta e custo de vida, e deseja determinar o
numero e a percentagem de cidad~aos da amostra que caem nas categorias de 75% a
80%.
Prever o metodo utilizado para assinalar o m dos dados.
13. A companhia de Pulverizac~ao PX Ltda executa pulverizac~ao de lavouras. Os cus-
tos de pulverizac~ao dependem do tipo da praga e da area da regi~ao que deve ser
pulverizada, conforme a seguinte tabela:
Codigo praga e preco por acre.
A ervas daninha, 10,00 por acre.
B gafanhotos, 20,00 por acre.
C broca, 30,00 por acre.
D tudo(os três acima), 25,00 por acre,
Se a area a ser pulverizada possui mais do que 1.000 acres, existe o desconto de 5%.
Se o custo de pulverizaca~o ultrapassar 25.000,00 ha um desconto de 10%. Se ambos
os descontos se aplicam, e calculado em primeiro lugar o relacionado com a area.
O CPD dessa companhia recebe a relac~ao dos servicos contratados, contendo as in-
formaco~es: numero de pedido, tipo de pulverizac~ao e area pulverizada. O CPD deve
emitir uma relaca~o da qual conste, em cada o valor da conta a pagar, correspondente
a cada pedido de servico. Prever sentinela para m de dados.
14. Dado um numero inteiro e positivo determinar e imprimir o maior divisor n~ao-
primo e o fator primo, excluindo em ambos os casos, ele proprio.
Por exemplo, se o numero for 12 dever~ao ser impressos 6(maior divisor n~ao-primo)
e 3(maior divisor primo). Se o numero for 13, devera ser impresso \n~ao existem
divisores". Se o numero for 15, devera ser impresso apenas 5 e a mensagem \o
maior divisor e primo".
15. Utilizar as informac~oes do exemplo 20 para imprimir a folha de pagamento dos
funcionarios, alem da emiss~ao do contracheque para cada um deles. Use sentinela
para assinalar m de dados.
16. Dado um numero inteiro maior que um, decomponha-o em seus fatores primos,
imprimindo uma tabela contendo os fatores e os respectivos expoentes.
Captulo 4
ALTERNATIVAS MU LTIPLAS
4.1 Selec~ao multipla
Sintaxe:
Escolha
caso <condic~ao1>
<comando-composto1>
caso <condic~ao2>
<comando-composto2>
....
...
caso <condic~aoN>
<comando-compostoN>
sen~ao
<comando-compostoL>
m-Escolha.
Sem^
antica
Entramos com um valor constante de um tipo basico, chamado chave,

se ele for igual a <condic~ao1>, ent~ao executar <comando-composto1>;
se ele for igual a <condic~ao2>, ent~ao executar <comando-composto2>;
e assim continua ate,
se ele for igual a <condic~aoN> executar <comando-compostoN>;
se nenhuma das condic~oes anteriors casar com a chave, ent~ao executar <comando-
compostoL>
79
80 CAPITULO 4. ALTERNATIVAS MULTIPLAS

Observe que pode n~ao existir o ramo sen~ao e, neste caso sera executado o proximo
comando apos o corpo de \Escolha". Alem disso, se houver uma condic~ao que case com
a chave, o camando correspondente e executado e o controle sai do corpo de \Escolha" e
vai para o proximo comando.
Exemplo 24 Enunciado: No correio local so existem selos de 3 e de 5 cen-
tavos. A taxa mnima para correspondência e de 8 centavos. Desejamos de-
terminar o menor numero de selos de 3 e 5 centavos que completam o valor
de uma taxa dada.
An
alise
O valor mnimo da taxa e 8 centavos e o valor maximo n~ao esta especicado.
Precisamos responder, inicialmente, a quest~ao de se, dado um numero inteiro
qualquer, existem parcelas de 3 e/ou 5 cuja soma seja igual a esse numero.
Isto corresponde a vericar se existe soluc~ao do problema.
Na lista abaixo relacionamos a decomposic~ao de alguns numeros inteiros a
partir de 8, em parcelas de 5 e/ou 3:
8=3+5 8=3+5
9=3+3+5 9=3+3+3
10=5+5 10=5+5
Observac~ao
11=3+8 11=3+(3+5) suc(5)=3+3 e suc(3+3+3)=5+5
a =inicial b=suc(a) c=suc(b)
12=3+9 12=3+(3+3+3) 8=3+3 9=3+3+3 10=5+5
13=3+10 13=3+(5+5) 11=3+(3+5).
A partir de suc(c) o padr~ao se repete.
14=3+11 14=3+3+(3+5)
15=3+12 15=3+3+(3+3+3)
16=3+13 16=3+3+(5+5)
A observaca~o nos permite concluir que os três primeiros sucessivos de (3+3)
est~ao escritos na forma de uma soma de 3 ou 5 e que o terceiro sucessivo
reproduz, em sua decomposic~ao, novamente a parcela (3+5).
Decorre deste ultimo resultado que a construc~ao dos proximos três sucessivos
mantera a decomposic~ao dos proximos numeros consecutivos em parcelas de 3
ou 5, reproduzindo novamente a parcela (3+5).
Repetindo esse procedimento tantas vezes quantas forem necessarias alcancaremos
o numero cuja decomposic~ao em parcelas de 3 ou 5 desejamos obter. A unica
restric~ao que podera existir para o valor maximo da taxa sera a limitac~ao do
tipo de dados disponvel na linguagem de implementac~ao do algoritmo.
Portanto, podemos concluir que o problema tem soluc~ao e
~ MULTIPLA
4.1. SELECAO 81
Entrada: Um numero n, a taxa a pagar.
Sada: Uma lista de dois naturais, quantas parcelas de 3 e quantas par-
celas de 5.
Metodo: Recebe como entrada um numero natural e devolve como sada
um par de numeros naturais.
Projeto
Como ja concluimos, na fase de analise do problema, que ele tem soluc~ao
precisamos agora encontrar um metodo para fornecê-la.
Se o valor da taxa fosse divisvel por 5, a soluc~ao seria obtida como o quociente
da divis~ao da taxa por 5: teramos a menor quantidade de selos de 5 cuja soma
fosse o valor da taxa. Se a divis~ao n~ao fosse exata e desse resto 1, por exemplo,
n~ao obteramos a decomposic~ao desejada. Neste caso, tentavamos diminuir a
menor quantidade possvel de selos de 5 que possibilitasse a soluc~ao. Por
exemplo, se a taxa fosse 11, retiraramos apenas um selo de 5 sobrando 6
sentavos. Como 6 e um multiplo de 3, a soluc~ao seria encontrada.
A seguir apresentamos alguns exemplos desse metodo para diferentes valores
de taxas:
taxa=75: 15 selos de 5 e nenhum de 3.
75 = 15 5 + 01
taxa=76:14 selos de 5 e 2 selos de 3.
75 = 14 5 + 1. Como 1 ! 5 e 15-1=14, temos 14 selos de 5
e 2 de 3.
taxa = 77: 13 selos de 5 e 4 de 3, pois
77 = 15 5 + 2. Como 2 selos de 5 fazem 10, temos 10 + 2 =
12 ! 3 selos de 3.
Repetindo esse racicnio para as taxas 78 e 79, e sabendo que 78 = 15 5 + 3
e 79 = 15 5 + 4, obteremos a seguinte tabela que relaciona o resto da taxa
por 5 e as quantidades de selos de 5 e 3:
1Estamos a formula de que se D e D s~ao inteiros positivos ent~ao D = quociente d + resto; com
resto quociente

resto selos de 5 selos de 3
0 quociente 0
1 quociente - 1 2
2 quociente - 2 4
3 quociente 1
4 quociente - 1 3
Estrategia 1
A tabela, acima, sugere a seguinte estrategia:
Determinar o quociente e o resto da taxa por 5.
Vericar qual alternativa ocorreu em func~ao do resto e
conforme o caso, determinar o numero de selos de 5 e o
numero de selos de 3.
Agora, temos uma situac~ao em que existem diversas alternativas(cinco) de-
pendendo do valor de uma variavel que pode ter diversos valores(neste caso,
s~ao somente cinco valores possveis).
8
>
>
> 0 ! selos de 5 = quociente e selos de 3 = 0
>
< 1 ! selos de 5 = quociente 1 e selos de 3 = 2
resto = > 2 ! selos de 5 = quociente 2 e selos de 3 = 4
>
: 34 !
>
> selos de 5 = quociente e selos de 3 = 1
! selos de 5 = quociente 1 e selos de 3 = 3
A descric~ao dessa estrutura de selec~ao por meio da instruc~ao de selec~ao de
dois ramos levara a um encadeamente de intruc~oes de selec~ao. Adotando uma
maneira para simplicar essa \cascata", temos
caso resto seja escolha
0: selos de 5 quociente;
selos de 3 0;
1: selos de 5 quociente - 1;
selos de 3 2;
selos de 3 4;
3: selos de 5 quociente;
selos de 3 1;
selos de 3 3;
m
~ MULTIPLA
4.1. SELECAO 83
Como vimos anteriormente, esta intruc~ao e denominada selec~ao multipla, e a
variavel resto, cujos valores condicionam a selec~ao da alternativa, e chamado
seletor.
Algoritmo selos
Objetivo: determinar o menor numero de selos de cinco ou
de três unidades cuja seja o valor da taxa(taxa 8).
Entrada: taxa(inteiro).
Sada: taxa, cinco, três(Inteiro).
selos();
leia(taxa);
quociente taxa div 5;
resto taxa mod 5;
caso resto seja escolha
0: cinco quociente; três 0;
1: cinco quociente - 1; três 2;
3: cinco quociente; três 1;
m
imprima(taxa,cinco,três);
Observe que a mesma estrutura poderia ser descrita utilizando-se um ninho

de instruc~oes de selec~ao de dois ramos, em forma de cascata:
se resto = 0
ent~ao <bloco1>
sen~ao se resto = 1
ent~ao <bloco2>
sen~ao se resto = 2
ent~ao <bloco3>
sen~ao se resto = 3
ent~ao <bloco4>
sen~ao <bloco5>
Outra maneira de apresentar a instruc~ao de selec~ao multipla e a seguinte:

caso seletor seja
v1:<bloco1>;
v2:<bloco2>;
.
.
.
vn:<blocon>;
A variavel seletor so pode ser do tipo escalar(inteiro,caractere,booleano). Cada
valor v1,v2,...vn determina uma unica das alternativa bloco 1,bloco 2,...,bloco
n, respectivamente.
Se o seletor n~ao tiver nenhum dos valores especicados na instruc~ao, nenhum
bloco sera executado.
Implementac~ao
void main()
{
int taxa, cinco, tr^
es, quociente, resto;
cout << "Digite a taxa: " << endl;
cin >> taxa ;
quociente = taxa/5;
resto = taxa % 5;
switch ( resto)
{
case 0:
cinco = quociente;
tr^
es = 0;
break;
case 1:
cinco = quociente - 1;
tr^
es = 2;
break;
case 2:
~ MULTIPLA
4.1. SELECAO 85
tr^
es = 4;
break;
case 3:
cinco = quociente;
tr^
es = 1;
break;
case 4:
tr^
es = 3;
break;
}
cout << taxa << cinco << tr^
es << endl;
}
Estrategia 2
Poderamos usar outra abordagem para resolver esse problema, com segue.
77 5 quociente resto observac~ao

2 15 15 2 2n~ao e multiplo de 3.
14 7 subtramos 1 do quociente e somamos 5 ao resto;
o novo resto 7 n~ao e multiplo de 3.
13 12 subtramos 1 do quociente e somamos 5 ao resto,
o novo resto 12 e um multiplo de 3.
Logo, s~ao 13 os selos de 5, e 4 os selos de 3 porque o quociente de 12 por 3 e

4.
Em resumo: inicialmente calculamos o quociente e o resto da divis~ao da taxa

por 5. Em seguida, enquanto o resto n~ao for multiplo de 3, diminuimos uma
unidade do quociente e adicionamos 5 unidades ao resto. Quando o valor
modicado do resto tornar-se multiplo de 3 obteremos a soluc~ao procurada: o
numero mnimo de selos de 5 e valor do \quociente modicado" e o numero
mnimo de selos de 3 e o valor do quociente da divis~ao do \resto modicado"
por 3.

selos2();
leia(taxa);
quociente taxa div 5;
resto taxa mod 5;
enquanto resto mod 3 6= 0 faca
quociente quociente - 1;
resto resto + 5;
cinco quociente;
três resto div 3;
imprima(taxa,cinco,três);
Implementa
c~ao de selos2()
void main()
{
int taxa, cinco, tr^
es, quociente, resto;
cout << "Digite a taxa: " << endl;
cin >> taxa ;
quociente = taxa/5;
resto = taxa % 5;
while (resto % 3 /= 0)
{
quociente = quociente - 1;
resto = resto + 5;
}
cinco = quociente;
tr^
es = resto/3;
cout << taxa << cinco << tr^
es << endl;
}
Exemplo 25 Enunciado: Dados três valores a, b e c, em que a e b s~ao

numeros reais e c e um caractere, imprimir o resultado da operac~ao de a por b
se c for um smbolo de operador aritmetico; caso contrario deve ser impressa
uma mensagem de operador n~ao denido.
An
alise
~ MULTIPLA
4.1. SELECAO 87
Vamos considerar alguns exemplos de entradas:
(a) entrada: a b c , sada: 3 + 5 = 8.

3 5 0 +0
(b) entrada: a b c , sada: 2 - 9 = -7.

2 9 0 0
(c) entrada: a b =c , sada: erro, divis~ao por 0.

12 0 0 0
(d) entrada: a b dc , sada: erro operador n~ao denido.

12 4 0 0
Embora no enunciado do problema n~ao haja especicac~ao da sada desejada

no caso de ocorrer divis~ao por zero, acrescentamos uma mensagem para esse
tipo de erro.
Entrada: a; b(real), c(caractere).

Sada: Um real ou uma mensagem.
Metodo: Recebe como entrada dois numeros reais e um caractere e de-
volve um real ou um caractere.
Projeto
A sada depende basicamente do valor de c. Conforme o valor de c existem

5 alternativas. Quatro correspondentes aos operadores arimeticos e uma aos
demais smbolos que n~ao s~ao operadores aritmeticos.
8
> 0+0 calcular
>
>
a+b
imprimir o resultado
>
>
>
>
>
> 0 0 calcular a - b
>
>
< imprimir o resultado
c= > 00 calcular a b
>
> imprimir o resultado
>
>
> se b 6= a calcule a=b e imprima o resultado
>
>
> 0 =0
>
: n:o:a caso
> contrario, imprima mensagem
imprimir mensagem
Vamos descrever esse tipo de selec~ao na forma:

caso c seja
0 +0 : resultado a + b;
imprima(a; c; b;0 =0; resultado);
0 0 : resultado a b;
0 0 : resultado a b;
se b 6= 0
ent~ao
0 =0 : resultado a=b;
sen~ao
imprima("erro : divis~ao por zero");
sen~ao
imprima("erro : operador n~ao denido");
fim
Essa instruc~ao e denominada instruc~ao multipla com ramo sen~ao. Seu formato
e:
caso seletor seja
v1:<bloco1>;
v2:<bloco2>;
.
.
.
vN:<blocoN>;
sen~ao <blocoF>
m
Se a variavel seletor tiver um dos valores v1, v2,..,vN, sera executado o blo-
co correspondente, mas se o seletor tiver valor diferente de todos os valores
esecicados na instruca~o, o bloco F sera executado.
A seleca~o contem, portanto, n+1 alternativas:
n correspondentes a cada uma das condic~oes seletor = vi com valor verda-
deiro e i um dos numeros de 1 a n.
1 correspondente a condic~ao seletor = vi com valor falso para qualquer valor
de i entre 1 e n.
~ MULTIPLA
4.1. SELECAO 89
Finalmente, podemos apresentar o algoritmo.
Algoritmo operac~ao
Objetivo: Dados dois numeros reais a e b e um caractere op, se op for um
smbolo de operac~ao aritmetica, calcular e imprimir o
resultado; caso contrario imprimir mensagem
Entrada: a; b(real), op(caractere).
Sada: resultado(real) ou mensagem(cadeia de caractere).
operac~ao();
leia(a,op,b);
caso op seja
'+': resultado a + b;
imprima(a,op,b,'=',resultado);
'-': resultado a - b;
imprima(a,op,b,'='resultado);
'*': resultado a b;
imprima(a,op,b'=',resultado;
se b 6= 0 ent~ao
resultado a/b;
'/': imprima(a,op,b,'='resultado;
sen~ao
imprima(\erro:divis~ao por zero");
sen~ao
imprimir(\erro:operador n~ao denido")
m
Implementa
c~ao
void main()
{
int a, b;
char op;
cout << "Digite a, b e op: " << endl;


cin >> a >> b >> op ;
switch (op)
{
case '+': cout << a + b; break;
case '-': cout << a - b; break;
case '*': cout << a*b; break;
case '/':
if (b /= 0)
cout << a/b;
else
cout << "erro: divis~
ao por zero";
break;
default : cout << "erro: operador n~
ao definido;
}
Exemplo 26 Enunciado: Uma companhia de seguros possui oito caterias de

seguros baseados na idade e ocupac~ao do segurado. Somente pessoas com pelo
menos 17 anos e n~ao mais de 70 poder~ao adquerir apolices de seguros. Quanto
as classes de ocupac~oes, foram denidos três grupos de riscos. A tabela abaixo
fornece as categorias em func~ao da faixa etaria e dos grupos de risco. Dados
idade e grupo de risco, determinar a categoria.
Grupo de risco
Idade Baixo Medio alto
17 a 20 1 2 3
21 a 24 2 3 4
25 a 34 3 4 5
35 a 64 4 5 6
65 a 70 7 8 9
An
alise
A idade e representada por um numero inteiros de anos, sendo, portanto, um

valor do tipo inteiro.
~ MULTIPLA
4.1. SELECAO 91
O grupo de risco gr, e uma variavel do tipo caractere que pode assumir os
valores `B', `M', À'.
Entrada: idade(real), gr(caractere).

Sada: categoria(cat).
Metodo: Recebe como entrada um inteiro, representando a idade, e
um caractere, representando o grupo de risco, e devolve um caractere,
representando a categoria.
Projeto
Na instruca~o de selec~ao multipla vimos que cada valor do seletor seleciona

uma alternativa, isto e, cada valor corresponde biuniocamente a uma unica
alternativa.
No nosso caso, desejamos que uma faixa de valores do seletor permita

selecionar uma mesma alternativa: para a idade na faixa de 17 a 20 anos,
temos uma mesma alternativa, que e a primeira linha da tabela dada.
Na linha selecionada, por sua vez, temos novamente que selecionar uma de
três alternativas, que e a primeira linha da tabela dada.
Na linha selecionada, por sua vez, temos novamente que selecionar uma das
três alternativas que depende do valor de um caractere(`B', `M',À').
Na intruc~ao de selec~ao multipla vamos descrever a faixa de valores escre-

vendo o primeiro valor separado do ultimo por dois pontos seguidos.
Como a categoria depende da faixa etaria combinada com o caratere do grupo

de risco, faremos uso de um ninho de instruc~oes caso-seja.

Algoritmo seguro
Objetivo: Calcular a categoria de seguro em func~ao da idade e do grupo de risco.
Entrada: idade(inteiro), gr(caractere).
Sada: cat(inteiro).
seguro();
leia(idade,gr);
caso idade seja
17..20:caso gr seja
`B':cat 1;
`M':cat 2;
À':cat 3;
m;
21..24:caso gr seja
`B':cat 2;
`M':cat 3;
À':cat 4;
m;
25..34:caso gr seja
`B':cat 3;
`M':cat 4;
À':cat 5;
m;
35..64:caso gr seja
`B':cat 4;
`M':cat 5;
À':cat 6;
m;
65..70:caso gr seja
`B':cat 7;
`M':cat 8;
À':cat 9;
m;
m;
imprimir(idade,gr,cat)
Implementa
c~ao
~ MULTIPLA
4.1. SELECAO 93
void main()
{
int idade, cat;
char gr;
cout << "Digite idade e grupo de risco: " << endl;
cin >> idade >> gr;
for(idade=17;idade<=20;idade++)
{
switch( gr )
case:`B'
cat = 1;
case:`M'
cat = 2;
case:À'
cat = 3;
}
{
switch( gr )
case:`B'
cat = 2;
case:`M'
cat = 3;
case:À'
cat = 4;
}
{
switch( gr )
case:`B'
cat = 3;
case:`M'
cat = 4;
case:À'
cat = 5;
}
{

switch( gr )
case:`B'
cat = 4;
case:`M'
cat = 5;
case:À'
cat = 6;
}
{
switch( gr )
case:`B'
cat = 7;
case:`M'
cat = 8;
case:À'
cat = 9;
}
cout << idade << gr << cat;
}
4.2 Exerccios
Em cada um dos exerccios abaixo deve ser feito a analise do problema, o projeto do
algoritmo e a implementac~ao do algoritmo.
1. Dada uma lista de datas de nasciemnto de varias pessoas imprimir a lista do tipo ca-
racterstico correspondente a cada data, de acordo com a regra abaixo.(n~ao esquecer
de usar sentinela).
Mensagens sobre a personalidade de pessoas s~ao estabelecidas de acordo com as
seguintes regras:
Seja D = dia do nascimento da pessoa(D = 1..31);
M = mês do nascimento da pessoa(M = 1..12);
A = ano do nascimento da pessoa(dado com 4 algarismos);
N = numero formado pela justaposic~ao dos três anteriores: DMA;
Z = numeo obtido de N pela regra dos \noves-foras".
A tabela abaixo fornece um traco marcante da personalidade da pessoa em conside-
rac~ao:
4.2. EXERCICIOS 95
Z tipo
0 irrestvel
1 impetuoso
2 discreto
3 amoroso
4 tmido
5 paquerador
6 estudioso
7 sonhador
8 charmoso
Exemplo: Se uma pessoa nasceu em 30/10/1972, teremos D=30, M=10, e A=1972.

Portanto, N=30101972. Aplicando a regra dos \noves-fora" temos Z=5, e portanto,
seu tipo e paquerador.
Esclarecimento. Regras do noves-fora: somam-se os algarismos dos numeros en-
quanto a soma for inferior a 9. Quando igualar a 9, subtrai-se 9 e continua-se
somando-se. No caso do exemplo, acima, os valores obtidos sucessivamente s~ao:
3+0=3; 3+1=4; 4+0=4; 4+1=5; 5+9=14;, nove-fora, 5, 5+7=12, nove-fora, 3,
3+2=5. A regra dos noves-fora pode ser implementada de varias outras maneiras.
Uma delas e considerar, simplesmente, o resto da divis~ao do numero Z por 9. A im-
plementac~ao, neste caso, depende do domnio denido na linguagem de programac~ao
utilizada.
2. Uma loja utiliza os seguintes codigos para as transac~oes de cada dia:
`*' signica compra a vista

`+' signica compra a prazo
`-' signica pagamento efetuado
Dada uma lista de transac~oes contendo o valor de cada transac~ao e o respectivo

codigo, imprima um relatorio com os totais de compras a vista, compras a prazo e
pagamentos efetuados. Usar o caractere zero como sentinela para o m de dados.
3. Dada a tabela abaixo, calcular e imprimir o salario reajustado.
Pross~ao % de reajuste

Agente tecnico 50%
Tecnico 40%
Engenheiro 30%
Outros 10%

4. Dado o numero do mês, imprimir o seu nome. Por exemplo, dado 5, imprimir
maio.
5. Dado o numero do dia da semana, imprimir seu nome.
Captulo 5
PROGRAMACA~ O MODULAR
5.1 Procedimentos e func~oes
Normalmente, comecamos aprendendo programac~ao escrevendo programas pequenos e
simples que consistem somente de um programa principal, como temos visto ate aqui
nestas notas. Aqui, \programa principal", signica uma sequência de comandos que mo-
dicam os dados, os quais s~ao globais atraves de todo o programa, no sentido de que
qualquer comando do programa pode modicar os dados. Esta tecnica de programac~ao,
chamada n~ao estruturada, e muito inconvinente quando o programa se torna razoavelmen-
te grande. Por exemplo, se a mesma sequência de comandos for necessaria em diferentes
locais no programa, ela deveria ser copiada. Isto levou a ideia de extrair essas sequências,
dar-lhes um nome, desenvolver uma tecnica para chama-las e retorna-las desses proce-
dimentos. Com esse tipo de programac~ao procedural somos capazes de combinar e
retornar sequências de comandos em um unico local. Uma chamada de procedimento e
usada para invocar o procedimento. Apos a sequência ser processada, o uxo de controle
vai para a posic~ao seguinte a que ele estava quando da chamado do procedimento. Intro-
duzindo parâmetros, assim como procedimentos de procedimentos(subprocedimentos), os
programas, agora, podem ser escritos de maneira mais estruturad0s e livres de erros. Por
exemplo, se um procedimento estiver correto, toda vez que ele for usado ele produz resul-
tados corretos. Por consequinte, em casos de erros podemos diminuir a busca daqueles
lugares que resultaram na incorrec~ao.
Agora, um programa pode ser visto como uma sequência de chamadas de procedimen-
tos. O programa principal e responsavel de passar dados para as chamadas individuais,
os dados s~ao processados pelos procedimentos e, uma vez o programa tenha terminado, os
dados resultantes s~ao apresentados.
Portanto, na programac~ao procedural temos um unico programa dividido em pecas me-
nores chamadas procedimentos. Para nos habilitar a usar um procedimento ou um grupo
de procedimentos em nossos programas, eles devem estar disponveis separadamente. Por
97
98 CAPITULO 5. PROGRAMACAO
~ MODULAR
esta raz~ao, a programac~ao modular nos permite agrupar procedimentos em modulos. Com
a programac~ao modular os procedimentos com funcionalidades comuns s~ao agrupados em
modulos separados. Um programa, portanto, n~ao consiste agora somente de uma unica
parte. Ele consiste, agora, de varias pequenas partes que interagem atraves das chamadas
de procedimentos, formando o programa todo. Cada modulo possui seus proprios dados.
Isso possibilita que cada modulo administre um estado interno que e modicado por cha-
madas de procedimentos deste modulo. Entretanto, existe um unico estado por modulo e
cada modulo existe no maximo uma vez no programa todo. A seguir analisaremos com
um pouco mais de profundidade esse modo de fazer programac~ao.
5.2 Procedimentos e func~oes

Antes de estudarmos os conceitos de func~ao e procedimento revisitaremos o conceito de
bloco, introduzindo os conceitos de variavel local e \escopo" de variaveis.
Blocos
Ate aqui usamos o conceito de bloco para agrupar comandos, com um incio e um m.
Neste sentido todo algoritmo e um bloco.
vezes, e necessario declarar novas variaveis, ao longo do desenvolvimento do algo-
As
ritmo. Para isso poderamos retornar ao incio do algoritmo e fazer novas declarac~oes.
Podemos tambem usar o conceito de bloco para contornar esse problema.
Como ja sabemos, um bloco consiste de um conjunto de declarac~oes e comandos delimi-
tados, implicita ou explicitamente, pelas palavras incio e m, como no seguinte exemplo:
~
5.2. PROCEDIMENTOS E FUNCOES 99
incio
< declarac~oes >;
c ;
11
c ;
12
.
.
.
c n;
1
incio
< declarac~oes >;
c ;
21
c ;
22
.
.
.
c m;
2
incio
< declarac~oes >;
c ; 31
c ; 32
.
.
.
c k;3
m
c p;2
m
c r;
1
m
Quando um bloco comeca a ser executado, as variaveis declaradas dentro dele s~ao
ativadas(isto e, passam a existir efetivamente) e permanecem ativas ate o termino da
execuc~ao do bloco. Ou seja, uma variavel declarada no incio de um bloco so existe dentro
dele. Com isso, dizemos que as variaveis s~ao locais ao bloco, permitindo, desse modo,
que elas so ocupem memoria quando necessario.
Isso possibilita que o progamador gerencie a utilizac~ao de memoria.
Escopo de variaveis
Dizemos que um bloco e externo a um outro quando este faz parte dele. Neste sentido,
uma variavel em bloco e global a todos os blocos internos e local para o proprio bloco.
Podemos ter diversos blocos aninhados, conforme mostra a gura a seguir.
~ MODULAR
M
P
A
B nvel bloco
0 M
Q 1 P, Q
R 2 A, R, S
3 B
S
P e Q s~ao internos a M M e externo a P e Q

A e interno a P P e externo a A
B e interno a A A e externo a B
R e S s~ao internos a Q Q e externo a R e S
Como ja observamos, uma variavel declarada dentro de um bloco so e conhecida dentro
deste bloco.
Se uma vaiavel A declarada em um bloco ja foi declarada com o mesmo nome num
bloco mais externo, a variavel ativa no bloco e aquela declarada localmente. A variavel
deixa de ser global para aquele bloco.
A seguir apresentamos exemplos de variaveis locais, globais e escopos de variaveis.
incio
int I, J;
leia(I);
J J ;
incio
Exemplo 27 real X;
X J + 1;
imprima(X);
m
leia(J);
I I J;
m
No exemplo 32, acima, I e J s~ao variaveis globais enquanto X e uma variavel local
ao bloco interno.
~
incio
int I, J;
leia(I);
J J ;
incio
Exemplo 28 real X, I;
X J + 1;
imprima(X);
m
leia(J);
I I J;
m
No exemplo 33, acima, I deixa de ser global porque foi declarada(com o mesmo nome)
no bloco interno. E como se X fosse uma nova variavel I . 0
No exemplo a seguir, utilizamos o conceito de bloco para ilustrar como e possvel en-
conomizar memoria. Consideramos o problema de trocar os conteudos de duas variaveis
entre si. Mostraremos primeiro o algoritmo como tem sido feito e a nova vers~ao utilizando
bloco:
inciofsem bloco internog
int aux, a , b;
leia(a,b);
Exemplo 29 aux a;
a b;
b aux;
imprima(a,b);
m
inciofcom bloco internog
int a , b;
leia(a,b);
incio
int aux;
aux a;
a b;
b aux;
m
imprima(a,b);
m
Nesta segunda soluca~o a variavel aux so e alocada no instante da troca. Isto se torna
mais relevante num contexto onde a troca seja eventual, isto e, pode acontecer ou n~ao
dependendo do teste.
~ MODULAR
Modulos
Os programas s~ao escritos, em geral, para resolver algum problema ou executar alguma
tarefa. Vejamos um exemplo. Uma livraria possui um arquivo organizada em ttulos
e editores de cada livro vendido. A informac~ao entra na ordem em que os livros s~ao
vendidos. Em cada duas semanas o proprietario manualmente computa o numero de
copias de cada ttulo vendido e o numero de livros vendidos de cada editor. A lista e
organizada em ordem alfabetica e usada para o proposito de reordenac~ao. Pretendemos
desenvolver um programa para realizar essa tarefa.
Como ja tivemos oportunidade de observar acima, um metodo de resolver um problema
maior e quebra-lo em um numero de problemas menores, que constituir~ao os futuros
modulos. Esperamos que estes problemas menores sejam mais faceis de resolver. No
nosso caso do problema da livraria, ele e dividido em quatro subproblemas ou tarefas
menores:
1. Ler no arquivo de vendas.
2. contar as vendas por ttulos e por editores.
3. Ordenar os ttulos por editor.
4. Imprimir os resultados.
Os itens 1, 2 e 4 representam problemas que ja sabemos resolver. Eles n~ao precisam
ser mais quebrados em problemas menores. Entretanto, o item 3 e um problema um
pouco mais complexo do que os problemas que sabemos resolver. Ent~ao, aplicaremos
nossa tecnica de renamentos a este item:1
3a. Ordenar as vendas por editor.
3b. Dentro de cada editor, ordenar as venda por ttulo.
1 Observe que as tecnicas de renamentos possibilitam ao programador, nas etapas inciais do desenvol-
vimento do algoritmo, certas abstrac~oes sobre o processo a serem descritos no algoritmo. Estas abstrac~oes
s~ao denidas, apenas, pelo seu uso(ou efeito) e constituem uma denic~ao funcional do processo. Nas eta-
pas posteriores, cada descric~ao funcional e substituda por trechos mais detalhados que especicam as
etapas do processo. Quando no processo de desenvolvimento do algoritmo optamos pelos renamentos
sucessivos(que corresponde a quebrar o problema em subproblemas na fase de analise) este procedimento
conduz a modularizac~ao da soluc~ao do problema. Portanto, um modulo e um grupo de comandos, cons-
tituindo um trecho de algoritmo, com uma func~ao bem denida. Dijkstra prop~oe a modulaizac~ao como
a regra aurea da programac~ao: dividir para conquistar. Esta divis~ao da atividade de programac~ao
permite, que a cada instante, toda atenc~ao do programador esteja concentrada na soluc~ao de cada pro-
blema especco e bem denido. Isto se torna muito importante na fase de vericac~ao do programa, pois
para verica-lo basta vericar a correc~ao de cada modulo.
~
3e. Comparar ttulos adjacentes dentro de cada grupo de editores. Para cada par que
casar, incrementar um contador de ocorrência e remover o segundo.
Os itens 3a, 3b e 3c representam, agora, problemas que sabemos como resolver. Como
poderemos resolver todos os subproblemas que geramos, resolvemos, de fato, o problema
original, maior. Observamos, agora, que a ordem original das tarefas estavam incorretas.
A sequência de ac~oes requeridas e a seguinte:
1. Ler no arquivo de vendas.
2. Ordenar o arquivo de vendas. Primeiro por editor e, em seguida, por ttulo dentro
de cada editor.
3. Compactar os ttulos duplicados.
4. Escrever os resultados dentro de um novo arquivo.
Como ja sabemos, essa sequência de ac~oes e o que chamamos algoritmo e cada ac~ao
constituinte um procedimento ou sub-rotina.
O problema da livraria nos mostra que um procedimento e uma ferramenta de progra-
mac~ao que serve basicamente a dois propositos:
evitar que uma certa sequência de comandos que ocorre em varios locais de um
algoritmo tenha que ser escrita repetidamente nestes locais;
dividir e estruturar um algoritmo em partes fechadas e logicamente coerentes.
Os algoritmos contêm, muitas vezes, grupos de comandos iguais e repetidos em varias
partes de seu corpo. Os procedimentos permitem economia de tempo de escrita e reduca~o
no tamanho do algoritmo, possibilitando a escrita dos comando repetidos apenas uma
vez. Nestes casos, a utilizac~ao de procedimentos permite tambem uma unica escrita dos
comandos que, ao serem executados, utilizam os parâmentros ou operandos adequados a
cada ocorrência.2
2 Bem mais importante que esta utilidade do uso de procedimentos, o seu uso na modularizac~ao de
algoritmos torna-se uma ferrramenta indispensavel na elaborac~ao de algoritmos mais complexos e de
maior tamanho. A divis~ao de estruturac~ao de algoritmos em partes logicas e uma tecnica indispensavel
em programac~ao estruturada.
Wirth considera o conceito de procedimentos um dos poucos realmente fundamentais na arte e na
tecnica da programac~ao cujo domnio exerce uma in uência decisiva no estilo e na qualidade do trabalho
de um programador. A divis~ao de um algoritmo em procedimentos, alem de facilitar a elaborac~ao do
algoritmo, permite uma melhor documentac~ao e vericac~ao de sua correc~ao. Cada modulo implementado
como um procedimento deve conter sua propria documentac~ao e pode ser vericado independetemente.
Alem disso, a modularizac~ao por procedimentos pode facilitar muito o trabalho de equipes de programac~ao
no sentido de que um algoritmo pode vir a ser dividido em partes e implementado, testado e catalogado
separadamente.
~ MODULAR
Estrutura dos modulos de um algoritmo
Um procedimento nada mais e que um algoritmo hierarquicamente subordinado a um outro
algoritmo, comumente chamado de modulo principal. Analogamente, um procedimento
pode conter outros aninhados, como observamos anteriormente.
O conceito de objeto(variavel) local e global visto anteriormente, e tambem valido
para procedimentos. Os procedimentos s~ao tambem objetos declarados em certos pontos
de um algoritmo ou de outros procedimentos e, portanto, podendo ou n~ao ter-lhes acesso,
dependendo de sua localizac~ao. Desse modo o algoritmo que resolve o problema da livraria
apresenta a seguinte estrutura.
Algoritmo(Modulo principal)
incio
leia();
Exemplo 30 ordene();
compacte();
imprima();
m
Utilizac~ao de procedimentos
Um procedimento e criado atraves de sua declarac~ao em um algoritmo. E um objeto
estatico no sentido de que, para ser executado, precisa de uma ativac~ao provocado por um
comando especial de chamada.
A declarac~ao de um procedimento deve ser feita como as demais declarac~oes de objetos
e sempre na parte inicial de um algoritmo, um bloco ou outro procedimento.
Uma declarac~ao e constituda de um cabecalho(prototipo) e um corpo. O cabecalho
identica o procedimento atraves de um nome e o corpo contem as declarac~oes locais e os
comando do procedimento. A ativac~ao do procedimento e feita atraves da referência feita
ao seu nome e ponto do algoritmo, respeitando as regras de escopo de objetos.
Existem dois tipos basicos de procedimentos:
as sub-rotinas ou rotina ou procedimento propriamente dito;

as func~oes.
Sub-rotinas
Uma sub-routina e declarada como a seguir:
~
sub-rotina nome
declaraca~o do objetos locais a subrotina
comandos da sub-rotina
m sub-rotina
onde \nome" e o nome de referência dado a sub-rotina.
A chamada de uma sub-rotina e feita com uma referência a seu nome, no local do
programa onde a sub-rotina deve ser ativada. Ou seja, onde a sua execuc~ao deve ser
iniciada. Desse modo, a execuc~ao de uma subrotina se constitui em uma transferência
temporaria da execuca~o do algoritmo chamador para a sub-rotina, retornando depois ao
algoritmo que chamou.
Exemplo 31 No exemplo da livraria, ordene() e uma sub-rotina e, portanto,

segundo a estruturac~ao acima, temos:
sub-rotina ordene()
< corpo >
Algoritmo(Modulo principal)
incio
leia();
ordene();
compacte();
imprima();
m
Func~oes
As func~oes constituem um tipo especial de procedimento, bastante semelhante as sub-
rotinas. As func~oes tem a caracterstica especiail de retornar ao algoritmo chamado um
valor associado ao nome da func~ao. Esta caracterstica permite uma analogia com o
conceito de func~ao em matematica.
Num dos captulos anteriores, quando apresentamos as express~oes aritmeticas usamos
func~oes como, por exemplo, abs()(func~ao valor absoluto). Podemos utilizar func~oes ma-
tematicas no algoritmo, como, por exemplo, seno, tangente, ou qualquer outra func~ao
especial, declarando um procedimento func~ao. A declarac~ao de uma func~ao e idêntica a
de uma sub-rotina, com excec~ao de que e necessario especicar na func~ao os tipos dos
argumentos de entrada e o tipo de retorno ou o tipo da func~ao propriamente dito. Dei-
xaremos os detalhes e exemplos de procedimentos func~ao e mesmo sub-rotina para a sua
implementac~ao em C++.
~ MODULAR
Func~oes recursivas
Existem casos em que um procedimento ou func~ao chama a si proprio. Dizemos ent~ao
que o procedimento ou func~ao e recursivo. Por exemplo, o fatorial de um numero n pode
ser denido recursivamente, ou seja:

n! = 1n;(se n 1)!; se n 1
n=0
Podemos escrever um algoritmo que implementa essa func~ao denida recursivamente.
int fat (int)
incio
int n;
se n=0 ent~ao
fat 1;
sen~ao
fat n fat(n 1);
m
Codicac~ao em C++
int fat (int n)
{
if (n=0)
fat = 1;
else
fat = n*fat(n-1);
return fat;
O fatorial de 3 sera calculada a partir da chamada a func~ao pelo comando, digamos,
fat (3);
que retornara em fat o valor 6.
Implementac~ao de procedimentos em C++

Inicialmente, observamos que o conceito de procedimento(func~ao ou sub-rotina) em al-
goritmo e implementado em C++ pelo conceito de func~ao. Como numa sub-rotina n~ao
existem os parâmetros de entrada ou de retorno, a linguagem C++ usa o tipo void para
simula-los. Portanto, quando, em C++, os valores de retorno ou de entrada for do tipo
void estamos diante de uma sub-routina.
~
Em C++, uma ac~ao e designada por uma express~ao. Uma express~ao terminada por
um ponto e vrgula e um comando. Um comando e a menor unidade idenpendente num
programa C++. Em linguagem natural o construto correspondente e a sentenca. Os
seguintes, por exemplo, s~ao comandos em C++.
int valor;
valor = 7 + 1;
cout << valor;
Ao primeiro comando chamamos declarac~ao. Ele dene uma area de memoria do

computador associada ao nome \valor" de modo que possa conter qualquer valor inteiro.
O segundo comando e um comando de atribuic~ao. Ele coloca na area da memoria do
computador associada com o nome \valor" o resultado da soma de 7 com 1. O terceiro
comando e um comando de sada. cout e o destino da sada associada ao terminal do
usuario. O comando escreve em cout, isto e, no teminal do usuario, o valor armazenado
na area de memoria do computador associada ao nome \valor".
Os comandos est~ao logicamente agrupados em unidades chamadas func~oes. Por exem-
plo, todos os comandos necessarios para ler no arquivo de vendas, no problema da livra-
ria, est~ao organizadas numa func~ao chamada leia(). Do mesmo modo, especicamos uma
func~ao chamada ordene(), uma compacte() e uma imprima().
Em C++ todo programa deve conter uma func~ao chamada main()(principal()), forne-
cida pelo programador, antes do programa ser executado. Aqui esta como a func~ao main
deve ser denida para o algoritmo das vendas.
void main(void)
{
leia();
ordene();
compacte();
imprima();
}
Um programa C++ comeca executando o primeiro comando de main(). No nosso

caso, o comando comeca executando a func~ao leia(). A execuc~ao do programa continua
sequencialmente executando os comandos dentro de main().
Uma funca~o e constituda de quatro partes: um tipo de retorno, o nome da func~ao,
uma lista de argumentos e o corpo da func~ao. As três primeiras, em grupo, e chamada o
prototipo da func~ao. A lista de argumentos, que deve estar dentro de parênteses, contem
uma lista de zero ou mais argumentos separados por vrgula. O corpo da func~ao esta dentro
de um par de chaves (f g). Ele consiste de uma sequência de comandos do programa.
No nosso exemplo, o corpo de main() chama para execuc~ao as func~oes leia(), ordene(),
compacte() e imprima().
~ MODULAR
Vejamos, agora, como providenciaremos para que o programa esteja pronto para exe-
cuc~ao. Primeiro devemos fornecer denic~oes de leia(), ordene(), compacte() e imprima().
Neste ponto apresentaremos os exemplos \mudos" dessas func~oes:
void leia(void)
{
cout << cout << "leia()\n";
}
void ordene(void)
{
cout << "ordene()\n";
}
void compacte(void)
{
cout << "compacte()\n";
}
void imprima(void)
{
cout << "imprima()\n";
}
void e usado para especicar uma func~ao que implementa uma sub-rotina, isto e, que
n~ao fornece um valor de retorno ou n~ao recebe parâmetros de entrada. Cada func~ao,
como foi denida, simplesmente anunciara sua presenca no terminal do usuario, quando
requisitada por main(). Mais adiante trocaremos essas instâncias mudas por denic~oes
\reais" dessas func~oes, quando elas forem implementadas. Essa maneira passo a passo
de construir programas e o modo seguro de prevenir possveis erros de programac~ao, que
inevitavelmente cometemos. Conseguir que um programa funcione n~ao e uma tarefa t~ao
simples como, a primeira vista, parece.
A identicac~ao de um arquivo fonte de um programa e constituda de duas partes: o
nome do arquivo e o suxo do arquivo. O suxo variara de acordo com as diferentes
implementac~oes de C++. Para diferenciar um arquivo fonte C++ de C, usaremos o
suxo cp ou cplus, dependendo do sistema operacional.
Considere o seguinte programa completo num arquivo fonte C++:
~
{
cout << cout << "leia()\n";
}
void ordene(void)
{
cout << "ordene()\n";
}
void compacte(void)
{
cout << "compacte()\n";
}
void imprima(void)
{
cout << "imprima()\n";
}
void main(void)
{
leia();
ordene();
compacte();
imprima();
}
A palavra \iostream.h" se refere ao arquivo de cabecalho. ele contem informac~oes

sobre cout necessarias ao nosso programa. #include se refere a uma diretiva do pre-
processador. Essa diretiva tem como efeito que o conteudo \iostream.h" seja lido dentro
de nosso arquivo texto. Mais adiante discutiremos com mais detalhes as diretivas do
preprocessador.
Uma vez que o programa esteja constitudo num arquivo, o proximo passo e compila-
lo. O nome do comando usado para chamar o compilador C++ depende do sistema
operacional e, portanto, n~ao o discutiremos aqui. Discutiremos, apenas, o processo de
compilac~ao.
Parte do trabalho do compilador e analizar o texto do programa para dectar possveis
erros. O compilador n~ao pode detectar se o signicado de um programa esta correto, mas
ele pode dectar erros na forma(errpsde sintaxe) do programa.
Uma outra tarefa do compilador e traduzir formalmente o texto do programa correto.
Esta traduc~ao denominada gerac~ao de codigo, gera objetos ou instruc~oes em linguagem
~ MODULAR
de montagem entendida pelo computador, onde esta sendo executado. O resultado de uma
compilac~ao bem sucedida e um arquivo executavel.
Alem do compilador da linguagem e dos comandos C++, uma implementac~ao forne-
ce um conjunto de bibliotecas padr~ao. As bibliotecas de programas s~ao uma colec~ao de
func~oes precompiladas. Em C++, por exemplo, as entradas e as sadas s~ao suportadas
pela biblioteca padr~ao de C++. Os programadores podem usar func~oes de biblioteca dentro
de seus programas, do mesmo modo que usam func~oes que eles denem.
Na melhor das hipoteses, uma biblioteca de programas permite a um especialista empa-
cotar seus conhecimentos para serem usados por programadores. Uma boa biblioteca pode
ser t~ao facil e util de usar quanto um interruptor de energia eletrica, que nos permite,
mesmo sem entender profundamente eletricidade, usa-las para os mais diversos ns.
Entrada/sada
As entradas e sadas n~ao fazem parte da linguagem C++, mas s~ao suportadas por uma
biblioteca escrita em C++, conhecida como biblioteca iostream.
As entradas provinientes do terminal do usuario s~ao denominadas entradas padr~ao(standart
input, em inglês). Elas s~ao associadas ao objeto de iostream cin. As sadas direcionadas
ao terminal do usuario, denominadas sadas padr~ao, est~ao associdas ao objeto cout.
O operador de sada (<<) e usado para direcionar a sada padr~ao. Por exemplo,
cout << "A soma de 7 + 3 = ";
cout << 7 + 3;
cout << "\n";
A sequência de dois caracteres \nn" representa um caractere de nova linha. Quando

escrito, o caractere de nova linha tem como efeito que a sada seja direcionada a proxima
linha. Em vez de escrever o caractere de nova linha explicitamente podemos aplicar o
manipulador endl, predenido em iostream. endl insere um caractere de nova linha na
cadeia de sada. Em vez de escrever
cout << "\n";
poderemos escrever
cout << endl;
As sucessivas ocorrências do operador de sada podem ser concatenadas. Por exemplo,

cout << "A soma 7 + 3 = " << 7 + 3 << endl;
Cada operador de sada sucessivo e aplicado em cout. Para n~ao perder a legibilidade,
o comando de sada concatenado pode ser distribudo em varias linhas. As três linhas a
seguir constituem um unico comando.
~
cout << "A soma"
<< v1 << "+"
<< v2 << "= " << v1 + v2 << endl;
Analogamente, o operador de entrada (>>) e usado para ler um valor da entrada

padr~ao. Por exemplo, o seguinte programa implementa um algoritmo para ler dois valores,
determina o maior dos dois e escreve-o
void leia(int&, int&);

int max(int, int);
void escrevMax(int);
main()
{
int val1, val2, maxValor;
leia(val1,val2);
escrevaMax(maxVal);
}
void leia(int&,int&)
{
cout << "Por favor entre com dois n
umeros: ";
cin >> v1 >> v2;
}
int max(int v1, int v2)

{
if( v1 > v2)
return v1;
else
return v2;
}
void escrevaMax(int val)

{
cout << val
<< "
e o maior valor."
}
~ MODULAR
Faremos algumas observac~oes sobre esse programa. Os nomes das três func~oes fo-
ram listadas antes da denic~ao de main(). Esta lista inicial, denominada declarac~ao de
prototipo, informa ao programa que essas func~oes existem e suas denic~oes ocorrem em
algum lugar mais adiante do programa, ou num arquivo de biblioteca ou mesmo num ar-
quivo separado construdo pelo programador. Uma func~ao deve, sempre, ser declarada ao
programa antes de ser chamada. Um prototipo e uma maneira de conseguir isso. val1 e
val2 s~ao denominadas variaveis simbolicas. O comando
int val1, val2;
dene essas variaveis para o programa. As variaveis tambem devem ser conhecidas do

programa antes dele vir a usa-las.
v1 e v2, designadas por argumentos formais, constituem a lista de argumentos para
leia() e max(). val e o unico argumento formal de escrevaMax().
Quando esse programa for compilado e executado, ele fornece como sada o seguinte,
na hipotese de que usuario entrou com os valores 17 e 124.
Por favor entre com dois n
umeros: 17 124
124
e o maior valor
Os dois valores fornecidos pelo usuario, 17 e 124, est~ao separados por um brando. Os
brancos, tabs e novas linhas s~ao referidos como espacos em branco em C++. O comando
cin >> v1 >> v2;
lê, corretamente, os dois valores porque o operador de entrada (\>>" ) desconhece

qualquer espco em branco que ele encontra.
As declarac~oes de cin e cout est~ao no arquivo de biblioteca de C++, iostream.h. Se
o programador esquecer de incluir esse arquivo, cada referência a cin ou cout sera consi-
derado pelo compilador como um erro. O armazenamento de prototipos e o primeiro uso
de arquivos de cabecalho.
O terceiro iostream predenido, cerr, diz respeito ao erro padr~ao, ligado ao terminal do
usuario. cerr e usado para alertar o usuario de alguma condic~ao excepcional, que ocorre
durante a execuc~ao do programa. Por exemplo, o seguinte fragmento de codigo alerta o
programador para uma tentativa de dividir por zero:
if(v2==0)
{
cerr "erro: tente dividir por zero";
return;
}
v3 = v1/v2;
~
O seguinte programa lê, da entrada padr~ao, um caractere de cada vez ate o m-de-
arquivo a ser encontrado. A sua sada e a seguinte:
contaLinha contaCaractere
A sua implementaca~o e a seguinte:
main()
{
char ch;
int contaLinha = 0, contaChar = 0;
while(cin.get(ch) ){
switch
{
case `\':
case ` ':
break;
case `\':
++contaLinha;
break;
default;
++contaChar;
}
}
cout << contaLinha << " " << endl;
}
get() e uma func~ao em iostream que lê um caractere de cada vez, colocando esse
caractere lido em seu argumento, no nosso caso ch. A sequência de dois caracteres `nt"
representa o caractere tab.
O comando switch fornece uma forma condicional de testar um valor. Se o valor
casar com um caso explicitado, os comandos seguintes default ser~ao executados. Para
cada caractere nova linha contaLinha e incrementado de um. contaChar e incrementado
de um cada vez que e lido um caractere que n~ao e branco, tab ou novaLinha. O comando
while, denominado laco, provê uma repetic~ao da execuc~ao de um conjunto de comandos
desde que a condic~ao seja verdadeira. Neste caso, o comando switch sera executado
enquanto get() lê um caractere da entrda padr~ao.
~ MODULAR
Uma palavra sobre comentarios
Comentarios servem como uma ajuda ao leitor humano de um programa. Eles podem
resumir o que faz um algoritmo, identicar o proposito de uma variavel, ou esclarecer
um fragmento de codigo obscuro. Os comentarios n~ao aumentam o tamanho do programa
executavel. Eles s~ao retirados pelo compilador antes da gerac~ao de codigo.
Existem dois delimitadores de comentarios em C++. O primeiro deles, o par de
comentarios \/* */", e o mesmo usado em C. O comeco de um comentario e indicado
por \/*". O compilador tratara tudo que estiver entre\/*" e \*/". como comentario. Um
comentario pode ser colocado em qualquer lugar onde seja permitido um tab, um espaco
em branco ou uma nova linha e pode abranger muitas linhas do programa. Por exemplo,
/*
* Este
e o primeiro contacto com a defini
c~ao de classe em C++.
* Classes s~
ao usadas tanto para abstra
c~
ao de dados como
* para programa
ca
~o orientada a objeto. Uma implementaca
~o
* da classe tela ser
a apresentada num cap
tulo adiante.
*/
Classe tela
{
/* Isto
e denominado corpo da classe*/
public:
void casa() /* move o cursor para 0,0 */
void refaz() /* redesenha a tela */
private:
/* Classes suportam "encapsulamento de informa c~
ao" */
/* encapsulamento de informac
ao restringe que um programa */
/* tenha acesso a uma representa ca
~o interna de */
/* uma classe(seus dados). Isto e realizado atrav
es do uso de
/* private:" */
char *cursor; /* posi
c~ao corrente da tela */
}
Existem muitos comentarios entremeados com os codigos do programa, o que pode

obscurecer o proprio codigo. Por exemplo, a declarac~ao de cursor esta quase imperceptvel.
Em geral, e prefervel um bloco de comentarios acima do texto que ele esta explicando.
Pares de comentarios n~ao podem estar aninhados. Isto e, um par de comentarios n~ao
pode ocorrer dentro de um outro par.
O segundo delimitador de comentarios, indicado por uma dupla barra, (\//"), serve
para delimitar uma unica linha de comentarios. Tudo na linha do programa a direita do
delimitador e tratado como um comentario e ignorado pelo cmpilador. Por exemplo,
~
#include "meu-io.h"
e
int Impar(int);
main()
{
int v1, v2; // cont
em valores do usu
ario
leia(v1,v2); // declarado em meu-io.h
e
if( Impar(v1) == 1)
cout << v1
e
<< " Impar \n";
e
if( Impar(v2) == 1)
cout << v2
e
<< " Impar\";
}
e
Impar(int val)
{
/* retorna 1 se val
e
mpar; caso contr
ario 0
/* %
e o operador de m
odulo: 3%2 resulta 1. */
return val % 2 !=0;
}
Este programa determina se os valores s~ao mpares. Ele reusa a func~ao leia(), denida
na sec~ao anterior. O prototipo desta func~ao foi armazenado num arquivo de cabecalho,
chamado meu-io.h. Quando o programa for compilado e executado sua sada tem a se-
guinte aparência, na hipotes de que o usuario entrou com os valores 498 e -25:
Por favor entre dois valores inteiros: 498 -25
498
e par
-25
e
mpar
Os caracteres de ambos os delomitadores de comentarios n~ao podem ser separados por
espacos em branco. As duas linhas seguintes, por exemplo, n~ao podem ser considerados
como comentarios, mas como um texto do programa:
/* n~
ao
e um coment
ario: espa
co em branco n~
ao
e permitido */
// tamb
em n~
ao
e um coment
ario: deve ser //
Os programas, tipicamente, contem uma mistura de ambos as formas de comentarios.
As explicac~oes multilinhas s~ao, em geral, colocadas entre barras de cmentarios. Metade
de linha e unica linha s~ao, geralmente, comentados por barra dupla.
~ MODULAR
Diretivas do preprocessador
As bibliotecas padr~ao s~ao um conjunto de arquivos de cabecalhos padr~ao, tais como ios-
tream.h. Esses arquivos de cabecalhos contem todas as informac~oes requeridas pelo usuario
de mdo a que ele faca uso da biblioteca. Para poder acessar uma variavel ou uma funca~o
denida na biblioteca padr~ao, devemos incluir no nosso programa o arquivo de cabecalho
correspondente.
Os arquivos de cabecalho tornam-se parte de nosso programa atraves da diretiva inclu-
de. As diretivas s~ao especicadas colocando-se o sinal \#" no incio das linhas atraves
das quais queremos incluir, em nosso programa, algum arquivo.
As diretivas s~ao processadas antes que o codigo fonte seja compilado. O programa que
manipula as diretivas e denominado precompilador.
A diretiva de #include lê o conteudo dos arquivos nomeados. Ela pode ter uma das
seguinte formas:
#include "meu-io.h"
Se o nome do arquivo esta entre < > presume-se que o arquivo seja de cabecalho
predenido ou padr~ao. Para pesquisar sua localizac~ao o preprocessador examinara um
conjunto predenido de localizac~oes.
Se o nome do arquivo esta sob aspas duplas, presume-se que o arquivo de cabecalho
e fornecido pelo usuario. O arquivo includo pode, ele proprio, conter uma diretiva
#include, e isto, em geral, causa problemas. Neste caso s~ao usados diretivas condicionais
para se evitar o multiplo processamento de um arquivo de cabecalho. Por exemplo,
#ifndef STRING_H
#define STRING_H
/* O conte
udo de STRING.H vai aqui */
#endif
A diretiva condicional #ifndef e avaliada como verdadeira se o nome que segue n~ao
esta ainda denido. Quando uma diretiva condicional for avaliada como verdadeira, as
linhas subsequentes ate um #endif ser encontrada s~ao includas. Se a diretiva condicional
for avaliada falsa, as linhas entre ela e a diretiva #endif s~ao ignoradas.
A diretiva #dene dene um nome que segue. No nosso exemplo, ela dene STRING H.
Se o arquivo de cabecalho string.h for includo novamente a diretiva #ifndef sera avaliada
falso. O conteudo de string.h n~ao sera mais includo. Por exemplo,
#ifdef u3b2
/* c
odigo espec
fico do sistema
* para computaores AT&T 3B vai aqui */
5.3. EXERCICIOS 117
#endif
#ifdef sun3
/* c
odigo espec
fico do sistema
* para a esta
c~
ao de trabalho sun/3 vai aqui */
C++ predene o nome -cplusplus. O usuario que desejar misturar codigo de programa
em C com o de C++ deve escrever o seguinte:
#ifdef__cpp
extern min(int, int);
int *pt = novo int;
#else
extern min();
int *pt;
#endif
Os comandos entre a diretiva #else e #endif ser~ao includos se a diretiva #ifdef

ou#ifndef for avaliada falso.
5.3 Exerccios
Viviane vol1 pag 180.
~ MODULAR
Captulo 6
DADOS ESTRUTURADOS
6.1 Introduc~ao
A ciência da computac~ao poderia ser considerada como o estudo de algoritmos. Como
ja sabemos, um algoritmo e um conjunto bem determinado de instruc~oes que, quando
seguidas desempenham um papel particular. Existe uma relac~ao bastante proxima entre
a estruturac~ao dos dados e a construc~ao de algoritmos. De fato, a estrutura de dados e
o algoritmo devem ser considerados como unidade, nenhum dos dois faz sentido sem o
outro. Por exemplo, considere uma lista de m pares de nomes e numeros de telefones,
f(n1; t1); (n2; t2); :::; (nm; tm)g, e suponha que pretendemos construir um programa que,
dado o nome da pessoa imprime o numero do telefone dessa pessoa. A tarefa e chamada
de busca. A maneira de como escreveremos esse algoritmo depende de como os nomes e
os numeros dos telefones estiverem armazenados ou estruturados.
Todas as estruturas de dados podem ser razoavelmente construdas dentro de uma
linguagem de programac~ao convencional. A estrutura de dados deve ser projetada de modo
que possamos saber o que ela faz(especicac~ao) e como ela vai fazê-lo(implementac~ao).
Uma estrutura de dados descreve o conjunto de operac~oes que podem ser aplicadas
legalmente aos objetos de dados. Por isso deveremos especicar o conjunto de operac~oes
e explicar como elas funcionam. Por exemplo, para o tipo inteiro temos as operac~oes
aritmeticas +, , , = e mod e as relac~oes >, <, , etc. Os objetos de dados numeros
inteiros conjuntamente com a descric~ao de como se comportam as operac~oes e as relac~oes
constituem a denic~ao da estrutura de dados.
Uma implementac~ao de uma estrutura de dados e um mapeamento que especica como
cada objeto sera representado. Assim, os inteiros ser~ao representados pela serie de bits,
os boleanos por zero e um e uma matriz por um conjunto de palavras consecutivas na
memoria.
119
120 CAPITULO 6. DADOS ESTRUTURADOS
6.2 Tipos abstratos de dados
Tipo de dados e o termo que pode ser atribudo aos grupos de dados, que podem ser su-
portados pelas variaveis dentro de uma linguagem de programac~ao. Um tipo abstrato
de dados e uma estrutura de objetos, operac~oes e relac~oes especicados por um formalis-
mo matematico. Exemplos de tipos abstratos de dados s~ao: booleanos, numeros inteiros,
numeros naturais, numeros reais, numeros complexos, vetores, grafos, arvores, etc. Den-
tro de cada linguagem de programac~ao existe embutida uma colec~ao de tipos de dados.
Isto signica que a linguagem permite as variaveis nomear os dados de determinado tipo
e fornecer um conjunto de operac~oes que manipulam essas variaveis.
Alguns tipos de dados s~ao fornecidos de maneira simples, pois ja est~ao embutidos no
conjunto de instruc~oes da maquina do computador ou e includo como um tipo abstrato
pelo usuario. Em outras palavras, para calcular o valor de uma express~ao constituda por
variaveis de tipos de dados embutidos(predenidas) ou includas pelo usuario(tipo abstra-
do denido pelo usuario) tudo que precisamos fazer e fornecer a express~ao a ser calculada
ao compilador, sem necessidade, portanto, de construir um programa para calcular essa
express~ao. Para esses tipos de dados tudo se passe como se o computador fosse uma
maquina de calcular. Exemplos de tipos embutidos na maioria das linguagens de progra-
mac~ao s~ao: os numeros inteiros, os naturais, os reais etc. Outros tipos de dados precisam
de um esforco consideravelmente maior para a sua implementac~ao. Em algumas lingua-
gens existem dispositivos que permitem construir as combinac~oes dos tipos embutidos.
E importante observar que a denic~ao(especicac~ao) de um tipo abstrato de dados n~ao
nos diz como ele sera implementado numa linguagem de programac~ao.
Desenvolveremos algoritmos e estruturas de dados no contexto de orientac~ao a objeto
usando C++. Por isso projetaremos cada estrutura de dados como um tipo abstrato que
dene tanto a organizac~ao dos dados quanto as operac~oes que manuseiam esses dados,
assim como as relaco~es entre eles. Essa estrutura, chamada tipo abstrato de da-
dos(TAD), e um modelo abstrato que descreve a interface entre um cliente(o usuario) e
os dados. A linguagem de programac~ao C++ providencia o conceito de classe(class) para
implementar ou representar um TAD e os itens do tipo classe, chamado objetos, para
armazenar e manuzear dados numa aplicac~ao.
A abstraca~o dene o domnio e a estrutura de dados, assim como uma colec~ao de
operac~oes que acessam esses dados.
Formato de um TAD
Um TAD e constitudo dos seguintes elementos:
o seu nome;
uma descrica~o dos tipos de dados;
6.2. TIPOS ABSTRATOS DE DADOS 121
uma lista de operac~oes;
uma lista de relac~oes.
Para cada operaca~o(uma relac~ao sera vista como uma operac~ao booleana) deveremos
especicar:
Os valores de entrada que s~ao fornecidos pelo cliente.
A precondic~ao que deve ser aplicada aos dados antes que a operac~ao possa ser
efetuada.
O processo que e efetuado pela operac~ao.
Os valores de sada que s~ao retornados aos clientes.
A poscondic~ao que indica qualquer alterac~ao nos dados.
Muitos TAD's tem uma operac~ao de inicializac~ao, o inicializador que atribui valores
iniciais aos dados. No ambiente C++, o inicializador e chamado um construtor.
Assim um TAD tem o seguinte formato:
TAD nomeDoTAD
Dados
Descreve a estrutura dos dados
Operaco~es
Construtor
Valores iniciais: Dados usados para inicializar os objetos.
Processo: Inicializa os objetos.
Operaca~o1
Entrada: Dados do cliente.
Precondic~oes: O estado necessario do sistema antes de executar.
a operac~ao.
Processo: Ac~oes efetuadas sobre os dados.
Sada: Dados retornados pelo cliente.
Poscondic~ao: O estado do sistema apos executar a operac~ao.
Operaca~o2
Operaca~o3
.
.
.
Operaca~oN
m nomeDoTAD
6.3 Tipos de dados basicos

A seguir, por quest~ao de completude, introduziremos uma serie de tipos de dados basicos
que incluem os numeros, os caracteres, tipos enumerados denidos pelo usuario e pon-
teiros. Estes tipos est~ao embutidos na maioria das linguagens de programac~ao. Cada
tipo de dados basico inclui dados e operac~oes, os componentes de um tipo abstrato de
dados(TAD). As linguagens de programac~ao implementam TAD's no computador usando
diferentes representac~oes para os dados, incluindo numeros binarios e o conjunto de carac-
teres ASCII. Continuaremos usando a linguagem de programac~ao C++ para implementar
os TAD's.
Os tipos numeros, caracteres e ponteiros descrevem dados simples porque os objetos
desses tipos n~ao podem ser divididos em partes mais simples. Por outro lado, os tipos de
dados estruturados tem componentes que s~ao construdos de tipos simples com regras para
denir relac~oes entre suas componentes. Dentre os tipos estruturados est~ao as matrizes1,
1 Alguns autores chamam esses tipos de vetores. Usaremos sem nenhuma mens~ao explcita qualquer

6.3. TIPOS DE DADOS BASICOS 123
strings(cadeias), registros(ou estruturas, como eles s~ao denominados em C++), arquivos,
listas, pilhas, las, arvores, grafos e tabelas. Estudaremos os três primeiros, deixandos
os demais para o proximo curso denominado \Algoritmo e estruturas de dados". Muitas
linguagens de programac~ao providenciam construtos ou biblioteca de func~oes para mani-
pular matrizes, strings, registros, arquivos. 2 Como tal, chamaremos esses tipos de dados
estruturados de tipos embutidos. Providenciaremos tipos de dados abstratos para esses
tipos estruturados embutidos e discutiremos suas implementac~oes em C++.
Tipos inteiros
Os inteiros positivos ou negativos consistem de um sinal e uma sequência de dgitos. Aos
inteiros nos referiremos como numeros com sinal. Por exemplo, o que segue s~ao exemplos
de valores inteiros especcos chamados constantes inteiras:
+35; 278; 19(o sinal e +); 28976510

Quem estiver familiarizado com a aritmetica elementar sabe que podemos denir uma
serie de operadores que resultam em novos valores inteiros. Operadores que recebem ou
um simples operando(operadores unarios) ou dois operandos(operadores binarios) criam
express~oes inteiras:
(Unario +) +35 = 35 (subtrac~ao -) 73 - 50 = 23
(Adic~ao +)4 + 6 = 10 (Multiplicac~ao *) -3*7 = -21
As express~oes inteiras podem ser usadas com os operadores relacionais da aritmetica
para produzir um resultado que seja verdadeiro ou falso.
(Menor do que relacional) 5<7 (verdade)
(Maior do que ou igaul relacional) 10>=18 (falso)
Teoricamente, os inteiros n~ao possuem limites de tamanho, um fato que esta re etido
na denic~ao do TAD.
Os TAD's que providenciaremos para os tipos primitivos assumem que o aluno esteja
familiarizado com as precondic~oes, a entrada e as poscondic~oes para cada operac~ao. Por
exemplo, uma especicac~ao da divis~ao inteira e:
Divis~
ao inteira
Entrada: Dois valores inteiros u e v.
Precondi
c~
oes: O denominador v n~
ao pode ser 0.
um desses dois nomes.

2 Mais recentemente, a partir de 1998, a linguagem C++ est
a providenciando classes abstratas ate
para essas outras estruturas de dados.
Processo: Divide u por v, usando a divis~
ao inteira.
Sada: O valor do quociente.
P
oscondi
c~
oes: Vai existir uma condi
c~
ao de erro se v=0.
Em nossas especicaco~es, usaremos a notac~ao de operadores de C++ em lugar de

nomes de operac~oes genericas e tambem somente descreveremos processo.
O TAd inteiro
e
Dado
Um n
umero inteiro N com sinal.
Opera
c~oes
Assuma que u e v s~ao express~
oes inteiras, e N
e
uma variavel inteira.
Atribui
ca~o
= N = u Atribui o valor da express~
ao u
a vari
avel N.
Operadores aritm
eticos bin
arios
+ u + v Adiciona dois valores inteiros.
- u - v Subtrai dois valores inteiros.
* u * v Multiplica dois valores inteiros.
/ u / v Computa o quociente usando divis~
ao inteira.
% u % v Computa o resto usando divis~
ao inteira.
Operadores aritm
eticos un
arios
- -u Troca o sinal (Menos un
ario).
+ +u +u
e o mesmo que u (Mais un
ario).
Operadores relacionais
(A express~
ao relacional
e verdadeira sob a condi
c~
ao
dada.)
== u == v Resulta verdadeiro se u e igual a v.
!= u != v Resulta verdadeiro se u n~ao for igual a v.
< u < v Resulta verdadeiro se u for menor que v.
<= u <= v Resulta verdadeiro se u for menor ou igual
a v.
> u > v Resulta verdadeiro se u for maior que v.
>= u >= v Resulta verdadeiro se u for maior ou igual
a v.
fim TAD inteiro.

Exemplo 32 3 + 2 (A express~
ao tem valor 5)
val = 25 / 20 (val = 1)
resto = 25 % 20 (resto = 5)
Armazenamento dos inteiros no computador

A implementac~ao dos inteiros e providenciada pelas declarac~oes de tipo numa linguagem
de programac~ao e o hardware do computador. Os sistemas de computac~ao armazenam os
inteiros em blocos de memoria de tamanho xo. O domnio de valores resultante pertence
a um intervalo nito. O tamanho do bloco de armazenamento e o intervalo de valores
dependem da implementac~ao. Para conseguir certa padronizac~ao, as linguagens de pro-
gramac~ao fornecem tipos de dados primitivos embutidos para os inteiros pequenos(short) e
grandes(long). Quando s~ao necessarios valores inteiros muito grande, uma aplicac~ao de-
ve fornecer uma biblioteca de subprogramas para efetuar essas operac~oes. Uma biblioteca
de operac~oes sobre os inteiros pode estender a implementac~ao dos inteiros para qualquer
tamanho, embora usualmente as rotinas diminuam a eciência de execuc~ao de uma apli-
cac~ao.
Num computador, os inteiros s~ao armazenados como numeros binarios, que consis-
tem de diferentes sequências dos dgitos 0 e 1. A representac~ao e modelada na base 10
ou sistema decimal, que usa os dgitos 0, 1, 2, ..., 9. Um numero decimal e armazenadoo
como um conjunto de dgitos d0 ; d1; d2 ; etc., representando as potências de dez. Por
exemplo, o numero de k dgitos
N = dk dk :::d d ; para 0 di 9
10 1 2 1 0
representa
N = dk (10k ) + dk (10k ) + ::: + di(10i ) + ::: + d (10 ) + d (10 )

10 1
1
2
2
1
1
0
0
O ndice 10 indica que N esta escrito como um numero decimal. Por exemplo, o
numero inteiro de 4-dgito 2589 representa
2589 = 2(10 ) + 5(10 ) + 8(10 ) + 9(10 ) = 2(1000) + 5(100) + 8(10) + 9
10
3 2 1 0
Os inteiros binarios usam os dgitos 0 e 1 e as potências de 2(2 = 1; 2 = 2; 2 =

0 1 2
4; 2 = 8; 2 = 16; etc.). Por exemplo, 13 tem a representac~ao binaria

3 4
10
13 = 1(2 ) + 1(2 ) + 0(2 ) + 1(2 ) = 1101

10
3 2 1 0
2
Um dgito binario e chamado um bit. Em geral, um numero binario com k dgito ou

k bit tem a representac~ao
0 0 1 0 0 0 1 1
Figura 6.1: O numero 35 como um byte
N = bk bk :::bi:::b b = bk (2k ) + bk (2k ) + ::: + bi(2i ) + ::: + b (2 ) +

2 1 2 1 0 1
1
2
2
1
1
b (2 ); 0 bi 1
0
0
O seguinte numero de 6-bit e a representac~ao binaria de 42. O valor decimal de um

numero binario e computado adicionando os termos na soma:
101010 = 1(2 ) + 0(2 ) + 1(2 ) + 0(2 ) + 1(2 ) + 0(2 ) = 42
2
5 4 3 2 1 0
10
Exemplo 33 Calcular o valor decimal do numero binario:

1. 1101012 = 1(25 ) + 1(24) + 0(23 ) + 0(21 ) + 1(22 ) + 1(20 ) = 5310
2. 100001102 = 1(27 ) + 1(22) + 1(21) = 13410
A convers~ao de um numero decimal a seu equivalente binario pode ser feito achando
a maior potência de 2 que seja menor ou igual ao numero. A progress~ao das potências de
2 s~ao 1, 2, 4, 8, 16, 32, 64, etc. Isto fornece o dgito principal na representac~ao binaria.
Preenchendo o resto das potências de 2 com 0. Por exemplo, considere o valor 35. A
maior potência de 2 que e menor que 35 e 32 = 25, o que implica que 35 e um numero
binario de 6 dgitos:
35 = 1(32) + 0(16) + 0(4) + 1(2) + 1 = 100011

10 2
Os numeros binarios puros s~ao simplesmente a soma das potências de 2. Eles n~ao
possuem sinal e s~ao designados por numeros sem sinal(unsigned). Os numeros repre-
sentam inteiros positivos. Os inteiros negativos usam a representac~ao do complemento de
dois ou a magnitude de sinal. Em qualquer um desses formatos, um bit especial, chamado
bit de sinal, indica o sinal do numero.
Dados na memoria
Os numeros s~ao armazenados na memoria como sequências de dgitos binarios de com-
primento xo. Dentre os comprimento mais comuns est~ao 8, 16 e 32 bits. Uma sequência
de 8 bits e chamada um byte.
A tabela 6.1 fornece o intervalo dos numeros com sinal e sem sinal para os tamanhos
mais comuns.

Tamanho intervalo dos numeros sem sinal intervalo dos numeros com sinal
8(1 byte) 0 a 255 = 2 1
8
2 = 128 a 127 = 2 1
7 7
16(2 bytes) 0 a 65.535=2 1 16

2 = 32768 a 32767 = 2 1
15 15
32(4 bytes) 0 a 4.294.967.295=2 132

2 a2 1
31 31
Tabela 6.1: Intervalos dos numeros e tamanho dos bits

01010111 00000001 11110100
enderecos 0 1 2 3 4 5
Figura 6.2: Uma vista da memoria
A memoria do computador e uma sequência de bytes referenciada pelos enderecos 0, 1,

2, 3, 4 e assim por diante. Na memoria, o endereco do inteiros e a localizac~ao do pri-
meiro byte da sequêcia. A gura 6.4 ilustra uma vista da memoria com o numero 87710 =
10101112 armazenado em um byte no endereco 3, e o numero 50010 = 00000001111101002
na memoria de endereco 4.
Representac~ao de inteiros em C++

Os tipos inteiros em C++ s~ao int, short int e long int. O tipo short int(short) fornece
um valor inteiro de 16-bits no intervalo -32768 a 32767. O tipo long int(long) fornece
o maior intervalo de valores inteiros e na maioria dos sistemas e implementado com 32
bits(4 bytes), com um intervalo de 231 a 231 1.
O tipo int, em geral, identica os inteiros e s~ao dependentes da maquina e do com-
pilador. Tipicamente, os compiladores usam inteiros de 16-bits ou 32-bits. Em alguns
casos, o usuario pode selecionar o tamanho do inteiro como uma opc~ao. Os tipos de
dados inteiros especicam um domnio de valores de dados e um conjunto de operadores
aritmeticos e relacionais. Cada tipo de dados fornece uma implementac~ao do TAD inteiro
com a restrica~o de que os valores inteiros estejam no intervalo nito.
Tipos de caracteres
Os tipos de dados caracteres incluem itens alfanumericos que denem as letras minusculas
e maiusculas, dgitos, sinais de pontuac~ao e alguns smbolos especiais. A industrias de
computadores usam representac~oes diferentes de caracteres nas aplicac~oes. O conjunto
de caracteres com 128 elementos na tabela ASCII tem a mais ampla aplicac~ao no pro-
cessamente de palavras, entrada e sada de textos e comunicac~ao de dados. Usaremos o
conjunto ASCII para nosso TAD de caracteres. Assim como os inteiros, os caracteres
ASCII contem uma relac~ao de ordem que dene uma serie de operadores relacionais. Pa-
ra os caracteres alfanumericos, as letras seguem a ordem do dicionario. Nesta relac~ao,
todas as letras maiusculas s~ao menores que as letras minusculas:
T < W; b < d; T < b

O TAD caracteres
e
Dados
O conjunto de caracteres da tabela ASCII.
Opera
c~oes
Atribui ca
~o
Um valor de caractere pode ser atribu
do a uma vari
avel
de caractere.
Relacional
Os seis operadores relacionais padr~
ao se aplicam a caracteres
usando a rela
ca
~o de ordem do dicion
ario da tabela ASCII.
fim TAD caracteres
Os caracteres ASCII
A maioria dos sistemas de computadores usam o esquema de codigo padr~ao ASCII para
a representaca~o de caracteres. Os caracteres ASCII s~ao armazenados como um codigo de
inteiros de 7-bits em um numero de 8-bits. Os 27 = 128 codigos diferentes s~ao divididos
em 95 caracteres imprimveis e 33 caracteres de controles. Um caractere de controle e
usado em comunicac~ao de dados e faz com que um dispositivo forneca uma func~ao de
controle, como o movimento de um cursor para cima e para baixo na tela do monitor.
A tabela 6.3 mostra o conjunto de caracteres imprimveis ASCII. O caractere branco
e representado por }. O codigo decimal para cada caractere e dado com os dez dgitos
nas linhas e um dgito nas colunas. Por exemplo, O caractere `T' tem valor ASCII 8410
e e armazenado em binario como 010101002 .
Dentro do conjunto de caracteres ASCII, os dgitos decimais e os caracteres alfabeticos
caem dentro de um intervalo bem denido(tabela 6.2). Isto facilita a convers~ao entre
letras maiusculas e minusculas e de um dgito ASCII(`0', `1', ..., `9') ao numero corres-
pondente(0, 1, ..., 9).
Exemplo 34 Os valores ASCII para os dgitos '0` e 48. Os dgitos s~ao
ordenados no intervalo de 48 a 57:
Dgito ASCII: `3' e 51(48 + 3)

Dgitos da direita
Dgitos da esquerda 0 1 2 3 4 5 6 7 8 9
3 } ! " # $ % & 0
4 ( ) + ` : = 0 1
5 2 3 4 5 6 7 8 9 : ;
6 < = > ? @ A B C D E
7 F G H I J K L M N O
8 P Q R S T U V W X Y
9 Z [ n ] ^ ` a b c
10 d e f g h i j k l m
11 n o p q r s t u v w
12 x y z f j g
Figura 6.3: Conjunto de caracteres ASCII imprimveis
Caracteres Decimal Binario

Espaco em branco 32 00100000
dgitos decimais 48-57 00110000-00111001
Letras maiusculas 65-90 00110000-00111001
Letras minusculas 97-122 01100001-01111010
Tabela 6.2: Intervalo dos caracteres ASCII
Os dgitos numericos correspondentes e obtido subtraindo `0'(48 ASCII):
Dgito numerico: 3 = `3' - `0' = 51 = 48
Para converter um caractere de minuscula para maiusculas, adicione 32
ao valor ASCII do caracterre:
ASCII(À')=65 ASCII(à') = 65 + 32 = 97
Em C++, o tipo primito char e usado para armazenar um caractere. Os codigos
ASCII est~ao no intervalo 0-127: entretanto, encontramos, com frequência, dependentes-
do-sistema, caracteres estendidos denidos para usar o resto dos valores no intervalo.
Como um tipo de dados inteiros, o valor e o codigo para o caractere.
Tipos de dados reais

Os tipos inteiros, que nos referimos como tipos discretos, representam valores de dados
que podem ser contados, por exemplo, -2, -1, 0, 1, 2, 3, e assim por diante. Muitas apli-
cac~oes requerem numeros que tem valores fracionarios. Esses valores, chamados numeros
reais, podem ser representados num formato de ponto xo com uma parte inteira e uma
parte fracionaria:
9; 6789 6; 245 + 18; 23

Os numeros reais podem ser escritos como numeros em ponto utuante em notac~ao
cientca. Este formato representa os numeros como uma serie de dgitos chamados a
mantissa e o expoente, que representam uma potência de 10. Por exemplo, 6,02 e 23
tem uma mantissa de 6,02 e um expoente de 23. Um numero de ponto xo e exatamente
um caso particular de um numero em ponto utuante com um expoente 0. Exatamente
como para os inteiros e os caracteres, os numeros reais constituem um tipo abstrato de
dados. A aritmetica padr~ao e as operac~oes racionais se aplicam com a divis~ao real usada
no lugar da divis~ao inteira.
1. O TAD real
e
Dados
N
umeros descritos com o formato ponto-fixo ou ponto flutuante.
Opera
c~oes
Atribui co
~es
Uma express~ao real pode ser atribu
da a uma vari
avel real.

Operadores aritmeticos
As opera
co~es aritm
eticas padr~
ao un
aria e bin
arias se aplicam
com a divis~ao real usada no lugar da divis~
ao inteira. N~
ao existe
operador de resto.
ao se aplicam aos n
umeros reais.
fim TAD real
Representac~ao dos numeros reais

Exatamente como os inteiros, o domnio dos numeros reais n~ao tem limite. Os valores dos
numeros s~ao ilimitados nas direc~oes negativas e positivas. A parte fracionaria aplica os
numeros reais sobre o contnuo de pontos numa linha reta. Os numeros reais s~ao imple-
mentados num bloco de armazenamento nito que limita o escopo dos valores, formando
pontos discretos numa reta.
Durante muitos anos, os pesquisadores de computadores tem usado varios tipos de
formatos para armazenar os numeros em ponto utuantes. O formato IEEE(Institute
of Electrical and Eletronics Engineers) e um padr~ao muito usado. Os numeros reais no
formato em ponto-xo s~ao separados numa parte inteira e numa parte fracionaria cujos
dgitos s~ao multiplicados por 101 , 100
1
, 1000
1
, e assim por diante. Uma vrgula decimal
separam as partes:
25; 638 = 2(10 ) + 5(10 ) + 6(10 ) + 3(10 ) + 8(10 )

1 0 1 2 3
Assim como para os numeros inteiros, existem representac~oes binarias correspondentes

para os numeros reais de ponto xo. Essses numeros contem uma parte inteira, uma parte
de frac~ao binaria e uma vrgula binaria, com os dgitos fracionarios correspondentes a 12 ,
1
, 1 , e assim por diante. A forma geral para tal representac~ao e
4 8
N = bn:::b :b b ::: = bn2n + ::: + b 2 + b 2 + b 2 + :::

0 1 2 0
0
1
1
2
2
Por exemplo,
10111; 11012 = 1(23 ) + 1(21) + 1(20) + 1(2 1 ) + 1(2 2 ) + 1(2 4 ) = 8 + 2 + 1 + 0; 5 +
0; 25 + 0; 0625 = 11; 812510
A convers~ao de numeros decimais para numeros binarios em ponto utuante usa algo-
ritmos analogos aqueles desenvolvidos para numeros inteiros. A convers~ao para numeros
decimais e realizada adicionando os produtos dos dgitos e as potências de 10. O processo
inverso e mais complexo, pois os numeros podem precisar de uma representac~ao binaria
innita para criar o numero em ponto utuante equivalente. No computador, o numero de
dgitos e limitado pois somente s~ao usados numeros em ponto utuante de comprimento
xo.
Exemplo 35 Converter um numero binario em ponto xo para decimal:
1. 0; 011012 = 14 + 18 + 321 = 0; 25 + 0; 125 + 0; 03125 = 0; 4062510
Converter o numero decimal para um numero binario em ponto utuant.
2. 4; 312510 = 4 + 0; 25 + 0; 0625 = 100; 01012
3. O numero decimal 0,15 n~ao tem uma frac~ao binaria de compriemento
xo equivalente. A convers~ao de um decimal para uma frac~ao binaria
requer uma expanc~ao innita binaria. Pelo fato do armazenamento do
computador ser restrito a numeros de comprimento xo, a cauda da ex-
panc~ao innita e uma soma parcial nita que e uma aproximac~ao do
valor decimal:
10
1 + 1 + 1 + ::: = 0; 0010011001:::
0; 15 = 81 + 64 128 1024
Muitos computadores armazenam numeros reais na forma binaria usando notac~ao
cientca, com um sinal, mantissa e expoente:
N = +Dn Dn :::D D ; d d :::dn 2e

1 1 0 1 2
C++ suporta três tipos de dados reais, oat, double, e double long. O tipo double
long esta disponvel para calculos que requerem alta precis~ao e n~ao usaremos em nossas
notas. Com frequência, o tipo oat e implementado usando o formato IEEE de ponto
utuante de 32-bits, enquanto o formato de 64-bits e usado para o tipo double.
Tipos enumerados
O conjunto de caracteres ASCII usa uma representac~ao inteira dos dados caracteres.
Uma representac~ao similar pode ser usada para descrever conjuntos de dados denidos
pelo programador. Por exemplo, o que segue e uma listas dos mezes de 30 dias:
abril; junho; setembro; novembro

O conjunto dos meses forma um tipo de dados enumerado. Para cada tipo, a
ordem dos itens e determinado pela maneira como os itens s~ao listados. Por exemplo,

Cor do cabelo
preto // primeiro valor

loiro // segundo valor
castanho // terceiro valor
fogo // quarto valor
preto loiro castanho fogo

O tipo suporta uma operaca~o de atribuic~ao e os operadores relacionais padr~ao.
Por exemplo,
preto<fogo // preto ocorre antes de fogo
castanho>=loiro // castanho ocorre apos loiro
Um tipo enumerado tem dados e operadores e portanto constitui um TAD.
o TAD enumerado
e
Dados
Lista de N itens distintos definidos pelo usu
ario.
Opera
c~oes
Atribuic~
ao
Qualquer item da lista pode ser atribu
do a uma vari
avel
do tipo enumerado.
Os seis operadores relacionais usam a rela
c~
ao de ordem determinada
pelos itens que s~
ao listadas.
fim do TAD enumerado
Implementac~ao em C++ do tipo enumerado

C++ tem um tipo enumerado que dene valores inteiros distintos referenciados pelas
constantes nomeadas.
Exemplo 36 O tipo booleano pode ser declarado como um tipo enume-
rado. O valor da constante falsa e 0, e o valor de verdadeiro e 1. A
variavel pronto e denida como booleana com valor inicial falsa.
enum booleana {falsa, verdadeira};
booleana pronto = falsa;

char=À' short int = 25
5000 5000 5001
(a) (b)
Figura 6.4: Tipo de dados ponteiro
Os meses do ano s~ao declarados como um tipo enumerado. Por con-

venc~ao, o valor inicial de janeiro e 0. Entretanto, a sequência inteira
pode comecar num outro valor, contanto que se atribua esse valor ao pri-
meiro item. Neste caso, jan e 1 e os meses correspondem a sequência 1,
2, ..., 12.
1. enum mes {jan=1, fev, mar, abril, maio, jun, jul, aug, set, out, nov, dez}
mes = dec;
Ponteiros
O tipo de dados ponteiro e fundamental em qualquer linguagem de programac~ao. Um
ponteiro e um inteiro sem sinal que representa um endereco de memoria. O ponteiro
tambem serve como uma referência aos dados no endereco. No endereco do ponteiro, o
tipo do dado e chamado um tipo base e e usada na denic~ao do ponteiro. Por exemplo,
descrevemos um ponteiro para um caractere, um ponteiro para um inteiro, e assim por
diante. Por exemplo, o ponteiro ptr tem valor 500 em cada um dos casos da gura 6.4.
Entretanto, em (a) o ponteiro referencia um caractere e em (b) o ponteiro referencia um
inteiro short.
Um ponteiro possibilita um acesso eciente aos itens numa lista e e fundamental no
desenvolvimento de estruturas de dados dinâmicas tais com listas encadeadas, arvores e
grafos.
O TAD ponteiro
Exatamente como um numero, um ponteiroo faz uso de certos operadores aritmeticos e
relacionais. As operac~oes aritmeticas requerem atenc~ao especial. Um ponteiro pode ser
incrementado ou decrementado por um valor inteiro para referenciar um novo dado na
memoria. Adicionando 1 atualiza o ponteiro para referenciar o proximo item daquela tipo
na memoria. Por exemplo, se ptr aponta para um objeto caractere, ptr + 1 aponta para o
proximo byte na memoria. Adicionar k > 0 tem como efeito mover o ponteiro k posic~oes
de dados para a direita. Por exemplo, se ptr aponta para um double, ptr + k referencia o
double:

N = sizeof (double) k bytes a direita de p

Tipo de dados Endereco corrente Novo endereco
char p = 5000 p + 1 = 5001
int (2 bytes) p = 5000 p + 3 = 5000 + 3*2 = 5006
double (4 bytes) p = 5000 p - 6 = 5000 -6*4 = 4976
Um ponteiro usa o operador de endereco \&" que retorna o endereco na memoria de
um item de dado. Inversamente, o operador \*" referencia o dado associado ao valor de
ponteiro. Os ponteiros s~ao ordenados comparando seus valores inteiros sem sinal.
A memoria dinâmica e uma nova memoria alocada durante a execuc~ao de um pro-
grama. A memoria dinâmica difere da memoria estatica cuja existência e determina-
da a priori para comecar a execuc~ao do programa. Discutiremos a memoria dinâmica
num curso de estruturas de dados. O operador new aceita um tipo t, aloca memoria
dinâmicamente para um item do tipo t e retorna um ponteiro para a memoria alocada por
ele. O operador delete recebe um ponteiro como parâmetro e destroi a memoria dinâmica
alocada previamente naquele endereco.
O TAD ponteiro
e
Dados
O conjunto de inteiros sem sinal que representam um endere
co
de mem
oria para um item de dado do tipo b
asico t.
Opera
c~oes
Assuma que u e v s~
ao express~
oes de ponteiros, i e
uma express~
ao
inteira, ptr
e uma vari
avel de ponteiro, e var e uma vari
avel do tipo t.
Endere
co
& ptr = &var Atribui o endere
co de var a ptr.
Atribui
ca~o
= ptr = u Atribui o valor de ponteiro u a ptr.
Defer^
encia
* var = *ptr Atribui o item do tipo t referenciado por
ptr
a vari
avel var.
Aloca
c~ao de Mem
oria Din^
amica e Desaloca
ca
~o
new ptr = new t Cria mem
oria din^
amica para um item do tipo
t e atribui seu endere
co a ptr.
delete delete ptr Destroi a mem

oria din^
amica alocada no endere
co
ptr.
Aritm
etica
+ u + i Aponta para o item localizado i itens de dados
a direita do item referenciado por u.

- u - i Aponta para o item localizado i itens de dados
a esquerda do item refenciado por u.

- u - v Retorna o n
umero de elementos do tipo base que
est
a entre os dois ponteiros.
ao se aplicam a ponteiros comparando
valores inteiros sem sinal.
fim do TAD ponteiro
Valores de ponteiros
Um valor de ponteiro e um endereco de memoria que usa 16, 32 ou mais bits, dependendo
da arquitetura da maquina. Como um exemplo, seja ptr1 um ponteiro para char(1 byte)
e ptr2 um ponteiro para um int short(2 bytes).
char str[] = "ABCDEFG";
char *ptr1 = str; // ptr1 aponta para str
short x = 33;
short *ptr2 = &x; // ptr2 aponta para short x
Os comandos que seguem ilustram as operac~oes fundamentais sobre ponteiros.

cout << *ptr1 << endl; // imprime 'A'
ptr1+ = 4; // move ptr para a direita 4 caracteres
cout << *ptr1 << endl; // imprime 'E'

ptr1--; // move ptr1
a esquerda 1 caractere
cout << *ptr1 << endl; // imprime 'D'

cout << *ptr2 + 3 << endl;// imprime 36 = 33 + 3
6.4. O TIPO MATRIZ 137
As operac~oes de ponteiro new e delete ser~ao discutidos nas notas de curso de estruturas
de dados.
6.4 O tipo matriz

Uma matriz e um exemplo de uma colec~ao de dados. Uma matriz unidimensional e
uma lista sequencial nita de elementos do mesmo tipo de dados(matriz homogênea).
A sequência identica o primeiro elemento, o segundo elemento, o terceiro elemento, e
assim por diante. A cada elemento esta associado um ndice que identica a posic~ao
do elemento na lista. Uma matriz tem um operador de ndice que possibilita um acesso
direto aos elementos na lista para armazenar ou recuperar um item.
a a a a
0 1 2 3
O TAD matriz
e
Dados
Uma colec~
ao de N itens do mesmo tipo de dados. Os
ndices s~
ao
escolhidos no domnio de inteiros de 0 a N - 1, que identificam
a posi
c~ao de um item na lista e permitem acesso direto aos elementos.
O
ndice 0 referencia o primeiro item na lista, o ndice 1 referencia o
segundo item, e assim por diante.
Opera
c~oes

Indice [ ]
Entrada: O
ndice
Precondico
~es: O
ndice esta no domnio de 0 a N - 1.
Processo: No lado direito de um comando de atribui c~
ao, o operador
de ndice recupera dados do item. No lado esquerdo de um
comando de atribui c~
ao, o operador de
ndice retorna o endere
c
do elemento da matriz que armazena o lado direito da express~ a
Sa
da: Se o operador de ndice estiver no lado direito de um comando
atribuic~
ao, a operac~
ao recupera dados da matriz e retorna os d
ao cliente.
P
oscondi
ca~o: Se a operac~
ao de
ndice estiver no lado esquerdo, o item da ma
sera alterado.
fim do TAD matriz.

O tipo matriz embutido em C++
Como parte de sua sintaxe basica, C++ providencia um tipo matriz estatica embutida
que dene uma lista de itens do mesmo tipo. A declarac~ao fornece explicitamente o
tamanho constante N da matriz e especica que os ndices est~ao no intervalo de 0 a
N 1. A declaraca~o no exemplo 37, a seguir dene uma matriz estatica em C++.
Usando ponteiros, criaremos mais adiante, no curso de estruturas de dados, matrizes
dinâmicas.
Exemplo 37 1. Declara duas matrizes do tipo double. A matriz x tem 50
itens e a matriz y tem 200 itens:
double x[50], y[200];
2. Declara a matriz a long com tamanho denida pela constante inteira

tamDaMatriz = 10.
const int tamDaMatriz = 10;
long a[tamDaMatriz];
O ndice da matriz, no intervalo de 0 a tamDaMatriz - 1, e usada para acessar os

elementos individuais da matriz. Um elemento no ndice i e representado por a[i].
O ndice da matriz em C++ e realizado usando o operador de ndice([ ]). Ele e um
operador binario cujo operando esquerdo e o nome da matriz e o operando da direita e a
posic~ao do elemento na matriz. Os elementos na matriz podem ser acessados em ambos
os lados de um operador de atribuic~ao:
a[i] = x; // atribui(armazena) x como dado ao elemento da matriz
t = a[i]; // recupera o dado de a[i] e o atribui a variavel t
a[i] = a[i+1] = x;
// atribui x a a[i+1]. Uma segunda atribui
c~
ao armazena os
os dados de a[i+1] em a[i]
Armazenamento numa matriz unidimensional

Uma matriz unidimensional em C++ a e logicamente armazenada como uma sequência
consecutiva de itens na memoria. Cada item e do mesmo tipo de dado.
a[0] .... a[i]
" "
endereco a[0] endereco a[i]
Em C++, um nome de uma matriz e uma constante e e considerada como sendo o
endereco do primeiro elemento da matriz. Portanto, na declarac~ao
6.4. O TIPO MATRIZ 139
tipo a[tamDaMatriz];
o nome, a, da matriz e uma constante e e a localizac~ao do primeiro elemento a[0].

Os lementos a[1], a[2], e assim por diante seguem consecutivamente. Assumindo que
sizeof(tipo) = M, a matriz toda, a, ocupa M*tamDaMatriz bytes.
a[0] a[1] a[2] a[3]
O compilador usa uma tabela para manter um registro das caractersticas da matriz.
Essa tabela inclui a informac~ao do tamanho de cada item, o endereco de incio da matriz
e o numero de elementos na matriz:
Endereco de incio: a
Numero de elementos da matriz: tamDaMatriz
Tamanho do tipo: M = sizeof(tipo)
A tabela e usada tambem pelo compilador para implementar uma func~ao de aces-
so que identica o endereco de um item na memoria. A func~ao acessoDaMatriz usa o
endereco de incio da matriz e o tamanho do tipo de dado para mapear um ndice i no
endereco de a[i]:
endere
co a[i] = acessoDaMatriz[(a, i, M)]
acessoDaMatriz e dada por

acessoDaMatriz(a, i, M) = a + i*M;
Exemplo 38 Assuma que oat e armazenado usando 4 bytes(sizeof( oat)=4)

e a altura da matriz comeca na localizac~ao de memoria 20000.
float altura[35];
o elemento altura[18] da matriz esta localizado no endereco
20000 + 18 4 = 20072
Limites da matriz
O TAD matriz assume que os ndices est~ao no intervalo de 0 a N - 1, onde N e o tamanho
da matriz. C++ faz o mesmo. Na realidade, muitos compiladores C++ n~ao geram
o codigo que testa se um ndice esta fora do limite durante um acesso a matriz. Por
exemplo, a sequência a seguir seria aceita por muitos compiladores:
int v = 20;
int a[20]; // o tamanho da matriz
e 20. O
ndice varia de 0 a 19
a[v] = 0; // o
ndice v
e maior do que o limite superior
Uma matriz ocupa memoria do espaco de dados do usuario. A func~ao de acesso

da matriz identica o endereco de memoria para um elemento particular. Geralmente,
n~ao e feito a checagem para vericar que o endereco, de fato, esta dentro do intervalo dos
elementos da matriz. Disso resulta que um programa em C++ pode usar ndices que est~ao
fora do intervalo. Os enderecos dos elementos que est~ao fora do intervalo ainda podem
cair dentro do espaco de dados do usuario. No processo, o programa pode sobrecarregar
outras variaveis e causar erros de execuc~ao indesejados.
Matrizes bidimensionais
Uma matriz bidimensional, e um tipo de dados estruturado que e criado aninhando-se
matrizes unidimensionais. Os itens s~ao acessados por ndices de linhas e colunas. Por
exemplo, a matriz de 32 elementos, t, que segue tem 4 linhas e 8 colunas. O valor 10 e
acessado pelo par, (linha, coluna), (1,2) e -3 e acessado pela par (2,6).
0 1 2 3 4 5 6 7
0
1 10
2 -3
3
O conceito de uma matriz bidimensional pode ser estendida para matriz de qualquer
dimens~ao, na qual os elementos s~ao acessados por três ou mais ndices. Matrizes de duas
dimens~oes tem aplicac~oes desde processamento de dados ate equac~oes diferenciais parcias.
A declarac~ao em C++ de matriz bidimensional, t, dene o numero de linhas, o numero
de colunas, e o tipo de dados dos elementos:
tipo t [contadorDeLinha][contadorDeColuna];
Os elementos de t s~ao referenciados pelos ndices de linhas e colunas:
t[i][j ]; 0 i contadorDeLinha 1; 0 j contadorDeColuna 1

Por exemplo, t e uma matriz de inteiros 4 por 8:
int t[4][8];

6.5. VARIAVEIS E LITERAIS DE STRING 141
O valores t[1][2] = 10 e t[2][6] = -3 s~ao, respectivamente, 10 e o valor da segunda
linha e terceira coluna, e -3 e o valor na terceira linha e setima coluna.
Poderemos pensar de uma matriz bidimensional como uma lista de matrizes unidi-
mensional. Por exemplo, t[0] esta na linha 0, que consiste de elementos individuais de
contadorDeColuna. Este conceito e util quando uma matriz bidimensional e passada como
parâmetro. A natoc~ao int t[ ][8] indica que t e uma lista de matrizes de 8 elementos.
0 1 2 3 4 5 6 7
t[0]
t[1] 10
t[2] -3
t[3]
Armazenamento de matrizes bidimensionais

Uma matriz bidimensional pode ser inicializada atribuindo de cada vez uma linha aos
itens. Por exemplo, a matriz t especifca uma tabela 2 por 4:
int t[3][4] = {{290,5,-30},{-40,13,32,8},{3,0,0,-1}};
Como na matriz unidimensional, os itens s~ao armazenados na ordem primeira linha,

segunda linha, terceira linha.
6.5 Variaveis e literais de string

Uma matriz e um tipo de dados estruturado que contem uma lista homogênea de itens.
Uma forma especial de matriz contem dados de caracteres que identicam nomes, pala-
vras, sentencas e assim por diante. Essa estrutura, chamada uma string(cadeia), trata
os caracteres como uma unica entidade e providencia operac~oes para acessar sequências
de caracteres dentro da string. Uma string e uma estrutura de dados crtica para mui-
tas aplicac~oes que usam dados alfanumericos. A estrutura e necessaria para manipular
processamento de textos com suas operac~oes para editar, seus algoritmos para pesquisar-
substituir e assim por diante. Por exemplo, um linguista pode precisar da informac~ao do
numero de vezes que uma certa palavra ocorre num documento ou um programador pode
usar o padr~ao encontrar/substituir para alterar o codigo fonte num documento. Muitas
linguagens declaram a estrutura string, providenciam operadores embutidos e func~oes de
bibliotecas para manipular strings.
Para determinar o comprimento de uma string, a estrutura pode incluir um 0 no m da
string(NULL-m do string) ou um parâmetro de comprimento separado. A representaca~o
da string seguinte contem o string de seis caracteres STRING.
S T R I N G NULL
Contador de comprimento da string
6
comprimento S T R I N G
Uma serie de operac~oes processam uma string como um unico bloco de catacteres.
Por exemplo, podemos determinar o comprimento de uma string, copiar uma string em
outra, juntar(concatenar) strings, e processar substrings com inserc~ao, remoc~ao e ope-
rac~oes de casamento de padr~ao. As strings tambem tem uma operac~ao de comparac~ao
que possibilitam a ordenac~ao de strings. A operac~ao usa a ordem ASCII. Por exemplo,
"Bernado"
e menor que "Martin" // B v
em antes de M
"Smith"
e menor que "Smithson"
"Bernado" v
em antes de "bernado" // o B mai
usculo precede o b min
usculo
"123Sim"
e menor que "AAA" // n
umeros precedem letras
O TAD string
e
Dados
Uma string e
uma sequ^
encia de caracteres com um comprimento
associado. A estrutura string pode ter um caractere de termina
c~
ao
NULL ou um par^
ametro de comprimento separado.
Opera
c~oes
Comprimento
Entrada: Nenhuma
Precondi
co
~es: Nenhuma
Processo: Para uma string terminando em NULL, conta os caracteres
at
e o caractere NULL. Para uma string com contador de comprimen
recupera o valor do comprimento.
P
oscondi
c~
oes: Nenhuma
Sada: Retorna o comprimento a string.
C
opia
Entrada: Duas strings str1 e str2. str2
e a fonte e str1 o destino.
Precondi
c~
oes: Nenhuma
Processo: Copia os caracteres de str2 para str1.
P
oscondi
c~
oes:
E criada uma nova string str1 com comprimento e dados obtidos
de str2.

Sa
da: Retorna o acesso a str1.
Concatena
ca~o
Entrada: Dois strings str1 e str2. Junta str2 na cauda de str1.
P
oscondi
c~oes: Nenhuma.
Processo: Achar o fim de str1. Copiar os caracteres de str2 na cauda de s
Atualizar a informa
ca
~o do comprimento de str1.
P
oscondi
c~
oes: str1
e modificada.
Sada: Retorna acesso a str1.
Compare
Entrada: Dois str1 e str2.
Precondi
c~
oes: Nenhuma.
Processo: Aplicar a ordem da tabela ASCII para as strings.
P
oscondi
c~
oes: Nenhuma.
Sada: Retorna um valor como segue:
str1 menor que str2: retorna um valor negativo.
str1 igual a str2: retorna valor 0
str1 maior que str2: retorna um valor positivo.

Indice
Entrada: Uma string str e um
unico caractere ch.
Precondi
c~
oes: Nenhuma.
Processo: Pesquisa str para a entrada ch.
P
oscondi
c~
oes: Nenhuma.
Sada: Retorna o endere
co da localiza
c~
ao contendo
a primeira ocorr^
encia de ch em str ou 0 caso
o caractere n~
ao seja encontrado.
ndiceDaDireita

Entrada: Uma string str e um unico caractere ch.
Precondi
c~
oes: Nenhuma.
Processo Pesquisa str buscando a ultima ocorr^
encia de
do caractere ch.
P
oscondi
c~
oes: Nenhuma.
Sada: Retorna o endereco da localiza
c~
ao contendo a
ultima ocorr^
encia de ch em str ou 0 se caractere
n~ao for encontrado.
Leia
Entrada: O arquivo stream do qual os caracteres s~
ao lidos e
uma string str contendo os caracteres.
Precondi
c~
oes: Nenhuma.
Processo: L^
e uma sequ^
encia de caracteres de stream na string str.
P
oscondi
c~
oes: Ao string str
e atribu
do os caracteres lidos.
Sada: Nenhuma.
Escreva:
Entrada: Uma string que contem caracteres para sa
da e uma stream
para o qual os caracteres ser~ao escritos.
Precondi
c~
oes: Nenhuma.
Processo: Envia os string de caracteres ao stream.
P
oscondi
c~
oes: Nenhuma.
Sada: A stream de sa
da
e modificada.
fim do TAD string.
Strings em C++
Numa outra oportunidade especicaremos e implementaremos uma classe C++ string.
Esta classe contera um conjunto estendido de operadores de comparac~oes e operac~oes
de E/S(Entrada/sada). Aqui, usaremos os strings de C++ com terminac~ao NULL e a
biblioteca de string C++ para implementar o TAD.
Um string de C++ e um string com terminac~ao NULL com o 0 de ASCII designando
o caractere NULL. O compilador identica um literal de string como uma sequência
de caracteres sob aspas duplas. Uma variavel de string e uma matriz de caracteres que
contem uma sequência de caracteres terminando com NULL. A declarac~ao seguinte cria
uma matriz de caracteres e atribui a ela um literal de string:
char str[9] = "Uma string";
A string "Uma string" e armazenada na memoria como uma matriz de caracteres com
onze elementos:
U m a s t r i n g NULL
C++ fornece alguns opradores de E/S para os streams cin(teclado), cout(tela), cerr(tela)
e streams de arquivos denidos pelo usuario.
A biblioteca de string C++ < string:h > contem uma colec~ao de func~oes para ma-
nipular strings bastante exvel que implementam diretamente muitas das operac~oes do
TAD. A tabela 6.3 lista as funco~es de strings principais.

char s1[20] = \dir/bin/appl", s2[20] = \le.asm", s3[20];
char *p;
int resultado;
Exemplos
1. Comprimento int strlen(char *s);

cout << strlen(s1) << endl; // A sa
da e
12
cout << strlen(s2) << endl; // A sa
da
e 8
2. C
opia char *strcpy(char *s1, *s2);
strcpy(s3,s1); // s3 = "dir/bin/appl"
3. Concatena
ca
~o char *strcat(char *s1, *s2);
strcat(s2,"/");
strcat(s3,s2); // s3 = "dir/bin/appl/file.asm"
4. Compare int strcmp(char *s1, *s2);
resultado = strcmp("bernado", "Bernado"); // resultado > 0
resultado = strcmp("12", "12"); // resultado = 0
resultado = strcmp("Joe", "Joseph"); // resultado < 0
5.
Indice char *strchr((char *s, int c);
p = strchr(s2,'.'); // p aponta para '.' ap
os file
if (p)
strcpy(p,".cpp"); // s2 = "file.cpp"
6.
IndiceDaDireita char *strrchr(char *s, int c);
p = strrchr(s1,'/'); // p aponta para '/' ap
os bin
if (p)
*p = 0; // termina string ap
os bin
// s2 = "dirbin"
7. Leia vari
avelDeStream >> s;
8. Escreva vari
avelDeStream << s;
cin >> s1; // se a entrada for "al^
o mundo"
cout << s1; // s1 e
"al^
o"
// sa
da
e "al^
o"
Tabela 6.3: Func~oes de string em C++ e exemplos

Aplicac~oes: Revertendo nomes
Um programa de aplicac~ao de string ilustra o uso das func~oes de biblioteca de string C++.
Na aplicac~ao, as func~oes strchr(), strcpy() e strcap() ser~ao combinadas de modo que um
nome tal como \Jose Dau" seja copiado como \Dau, Jose" na string novoNome. Os
seguintes comandos implementam o algoritmo.
char nome[10] = "Jos
e Dau", novoNome[30];
char *p;
Comando 1: p = strchr(nome, ` ');

Retorna um ponteiro p para o primeiro branco no nome. A primeira
letra do
ultimo nome come
ca no endere
co p + 1.
J o s e D a u NUL
Comando 2: *p = 0; // substitui o branco pelo caractere NULL.
J o s e NULL D a u NULL
Comando 3: strcpy(novoNome,p+1); // copia o
ultimo nome em novoNome
J o s e NULL D a u NULL
D a u NULL
Comando 4: strcat(novoNome, " "); // adiciona `,' e branco ao novoNome
D a u , NULL
Comando 5: strcat(novoNome, nme); // concatena o primeiro nome
J o s e NULL
D a u , J o s e NULL
Programa: Reverter um nome

O programa a seguir usa os comandos de 1 a 5 para reverter um nome. As etapas ser~ao
codicadas na func~ao reverteNome(). Um laco testa o algoritmo para três strings de
entrada. Em cada a sada e o nome revertido.

#include <string.h>
// reverte o primeiro e
ultimo nomes e os separa com v
rgulas, copia
// o resultado em novoNome.
void reverteNome(char *nome, char *novoNome)
{
char *p;
// busca o primeiro branco em nome e o substitui pelo caractere NULL

p = strchr(nome, ` ');
*p = 0;
// copia o
ultimo nome em novoNome, acrescenta `,' e
// concatena primeiro nome.
strcpy(novoNome, p+1);
strcat(novoNome,nome);
strcat(novoNome,nome);
// substitui o branco original pelo caractere NULL

* = ` ';
}
void main(void)
{
char nome[32], novoNome[32];
int i;
// l^
e e processa tr^
es nomes
for (i = 0; i < 3 ; i++)
{
cin.getline (nome, 32, `/');
reverteNome(nome,novoNome);
cout << ``Nome revertido:" << endl << endl;
}
}
Executando esse programa para a entrada ``Jos

e Dau", a sa
da ser
a
Dau, Jos
e.
6.6 Registros
Um registro e uma estrutura que combina itens de tipos diferentes num unico objeto.
Os itens no registro s~ao chamados campos. Como na matriz(tambem conhecida como
vetor ou array), um registro tem um operador de acesso que possibilita um acesso direto
a cada campo. Por exemplo, estudante e um registro que descreve informac~oes sobre um
estudante que frequenta uma escola. Dentre as informac~oes est~ao: o nome do aluno, o
endereco do local, a idade, curso, media.
nome endereco do local idade curso media
Neste exemplo, os campos nome e endereco do local s~ao do tipo string, idade e do
tipo inteiro, curso do tipo enumerac~ao e media do tipo real. Assumindo que Toni e um
estudante, podemos acessar os campos individuais combinando o nome do registro com o
campo, usando o operador \.":
Toni.nome Toni.idade Toni.m
edia Toni.curso
Um registro possibilita o agrupamento de tipos diferentes(tipos heterogêneos) na

estrutura. Diferentemente da matriz, um registro descreve um valor unico, em vez de
uma lista de valores.
O TAD registro
e
Dados
Um item contendo um conjunto de campos de tipos heterog^
eneos.
Cada campo possui um nome que permite um acesso direto aos dados no campo.
Opera
c~oes
Operador de acesso
Precondico
~es: Nenhuma.
Entrada: Nome do registro e do campo.
Processo: Acessa os dados no campo.
Sa
da: Quando recuperando dados, retorna o valor do campo
ao cliente.
P
oscondi
co~es: Quando armazenando dados, o registro
e alterado.
C++ implementa registro com estrutura

C++ possui o tipo embutido struct(estrutura) que representa um registro. Essa estrutura
e herdada da linguagem C com a qual continua compatvel. C++ dene o tipo struct como
um caso especial de uma classe na qual todos os membros s~ao publicos. Usamos o tipo
estrutura nestas notas somente quando lidarmos com uma estrutura de registro.
6.7. ARQUIVOS(FILE) 149
Exemplo 39 struct estudante
{
int ident;
char nome[30];
}
estudante s = {555, ``Dau, Samuel"};

cout << s.ident << `` " << s.nome << endl;
6.7 Arquivos(File)
Muitas vezes em nosso curso estaremos interessados no projeto e implementac~ao de estru-
turas de dados internas, que acessam informac~oes residentes na memoria. Nas apli-
cac~oes, entretanto, assumiremos, com frequência, que os dados estar~ao disponveis num
dispositivo de armazenamento externo como um disco. O dispositivo(arquivo fsico)
armazena informac~oes numa stream(corrente) de caracteres e o sistema operacional pro-
videncia uma serie de operac~oes para transferir para e da memoria. Isto nos possibilita
entrar e recuperar dados que possam estar permanentemente armazenados num disposi-
tivo externo. Os dados armazenados conjuntamente com as operac~oes de transferência
dene uma estrutura de dados, chamada um arquivo(le)(logico), que tem a importante
vantagem de manter uma grande quantidade de informac~oes que residiriam tipicamente
na memoria.
As linguagens de programac~ao provêem operac~oes de manipulac~ao de arquivos em alto
nvel para liberar o programador de ter que usar chamadas do sistema operacional de baixo
nvel. As operac~oes de arquivos usam um dado stream que esta logicamente conectado
ao arquivo. O stream associado aos dados ui com o arquivo. Para a entrada, o stream
possibilita que os dados uam do dispositivo externo para a memoria. O mesmo programa
pode recuperar informac~oes para o arquivo usando um stream de sada.
E util denir um TAD para um arquivo. Os dados consistem de uma sequência de
caracteres que representam dados de texto ou bytes que representam dados binarios. Para
o texto, os dados s~ao armazenados como uma sequência de caracteres ASCII separados
pelo caracre novaLinha. As operac~oes do TAD s~ao dados de modo que sejam bastante
gerais, focalizando as operac~oes primitivas de E/S. A operac~ao de entrada Ler()(Read)
extrai uma sequência de caracteres do stream. A operac~ao de sada relacionada Escre-
ver()(Write) insere uma sequência de caracteres na stream. As operac~oes especiais Get()
e Put() manipulam as E/S para um unico caractere.
Uma stream mantem um ponteiro de arquivo que identica a posic~ao corrente na
stream. A entrada desloca do ponteiro de arquivo para o proximo item de dado n~ao lido na
stream. A sada localiza o ponteiro de arquivo na proxima posic~ao da sada. Uma operac~ao
de procura nos possibilita posicionar o ponteiro de arquivo. Esta operac~ao assume que
temos acesso a todos os caracteres no arquivo e podemos nos mover para diante, para
tras, ou uma posic~ao intermediaria. Tipicamente, a operac~ao de procura e usada para os
arquivos de disco.
Usualmente, um arquivo e colocado num stream em um dos três modos seguintes:
ready-only(somente leitura), write-only(somente escrita) e ready-write(leitura escrita). O
modo ready-only e write-only especica que o stream e usado para entrada e sada, res-
pectivamente. O modo ready-write possibilita o uxo dos dados em ambas as direc~oes.
O TAD arquivo
e
Dados
Uma identifica
ca
~o do arquivo externo e a dire
c~
ao do fluxo de dados. Uma sequ^
enci
Opera
c~oes
Abrir
Entrada: Nome do arquivo e a dire
c~
ao do fluxo.
Precondica
~o: Para a entrada, o arquivo externo deve existir.
Processo: Conecta um stream a um aruivo.
Sada: Um aviso(flag) que indica que a opera
c~
ao foi bem sucedida.
P
oscondico
~es: Os dados podem fluir entre o arquivo externo e a mem
oria do sis
via o stream.
Fechar
Entrada: Nenhuma.
Precondi
c~oes: Nenhuma.
Processo: Desconecta o stream do arquivo.
Sada: Nenhuma.
P
oscondico
~es: Os dados n~
ao podem mais fluir do arquivo externo via
o stream entre o arquivo externo e a mem
oria do sistema.
Ler
Entrada: Uma matriz contendo blocos de dados. Um contador N.
Precondi
co~es: O stream deve estar aberto com dire
c~
ao ready-only ou ready-writ
Processo: Entram N caracteres do stream na matriz.
Para quando for encontrado fim-de-arquivo.
Sada: Retorna o n
umero de caracteres que forem lidos.
P
oscondi
co~es: O ponteiro de arquivo
e movido para adiante N caracteres.
Escrever
Entrada: Uma matriz e um contador .
Precondic~
oes: O stream deve estar aberto para a dire
c~
ao write-only
6.7. ARQUIVOS(FILE) 151
ou ready-write.
Processo: Sai N caracteres na stream.
Sada: Retorna o n
umero de caracteres que foram lidos.
P
oscondi
co~es: O stream cont
em os dados de sa
da, e o ponteiro de arquivo
avan
ca N caracteres.
Procurar
Entrada: Par^
ametros para reinicializar o ponteiro de arquivos.
Precondico
~es: Nenhuma.
Processo: Reinicializa o ponteiro de arquivo.
Sa
da: Retorna uma mensagem(flag) que indica se a procura
foi bem sucedida.
P
oscondi
c~
oes:
E estabelecido um novo ponteiro de arquivo.
fim do TAD arquivo
Hierarquia de stream em C++

C++ providencia para que seja possivel manipular o arquivo com um sistema de stream
E/S que e implementado usando uma hierarquia de classe C++. Um stream C++ e um
objeto correspondendo a uma classe na hierarquia. Cada stream identica um arquivo e
a direc~ao do uxo de dados.
A classe raz na hierarquia e ios, que contem dados e operac~oes para todas as classes
derivadas. A classe contem mensagens que identicam atributos especcos do stream e
metodos de formatos que s~ao precisos para a entrada e sada. Por exemplo,
cout.setf(ios::fixed);
inicializa o modo display(visualizac~ao) para os numeros reais para o formato xo em

vez do formato cientco.
As classes istream e ostream providenciam operac~oes de entradas e sadas basicas
que ser~ao usadas como classes base para o resto da hierarquia de stream de E/S.
A classe istream-withassigh e uma variante do stream que possibilita atribuic~ao de
objetos. O objeto predenido cin e um dessa classe. Os objetos predenidos cout e cerr
s~ao do tipo de classe ostream-wthassign. Em tempo de execuc~ao, esses três streams
s~ao abertos para a entrada do teclado e sada pela tela. As declarac~oes est~ao no arquivo
< iostream:h >.
A classe ifstream e uma istream derivada usada para a entrada do arquivo de disco.
Analogamente, ostream e usado para a sada de arquivo de disco. Essas classes est~ao
declaradas no arquivo < fstream:h >. Ambas as classes contem a operac~ao abrir(open)
para colocar um arquivo no stream e a operac~ao fechar(close) para separar um arquivo de
um stream.
Os dois tipos de arquivos de discos s~ao arquivos de textos e arquivos de binarios.
Um arquivo de texto contem caracteres ASCII e e imprimvel, enquanto um arquivo de
binario contem dados binarios puros. Por exemplo, um editor usa arquivo de texto e
um programa de spreadsheet cria e usam arquivos binarios. A seguir apresentaremos um
exemplo de um programa de E/S de arquivo de texto e de arquivos de binarios os quais
futuramente ser~ao desenvolvidos como classes. A classe de arquivo binario e usada para
implementar busca externa e algoritmos de ordenac~ao.
A classe fstream possibilita ao usuario criar e manter arquivos que requeram acessos
de leitura e escrita.
E/S baseadas em matriz est~ao implementadas pelas classes istream e ostream que
est~ao declaradas no arquivo < iostream:h >. Aqui os dados s~ao lidos de uma matriz ou
escritos na matriz por um dispositivo externo. Editores de textos usam com frequência
E/S baseados em matriz para efetuarem operac~oes de formatac~ao complexas.
Programa: arquivo E/S
Este programa ilustra os streams de C++, incluindo arquivo de texto e E/S baseadas em
matrizes.
Este programa usa cout e cerr que est~ao includos em < iostream:h >. Entradas de
arquivos de textos e sadas baseadas em matrizes usam os arquivos < fstream:h > e
< strstream:h >, respectivamente. O programa abre o arquivo e lê cada linha contendo
os pares variavel/valor nos formatos nome valor. Usando a operac~ao de stream baseado
em matriz, o par e escrito na matriz outputstr no formato
``nome = valor"
e ent~ao com um comando cout. Por exemplo, as linhas de sada

in
cio 55
para 8.5
s~ao impressos como os strings

in
cio = 55 pare = 8.5
#include <fstream.h>
#include <strstream.h>
#include <stdlib.h>
#include <string.h>
void main(void)
~ DE MATRIZES E REGISTROS
6.8. APLICACOES 153
{
// arquivo de entrada de texto contendo nomes e valores
ifstream fin;
// l^
e idenficadores nos nomes e escreve os resultados no outputstr
char nome[30],
// declara uma stream de sa

da baseada em matriz que usa outputstr
ostream outs(outputstr, sizeof(outputstr));
double valor;
// abre "nomes.dat" para input. Assegura que ele existe.

fin.open("nomes.dat", ios::in | ios::nocreate);
if (!fin)
{
cerr << "N~
ao
e poss
vel abrir "nomes.dat" " << endl;
exit(1);
}
// ler um nome e valor. Escreve para outs como "nome = valor"

while (fin >> nome)
{
fin >> valor;
outs << nome << " = " << valor << " ";
}
// termina em null o string de sa

da
outs << ends;
cout << outputstr << endl;
6.8 Aplicac~oes de matrizes e registros

Matrizes e registros s~ao estruturas de dados embutidos em muitas das linguagens de pro-
gamac~ao. Nesta seca~o introduziremos TADs para essas estruturas e discutiremos suas
implementac~oes em C++. Usaremos essas estruturas de dados para desenvolver alguns
algoritmos importantes. Uma matriz e uma estrutura de dados fundamental para listas.
Em muitas aplicaco~es, usaremos busca e ordenac~ao por troca para encontrar um item
numa lista baseada em matriz e para ordenar os dados. A seguir, introduzirems a busca
sequencial e a ordenac~ao por trooca que s~ao simples de codicar e entender.
Busca sequencial
Uma busca sequencial procura um item numa lista usando um valor chamado chave. O
algoritmo comeca com um ndice fornecido, chamado incio, e percorre os itens restantes
na lista, comparando cada item com a chave. A pesquisa continua ate que a chave seja
encontrada ou a lista tenha sido totalmente percorrida. Se a chave for encontrada, a
func~ao retorna o ndice do elemento da lista que casou. Caso contrario, e retornado o
valor -1. A funca~o buscaSeq() requer quatro parâmetros, o endereco da lista, o ndice de
incio para a busca, o numero de elementos e a chave. Por exemplo, considere a seguinte
lista de inteiros contida na matriz a:
a: 8 3 62 6
1. chave = 6, incio = 0, n = 5. Pesquisar a lista do incio, retornando o ndice da
primeira ocorrência d o elemento 6.
8 3 6 2 6
2. chave = 6, incio = 3, n = 2. Iniciar em a[3] e pesquisar a lista, retornando um

ponteiro para a primeira ocorrência do elemento 6.
3. chave = 9, incio = 0, n = 5. Iniciar no primeiro elemento e procurar na lista o
elemento 9. Com ele n~ao sera encontrado, retornar o valor -1.
O algoritmo da busca sequencial se aplica a qualquer matriz para o qual o operador
\==" esteja denido para o tipo do item. Um caso mais geral sera discutido num curso
de estruturas de dados.
Fun
c~ao da busca sequencial
int buscaSeq(int lista[], int in cio, int n, int chave)

{
for (int i=incio; i < n; i++)
{
if (lista[i] == chave)
return i;
}
return -1;
}
6.8. APLICACOES 155
Programa da busca sequencial
Este programa testa a busca sequencial contando o numero de ocorrência de uma chave
numa lista. O programa principal primeiro fornece como entrada 10 inteiros numa mtriz
a e ent~ao procura uma chave.
O programa faz rpetidas chamadas da func~ao buscaSeq() usando diferentes ndices para
incio. Inicialmente, comecamos no ndice 0, o comeco da matriz. Apos cada chamada
de buscaSeq(), o o contador do numero de ocorrências e incrementado se a chave for
encontrada: caso contrario a busca termina e o contador e a sada. Se a chave for
encontrada, o valor de retorno identica sua posic~ao na lista. A proxima chamada para
buscaSeq() e feita com o incio no elemento imediatamente a direita.
#\include <iostream.h>
// pesquisa a matriz de inteiros com n elementos procurando um elemento que case com
// retorna um ponteiro para o dado ou null caso a chave n~
ao seja encontrada.
int buscaSeq(int lista[], int in
cio, int n, int chave)
{
for(int i=in
cio;i < n; i++)
if (lista[i] == chave)
return i; // retorna o
ndice do item que cas
return -1; // caso falhe, reorne -1
}
void main(void)
{
int a[10];
int chave, contador=0, pos;
// entra uma lista de 10 inteiros

cout << "Entre uma lista com 10 inteiros:";
for (pos=0; pos < 10; pos++)
cin >> a[pos];
cout << "Entre com uma chave:";

cin >> chave;
// incia a busca no primeiro elemento da matriz

pos = 0;
// move-se na lista at

e que a chave seja encontrada
while ((pos = buscaSeq(a,pos,10,chave) !-1)
{
contador++;
// move-se para o pr
oximo inteiro ap
os casar
pos++;
}
cout << chave << "ocorre"<< contador

<< "na lista." << endl;
}
Executando este programa:
Entre uma lista com 10 inteiros: 5 2 9 8 1 5 8 7 5 3

Entre com uma chave: 5
5 ocorr 3 vezes na lista
Ordenac~ao por troca

A ordenac~ao dos itens numa lista e importante em muitas aplicac~oes. Por exemplo, uma
lista de inventario pode ordenar registros pelo seu numero de partes para permitir um
rapido acesso a um item, um dicionario contem palavras na ordem alfabetica, e na ordem
do registro estudantes podem ser ordenados pelo cpf.
Para criar uma lista ordenada, introduzimos um algoritmo de ordenac~ao chamado
ordPorTroca() que ordena os itens na ordem ascendente. O algoritmo e ilustrado com
a lista 8, 3, 6, 2 e produz a lista ordenada 2, 3, 6, 8.
Indice 0: Considere a lista completa 8, 3, 6, 2. O item no ndice 0 e comparado com
cada item subsequente na lista no ndice 1, 2, 3. Para cada comparac~ao, se o ndice
subsequente for menor que o elemento no ndice 0, as duas entradas ser~ao trocadas. Apos
todas as comparaco~es terem sidos feitas, o menor elemento estara localizado no ndice 0.
Lista inicial Ac~ao Lista resultante
ndice 0 8 3 6 2 troca ! 3 8 6 2
3 8 6 2 troca ! 3 8 6 2
8 3 6 2 troca
! 2 8 6 3
Indice 1: Uma vez que o menor ja esta localizado no ndice 0, consideremos a sublista
8, 6, 3. Somente os itens do ndice 1 em diante ser~ao considerados. O item no ndice
1 e comparado com os subsequentes itens nos ndices 2 e 3. Para cada comparac~ao, se
o maior estiver no item 1, as duas entradas ser~ao trocadas. Apos cada comparac~ao, o
6.8. APLICACOES 157
segundo menor elelento na lista e armazenado no ndice 1.
ndice 1 2 8 6 3 troca ! 2 6 8 3
2 6 8 3 troca ! 2 3 8 6
ndice 2: Considere a sublista 8, 6. O processo continua para a sublista de dosi itens
com ndices 2 e 3. Uma unica comparac~ao, resultando numa troca, e feita entre esses
itens.
ndice 2 8 3 8 6 troca ! 2 3 6 8
Terminamos com somente um unico item no ndice 3 e a lista esta ordenada.
Lista nal ordenada
2 3 6 8
A func~ao de C++ ordPorTroca() usa lacos aninhados. Assuma que o tamanho da
lista da lista e dado n. O laco mais externo incrementa o ndice i no intervalo de 0 a n -
2 Para cada ndice i, compare os ndices subsequentes aos 'dices j = i + 1, i + 2, ..., n -
1. Faca a comparac~ao e ent~ao troque os elementos se lista[i] > lista[j ].
Programa: Ordenando uma lista

Este programa ilustra o algoritmo de ordenac~ao. Uma lista e constituda de 15 inteiros no
intervalo de 0 a 99. A func~ao ordPorTroca() ordena a lista, usando a func~ao troca() para
trocar os elementos na matriz. O programa imprima a lista antes e apos a ordenac~ao.
// troca os valores das duas vari

aveis inteiras x e y.
void troca(int & x, int & y)
{
int temp = x; // armazena o valor original de x
x = y; // troca o valor de x pelo de y
y = temp; // atribu y ao valor original de x

}
// ordena a matriz inteira, a, de n elementos na ordem ascendente

void ordPorTroca(int a[], int n)
{
int i, j
// implementa n - 1 passos. Localiza os valores corretos em

// a[0], ..., a[n-2].
for (i=0; i < n-1; i++)
// coloca o m
nimo de a[i+1],...,a[n-1] em a[i]
for (j=i+1; j < n; j++0
// troca se a[i] > a[j]
if (a[i] > a[j])
troca(a[i],a[j]);
}
// percorre a lista e imprime cada valor

void imprimaLista(int a[], int n)
{
for (int i=0; i < n; i++)
cout << a[i] << " ";
cout << endl;
}
void main(void)
{
int lista[15] = {38,58,13,15,51,27,10,19,12,86,49,67,84,60,25,};
int i;
cout << "Lista original \n"

imprimaLista(lista,15);
ordPorTroca(lista,15);
cout << endl << "Lista ordenada:" << endl;
imprimaLista(lista,15);
}
Executando este progragrama para a lista original

38 58 13 15 51 27 10 19 12 86 49 67 84 60 25
A lista ordenada
10 12 13 15 19 25 27 38 49 51 58 60 67 84 86
6.8. APLICACOES 159
Contando palavras reservadas em C++
Anteriormente discutimos o tipo de dados registro que e implementado em C++ como
uma estrutura(struct). Para ilustrar o uso de registros, um programa computa o numero
de vezes que as palavras reservadas "else" "for" "if", \include" e "while" ocorrem num
programa C++. O programa usa variaveis de strings assim como uma matriz de registros.
A principal estrutura de dados do programa e a estrutura palavraChave cujos os cam-
pos consistem da variavel de string PalavraChave e o inteiro contador:
struct palavraChave
{
char PalavraChave[20];
int contador;
};
A tabela para as cinco palavras reservadas e criada na matriz tabDePalavrasChave.

Cada item na tabela e inicializado especicando a palavra reservada e um contador ini-
cial de 0. Por exemplo, o primeiro inicializador de matriz f\else"; 0g faz com que a
tabDePalavrasChave[0] de entrada contenha o strint \else" com o contador 0:
palavraChave tabDePalavrasChave[] =
{
{"else",0},{"for",0},{"if",0},{"include",0},{"while",0}
};
O programa lê as palavras individuais num arquivo usando a func~ao GetWord(). Uma
palavra e qualquer sequência de caracteres comecando com uma letra e continua com letras
ou dgitos. Por exemplo, quando e apresentado a linha
"Express~
ao: 3 + 5 = 8 (N1 + N2 = N3) "
A func~ao GetWord() extrai as palavras \Express~ao", \N1", \N2" e \N3"e descarta os

outros smbolos.
A func~ao buscaSeq() percorre a tabela procurando por um item que case com a pala-
vraChave. Quando ocorre o casamento, a func~ao retorna o ndice do registro que casou,
o qual pode, ent~ao, ter o seu campo contador incrementado.
Programa: Contando palavras reservadas
Este programa lê seu proprio codigo fonte como entrada. Um laco lê cada palavra e chama
a func~ao buscaSeq() para determinar se a entrada casa com uma palavra reservada em
tabDePalavrasChave. Se for o caso, incrementamos o campo de contador do registro. Apos
a entrada estiver completada, e impresso o numero de ocorrências de cada palavraChave.
O programa ilustra um comando interessante que computa dinâmicamente o numero
de elementos na matriz tabDePalavrasChave, usando a express~ao
sizeof(tabDePalavrasChave)/sizeof(palavraChave)
Esta express~ao provê um metodo de computar o numero de elementos numa matriz

independente da maquina. Se forem adicionadas outras palavras chave a tabela, uma
compilac~ao subsequente gerara um novo contador de elementos.
#include <fstream.h>
#include <string.h> // deve incluir as func~
oes de string usadas
#include <ctype.h> // prov^
e
eAlfa e
eD
gito
#include <stdlib.h>
// declara a estrutura de palavras

struct palavraChave
{
char PalavraChave[20];
int contador;
};
// declara e inicializa a tabela de palavras chave

palavraChave tabDePalavrasChave[ ] =
{
{"else",0},{"for",0},{"if",0},{"include",0},{"while",0}
};
// algoritmo de busca sequencial para palavras chave

int buscaSeq(palavraChave *tab, int n, char *palavra)
{
int i;
// percorre a lista. Compara palavra com palavraChave no registro corrente

for (i=0; i < n; i++, tab++)
if (strcmp(palavra, tab->palavraChave == 0)
return i; // retorna
ndice se casar
return -1; // n~
ao casa
}
// extrai a palavra come

cando com uma letra e possivelmente
// outras letras/d
gitos
int GetWord (ifstream& fin, char w[])
{
6.8. APLICACOES 161
char c;
int i = 0;
// pula entrada n~
ao alfab
etica
while ( fin.get(c) && !isalpha(c))
;
// retorna 0(falha) no fim da fila.

if (fin.eof())
return 0;
// registra a primeira letra da palavra

w[i++] = c;
// coleta letras e d
gitos e strings terminando com NULL
while (fin.get(c) && (isalpha(c) || isdigit(c)))
w[i++] = c;
w[i] = "\n";
return 1; // retorna 1 (sucesso)

}
void main(void)
{
const int tamM
aximo = 50; // tamanho m
aximo de cada palavra
// declara o tamanho da tabela e inicializa seus valores

const int NpalavrasChave = sizeof(tabDePalavrasChave)/sizeof(PalavraChave);
int n;
char palavra[tamM
aximo];
ifstream fin;
// abre arquivo com cheque de erro

fin.open("prog2_5.cpp",ios::in | ios::nocreate);
if (!fin)
{
cerr << "N~
ao
e possivel abrir arquivo 'prog2_5.cpp'" << endl;
exit(1);
}
// extrai palavras at

e o fim da fila
while (GetWord(fin, palavra)
// se casar na tabela de palavras chave, incrementar contador
if ((n = buscaSeq(tabDePalavrasChave, NpalavraChave, palavra)
tabDePalavrasChave[n].contador++;
// percorre a tabela de palavras chave e imprime campos do registro

for (n = 0; n < NpalavraChave; N++)
if (tabDePalavrasChave[n].contador > 0)
{
cout << tabDePalavrasChave[n].contador;
cout << " " << tabdepalavrasChave[n].palavraChave << endl;
}
fin.close();
}
Executando este programa tem a seguinte sa

da:
1 else
3 for
9 if
7 inlude
4 while
6.9 Exerccios
1. Computar o valor decimal de cada numero binario:
(a) 101
(b) 1110
(c) 110111
(d) 1111111
2. Escrever cada numero decimal em binario:
(a) 23 (b) 55 (c) 85 (d) 253
3. Nos sistemas de computadores modernos, os enderecos s~ao usualmente implementa-

dos no nvel de hardware como valores binarios de 16-bits ou 32-bits. E natural lidar
6.9. EXERCICIOS 163
com enderecos em binarios em vez de convertê-los em decimal. Como os numeros
desses tamanhos s~ao ruins de escrevê-los como strings de dgitos binarios, s~ao usados
os numeros na base 16 ou hexadecimais. Tais numeros referidos como numeros
hex, s~ao representac~oes importantes para os inteiros permitindo uma convers~ao facil
para e de binarios. Muitos softwares lidam com enderecos de maquinas em hex.
Os numeros hex s~ao construdos de uma base de 16 dgitos percorrendo de 0-15(decimal).
Os primeiros dez dgitos s~ao herdados dos numeros decimais: 0, 1, 2 ,3, 4, 5, 6, 7,
8, 9. Os dgito de 10 a 15 s~ao representados por A, B, C, D, E e F. As potências
de 16 s~ao: 160 = 0 161 = 16 162 = 256 163 = 4096 e assim por diante. Na forma
de notac~ao posicional, exemplos de numeros s~ao: 17E, 48 e FFFF800. Os numeros
s~ao convertidos para decimal expandindo as potências de 16 exatamente como para
as potências de 2 s~ao expandidas para numeros binarios.
Por exemplo, o numero hex 2A3F16 e convertido para decimal expandindo as potências
de 16.
2A3F16 = 2(163 ) + A(162) + 3(161 ) + F (160) = 2(4096) + 10(256) + 3(16) + 15(1) =
8192 + 2560 + 48 + 15 = 1018510
Converter cada numero hex para decimal:
(a) 1A (b) 41F (c) 10EC (d) FF (e) 10000
4. Converter cada numero decimal para hex:

(f) 23 (g) 87 (h) 115 (i) 255
5. O principal motivo para introduzir numeros hex e sua correspondência natural com
os numeros binarios. Eles possibilitam uma representac~ao compacta de dados binarios
e enderecos de memoria. Os dgitos hex tem uma representac~ao binaria de 4-bits
no intervalo 0-15. A tabela seguinte lista a correspondência entre dgitos binarios e
hex.
hex binario hex binario
0 0000 8 1000
1 0001 9 1001
2 0010 A 1010
3 0011 B 1011
4 0100 C 1100
5 0101 D 1101
6 0101 E 1110
7 0111 F 1111
Para representar um numero binario em hex, comecar no nal do lado direito do
numero e partir os bits em grupos de quatro, adicionando 0's no ultimo grupo da
esquerda, se for necessario. Escrever cada grupo de 4 bits como um dgito hex. Por
exemplo, 1111000111011112 = 0111 1000 1110 1110 = 78EE16
Para converter de um numero hex para para um numero binario, reverter o processo
e escrever cada dgito hex como 4 bits. Considere o seguinte exemplo:
A78916 = 101 0111 1000 1001 = 10100111100010012
Converter de binario para hex
(a) 1100 (b) 1010 0110 (c) 1111 0010 (d) 1011 1101 1110 0011
Converter hex para binario

(e) 0610 16
(f) AF 2016
6. C++ permite ao programador entrar e sair numeros em hex. Colocando o manipu-
lador \hex" no stream, o modo para a entrada ou sada de numeros e hex. O modo
tem efeito ate ele retornar o decimal com manipulador \dec". Por exemplo:
cin >> hex >> t >> dec >> u; // t
e lido como hex e u
e lido como decimal
< entrada; 100 256 > t = 100 e u = 256

16 10
cout << hex << 100 << t << u; // a sa

da e
64 100 100
cout << dec << 100 << t << u; // a sa
da
e 100 256 256
Considere a seguinte declarac~ao e comando executaveis:

int i j, k;
cin >> i;
cin >> hex >> j >> dec;
cin >> k;
Assuma que <entrada>

e 50 50 32. Qual
e a sa
da do comando?
(a) cout << hex << i << " " << j << " " << dec << k << endl;
(b) assuma que <entrada>

e 32 32 64. Qual
e a sa
da do comando?
cout << dec << i << " " << hex << j << " " << k << endl;
6.9. EXERCICIOS 165
7. Escrever uma especicac~ao completa para operador % no tipo de dados inteiro. Faca
o mesmo para o operador de comparac~ao !=.
8. O tipo booleano dene dados que s~ao os valor verdadeiro ou falso. Algumas lingua-
gens de programac~ao dene o tipo nativo Boolean com uma serie de func~oes em-
butidas para processar os dados. C++ associa um valor booleano a cada express~ao
numerica.
(a) Defina um TAD booleano que descreve o domnio de dados e suas opera
c~
oes.
(b) Descreva uma implementa
ca~o do TAD usando os construtos da linguagem C++.
9. (a) Que caractere ASCII corresponde ao numero decimal 78?

(b) Qual caractere ASCII corresponde ao numero binario 10010112 ?
(c) Quais s~ao os codigos ASCII para os caracteres \*", \q" e o retorno do carro?
Dê sua resposta em binario e decimal.
10. O que sera impresso a partir do seguinte fragmento de codigo?
cout << char(86) << " " << int('q') << " " <<
char(int("0") + 8) << endl;
11. Explicar porque o operador %(resto)n~ao esta disponvel no TAD numeros reais.
12. Converter cada numero binario de ponto xo para deciamal:
(a) 110,110
(b) 1010,0101
(c) 1110,00001
(d) 11,111....111...(suagest~
ao: usar a f
ormula para a soma de uma s
erie geom
etric
13. Converter cada numero decimal de ponto xo para binario:
(a) 2,25
(b) 1,125
(c) 1,0875
14. (a) No TAD dos n

umeros reais, existe o menor n
umero real positivo?
(b) Quando os n
umeros s~
ao implementados num computador, existe o menor n
umero pos
15. O formato de ponto utuante IEEE armazena o sinal do numero separado e arma-
zena o expoente e a mantissa usando numeros sem sinal. Uma forma normalizada
permite uma representac~ao unica para cada numero em ponto utuante.
Forma Normalizada: O numero em ponto utuante e ajustado para ter um unico
dgito diferente de zero a esquerda do ponto binario.
N = +1; d d :::dn 2e
1 2 1
O numero em ponto utuante 0,0 e armazenado com sinal, expoente, e mantissa 0.

Como um exemplo, dois numeros binarios s~ao convertidos para a forma de reprsen-
tac~ao normalizada.
Numeros binarios Forma normalizada
1101; 101 21 1; 1011010 24
0; 0011 2 6
1; 1 23
Os numeros de ponto utuante de trinta e dois bits s~ao armazenados na forma
normalizada usando o formato interno IEEE:
Sinal O bit mais a esquerda e usado para o sinal. Um "+ " tem 0 bit de sianl. e u
tem um bit de sinal 1.
Expoente O expoente
e armazenado em 8 bits. Para assegurar que todos os expoentes
s~
ao armazenados como n
umeros positivos(sem sinal), o formato IEEE especi
usando a nota
c~
ao "excesso-127" para o expoente. O expoente armazenado, E
Exps = Exp + 127
ExpoenteVerdadeiro ExpoenteArmazenado
Escopo escopo
-127 <= Exp <= 128 0 <= Exps <= 255
Mantissa Assumindo que o n

umero est
a armazenado na forma normalizada, o d
gito
l
der 1 est
a escondido. Os d
gitos fracion
arios s~
ao armazenados numa ma
dando 24 bits deprecis~
ao.
sinal expoente mantissa

1 bit 8 bits 23 bits
Como um exemplo, computaremos a representac~ao interna de -0,1875.
6.9. EXERCICIOS 167
Forma normalizada (-)1,1.10023
sinal 1
Expoente Exps = 3 + 127 = 124 = 011111002
Mantissa < 1 >100000...0
0; 1875 = 10111110010000000000000000000000
Registre cada numero na notac~ao de ponto utuante UEEE em 32-bits.
(a) 7,5 (b) -1/4
Qual e o valor do seguinte numero na forma decimal formatado em IEEE de 32-bits?

Cada numero e dado em hex.
(c) C1800000 (d) 41E90000
16. (a) Listar na ordem do calendario os meses do ano que tem um "a" no seu nome.
Isto e um tipo enumerado.
(b) Escrever em C++ uma impementac~ao do tipo enumerado.
(c) Na implementac~ao C++, que mes corresponde ao inteiro 4? Qual e a posic~ao
de outubro?
(d) Escrever a enum em ordem alfabetica. Quais meses tem a mesma posic~ao em
ambas as listas?
17. Adicionar as operac~oes de sucessor e predecessor ao TAD para tipos enumerados.
Use especicac~oes completas. O sucessor retorna o proximo item na lista e o pre-
decessor retorna o item anterior. Tome cuidado em denir o que acontece nos
extremos da lista.
18. Dados as seguintes declarac~oes e comandos, especicar os conteudos de X, Y e A
apos a execuc~ao do seguinte comando:
int X=A, y=7, *PX = &X, *Py;
double A[] = {2,3, 4,5, 8,9, 1,0, 5,5, 3,5}, *PA = A;
PY = &Y; *(PX)--; *PY+=*PX; PY = PX;
*PY = 55; *PA+=3,0; PA++; *PA++ = 6,8;
PA+=2;
*++PA = 3,3;
19. (a) A e declarado como

short A[5];
Quantos bytes s~ao alocados para a matriz A? Se o endereco da matriz for A =

6000, compute o endereco de A[3] e A[1].
(b) Assuma a declarac~ao
long A[] = {30, 500000, -100000, 5, 33};
Se uma palavra long for de 4-bytes e o endereco de a for 2050.

Qual e o conteudo do endereco 2066?
Duplique os conteudos nos enderecos 2050 e 2062. Escrever a matriz A.
Qual e o endereco de A[3]?
20. Assuma que A e uma matriz m n com os ndices das linhas no intervalo de 0 a
(m-1) e os das colunas no intervalo de 0 a (n-1). Gerar uma func~ao de acesso que
computa o endereco de A[linha][col], assumindo que os elementos s~ao armazenados
por colunas.
21. A e declarado como
short A[5][6];
(a) Quantos bytes s~ao alocados para a matriz A?

(b) Se o endereco da matriz for A = 1000, computar o endereco de A[3][2] e A[1][4].
(c) Qual a entrada da matriz que esta localizada no endereco 1020? e no endereco
1034?
22. (a) Declarar uma string NOME com valor inicial de seu primeiro nome.
(b) Considere as declarac~oes de variavel de string
char s1[50], s2[50];
e os comandos de entrada
cin >> s1 >> s2;
Quais os valores de s1 e s2 para a linha de entrada\George voa"? Quais os

valores de s1 e s2 na entrada do seguinte texto (3 e um caractere branco e [ e
o m de linha.)?:
Proximo [ 3333 Palavra
23. Assuma as seguintes declarac~oes de strings:
6.9. EXERCICIOS 169
char s1[30] = "Stockton, CA", s2[30] = "March 5, 1994", *p;
char s3[30];
(a) Qual e o valor de *p apos a execuc~ao de cada um dos seguintes comandos?

p = strchr(s1, 't');
p = strrchr(s1, 't');
p = strrchr(s2, '6');
(b) Qual e valor de s3 apos a execuc~ao dos seguintes comandos?

strcpy (s3,s1);
strcap (s3, ", ");
strcat (s3, s2);
(c) O que a chamada de func~ao strcmp (s1,s2) retorna?

(d) O que a chamada de func~ao strcmp (&s1[5],"tom") retorna?
24. A func~ao
void strinsert(char *s, char *t, int i);
insere o string t no string s comecando no ndice i. Se i for maior que o comprimento

de s, a inserc~ao n~ao sera efetuada. Implemente strinsert usando as func~ao de
biblioteca C++ strlen(), strcy(), e strcat(). E preciso declarar uma variavel de string
temporaria para conter os caracteres originais em s do ndice i ao ndice strlen(s)-1.
Assuma que esta cauda nunca excede 127 caracteres.
25. A func~ao
void strdelete(char *s, int i, int n);
remove uma sequência de n caracteres do string s comecando o ndice i. Se i+n for

maior ou iqual que o comprimento de s, o m do string sera removido comecando no
ndice i. Implemente strdelete() usando as func~oes de biblioteca strlen() e strcy().
26. Uma alternativa do uso de string com terminac~ao NULL e colocar um contador de
caracteres no primeiro elemento da matriz de caracteres. Isto e chamado formato
de contador de bytes. Tais strings s~ao usados com frequência com o nome strings
de Pascal, pois o sistema de programac~ao Pascal usa esse formato de strings.
(a) Implemente a func~ao strcat() assumindo que os strings s~ao armazenados no
formato de contador de bytes.
(b) As func~oes PtoCstr() e CtoPStr() fazem a covers~ao entre os dois formatos de
strings:
void PtoCStr(char *s); // converte s de Pascal para C++
void CtoPStr(char *s); // converte s de C++ para Pascal
Implemente essas duas func~oes.

27. Adicionar o operador de atribuic~ao \=" ao TAD registro usando uma especicaca~o
completa. Dena com cuidado que ac~oes ter~ao lugar durante a atribuic~ao.
28. Um numero complexo e da forma x + iy , onde i2 = 1. Os numeros complexos
s~ao usados em matematica , fsica e engenharia. Eles possuem uma aritmetica
governada por uma serie de regras incluindo as seguintes:
Sejam u = a + ib, v = c + id
u+v = (a+c)+i(b+d)
u-v = (a-c)+i(b-d)
u*v = (ac-bd)+i(ad+bc)
a=v = ac c+ bd + i( bc
2 2
bd )
c +d 2
Represente um numero complexo usando a estrutura de registro:

struct complexo
{
float real;
float imag;
};
e implemente as seguintes func~oes que efetuam operac~oes sobre os numeros comple-

xos:
complexo cadd(complexo& x, complexo& y); // x + y
complexo csub(complexo& x, complexo& y); // x - y
complexo cmul(complexo& x, complexo& y); // x * y
complexo cdiv(complexo& x, complexo& y); // x / y
29. Adicone uma operac~ao tamDeArquivo() ao TAD para stream. Ele deve retornar o
numero de caracteres no arquivo. Tome cuidado quando especicar que precondic~oes
devem existir para que esta operac~ao tenha sentido. (Susgest~ao: que tal cin/cout?)
6.9. EXERCICIOS 171
30. Distinga cuidadosamente um texto dum arquivo binario. Você pensa que e possvel
desenvolver um programa que recebe como entrada o nome de um arquivo e deter-
mina se ele e um texto ou um arquivo binario?
31. Escreva uma func~ao
void baseOut(unsigned int n, int b);
que devolve n na base b, 2 b 10, imprime cada numero no intervalo 2 n 50

nas bases 2, 4, 8 e 9.
32. Escrever uma func~ao
void octIn(unsignet int& );
que lê um numero na base 8(0ctal) e atribui ele a n. Use octIn() num programa
main() que lê os seguintes numeros octais e imprime os equivalentes decimais:
7; 177; 127; 7776; 177777
33. Escrever um programa que declara três variaveis inteiras i, j, k. Entre um valor
decimal para i em decimal e valores para j e k em hex. Imprima as três variaveis
em hex e decimal.
34. Considere o tipo enumerado
enum diasDaSemana {domingo, segunda, ter
ca, quarta, quinta, sexta, s
abado};
Escreva uma func~ao

void getDia(diadDASemana& dia);
que que lê o nome de um dia do teclado como uma string e atribui o corespondente
valor enum do dia. Escreva tambem uma func~ao
void putDia(diasDaSemana dia);
que escreve o valor enum na tela. Desenvolver um programa main() para testar as
duas func~oes.
35. Entre uma serie de palavras ate m do arquivo(fda), cada uma das palavras. Se a
palavra comeca com uma consoante, mover o primeiro caractere da palavra para a
ultima posic~ao e colocar \ay". Se a palavra comeca com uma vogal, simplesmente
coloque \ay" Por exemplo,
Entrada: tudo
e possvel
Sa
da: udoay eay oss
velay
36. Uma string de texto pode ser encriptado usando um mapeamento tabular que associa
a cada letra do alfabeto uma unica letra. Por exemplo,
abcdfghijklmnopqrstuvwxyz ==> ngzqtcobmuhelkpdawfyivrsj
mapeia \encrypt" em "tkzwsdf". Escreva um programa que lê um texto ate o m do

arquivo e devolve a forma encriptada.
37. Escreva um programa que faz com que um ou mais ndices da matriz sai do limite.
Torne a situac~ao bastante ruim fazendo com que o programa trave.
38. Modique a ordenac~ao por troca de modo que ele ordene a lista em ordem descen-
dente.
39. Considere a declarac~ao
struct mes
{
char nome[10]; // nome do mes
int numDoMes; // n
umero do dia no mes
};
(a) Escrever uma func~ao

void ordPorNome(mes Mes[], int n);
que ordena uma matriz cujos elelementos s~ao do tipo mes comparando no-
mes(use a func~ao C++ strcmp()). Escreva tambem uma func~ao
void ordPorDias(mes Mes[], int n);
que ordena a lista comparando o numero de dias num mes. Escreva um progra-
ma Main() que declara uma matriz contendo todos os meses do ano e ordena-os
usando ambas as func~oes. Imprima cada lista ordenada.
40. Escreva um programa que lê um arquivo de texto e imprime um contador do numero
de ocorrências dos sinais de pontuac~ao (.,!?).
41. Escreva um programa que entra uma matriz N N , a, de valores inteiros e imprime
o traco da matriz. O traco e denido como a soma dos elementos da diagonal.
tra
co(a) = a[0,0] + a[1,1] + ... + a[N-1,N-1]
6.9. EXERCICIOS 173
42. Escreva uma func~ao f(z) que(use o exerccio sobre complexos) avalia a func~ao poli-
nomial complexa:
z 3
3z + 4z 2
2
Avalie o polinômio para os seguintes valores de z:

z = 2 + 3i, -1 + i, 1 + 1, i - 1, 1 + 0i
Observe que os três ultinos valores s~ao razes de f.

Bibliograa
[1] Abramsky, S. Domain theory in logical form. In Domain Theory in Computing
Science, pages 47{53. Computer Society Press of the IEEE, 1987.
[2] Benedito M. Acioly. The scott interval analysis: A new approach to interval ma-
thematics. Revista de Informatica Teorica e Aplicada (RITA), 1996. To Appear.
[3] Benedito M. Acioly. The Scott Interval Analysis. In Marclia A. Campos; Dalcdio
M. Claudio, editor, Proceedings of the Second Workshop on Computer Arithmetic,
Interval and Symbolic Computation, pages 4{6. Brazilian Computer Society (SBC),
August 1996.
[4] Acioly B. & Bedregal, B. A quasi-metric topology compatible with inclusion-
monotonicity property on interval space. Reliable-Computing, 3(3), 1997.
Ed.Kluwer.
[5] Acioly, Benedito. Notas em logica. Technical report, Instituto de Informatica,
Universidade Federal do Rio Grande do Sul., Setembro 1990.
[6] Acioly, Benedito M. Computational foundations of Interval mathematics. PhD the-
sis, Instituto de Informatica, Universidade Federal do Rio Grande do Sul, Dezembro
1991. in Portuguese.
[7] Aczel, Peter H.G. Term declaration logic and generalized composita. In Six An-
nual IEEE Symposium on Logic in Computer Science(LICS'91), pages 22{30. IEEE
Press, 1991.
[8] Alefeld, G. & Herzberger, J. An Introduction to Interval Computation. Academic
Press, New York, 1983.
[9] Arbib,M.A. & Manes E.G. Arrows, Structures and Functors. Academic Press,
1975.
[10] Asperti, Andrea & Longo Giuseppe. Categories, Types and Structures. Massachu-
setts Institute of Technology, 1991.
175
176 BIBLIOGRAFIA
[11] Barendregt, H. The lambda calculus. it's syntax and semantics. In Studies in Logic
and Foundation of Mathematics, volume 103. North-Holland Publishing Company,
1984.
[12] Barr, Michael & Wells, Charles. Category Theory for Computing Science. C.A.R
Hoare, Series Editor. Pretince Hall International (UK), rst edition, 1990.
[13] Bedergal, B.R. & Acioly, B.M. Sistemas de informac~ao contiInuos. Technical
Report RT-001/95, UFPe-CCEN, Depto. de Informatica, Recife, 95.
[14] Michael Beenson. Foundation of constructive Mathematics. springer-Verlag, 1985.
[15] Beenson, M.J.ll. Formalizing constructive mathematics. why and how? In
F.Richman, editor, Constructive Mathematics. Proceedings,, number 873 in Lecture
Notes in Mathematics, pages 146{190, Las Cruces, New Mexico, 1981. Springer-
Verlag.
[16] Bell, J.L. Toposes and Local Set Theories. An Introduction. Number 14 in Oxford
Logic Guides. Clarendon Press - Oxford, 1988.
[17] Berti, S. The Solution of an Interval Equation. 1969.
[18] Bird, Richard. Programs and Machines. An Introduction to the Theory of Compu-
tation. John Wiley & Sons, 1976.
[19] Birko, Garret. On the structure of abstract algebras. Proceedings Cambridge
Philosophical Society, 31:433{454, 1935.
[20] Erret Bishop. Foundations of Constructive Analysis. Mc-Graw Hill, 1967.
[21] C.Thomas; Hahn S.W. Bullof, Jack J.; Holyoke, editor. Foundations of Mathe-
matics (Symposium Papers Commemorating the Sixtiex Birthday of Kurt Godel,
1969.
[22] Bunge, Mario. Tratado de losoa basica. In Semântica I, volume vol 1. EDUSP,
1976.
[23] Bunge, Mario. Tratado de losoa basica. In Semântica II. Interpretac~ao e Verdade,
volume vol 2. EDUSP, S~ao Paulo, 1976.
[24] Burris, Stanley & Sankappanavar, H.P. A Course in Universal Algebra. Springer-
Verlag, 1981.
[25] Georg Cantor. Contributions to the foundation of the theory of transnite numbers.
Dover Publications.
BIBLIOGRAFIA 177
[26] Cardelli, Luca & Wagner, Peter. On understanding types, data abstraction and
polimorphism. Computing Surveys, 17(04), December 1985.
[27] Cohn, P.M. Universal Algebra. Harper & Row and John Weatherhill Inc., 1965.
[28] Costa, M.Amoroso. In Texto 4. As Ideias Fundamentais da Matematica e Outros
Ensaios, Biblioteca do Pensamento Brasileiro. EDUSP, 1981.
[29] daCosta, Newton C.A. Introduc~ao aos Fundamentos da Matematica. HUCITEC,
S~ao Paulo, 3ed., edition.
[30] B.A. Davey and H.A. Priestley. An introduction to lattices and order. Cambridge
University Press, 1992.
[31] Davis, Ruth. Truth, Deduction, and Computation. Logic and Semantics for Com-
puting Science. Computer Science Press, 1989.
[32] deQueiroz, Ruy J.G.B. A proof-theoretic account of programming and the role of
reduction rules. Dialectica, 42(04), 1988.
[33] deQueiroz, Ruy J.G.B. Proof Theory and Computer Programming. The Logical
Foundations of Computing. PhD thesis, Department of Computing, Imperial Col-
lege, University of London, 1991.
[34] deQueiroz, Ruy J.G.B. & Gabbay, M. Dov. An introduction to labelled natural de-
duction. Technical report, Departament of Computing, Imperial College, University
of London, September 1982.
[35] deQueiroz, Ruy J.G.B. & Maimbaum, Thomas S.E. Proof theory and computer
progamming. Zeitschrift Fur Mathematishe Logik und Grundlagen der Mathematik,
36:389{414, 1990.
[36] Diller A. Z. An Introduction to Formal Methods. John Wiley & Sons, 1994.
[37] Domingues, H.H. & Iezzi, G. A lgebra Moderna. 2a ed. edition, 1982.
[38] Dummet, Michael. What is a theory of meaning? In Evans & John McDowell,
editor, Essays in Semantics. Claredon Press, 1976.
[39] H. Enderton. A mathematical introduction to logic. Academic Press Inc, 1972.
[40] Bell. E.T. Men of mathematics.
[41] Ferrari, A. T. Metodologia da Pesquisa Cientca. McGraw-Hill, 1982.
178 BIBLIOGRAFIA
[42] F.B. Feys, R.; Fitch. Dictionary of Mathematical Logic. Studies in Logic and The
Foundations of Mathematics. North-Holland, 1969.
[43] M.C. Fitting. Intuitionistic Logic Model Theory and Forcing. Studies In Logic and
the Foundations of Mathematics. North-Hollad, 1969.
[44] M. P. Fourman and D. S. Scott. Sheaves and logic. In M. P. Fourman, C. J. Mulvey,
and D. S. Scott, editors, Applications of Sheaf Theory to Algebra, Analysis, and
Topology, number 753 in Lecture Notes in Mathematics, pages 302{401. Springer-
Verlag, 1979.
[45] Frege, Gottlob. Function and concept. In Brian McGuinness, editor, Collected
Papers on Mathematics, Logic and Philosophy.
[46] F.W.Lawvere, editor. Toposes, Algebraic Geometry and Logic. Number 274 in
Lecture Notes in Mathematics. Springer-Verlag, 1972.
[47] Gabbay, Dov M. Labelled Deductive Systems. Part 1. Oxford University Press,
1996.
[48] Gabbay, M.Dov & de Queiroz, Ruy J.G.B. Extending the curry-howard interpreta-
tion to linear, relevant and other resourcer logic. The Journal of Symbolic Logic,
57(4), December 1992.
[49] Gallier, Jean. Contructive logics. Technical report, digital, Paris Research Labora-
tory, 1991.
[50] Gallier, Jean H. Logic for Computer Science. Foundations of Automatic Theorem
Proving. John Wiley & Sons inc., 1987.
[51] Gentzen, G. The collected papers of gerard gentzen. In Szabo, M.E., editor, Studies
In Logic And Foundations of Mathematics. North-Holland Publishing Company,
1969.
[52] Gierz, G.; Hofmann, K.H.;Keimel, K.; Lawson, J.D.; Mislove, M.; Scott, D.S. A
Compendium of Continuous Lattices. Springer-Verlag, 1980.
[53] Girard, Jean-Yves. Proof Theory and Logical Complexity, volume I. Bibliopolis,
1987.
[54] Girard, Jean-Yves; Lafont, Yves & Taylor, Paul. Proofs and Types, volume 7 of
Tracts in Theoretical Computer Science. Cambridge University Press, 1989.
[55] Andrew H. Gleason. Fudamentals of Abstract Analysis.
BIBLIOGRAFIA 179
[56] Goguen, Joseph A. Theorem Proving and Algebra. To be published, 1997. Draft of
May 16, 1997.
[57] Goguen,J, et.al. Initial algebra semantics and continuous algebras. Journal of ACM,
24(1):32{101, January 1977.
[58] Goldblatt, R. Topoi. The Categorial Analysis of Logic, volume 98 of Studies in
Logic and The Foundations of Mathematics. north-holland, 1984.
[59] R.L. Goodstein. Recursive Number Theory. Studies in Logic and the Foundation
of Mathematics. North-Holland, 1964.
[60] Michael J.C. Gordon. Programming Language Theory and Its Implementation.
C.A.R. Hoare. Pretince-Hall, 1988.
[61] Guelli, C.A; et.al. Algebra IV. Editora Moderna ltda.
[62] Halmos, Paul R. Naive Set Theory. D.Van Nostrand Company inc., 1960.
[63] Heijenoort, Jean Van. From frege to godel. a source book in mathematical logic 1879-
1931. Series Source Books in History Of The Science, pages xii+665pp. Harvard
University Press.
[64] Heijnoort, Jean Van. Logic as calculus and logic as language. Synthese, 53, 1967.
[65] Hennessy, Matthew. Algebraic Theory of Process. The MIT Press, 1988.
[66] Hindley, J. Roger & Seldin, Jonathan P. Introduction to Combinators and -
calculus.
[67] Howard, W.A. The formulae-as-types notion of construction. In J.P. Seldin & J.R.
Hindley, editor, Essays on Combinatory Logic, Lambda Calculus and Formalism,
pages xxv+606p. Academic Press, 1980.
[68] Huet, Gerard, editor. Logical Foundations of Functional Programming. Addison-
Wesley, 1990.
[69] Peter T. Johnstone. Stone Spaces. Cambridge University Press, 1982.
[70] P.T. Johnstone. Stone Spaces. Cambridge University, 1982.
[71] Johnstone, P.T. Stone Spaces. Cambridge University Press, 1982.
[72] Robert H. Kasriel. Undergraduate Topology.
[73] Kleene, Stephen Cole. Mathematical Logic. John Wiley & Sons, Inc., 1967.
180 BIBLIOGRAFIA
[74] Kneale, William & Kneale, Martha. O Desenvolvimento da Logica. Fundac~ao
Calouste Gulbenkian, 1991.
[75] G. Kreisel. Elements of mathematical logic (model theory). In Studies in Logic and
The Foundation of Mathematics. North-Holland Publishing Company, 1971.
[76] Lambeck,J.& Scott,P.J. Introduction to Higher Order Categorical Logic. Cambridge
University Press, 1986.
[77] P.D. Lax. Calculus with application and computing.
[78] Leisenring, A.C. Mathematical Logic and Hilbert's -Symbol. MacDonald Technical
and Scientic, 1969.
[79] Lipschutz, Seymour. Teoria dos Conjuntos. AO Livro Tecnico S.A., 1968.
[80] Manes, Ernest G. & Arbib, Michael A. Algebraic Approaches To Program Seman-
tics. Springer-Verlag, 1986.
[81] Manzano, Maria. Teoria de Modelos. Alianza Universidad Textos, 1989.
[82] Martin-Lof, Per . Notes on Constructive Mathematics. Almqvist & Wiksell, 1968.
[83] Martin-Lof, Per. Constructive mathematics and computer programming. In J.Tos,
H.Pfeier & K.P.Pdewski L.J. Cohen, editor, Logic, Methodology and Philosophy
of Science, number VI. North-Holland, 1982.
[84] Martin-Lof, Per. Intuitionistic Type Theory. Bibliopolis, 1984.
[85] Martin-Lof, Per. Truth of a proposition, evidence of a judgement, validity of a
proof. Synthese, (73):407{420, 1987.
[86] Moore, Ramon E. Interval Analysis. Pretince Hall, New Jersey, 1966.
[87] Moore, Ramon E. Methods and Applications of Interval Analysis. SIAM, 1979.
[88] Mosses, Peter D. Handbook of Theoretical Computer Science, chapter 11, pages
577{674. 1990.
[89] Nordstrom, Bengt ; Peterson, Kent & Smith, Jan M. Programming in Martin-Lof's
Type Theory. An Introduction. Clarendon Press. Oxford, 1990.
[90] Paulson, L. Tracts in theoretical computer science. In Logic and Computation.
Interactive Proof with Cambridge LCF, volume 2. Cambridge University Press,
1987.
BIBLIOGRAFIA 181
[91] Prawitz, Dag. Ideas and results in proof theory. In Fenstad, J.E., editor, Procee-
dings of The Second Scandinavian Logic Symposium, pages 235{307, Amsterdam,
1971. North-Holland.
[92] Prawitz, Dag. Towards a foundation of general proof theory. In Proceedings ,of The
Fourth International Congress For Logic, Methodology And Philosophy of Science,
pages 225{250. North-Holland Publishing Company, 1971.
[93] Prawitz, Dag. On the idea of a general proof theory. Synthese, (27):63{77, 1974.
[94] Prior, A.N. The runabout inference-ticket. Analysis, (21):38{39, 1960.
[95] Interval'96, 1996.
[96] Revesz. Lambda-Calculus, Combinators and Functional Programing. Cambridge
Tracts in Theoretical Computer Science. Cambridge University Press, 1988.
[97] Reynolds, John C. Polymorphism is not set theoretic. Semantics of Data Types,
page 184, June. International Symposium, France.
[98] Reynolds, John C. Types, abstraction and parametric polimorphism. Information
Processing, 1983.
[99] Ross, Keneth A. & Wright, Charles R.B. Discrete Mathematics. Pretince Hall,
1988.
[100] Walter Rudin. Principles of Mathematical Analysis. McGraw-Hill, 1953.
[101] Santiago, Regivan. Toward a constructive logic to real analysis. Master's thesis,
Universidade Federal de Pernambuco, March 1995. In Portuguese.
[102] Santiago, Regivan & Acioly Benedito. Intervals as real numbers specication. In
Interval'96, October 1996.
[103] Santiago, Regivan & Acioly Benedito. A numerical approximation logic. In
Workshop in Arithmetic, Interval and Symbolic Computation, July 1996.
[104] Santiago, Regivan & Acioly, Benedito. Toward a logic for numerical approximations.
Revista de Informatica Teorica e Aplicada, 1996. To appear.
[105] Santiago, Regivan & deQueiroz, Ruy J.G. Toward a proof theory for proofs by
induction. In 1st. Workshop LaLLIC, pages 149{164, July 1994.
[106] Santiago, Regivan & deQueiroz, Ruy J.G. Notas em logica e topoi. Manuscript,
July 1996.
182 BIBLIOGRAFIA
[107] Dana S. Scott. Domains for denotational semantics. In M. Nielsen and E. M.
Schmidt, editors, Automata, Languages and Programming, volume 140 of Lecture
Notes in Computer Science, pages 577{613, Berlin, 1982. Springer-Verlag.
[108] Scott, Danna. Continuous lattices. In F.W.Lawvere, editor, Toposes, Algebraic
Geometry and Logic, number 274 in Lecture Notes in Mathematics, pages 97{136.
Springer-Verlag, 1972.
[109] M.B. Smith. Topology. Handbook of Logic in Computer Science, 1:641{751, 1992.
[110] Smorynski, C.A. Applications of kripke models. In A.S. Troelstra, editor, Ma-
thematical Investigation of Intuitionistic Arithmetic and Analysis, number 344 in
Lecture Notes in Mathematics, chapter V, pages 324{391. springer-Verlag, 1973.
[111] Spivey, J.M. Understanding Z.A Specication Language and its Formal Semantics.
Cambridge University Press, 1988.
[112] Spivey, J.M. The Z Notation. A Reference Manual. C.A.R. Hoare Series. Pretince
Hall, 1992.
[113] Sundholm, Goran. Proof theory and meaning. In Gabbay, Dov & Guenthner, F.,
editor, Handbook of Philosophical Logic, pages 471{506. D.Reidel Publishing com-
pany, 1986.
[114] Thompson, S. An introduction to type theory and constructive mathematics. No-
vember 1987.
[115] A.S. Troelstra. Mathematical Investigation of Intuitionistic Arithmetic and Analy-
sis. Lecture Notes In Mathematics. Springer-Verlag, 1973.
[116] Troelstra, A.S. Principles of Intuitionism. Lecture Notes In Mathematics. Springer-
Verlag, 1969.
[117] Troelstra, A.S. & Van Dalen, Dirk. Constructivism in mathematics. In Studies in
Logic and the Foundations of Mathematics, volume II. North-Holland, 1988.
[118] Dirk Van Dalen. Intuitionisc logic. Handbook of Philosophical Logic, 3, 1986.
[119] Van Dalen, Dirk. Intuitionistic logic. In Gabbay, Dov & Guenthner F., editor,
Handbook of Philosophical Logic, volume III, chapter III.4, pages 225{339. D.
Reidel Publishing Company, 1986.
[120] Vickers, S. Topology via logic. Number 5 in Cambridge Tracts in Theoretical
Computer Science. Cambridge University Press, 1989.
BIBLIOGRAFIA 183
[121] David A. Watt. Programming Concepts and Paradigms. C.A.R. Hoare. Pretince-
Hall, 1990.
[122] Wechler, Wolfgang. Universal Algebra For Computer Scientists. Springer-Verlag,
1992.
[123] Woodcock,J. & Davies, J. Using Z.Specication, Renement, and Proof. Pretince
Hall, 1996.
[124] Martin M. Zuckerman. Sets and Transnite Numbers. Collier Macmillian, 1974.

Linguagem de Programacao e Estruturas de

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Linguagem de Programacao e Estruturas de

Uploaded by

Copyright:

Available Formats

LINGUAGEM DE PROGRAMACA~ O E

cisamente estabelecidas. O computador possui um repertorio limitado de instruc~oes ele-

Quando forem dados valores determinados a x e a y, o processo correspondente pode

x=qy+r e 0r <y (1.4)

(q; r) x div y (1.5)

100 = 6 15 + 10 e 0  10 < 15 (1.6)

Os exemplos 1 e 2, descritos acima, s~ao processos sequenciais nos quais as atribuic~oes

uma informac~ao e capaz de transmitir um conhecimento. Para que haja transmiss~ao de

1.2 Organizac~ao de um computador

dade logica-aritmetica) e a unidade memoria.

Unit) MEMORIA E CPU .

representados por enderecos na posic~ao de memoria e se os enderecos forem numeros

Alguns disposivos de entradas: teclado,disk driver.

1.3 Sistema de programac~ao de apoio

1.4 Construc~ao de programas

cuja execuc~ao, em tempo nito, resolve um problema computacional, qualquer que

e representada por um desenho. Na linguagem algortmica cada operac~ao basica e

de programac~ao, mais amplamenente utilizada, como C, C++ ou Java. Usaremos o C++,

2.1 Problemas usando o tipo abstrato de dados in-

tabela do tipo abstrado numero inteiro, com suas operac~oes e relac~oes.

Exemplo 7 Enunciado do problema: Calcular a soma de dois numeros in-

algoritmo de resoluca~o do problema proposto. Podemos escrev^e-las na mesma linha, como

cin >> A >> B ;

cout << soma = A + B << endl;

cout << unidade << endl;

Em cada um dos execcicios, abaixo, fazer analise do problema, o projeto do algoritmo

2.3 Algoritmos estruturados

construc~ao: expr1 ? : expr2 : expr3. A sem^antica desse operador e a seguinte: A expr1 e

O separador \;" e um operador de continuac~ao. Ele ocasiona a execuc~ao do comando

zes, se constituir de um grande numero de comando basicos ou elementares, assumindo

Estruturas de repetic~ao(lacos ou loops)

Procuraremos entender essas duas estruturas atraves de exemplos.

Sem^antica: deveremos ter o seguinte entendimento desse trecho de programa.

para i de 1 ate n repita < bloco >

A instruca~o de repetica~o, presente neste algoritmo, e controlodada pela variavel

valor final valor inicial = n 1 + 1 = n vezes

cout << ``Entre com um valor n" << endl;

for(i=1; i<=n; i++)

cout << S << endl;

Este problema e analogo ao anterior.

Finalmente, o algoritmo tem a seguinte redac~ao:

cout << ``Entre com um valor n" << endl;

for(i=1; i<=n; i++)

Exemplo 11 Enunciado: Imprimir os n primeiros numeros mpares em or-

Geramos os numeros mpares desde o n-esimo ate o primeiro. A medida que

cout << ``Entre com um valor n" << endl;

for(i=n; i>=1; i--)

Exemplo 12 Enunciado: Imprimir os n primeiros termos da sequ^encia

 Entrada: um numero natural positivo, n;

Cada termo da sequ^encia e igual a soma do termo anterior com a constante 2.

Observe que n~ao e necessario guardar todos os elementos da sequ^encia. Po-

Observe que a sequ^encia de nida pela relac~ao de recorr^encia dada, de ne em

cout << ``Entre com um valor n" << endl;

cout << y << endl;

for(i=1; i<=n-1; i++)

Tipo abstrato de dados real

A implementac~ao do tipo inteiro, assim como do tipo real, em uma linguagem de

 Entrada: um numero real positivo, A;

Vamos ilustrar o processo para A = 2, considerando-se os racionais escritos

x 2= (x + x1 )=2 = 1; 416 666 667

x 3= (x + x2 )=2 = 1; 414 215 686

x 4= (x + x3 )=2 = 1; 414 213 562

x 5= (x + x4 )=2 = 1; 414 213 562

LINGUAGEM DE PROGRAMACA~ O E

cisamente estabelecidas. O computador possui um repertorio limitado de instruc~oes ele-

x=qy+r e 0r <y (1.4)

100 = 6 15 + 10 e 0 10 < 15 (1.6)

Os exemplos 1 e 2, descritos acima, s~ao processos sequenciais nos quais as atribuic~oes

uma informac~ao e capaz de transmitir um conhecimento. Para que haja transmiss~ao de

1.2 Organizac~ao de um computador

dade logica-aritmetica) e a unidade memoria.

Unit) MEMORIA E CPU .

representados por enderecos na posic~ao de memoria e se os enderecos forem numeros

1.3 Sistema de programac~ao de apoio

1.4 Construc~ao de programas

cuja execuc~ao, em tempo nito, resolve um problema computacional, qualquer que

e representada por um desenho. Na linguagem algortmica cada operac~ao basica e

de programac~ao, mais amplamenente utilizada, como C, C++ ou Java. Usaremos o C++,

tabela do tipo abstrado numero inteiro, com suas operac~oes e relac~oes.

Exemplo 7 Enunciado do problema: Calcular a soma de dois numeros in-

algoritmo de resoluca~o do problema proposto. Podemos escrev^e-las na mesma linha, como

Em cada um dos execcicios, abaixo, fazer analise do problema, o projeto do algoritmo

construc~ao: expr1 ? : expr2 : expr3. A sem^antica desse operador e a seguinte: A expr1 e

O separador \;" e um operador de continuac~ao. Ele ocasiona a execuc~ao do comando

zes, se constituir de um grande numero de comando basicos ou elementares, assumindo

Estruturas de repetic~ao(lacos ou loops)

Procuraremos entender essas duas estruturas atraves de exemplos.

para i de 1 ate n repita < bloco >

A instruca~o de repetica~o, presente neste algoritmo, e controlodada pela variavel

Este problema e analogo ao anterior.

Finalmente, o algoritmo tem a seguinte redac~ao:

Exemplo 11 Enunciado: Imprimir os n primeiros numeros mpares em or-

Geramos os numeros mpares desde o n-esimo ate o primeiro. A medida que

Entrada: um numero natural positivo, n;

Cada termo da sequ^encia e igual a soma do termo anterior com a constante 2.

Observe que n~ao e necessario guardar todos os elementos da sequ^encia. Po-

Observe que a sequ^encia denida pela relac~ao de recorr^encia dada, dene em

A implementac~ao do tipo inteiro, assim como do tipo real, em uma linguagem de

Entrada: um numero real positivo, A;

O valor da raz quadrada de 2, obtido atraves da quinta iterac~ao do processo

Exemplo 14 Enunciado: Usando a relac~ao a relac~ao de recorr^encia denida

calcule a aproximac~ao x da raz quadrada de A

4. Partindo-se de um unico casal de coelhos lhotes recem-nascidos e supondo que um

7. Em um campeonato de futebol cada time tem uma lista ocial de 23 jogadores.

A entrada consiste de uma lista de numeros para os quais desejamos calcular

O problema e dividido nos seguintes subproblemas.

O problema no projeto desse algoritmo e saber quantas vezes executar a repe-

enquanto < condic~ao > faca < bloco >

Observe que o algoritmo quadrados \funcionara" mesmo que seja colocado

cout << ``Entre com um lista de n

Apresentaremos, tambem, o projeto desse algoritmo, assim como sua imple-

repita < bloco > ate que < condic~ao >

Observe que a primeira estrutura de repetic~ao (enquanto-faca) e mais conve-

cout << ``Entre com um lista de n

Exemplo 16 Enunciado: Suponha que no ano N a populac~ao americana seja

A entrada consiste de tr^es numeros: ano, populac~ao brasileira e populac~ao

A correc~ao do valor da populac~ao e feita somando-se ao valor existente o valor

Na instruca~o de sada acrescentamos uma mensagem que esclarece o signi-

cout << "Entre com o ano, a popula

Na linha superior do dispositivo pratico registramos os quocientes obtidos, na

Podemos armar que

Na primeira divis~ao um dos dividendos e um dos numeros dados e o divisor

Portanto, o problema e dividido nos seguintes subproblemas.

custo de produca~o = custo xo + (num de copias) (num de pags.) 0; 031

3.1 Estruturas de decis~ao de selec~ao ou de alternati-

Podemos de incio identicar a seguinte estrutura sequencial do algoritmo:

Para determinar o maior dos dois numeros A e B , e preciso comparar A com

Vejamos que modicac~ao deve sofrer o algoritmo maior1() se os numeros A e

O ramo sen~ao(<bloco2>) dessa instruc~ao nada mais e que o algoritmo ante-

cout << "Digite dois n

cout << "Digite dois n

Exemplo 19 Enunciado: Determinar se uma pessoa e maior ou menor de

A entrada consiste de um numero que e a idade alguem, enquanto a sada deve

Exemplo 20 Enunciado: Numa pequena empresa, cada funcionario recebe

rendimento = salario bruto + pr^emio,

salario lquido = rendimento desconto INPS desconto IR

salario lquido = 3000 300 0 = 2700

Analisando o processo executado observamos que o desconto do INPS so ocorre

cout << "Digite sal

Tipos de dados booleano(l

A implementac~ao do tipo caractere numa liguagem de programac~ao representara os