Apostila Tec I Algoritmos

Faculdade SATC
Tcnicas de Programao I
Algoritmos
Engenharias Eltrica e Mecnica
Prof.: Giovani Martins Cascaes

giovani.cascaes@satc.edu.br
http://www.satc.edu.br/gcascaes/
verso 1.05.111
2008/2009
Acontece que muito difcil inventar uma teoria que descreva o
universo de uma s vez. Pelo contrrio, decompomos o problema
em pedaos e inventamos vrias teorias parciais. Cada uma
dessas teorias parciais descreve e prev uma determinada e
limitada classe de observaes, desconsiderando os efeitos de
outras quantidades, ou representando-os por simples conjuntos
de nmeros. possvel que este enfoque esteja inteiramente
errado. Se tudo no universo depender de tudo o mais de uma
maneira fundamental, poderia ser impossvel chegar mais perto
de uma soluo completa atravs da investigao de partes
isoladas do problema. Ainda assim, foi desta maneira que
fizemos progresso no passado.
HAWKING e MLODINOW Uma nova histria do tempo

Sumrio
Listas de figuras............................................................................................................... 5
Lista de tabelas.................................................................................................................6
1 Introduo..................................................................................................................... 7
1.1 Definio de algoritmo............................................................................................. 8
1.2 Formas de representaes de algoritmos................................................................. 8
1.2.1 Descrio narrativa........................................................................................... 9
1.2.2 Fluxogramas....................................................................................................10
1.2.3 Portugus estruturado ou pseudocdigo........................................................ 11
2 Variveis, expresses, funes, atribuies, entrada e sada...................................15
2.1 Variveis................................................................................................................ 15
2.1.1 Tipos de variveis........................................................................................... 16
2.2 Exerccios propostos.............................................................................................. 19
2.3 Expresses............................................................................................................. 20
2.3.1 Aritmticas...................................................................................................... 20
2.3.2 Relacionais...................................................................................................... 21
2.3.3 Lgicas............................................................................................................22
2.3.4 Prioridade de operadores................................................................................ 23
2.4 Funes primitivas................................................................................................. 23
2.5 Atribuies............................................................................................................. 24
2.6 Sada de dados....................................................................................................... 26
2.7 Entrada de dados................................................................................................... 29
3 Comandos de controle de fluxo..................................................................................36
3.1 Seqncia ou bloco................................................................................................ 36
3.2 Seleo................................................................................................................... 38
3.3 Seleo entre mltiplas escolhas............................................................................ 42
3.5 Estruturas de repetio.......................................................................................... 51
3.5.1 Enquanto......................................................................................................... 51
3.5.2 Faca enquanto................................................................................................. 52
3.5.3 Para................................................................................................................. 54
4 Modularizao.............................................................................................................63
4.1 Funes.................................................................................................................. 63
4.1.1 Exerccios propostos....................................................................................... 69
4.2 Funes sem retorno.............................................................................................. 71
5 Estruturas e classes..................................................................................................... 75
5.1 Estruturas............................................................................................................... 75
5.1.1 Definindo e declarando estruturas...................................................................76
5.1.2 Acessando os membros de estruturas............................................................. 78
5.1.3 Estruturas mais complexas.............................................................................. 79
5.2 Classes................................................................................................................... 82
5.2.1 Programas desestruturados............................................................................. 82
5.2.2 Programas estruturados.................................................................................. 82
5.2.3 Programas orientados a objetos...................................................................... 83
5.2.4 Declarando classes.......................................................................................... 83
5.2.5 Permitindo o acesso aos membros da classe................................................... 86
6 Tipos de dados estruturados...................................................................................... 90
6.1 Vetores...................................................................................................................90
6.2 Vetores de caracteres............................................................................................. 93
6.2.1 Funes para manipulao de vetores de caracteres....................................... 96
6.2.2 Exerccios propostos..................................................................................... 100
6.3 Matrizes............................................................................................................... 101
6.3.1 Matrizes bidimensionais................................................................................ 101
6.3.2 Matrizes de cadeias de caracteres................................................................. 103
6.3.3 Inicializaes de matrizes.............................................................................. 104
6.3.4 Inicializaes sem a especificao de tamanho............................................. 104
6.3.5 Exerccios propostos..................................................................................... 105
7 Mini Manual do C Quietly.......................................................................................106
Bibliografia...................................................................................................................111
Obs.: Os exerccios presentes nas listas em cada captulo

desta, foram retirados ou adaptados de livros e pginas
da internet e pertencem a seus respectivos donos.
4
Listas de figuras
Figura 1.1 Etapas que antecedem o desenvolvimento de programas...................... 7

Figura 1.2 Fluxograma clculo do Triplo de um Nmero.......................................11
Figura 3.1 Fluxograma para estrutura SE............................................................... 39
Figura 3.2 Fluxograma para estrutura SE SENAO................................................ 40
Figura 3.3 Fluxograma para estrutura ESCOLHA CASO.................................... 46
Figura 3.4 Fluxograma para estrutura ENQUANTO............................................. 51
Figura 3.5 Fluxograma para estrutura FACA ENQUANTO................................. 53
Figura 3.6 Fluxograma para estrutura PARA......................................................... 55
Figura 5.1 Um retngulo representado no plano cartesiano.................................. 80
Figura 5.2 Algoritmo desestruturado........................................................................82
Figura 5.3 Algoritmo modular...................................................................................83
Figura 5.4 Algoritmo orientados a objetos............................................................... 83
Figura 7.1 Iniciando o C Quietly com um novo algoritmo................................... 106
Figura 7.2 Novo cdigo-fonte em linguagem C......................................................107
Figura 7.3 Compilando um cdigo-fonte................................................................108
Figura 7.4 Trmino da compilao do cdigo-fonte..............................................108
Figura 7.5 Executando o programa........................................................................ 109
Figura 7.6 Sada de execuo do programa............................................................109
Figura 7.7 Inserindo novas palavras-chave............................................................110
Lista de tabelas
Tabela 2.1 Exemplos de nomes de variveis.............................................................16

Tabela 2.2 Operadores aritmticos........................................................................... 20
Tabela 2.3 Operadores relacionais............................................................................ 21
Tabela 2.4 Operadores lgicos...................................................................................22
Tabela 2.5 Conjuno.................................................................................................22
Tabela 2.6 Disjuno.................................................................................................. 22
Tabela 2.7 Negao..................................................................................................... 23
Tabela 2.9 Caracteres de converso para funo imprima.....................................27
Tabela 2.10 Caracteres de controle........................................................................... 27
Tabela 2.11 Caracteres de converso para funo leia........................................... 30
6
1 Introduo
A automatizao de tarefas um aspecto marcante da sociedade moderna. O

aperfeioamento tecnolgico alcanado, com respeito a isto, teve como elementos
fundamentais a anlise e a obteno de descries da execuo de tarefas em termos de
aes simples o suficiente, tal que pudessem ser automatizadas por uma mquina
especialmente desenvolvida para este fim, o Computador.
Em cincia da computao houve um processo de desenvolvimento simultneo e
interativo de mquinas (hardware) e dos elementos que gerenciam a execuo
automtica (software) de uma dada tarefa. E essa descrio da execuo de uma tarefa,
como considerada acima, chamada Algoritmo.
Lgica de programao a tcnica de encadear pensamentos para atingir
determinado objetivo. Quando h um problema e o objetivo solucion-lo, necessrio
ordenar o pensamento de forma lgica durante a elaborao das aes a serem seguidas
para solucionar o problema. Sendo assim, algoritmo no a soluo do problema (fig.
1.1), mais a maneira de representar a soluo do problema criada por cada indivduo. Os
caminhos que levam a soluo de um determinado problema podem ser inmeros,
estando, assim, a cargo de cada pessoa desenvolver seu raciocnio lgico na elaborao
de solues criativas e inovadoras.
Problema
Soluo
Algoritmo
Figura 1.1 Etapas que antecedem o desenvolvimento de programas.
O programa escrito em uma linguagem de programao no nada mais do que a

representao, obedecendo sintaxe e semntica da linguagem, do algoritmo que
7
representa a soluo do problema proposta pelo programador.
O objetivo desse curso a Lgica de Programao dando uma base terica e
prtica, suficientemente boa, para que, o aluno domine os algoritmos e esteja habilitado a
aprender uma linguagem de programao.
1.1 Definio de algoritmo
O conceito central da programao o conceito de algoritmos, isto ,

programar basicamente construir algoritmos.
a descrio, de forma lgica, dos passos a serem executados no cumprimento
de determinada tarefa.
O algoritmo pode ser usado como uma ferramenta genrica para representar a
soluo de tarefas independente do desejo de automatiz-las, mas em geral est
associado ao processamento eletrnico de dados, onde representa o rascunho para
programas (Software).
Serve como modelo para programas, pois sua linguagem intermediria
linguagem humana e s linguagens de programao, sendo ento, uma boa ferramenta na
validao da lgica de tarefas a serem automatizadas.
Um algoritmo uma receita para um processo computacional e consiste de uma
srie de operaes primitivas, interconectadas devidamente, sobre um conjunto de
objetos. Os objetos manipulados por essas receitas so as variveis.
a forma pela qual se descreve solues de problemas do mundo real, a fim de
serem implementadas utilizando os recursos do mundo computacional. Como este possui
severas limitaes em relao ao mundo real, exige-se que, sejam impostas algumas
regras bsicas na forma de solucionar os problemas, para que, possamos utilizar os
recursos de hardware e software disponveis. Pois, os algoritmos, apesar de servirem
para representar a soluo de qualquer problema, no caso do Processamento de Dados,
eles devem seguir as regras bsicas de programao para que sejam compatveis com as
linguagens de programao.
1.2 Formas de representaes de algoritmos
Existem diversas formas de representao de algoritmos, mas no h um

consenso com relao a melhor delas. O critrio usado para classificar hierarquicamente
estas formas est diretamente ligado ao nvel de detalhe ou, inversamente, ao grau de
abstrao oferecido.
Algumas formas de representao de algoritmos tratam os problemas apenas em
nvel lgico, abstraindo-se de detalhes de implementao muitas vezes relacionados com
alguma linguagem de programao especfica. Por outro lado existem formas de
representao de algoritmos que possuem uma maior riqueza de detalhes e muitas vezes
acabam por obscurecer as idias principais do algoritmo, dificultando seu entendimento.
Dentre as formas de representao de algoritmos mais conhecidas pode-se citar:
i) Descrio Narrativa;
ii) Fluxogramas;
iii) Pseudocdigo, tambm conhecido como Portugus Estruturado.
8
1.2.1 Descrio narrativa
Nesta forma de representao os algoritmos so expressos diretamente em

linguagem natural. Como exemplo, tm-se os algoritmos a seguir:
Exemplo 1.1 Algoritmos em linguagem natural.
Algoritmo 1 - Troca de um pneu furado
Afrouxar ligeiramente as porcas

Suspender o carro
Retirar as porcas e o pneu
Colocar o pneu reserva
Apertar as porcas
Abaixar o carro
Dar o aperto final nas porcas
Algoritmo 2 - Clculo da mdia de um aluno
Obter as suas trs notas de provas

Calcular a mdia aritmtica
Se (mdia for maior que 7)
Aluno foi aprovado
Seno
ele foi reprovado
Algoritmo 3 - Troca de lmpadas queimadas
Se (lmpada estiver fora de alcance)

Pegar escada;
Pegar lmpada;
Tirar lmpada queimada;
Colocar lmpada nova;
Algoritmo 4 Realizar uma prova
Ler a prova;
Pegar a caneta;
Enquanto ((houver questo em branco) e (tempo no terminou)) faa
Se (souber a questo)
Resolv-la;
Seno
Pular para prxima;
Entregar a prova.
Exerccios propostos
9
Exerccio 1.1 Um homem precisa atravessar um rio com um barco que possui
capacidade de carregar apenas ele mesmo e mais uma de suas trs
cargas, que so: um lobo, um bode e um fardo de capim. O que o
homem deve fazer para conseguir atravessar o rio sem perder suas
cargas?
Exerccio 1.2 Construa a seqncia/soluo que mova trs discos de uma Torre de
Hani, que consiste em trs hastes (a-b-c), uma das quais serve de
suporte para trs discos de tamanhos diferentes (1-2-3), os menores
sobre os maiores. Pode-se mover um disco de cada vez para qualquer
haste, contanto que nunca seja colocado um disco maior sobre um
menor. O objetivo transferir os trs discos para outra haste.
a b c
Exerccio 1.3 Trs jesutas e trs canibais precisam atravessar um rio; para tal,
dispem de um barco com capacidade para duas pessoas. Por medidas
de segurana no se permite que em alguma margem a quantidade de
jesutas seja inferior de canibais. Qual a seqncia de passos que
permitiria a travessia com segurana?
Esta representao pouco usada na prtica porque o uso da linguagem natural

muitas vezes d oportunidade a ms interpretaes, ambigidades e imprecises. Por
exemplo, a instruo afrouxar ligeiramente as porcas no algoritmo da troca de pneus
est sujeita a interpretaes diferentes por pessoas distintas. Uma instruo mais precisa
seria: afrouxar a porca, girando-a 30 no sentido anti-horrio.
1.2.2 Fluxogramas
a utilizao de smbolos grficos para representar algoritmos. Nos fluxogramas

existem smbolos padronizados para incio, entrada de dados, clculos, sada de dados,
fim, etc.
Exemplo 1.2 Fluxograma para calcular o triplo de um nmero qualquer, fornecido

pelo usurio.
10
Incio
Num
Triplo = Num * 3
Triplo
Fim
Figura 1.2 Fluxograma clculo do Triplo de um Nmero.
1.2.3 Portugus estruturado ou pseudocdigo
Esta forma de representao de algoritmos rica em detalhes, como a definio

dos tipos das variveis usadas no algoritmo. Por assemelhar-se bastante forma em que
os programas so escritos, encontra muita aceitao no meio acadmico. Na verdade,
esta representao suficientemente geral para permitir a traduo de um algoritmo nela
representado para uma linguagem de programao especfica, praticamente de maneira
direta.
Aps a criao do algoritmo que representa a soluo do problema, o mesmo
dever ser testado em papel ou em uma ferramenta que interprete as aes do algoritmo,
com a finalidade de validar a soluo descrita no algoritmo.
Cada ao contida nas linhas do algoritmo pode ser chamada de instruo. Desta
maneira, pode-se dizer que um algoritmo formado por um conjunto finito de
instrues. E um programa o que ?
Um programa de computador nada mais do que a representao do algoritmo
numa linguagem de programao, seja ela C, Pascal, Delphi, Cobol, etc. Como a maioria
das linguagens de computadores est escrita em ingls, a tarefa dos programadores
consiste em traduzir os algoritmos escritos em portugus para a linguagem de
programao, em ingls.
A forma geral da representao de um algoritmo na forma de pseudocdigo

adotada nesta apostila a seguinte:
#incluir biblioteca
/* 1. Declarao das bibliotecas utilizadas */
#definir constantes ou macros
11
/* 2. Declarao de constantes, entre outras */
principal () /* 3. Funo principal do algoritmo */
inicio /* 4. Incio do escopo / bloco principal */
/* 5. Declarao e classificao de variveis */
/* 6. Iniciar as variveis */
/* 7. Solicitar a entrada de dados ao usurio */
/* 8. Entrada de dados */
/* 9. Processamento / Clculos */
/* 10. Sada de informaes */
/* 11. Retorno de erro ou Ok */
fim /* 12. Final do escopo / bloco principal */
incluir uma palavra que indica a incluso de bibliotecas no algoritmo;
definir consiste em uma poro opcional onde so declaradas as constantes

globais usadas no algoritmo;
principal uma palavra que indica o incio da execuo de um algoritmo em

forma de pseudocdigo, com a sintaxe prxima da linguagem de programao C;
variveis consistem em uma poro opcional onde so declaradas as

variveis usadas no algoritmo;
inicio e fim so respectivamente as palavras que delimitam o incio e o

trmino do conjunto de instrues do corpo do algoritmo e em todas as demais
estruturas composta por uma seqncia ou bloco de instrues.
Comentrios /*...*/ utilizados ao longo do algoritmo, servem como

informaes adicionas e que facilitam o entendimento da soluo proposta. No so
analisados pelas ferramentas de desenvolvimento de programas, como o C. O C Quietly
tambm ignora comentrios durante o processamento.
O algoritmo do clculo da mdia de um aluno, na forma de um pseudocdigo,

apresentado a seguir (ex. 1.3).
Exemplo 1.3 Algoritmo para calcular a mdia aritmtica simples de duas notas.
Inicialmente ser mostrado como algoritmo generalizado e em seguida,
como dever estar ao longo desta apostila. Usando a sintaxe da
linguagem C e o C Quietly.
12
Situao 1: Visto como algoritmo presente em vrios livros de estrutura de dados
e algoritmos:
Algoritmo Calculo_Media
inteiro nota1, nota2;

real media;
Inicio
Leia(nota1, nota2);
media <- (nota1 + nota2)/2;
Se (media >= 7)
Ento
Escreva (Aprovado)
Seno
Escreva (Reprovado);
Fim
Situao 2: Visto como algoritmo com a sintaxe da linguagem C e podendo ser

utilizado no C Quietly:
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro nota1, nota2;

real media;
leia("%d",&nota1);
leia("%d",&nota2);
media = (nota1 + nota2)/2.0;
se (media >= 7.0)

inicio
imprima ("Aprovado\n");
fim
senao
inicio
imprima ("Reprovado\n");
fim
getch(); /* Aguarda uma tecla para finalizar */
retorno (0);
fim
13
Para escrever algoritmos preciso uma linguagem clara e que no deixe margem
a ambigidades, para isto, deve-se definir uma sintaxe e uma semntica, de forma a
permitir uma nica interpretao das instrues em um algoritmo. A sintaxe aqui
proposta, tende a uma maior proximidade com a linguagem C, mas ainda assim poder
ser convertida para outras linguagens como exemplo a linguagem Pascal.
14
2 Variveis, expresses, funes, atribuies, entrada e sada
Desenvolver algoritmos requer o conhecimento do conceito de alguns itens

indispensveis na representao da soluo de um problema qualquer. A compreenso
ou entendimento destes conceitos e das possibilidades de utilizao de cada um dos
elementos acima, permite a precisa definio de quais elementos faro parte da soluo
proposta durante a elaborao da mesma.
Na seqncia, apresentado alm dos conceitos de cada um dos itens anteriores
tambm, as formas de sua aplicao e uso em determinadas situaes.
2.1 Variveis
Toda varivel identificada por um nome ou identificador. Assim, por

exemplo, em um algoritmo para calcular a rea de um tringulo retngulo pelo teorema
de Pitgoras (a2 = b2 + c2), os identificadores a, b e c podem representar as
posies na memria (RAM ou memria principal) que armazenam o valor da
hipotenusa e dos catetos.
O contedo de uma varivel pode ser de vrios tipos: inteiro, real, caractere e
lgico, entre outros. Trabalharemos inicialmente com estes quatro tipos no C Quietly.
No C Quietly as variveis sero definidas na parte inicial do algoritmo da
seguinte forma:
tipo_da_variavel nome_da_variavel ;
Exemplo 2.1 - Declaraes de variveis.
inteiro a;
real x;
char letra;
char nome[40]; /* Armazena at 40 caracteres */
Os identificadores representam os nomes escolhidos para rotular as variveis, as

constantes e as funes, obedecendo as seguintes regras:
i) O primeiro caractere deve ser uma letra;

ii) Se houver outros caracteres, estes s podero ser letra, algarismo e o _
(sublinha);
15
iii) Os nomes das variveis escritas com letras maisculas so diferentes das
letras minsculas. Assim, nota1 diferente de NOTA1.
iv) Palavras chaves ou reservadas de cada linguagem tambm no podem ser
utilizadas, facilitando a converso do algoritmo para o cdigo fonte da
linguagem a ser utilizada.
A seguir (tab. 2.1), alguns exemplos de nomes de variveis permitidos, alm de

alguns dos erros que poderiam ser cometidos durante a escolha do nome de um
identificador, seja ele, uma varivel, uma constante ou de funes.
Tabela 2.1 Exemplos de nomes de variveis

Nomes Vlidos Nomes No-Vlidos
valor, IDADE, nota1, Nome 4mes /* invlido */
a, X, x
main /* invlido */
fim /* invlido para o C Quietly, pois
este o traduziria para } */
Declarar uma varivel consiste em reservar espao na memria principal (RAM)

do computador. Desta forma, um endereo de memria alocado e pode-se ter acesso a
este endereo por meio do nome da varivel. Esta uma caracterstica das linguagens de
alto nvel como a linguagem C e Pascal.
Nos algoritmos destinados a resolver um problema no computador, cada varivel
corresponde a uma posio de memria, cujo contedo pode variar ao longo do tempo
durante a execuo do algoritmo/programa. Embora a varivel possa assumir diferentes
valores, ela s pode armazenar um nico valor a cada instante.
2.1.1 Tipos de variveis
Os tipos de variveis utilizados no algoritmo (representao da soluo do

problema) dependem da finalidade do mesmo, mas, podem-se definir alguns tipos de
variveis pelo fato de serem largamente utilizados e implementados na maioria das
linguagens de programao, sendo estes:
Numricas
So variveis que armazenam dados numricos e esto divididas em duas classes.

A classe das variveis inteiras representada pelo tipo inteiro e a classe das variveis
fracionrias pelo tipo real.
inteiro
Os nmeros inteiros so aqueles que no possuem casas decimais, somente a

parte inteira considerada. Estes podem ser positivos ou negativos.
As variveis declaradas como inteiro no podero receber valores fracionrios,
somente valores inteiros. Ex.: 15, 56, -67, 0, para declarar uma varivel numrica
do tipo inteiro, utilize:
16
inteiro a;
inteiro b;
ou
inteiro a,b;
real
Os nmeros reais so aqueles que possuem alm da parte inteira do nmero,

tambm a parte fracionria deste. Podendo ser positivo ou negativo.
Uma varivel declarada como sendo do tipo real tem a capacidade de armazenar
o nmero completo, ou seja, parte inteira e fracionria deste. Ex.: 34.97, 6.5067,
-56.0, 10.1, para declarar uma varivel numrica do tipo real, utilize:
real x;
real y;
ou
real x,y;
Caracteres
Os caracteres podem armazenar letras (a..z; A..Z), nmeros (0..9) ou

outros caracteres especiais (@,#, $, %, *, \, ...). Eles podem aparecer isolados
(tipo char), ou agrupados formando palavras/frases (tipo char[]).
char
Uma varivel do tipo char, pode armazenar um nico caractere e o mesmo

necessita estar entre (apstrofo). E quando for necessrio armazenar vrios
caracteres? H um outro tipo (string) tal qual outras linguagens? Em C ANSI, no. A
linguagem C, assim como o C Quietly, utilizam um arranjo ou vetor de caracteres,
definido como char [ ]. Para definir uma varivel capaz de armazenar um caractere ou
outra para vrios caracteres, proceda da seguinte maneira:
char ch; /* ch pode armazenar um nico

caractere */
char endereco[40]; /* endereco pode armazenar at 40
caracteres */
char disciplina[TAMANHO]; /* disciplina pode armazenar at
TAMANHO caracteres, veja definio
de TAMANHO a seguir */
Lgicos
Tambm conhecido como tipo booleano. Pode representar apenas dois valores:
Verdadeiro ou Falso. Pode ser utilizado em algumas linguagens de programao com
17
outras denominaes, tais como Sim/No, True/False, 1/0, Verdadeiro/Falso.
Ao utilizarmos o C Quietly, e indiretamente a linguagem C, buscaremos outro
conceito antes de continuarmos com o tipo lgico: o conceito de constante simblica.
Constante simblica
A declarao de constantes nos programas d ao programador a facilidade de

utilizar o nome da constante como valor substituvel em qualquer parte do programa,
com a vantagem de defini-la em um nico local. Seu valor permanece inalterado durante
toda execuo do programa. Para se definir constantes, deve-se declar-las de acordo
com a sintaxe:
#definir nome_da_constante valor
Exemplo 2.2 Definindo constantes simblicas.
#definir TAMANHO 50
#definir MAX 100
#definir VERDADEIRO 1
#definir FALSO 0
e/ou
#definir TRUE 1
#definir FALSE 0
Utilizando a instruo #definir, pode-se representar um tipo de varivel

lgica tratando-a como varivel do tipo inteiro.
Exemplo 2.3 - Exemplo de Algoritmo/C com o uso de constantes simblicas.
#definir APROVADO 1
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro nota1, nota2, aluno;
real media;
leia("%d",&nota1);
leia("%d",&nota2);
media = (nota1 + nota2)/2.0;
aluno = (media >= 7.0);
se (aluno == APROVADO)
18
inicio
imprima ("Voce foi Aprovado\n");
fim
senao
inicio
imprima ("Voce foi Reprovado\n");
fim
imprima ("\npressione qualquer tecla...");

retorno (0);
fim
Exemplo 2.4 - Exemplo de Algoritmo com o uso de Variveis.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro num, dobro;
imprima("Entre com um numero: ");

leia("%d",&num);
dobro = num * 2;
imprima("%d, e seu dobro = %d\n",num,dobro);
imprima("\npressione qualquer tecla...");

retorno(0);
fim
2.2 Exerccios propostos
Exerccio 2.1 - Quais as palavras abaixo possuem nomes vlidos para identificadores?
Vlido/Invlido
Salario_Real ( ) ( )
TotalEmDolares ( ) ( )
Real ( ) ( )
Nota GrauA ( ) ( )
@Home ( ) ( )
Web@Home ( ) ( )
web ( ) ( )
Salrio2006 ( ) ( )
Opo_Inicial ( ) ( )
Last ( ) ( )
4Ever ( ) ( )
19
2.3 Expresses
Um algoritmo tem como caracterstica fundamental a capacidade de processar

dados. Processar dados significa realizar operaes com estes dados. O uso de
operadores permite a realizao de tais operaes. Por exemplo, o smbolo + um
operador que representa a operao aritmtica de adio.
Uma expresso um arranjo de operadores e operandos. A cada expresso
vlida atribudo um valor numrico. Como exemplo tm-se, 4 + 6 que uma
expresso cujo valor resultante 10.
Os operandos podem ser variveis, constantes ou valores gerados por funes.
Os operadores identificam as operaes a serem efetuadas sobre os operandos. Cada tipo
de dados possui um conjunto de operadores relacionados. Os operadores classificam-se
em unrios e binrios, conforme tenham um ou dois operandos, respectivamente.
Na soluo da grande maioria dos problemas necessrio que as variveis
tenham seus valores consultados ou alterados e, para isto, deve-se definir um conjunto
de operaes a serem utilizadas nas expresses, sendo eles:
2.3.1 Aritmticas
So aquelas cujo resultado da avaliao do tipo numrico, seja ele inteiro ou

fracionrio (real). Somente o uso de operadores aritmticos (tab. 2.2) e variveis
numricas permitido em expresses aritmticas.
Tabela 2.2 Operadores aritmticos

Smbolo Significado Matemtica
+ Adio +
* Multiplicao x
- Subtrao ou inversor do sinal -
/ Diviso
resto Resto da diviso de inteiros
Exemplo 2.5 - Algoritmo para somar dois nmeros, incluindo tambm outras operaes.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro a, b, r;
real r2;
imprima ("Digite o primeiro numero: ");

leia ("%d",&a);
imprima ("Digite o segundo numero: ");
leia ("%d",&b);
r = a + b;
imprima ("A soma de %d e %d = %d\n",a,b,r);
20
r2 = (real) a / b;
imprima ("A Divisao de %d e %d = %0.2f\n",a,b,r2);
r = a - b;
imprima ("A subtracao de %d e %d = %d\n",a,b,r);
r = a * b;
imprima ("A multiplic de %d e %d = %d\n",a,b,r);
r = a / b;
imprima ("A Divisao int %d e %d = %d\n",a,b,r);
r = a resto b;
imprima ("O Resto Div de %d e %d = %d\n",a,b,r);

retorno (0);
fim
Obs.: A diviso de um nmero inteiro por outro, tambm inteiro, sempre um

nmero inteiro; se o resultado for fracionrio, este ser truncado.
2.3.2 Relacionais
Os operadores relacionais (tab. 2.3) so utilizados para efetuar a comparao

entre dados de mesmo tipo, relacionando variveis ou expresses, resultando em um
valor lgico (Verdadeiro ou Falso).
Exemplos:
A == B; A igual a B
C != D; C diferente de D
F >= E; F maior ou igual a E
J < H; J menor que H
X <= 5; X menor ou igual a 5
3 > W; 3 maior que o valor da varivel W
Tabela 2.3 Operadores relacionais

Operador Operao Matemtica
== Igual =
!= Diferente
< Menor que <
> Maior que >
<= Menor ou Igual
>= Maior ou Igual
21
2.3.3 Lgicas
So utilizadas para avaliar expresses lgicas. Os operadores lgicos

fundamentais esto relacionados na tabela seguinte (tab. 2.4). As tabelas verdade de cada
um dos operadores lgicos so apresentadas logo a seguir.
Tabela 2.4 Operadores lgicos

Operador Operao Matemtica
&& conjuno e
|| disjuno ou
! negao nao
Tabela verdade do operador &&
Suponha que uma empresa da regio esta fazendo uma entrevista com quatro
pessoas, para o preenchimento de uma vaga de programador snior. Cada pessoa ir
responder 1 se domina a linguagem e 0 caso no seja de seu domnio.
Tabela 2.5 Conjuno

Voc conhece a Voc conhece a Sada
linguagem C? linguagem Pascal?
1 1 1
1 0 0
0 1 0
0 0 0
Ir conseguir o trabalho o candidato que dominar ambas as linguagens exigidas

para o preenchimento da vaga. O operador && (tab. 2.5) somente considera vlida a
expresso em que todas as respostas so verdadeiras.
Tabela verdade do operador ||
Suponha que a mesma empresa disponha de uma outra vaga de programador

jnior e exige que o candidato conhea pelo menos uma linguagem de computador. Cada
pessoa ir responder 1 se domina a linguagem e 0 caso no seja de seu domnio.
Tabela 2.6 Disjuno

Voc conhece a Voc conhece a Sada
linguagem C++? linguagem PHP?
1 1 1
1 0 1
0 1 1
0 0 0
Ir conseguir o trabalho o candidato que dominar ao menos uma das linguagens

exigidas para o preenchimento da vaga. O operador || (tab. 2.6) considera vlida a
expresso em que pelo menos uma resposta seja verdadeira.
22
Tabela verdade do operador !
Tabela 2.7 Negao

Voc conhece Sada
Algoritmos?
1 0
0 1
O operador ! (tab. 2.7) inverte a sada.
2.3.4 Prioridade de operadores
Durante a execuo de uma expresso que envolve vrios operadores,

necessrio existir certas prioridades, caso contrrio pode-se obter valores que no
representam o resultado esperado. A maioria das linguagens de programao utiliza as
seguintes prioridades de operadores:
i) Efetuar operaes embutidas em parnteses mais internos

ii) Efetuar funes
iii) Efetuar resto, multiplicao e/ou diviso
iv) Efetuar adio e/ou subtrao
v) Operadores relacionais
vi) Operadores lgicos
Obs.: O programador tem plena liberdade para incluir novas variveis,

operadores ou funes para adaptar o algoritmo as suas necessidades,
lembrando sempre, de que, estes devem ser compatveis com a linguagem
de programao a ser utilizada.
2.4 Funes primitivas
Tabela 2.8 Funes Primitivas

Funo Finalidade
sen (x); Seno do ngulo x
cos (x); Co-seno do ngulo x
tan (x); Tangente do ngulo x
abs (x); Valor absoluto de x
potencia (y,x); Eleva y a x
raiz (x); Raiz quadrada de x
log (x) Logaritmo Natural de x
Uma linguagem de programao oferece um conjunto de funes pr-definidas,

que so usadas com vrios tipos de dados simples. As funes esto intimamente ligadas
ao conceito de funo (ou frmula) matemtica, na maioria das vezes, necessitam de
dados como parmetro (dados de entrada). Em algoritmos utilizam-se as funes
23
facilmente encontradas nas principais linguagens de programao. Veja (tab. 2.8)
algumas dessas funes a seguir.
Exemplo 2.6 Usando funes pr-definidas, para determinar o valor da hipotenusa.
#incluir <stdio.h>
#incluir <conio.h>
#incluir <math.h>
#definir quadrado(x) (x)*(x)
principal ()
inicio
inteiro ladoA, ladoB;

real Q1, Q2, hipotenusa;
imprima ("Entre com o cateto A: ");

leia ("%d",&ladoA);
imprima ("Entre com o cateto B: ");
leia ("%d",&ladoB);
Q1 = potencia(ladoA,2);
Q2 = quadrado(ladoB);
hipotenusa = raiz(Q1 + Q2);
imprima ("CA = %d e CB = %d\n",ladoA,ladoB);

imprima ("Hipo = %0.4f\n",hipotenusa);

retorno (0);
fim
Obs.: O teorema de Pitgoras foi citado anteriormente (seo 2.1).
2.5 Atribuies
Um comando de atribuio altera o contedo de um identificador (lado esquerdo)

pelo valor resultante da expresso (lado direito). A varivel e a expresso devem ser do
mesmo tipo, exceto no caso em que a varivel do tipo real e o resultado da expresso
do tipo inteiro, quando o valor inteiro da expresso transformado em real.
A operao de atribuio permite que se fornea um valor a uma certa varivel.
Caso seja atribuda uma expresso varivel, ser armazenado o resultado daquela
expresso. Se for atribuda uma outra varivel, ser armazenado o contedo daquela
varivel. Para a operao de atribuio, utiliza-se a seguinte sintaxe:
variavel = valor ou expresso ;
24
Exemplo 2.7 Atribuio de um valor a uma varivel inteira.
y = 6;
L-se da seguinte forma:
A varivel y recebe o valor 6 ou o valor 6 atribudo a varivel y.
O computador por sua vez:
Assume que o valor 6 deve ser armazenado (guardado, alocado) na memria,

em um local previamente reservado por meio da declarao da varivel y.
Memria principal (RAM)
y
6
Exemplo 2.8 Atribuio de uma expresso envolvendo operandos inteiros a uma

varivel do mesmo tipo.
z = y * x;
L-se da seguinte forma:
A varivel z recebe o valor da multiplicao de y por x ou y multiplicado por

x atribudo a varivel z.
O computador por sua vez:
O resultado da multiplicao do contedo das variveis y e x armazenados

na memria, ser alocado na varivel z.
Memria principal (RAM)
y x z
6 3 18
No comando de atribuio, a varivel e valor/expresso devem ser do mesmo

tipo, exceto nos seguintes casos:
i) A varivel sendo real, a expresso ou a outra varivel podem ser do tipo

inteiro;
ii) A varivel sendo char[], a expresso ou a outra varivel podem ser do tipo
char.
25
Exemplo 2.9 Trocando o contedo das variveis a e b com auxlio de uma varivel
temporria.
a = 2;
b = 3; /* Passo 1 */
temp = a;
a = b; /* Passo 2 */
b = temp; /* Passo 3 */
Memria (RAM) Memria (RAM) Memria (RAM)
a b temp a b temp a b temp

2 3 2 3 3 2 3 2 2
Passo 1 Passo 2 Passo 3
Exemplo 2.10 Incrementando e decrementando as variveis a e b com auxlio dos

operadores ++ e --.
a = 5;
b = 7; /* Passo 1 */
a++; /* Passo 2 */
b--; /* Passo 3 */
Memria (RAM) Memria (RAM) Memria (RAM)
a b a b a b
5 7 6 7 6 6
Passo 1 Passo 2 Passo 3
No algoritmo preciso representar a troca de informaes que ocorrer entre o

mundo da mquina e o nosso mundo, para isso, deve-se utilizar comandos de entrada e
sada, sendo que, no algoritmo esses comandos representam apenas a entrada e a sada
da informao, independente do dispositivo utilizado (teclado, discos, impressora,
monitor, ...).
2.6 Sada de dados
Um comando de sada serve para que o algoritmo mostre ao usurio os

resultados desejados. A unidade de sada padro o monitor de vdeo, podendo ser
tambm a impressora ou uma memria auxiliar como o disco rgido.
imprima (texto, conversao e controle, varivel, constante ou expresso );
26
Os identificadores contidos na lista, devem estar separados por vrgula.
Considerando a unidade de sada padro, o monitor de vdeo, no algoritmo o
comando seria:
imprima ("texto");
ou
imprima ("texto %caractere",variavel);
ou
imprima ("texto %caractere",constante);
ou
imprima ("texto %caractere",expressao);
Onde %caractere pode ser substitudo por qualquer um dos caracteres de

converses apresentados (tab. 2.9) a seguir.
Tabela 2.9 Caracteres de converso para funo imprima

Converso Finalidade
%c Imprime o contedo da varivel com representao ASCII
%d Imprime o contedo da varivel com representao decimal com sinal
%u Imprime o contedo da varivel com representao decimal sem sinal
%o Imprime o contedo da varivel com representao octal sem sinal
%x Imprime o contedo da varivel com representao hexadecimal sem
sinal
%f Imprime o contedo da varivel com representao com ponto decimal
%e Imprime o contedo da varivel com representao em notao cientfica
(exponencial)
%g Formato geral, escolhe a representao mais curta entre %f e %e
Alm dos caracteres de converso, tambm possvel utilizar-se caracteres de

controle (tab. 2.10) por meio da \ (contra barra) seguida do caractere correspondente
ao desejada. Desta maneira, pode-se mover o cursor para a linha seguinte (\n),
separar dados usando tabulaes (\t) entre eles e representar caracteres utilizados na
sintaxe do comando de sada, tal qual aspas ou a prpria contra barra, utilizada em
conjunto com os caracteres de controle.
Tabela 2.10 Caracteres de controle

Caractere de Controle Finalidade
\n Nova linha
\t Tabulao
\b Retrocesso
\r Retorno de carro
\f Salto de pgina
\a Sinal sonoro
\\ Contra barra
\ Apstrofo
\ Aspas
\0 O caractere NUL
27
Com imprima o cursor permanece na mesma linha aps a execuo do
comando, utilizando-se o caractere de controle (\n) move-se o cursor para a prxima
linha.
Exemplo 2.11 Mostrando os contedos das variveis A e B aps sua declarao

seguida de atribuies de valores inteiros as mesmas, alm de realizar e
exibir a soma entre elas.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro a, b;
a = 5;
b = 10;
imprima ("A = %d e B = %d\n",a,b);

imprima ("Soma = %d\n",a + b);

retorno (0);
fim
Para o caso de utilizar-se de variveis do tipo real, os valores so mostrados na

notao exponencial, em um campo de 6 posies, a menos que uma formatao seja
especificada, veja exemplo na seqncia.
Exemplo 2.12 Mostrando a mdia aritmtica simples entre as variveis A e B do

exemplo anterior.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro a, b;
real m;
a = 5;
b = 10;
m = (a + b)/2.0;
imprima ("A = %d e B = %d\n",a,b);

imprima ("Media = %e\n",m);
imprima ("Media = %f\n",m);
28
imprima ("Media = %.2f\n",m);

retorno (0);
fim
Memria (RAM)
a b m
5 10 7.5
Vdeo
A = 5 e B = 10
Media = 7.50000e+00
Media = 7.500000
Media = 7.50
pressione qualquer tecla...
Na formatao, se a varivel for real especifica-se o total de posies ocupadas e

a quantidade de casas decimais. Se for inteira, somente total de posies.
2.7 Entrada de dados
Um comando de entrada serve para que o algoritmo solicite dados no momento

em que o mesmo est sendo executado. Esses dados fornecidos sero armazenados em
variveis na memria. Em geral a unidade de entrada o teclado, podendo tambm ser
uma memria auxiliar como o disco rgido.
leia (conversao, variavel1, variavel2, ... );
Os identificadores contidos na lista, devem estar separados por vrgula.

Considerando a unidade de entrada padro, o teclado, no algoritmo o comando
seria:
leia ("%conversao",&variavel);
ou
leia ("%conversao %conversao",&var1, &var2, ...);
Onde %conversao deve ser substitudo por um dos caracteres de controle (tab.
2.11) a seguir. Cada varivel ou lista de variveis deve vir precedida por um caractere &
29
(E comercial), que indica o fornecimento do endereo de memria representado pelo
identificador (nome da varivel).
Tabela 2.11 Caracteres de converso para funo leia

Converso Finalidade
%c Espera-se um nico caractere na entrada
%d Espera-se um inteiro decimal na entrada
%u Espera-se um inteiro decimal na entrada
%o Espera-se um inteiro octal na entrada
%x Espera-se um inteiro hexadecimal na entrada
%f Espera-se um nmero de ponto flutuante na entrada
%h Espera-se um inteiro curto na entrada
%s Espera-se uma cadeia de caracteres na entrada
Exemplo 2.13 Desenvolver um algoritmo para obter as trs notas de um aluno e

armazen-las na memria do computador por meio das variveis
nota1, nota2 e nota3, estas devem ser capazes de guardar notas com
casas decimais.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
real nota1, nota2, nota3;
leia ("%f%f%f",&nota1,&nota2,&nota3);

retorno (0);
fim
No momento da execuo do algoritmo com os comandos acima, o programa

mostra a tela do usurio e o cursor aparece esperando a digitao dos trs valores que
devem ser separados por, pelo menos, um espao em branco. Com uma nica
(<enter>) confirmao ao final da digitao dos valores.
Vdeo
_ 3.5 7.8 8.4 <enter>
30
Assim, valor 3.5 ser armazenado na varivel nota1, o valor 7.8 em nota2
e o valor 8.4 em nota3.
No instante da solicitao de dados, podemos usar junto com o leia um comando

de sada (imprima) com a finalidade de emitir mensagens que orientem o usurio na
digitao dos dados.
Exemplo 2.14 Algoritmo que calcula a mdia aritmtica simples de trs notas com
mensagens indicando ao usurio quais dados fornecer.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
real nota1, nota2, nota3;

real media;
imprima ("Entre com a primeira nota: ");

leia ("%f",&nota1);
imprima ("Entre com a segunda nota: ");
leia ("%f",&nota2);
imprima ("Entre com a terceira nota: ");
leia ("%f",&nota3);
media = (nota1 + nota2 + nota3)/3.0;
imprima ("\nMedia Final = %.2f\n",media);

retorno (0);
fim
A seguir, v-se como seria a entrada das notas e a exibio da mdia aritmtica
simples aps seu clculo pelo computador.
Inicialmente mostrada a primeira mensagem Entre com a primeira
nota: e em seguida o programa fica aguardando at que o usurio fornea um nmero
(fracionrio ou inteiro) correspondente primeira nota do aluno, para ento prosseguir
com a instruo seguinte. De maneira semelhante acontece tambm com a leitura das
demais notas.
Memria (RAM)
nota1 nota2 nota3 media

5.0 6.0 9.0 6.67
31
Vdeo
Entre com a primeira nota: 5.00

Entre com a segunda nota: 6.00
Entre com a terceira nota: 9.00
Media Final = 6.67

Cada valor lido pelo comando leia e armazenado na memria. Para realizar o
clculo da mdia o computador acessa as posies de memria das notas e realiza a
soma das notas para ento dividir o resultado pela constante 3.0. O Resultado final
exibido logo depois. Para finalizar o programa pressione uma tecla.
Exerccio 2.1 Exemplifique o uso dos comandos de Atribuio, Entrada e Sada.
Exerccio 2.2 Qual a diferena entre os comandos imprima e leia?
Exerccio 2.3 Como podemos imprimir a mensagem Linha inicial, seguida de duas
linhas em branco e uma outra mensagem Linha final? possvel
realizar esta tarefa em um nico comando? D exemplos.
Exerccio 2.4 Como podemos orientar o usurio na digitao dos dados?

Exemplifique.
Exerccio 2.5 Escreva os comandos necessrios para ler:

i) as 3 notas de um aluno
ii) o peso e altura de uma pessoa
Exerccio 2.6 Escreva os comandos necessrios para exibir:

i) o contedo da varivel x
ii) o resultado da expresso 2+3
Exerccio 2.7 Determine os valore finais de a, b e c aps a execuo do trecho do

programa abaixo:
a = 0;
b = 1;
c = a + b;
a = a + 1;
b = a + b + c;
Exerccio 2.8 A ordem das atribuies importante? a = b e c = a tem o

mesmo efeito de c = a e a = b ?
32
Exerccio 2.9 Em qual dos seguintes pares importante a ordem dos comandos?
Supor: x y z.
a) x = y; b) x = y; c) x = z; d) z = y;
y = z; z = x; x = y; x = y;
Exerccio 2.10 Fazer um algoritmo que dadas s dimenses de um retngulo, calcule a

sua rea e mostre na tela.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro base, altura, area;
imprima ("Digite o valor da base do retangulo: ");

leia ("%d",&base);
imprima ("Digite o valor da altura do retangulo: ");
leia ("%d",&altura);
area = base * altura;
imprima ("Area = %d\n",area);

retorno (0);
fim
Exerccio 2.11 Escreva um algoritmo que leia um nmero inteiro positivo e exiba o
dobro do mesmo.
Exerccio 2.12 Escreva um algoritmo para calcular e exibir o comprimento de uma

circunferncia, sendo dado o valor de seu raio. (C = 2 R)
Exerccio 2.13 Escreva um algoritmo para ler uma temperatura dada na escala
Fahrenheit e exibir o equivalente em Celsius. (C = 5 (F 32))
9
Exerccio 2.14 Escreva um algoritmo para calcular e exibir a mdia ponderada de duas
notas dadas. (nota1 = peso 6 e nota2 = peso 4)
Exerccio 2.15 Escreva um algoritmo que leia duas variveis inteiras e troque o
contedo entre elas.
Exerccio 2.16 Escreva um algoritmo para calcular e exibir o valor de x y, sendo dados
a base (x) e o expoente (y).
Exerccio 2.17 As razes de uma equao quadrtica da forma
33
ax2 + bx + c = 0
so reais se e somente se o discriminante dado por
b2 4ac
for maior ou igual a zero. Preparar um algoritmo para ler os valores

dos coeficientes a, b e c e imprimir o valor do discriminante. Mostrar
tambm uma mensagem se possvel encontrar as razes reais ou no.
Exerccio 2.18 - Qual o resultado das expresses aritmticas abaixo, sabendo-se que os
valores de X, Y e Z so, respectivamente, 1, 2 e 5 ?
a) Z resto Y / Y
b) X + Y + Z / 3
c) raiz( Z / Y + X * Y)
d) Z - abs (X potencia (Y,2))
Exerccio 2.19 - Escreva o resultado das seguintes funes:
a) abs (-4)
b) abs (5.2)
c) potencia (1.0,4)
d) potencia (10,2)
e) raiz (25)
f) raiz (9.0)
Exerccio 2.20 - Preencha a Tabela Verdade abaixo:
a b a && b a || b !a !b
TRUE TRUE
TRUE FALSE
FALSE TRUE
FALSE FALSE
Exerccio 2.21 - Escreva o resultado das seguintes comparaes:

a) 1 != 1.0
b) FALSE == FALSE
c) TRUE != TRUE
d) 3 > 5.0
e) 2 <= 2
f) a == A
Exerccio 2.22 - Qual o resultado das expresses lgicas abaixo, sabendo-se que os
valores de A e B so, respectivamente, TRUE e FALSE?
a) !A && B || A && !B
34
b) !(!(A || B) && (A || B))
c) A || B && !A || !B
d) (A || B) && (!A || !B)
Exerccio 2.23 - Faa um algoritmo que calcule o permetro de um retngulo, sendo

dado o comprimento e a largura desse retngulo. P = 2 x (c + l)
Exerccio 2.24 - Faa um algoritmo que leia dois valores numricos inteiros para duas
variveis e que troque o contedo dessas variveis, visualizando o
valor das mesmas antes e depois da troca.
Exerccio 2.25 - Faa um algoritmo que leia dois nmeros reais e que calcule a soma,
produto e a mdia desses nmeros.
Exerccio 2.26 - Faa um algoritmo que determine o volume de uma esfera, sendo dado
o respectivo raio. (V = 4/3 x x r3) Repare que, em C, a diviso de 4
por 3 d um valor inteiro se no tomar medidas adequadas.
35
3 Comandos de controle de fluxo
Para representar a soluo de um problema deve-se escrever o conjunto de

passos a serem seguidos, sendo que, a maioria dos problemas exige uma dinmica na sua
soluo, impondo assim que os algoritmos executem um conjunto de instrues de
acordo com as possveis situaes encontradas no problema original. Na maioria das
linguagens de programao os mecanismos utilizados para esse controle so: Seqncia,
Seleo e Repetio.
3.1 Seqncia ou bloco
Usada para executar comandos passo a passo, sabendo que todos eles sero
executados na ordem descrita, sem nenhum desvio. Uma seqncia ou bloco pode
possuir um ou vrios comandos, os quais devem ser delimitados pelos identificadores de
inicio e fim.
inicio
comando1;
...
comandon;
fim
Exemplo 3.1 Desenvolver um algoritmo para ler um nmero inteiro e escrever seu
sucessor e seu antecessor.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro num, suc, ant;
imprima ("Entre com um numero: ");

leia ("%d",&num);
suc = num + 1;
ant = num - 1;
imprima ("Sucessor = %d\n",suc);
36
imprima ("Antecessor = %d\n",ant);

retorno (0);
fim
Exemplo 3.2 Desenvolver um algoritmo para ler dois nmeros inteiros e escrever a
seguinte sada:
Dividendo: __
Divisor: __
Quociente: __
Resto: __
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro valor1, valor2, q, r;
imprima ("Entre com o dividendo: ");

leia ("%d",&valor1);
imprima ("Entre com o divisor: ");
leia ("%d",&valor2);
q = valor1 / valor2;
r = valor1 resto valor2;
imprima ("Dividendo: %d\n",valor1);

imprima ("Divisor: %d\n",valor2);
imprima ("Quociente: %d\n",q);
imprima ("Resto: %d\n",r);

retorno (0);
fim
Exemplo 3.3 Desenvolver um algoritmo para ler um ngulo em graus e escrever:

seno, co-seno, tangente, secante, co-secante e cotangente deste
ngulo.
#incluir <stdio.h>
#incluir <conio.h>
#incluir <math.h>
#definir PI 3.1415926
principal()
37
inicio
real angulo, rang;
imprima ("Entre com um ngulo em graus: ");
leia ("%f",&angulo);
rang = angulo * PI / 180;
imprima ("Valor do PI:%f\n",PI);

imprima ("Seno: %f\n",sen(rang));
imprima ("Co-seno: %f\n",cos(rang));
imprima ("Tangente: %f\n",tan(rang));
imprima ("Co-secante: %f\n",(1 / sen(rang)));
imprima ("Secante: %f\n",(1 / cos(rang)));
imprima ("Cotangente: %f\n",(1 / tan(rang)));

retorno (0);
fim
3.2 Seleo
Usada para tomar decises, ou seja, desviar a execuo do algoritmo de acordo

com uma condio (Expresso Lgica), podendo ser simples (fig. 3.1) ou
composta (fig. 3.2).
Veja as afirmaes a seguir:
i) Todos os alunos tero bolsas de estudos integrais;

ii) Somente alunos com renda inferior ou igual a dois salrios mnimos,
recebero a bolsa de estudos;
iii) Os alunos com renda superior a dois salrios mnimos, portanto, sem
direito bolsa de estudo, recebero auxlio transporte, o qual no
concedido aos alunos que possuem a bolsa integral;
iv) Os alunos com renda inferior a um salrio mnimo recebero bolsa
integral e para os alunos com renda superior a este e de no mais que dois
salrios mnimos as bolsas sero de 50%. Demais alunos com renda
superior a dois salrios mnimos ganham somente o auxlio transporte.
O primeiro item refere-se a uma seqncia de instrues onde nenhuma deciso

precisa ser tomada, pois todos os alunos iro receber a bolsa de estudos. Os primeiros
exemplos deste captulo demonstram este conceito. J na segunda afirmao, aparece
uma situao de deciso simples (fig. 3.1), onde para estar habilitado a receber a bolsa de
estudos cada aluno precisa preencher o requisito de renda mnima exigido. A seguir, a
sintaxe de uma estrutura de deciso simples. Os colchetes [...] delimitam uma parte
opcional da estrutura.
Sintaxe:
38
se (condicao)
inicio
comando ;
[ou sequencia1 ;]
fim
Fluxo
se
Figura 3.1 Fluxograma para estrutura SE.
A terceira afirmao apresenta uma situao um pouco mais complexa, o que

exige uma estrutura de deciso composta (fig. 3.2). Levando em considerao que
somente os alunos com renda superior a dois salrios mnimos recebero o auxlio
transporte se faz necessrio informar que os alunos que recebem a bolsa de estudos, no
sero contemplados com este auxlio. Na seqncia a sintaxe de uma estrutura de
deciso composta. Os colchetes [...] delimitam uma parte opcional da estrutura.
Sintaxe:
se (condicao)
inicio
comando ;
[ou sequencia1 ;]
fim
senao
inicio
comando ;
[ou sequencia2 ;]
fim
Os exemplos seguintes demonstram a funcionabilidade de cada uma das verses

da estrutura de deciso.
Exemplo 3.4 Desenvolver um algoritmo para ler um nmero inteiro e exibi-lo se for
positivo.
#incluir <stdio.h>
#incluir <conio.h>
39
principal ()
inicio
real n;

leia ("%f",&n);
se (n > 0.0)
inicio
imprima ("%f eh positivo!\n",n);
fim

retorno (0);
fim
Fluxo
se
Figura 3.2 Fluxograma para estrutura SE SENAO.
No exemplo (ex. 3.4) anterior, o comando imprima s ser executado se a

condio (n > 0.0) for verdadeira. Caso contrrio, nenhuma ao ser executada.
Exemplo 3.5 Desenvolver um algoritmo para ler um nmero e determinar se ele

maior que zero ou no.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
40
real n;

leia ("%f",&n);
se (n > 0.0)
inicio
imprima ("%f eh maior que zero!\n",n);
fim
senao
inicio
imprima ("%f nao eh maior que zero!\n",n);
fim

retorno (0);
fim
Neste exemplo (ex. 3.5), a mensagem que ser exibida depender do resultado da
expresso lgica (n > 0.0). Se ela for verdadeira, ser executado o comando
imprima do bloco inicio e fim que se refere palavra se. Caso contrrio, ser
executado o comando imprima do bloco inicio e fim que se refere palavra
senao. Em nenhuma hiptese ser executado ambos os comandos imprima.
E a quarta afirmao, como empreg-la em um algoritmo? H uma nova

estrutura para tal? Respostas a seguir.
H casos em que necessria a realizao de mais de dois testes, como na

afirmao ainda no discutida. Para satisfazer as condies da ltima afirmao, ser
preciso testar se o aluno possui renda inferior a um salrio mnimo para poder receber a
bolsa de estudos integral e na seqncia determinar por meio de outro teste se a renda do
aluno encontra-se situada entre um e dois salrios mnimos, garantindo-lhes uma bolsa de
estudos de 50%. O fato do aluno no estar incluso no primeiro grupo no lhe garante a
indiscriminadamente a bolsa de estudos de 50%. Por fim indicar aos alunos que se
encontram fora das situaes anteriores que recebero o auxlio transporte.
Para estes casos empregam-se mais de uma estrutura de deciso simples e/ou
composta, denominando-se de ses encaixados/aninhados (se senao se). O exemplo
(ex. 3.6) a seguir ilustra este conceito.
Exemplo 3.6 Desenvolver um algoritmo para ler um nmero e determinar se ele

maior, menor ou igual a zero.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
real n;
41
leia ("%f",&n);
se (n > 0.0)
inicio
imprima ("%f eh maior que zero!\n",n);
fim
senao
inicio
se (n < 0.0)
inicio
imprima ("%f eh menor que zero!\n",n);
fim
senao
inicio
imprima ("%f eh igual a zero!\n",n);
fim
fim

retorno (0);
fim
Pode-se observar que diversas linhas deste algoritmo terminam sem o ponto-e-
vrgula, isto porque o ponto-e-vrgula s utilizado para separar comandos e/ou
estruturas.
Deve-se tomar cuidado quando da utilizao de ses aninhados, pois a clusula
senao sempre relacionada ao ltimo se. Se, dentro de algum algoritmo, necessitar-se
contornar este fato, pode-se faz-lo com uso dos delimitadores inicio e fim. Estes
tambm so utilizados em seqncias ou blocos.
3.3 Seleo entre mltiplas escolhas
Utilizada quando se deseja executar um entre vrios comandos (ou uma entre
vrias seqncias de comandos) dependendo do resultado de uma expresso. Mais de um
comando ou vrios comandos ou seqncias podem ser executados tambm, veja ainda
nesta seo.
A estrutura de seleo (deciso mltipla) chamada de escolha caso e em
linguagem C apresenta-se como comando de nome switch case, e obedece a seguinte
sintaxe.
Sintaxe:
escolha (expressao)
inicio
caso <constante1> : comando ;
comando ;
pare;
42
comando ;
pare;

comando ;
pare;
...
[padrao : comando ;
comando ;
pare ;]
fim
O comando escolha delimitado pelo bloco de inicio e fim. Internamente

possui uma expressao e suas opes de comparao por meio de clusulas caso. A
expressao aps o comando escolha avaliada e comparada com cada uma das
constantes de cada clusula caso. Cada uma das constantes deve ser bem definida. A
seqncia a ser executada logo que uma constante seja igual expresso pode ser um ou
mais comandos. O resultado da expressao comparado com cada constante da lista
para verificar-se a igualdade entre eles. Caso esta igualdade seja encontrada, o comando
correspondente executado e a estrutura finalizada ou no, dependendo da existncia
de comandos pare. Caso nenhuma igualdade entre a expressao e as constantes
sejam verificadas, os comandos correspondentes clusula padrao sero executados.
Os colchetes [...] delimitam uma parte opcional da estrutura.
Os prximos exemplos ilustram formas de utilizao do comando de seleo
entre mltiplas escolhas.
Exemplo 3.7 Desenvolver um algoritmo para simular uma calculadora bsica de

nmeros inteiros utilizando o comando escolha caso.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
char op;
inteiro x,y;
imprima ("Digite o operador: ");
leia ("%c",&op);
imprima ("Entre com os operandos: ");
leia ("%d%d",&x,&y);
escolha (op)
inicio
caso + : imprima ("Soma = %d\n",x + y);
pare;
caso - : imprima ("Subtracao = %d\n",x - y);
43
pare;
caso * :
caso x :
caso X : imprima ("Produto = %d\n",x * y);
pare;
caso / : imprima ("Divisao = %d\n",x / y);
pare;
padrao : imprima ("Operador invalido!\n");
pare;
fim

retorno (0);
fim
Neste exemplo a mensagem que ser exibida, bem como a operao executada,
depender do contedo da varivel op. Se for igual a uma das constantes especificadas,
ser executado o comando imprima correspondente. Se nenhuma constante for igual
ao contedo de op, ser executado o imprima da clusula padrao.
Pode-se tambm escrever o mesmo programa anterior (ex. 3.7) sem utilizar a
estrutura escolha caso, apenas utilizando se's aninhados, como demonstra a
algoritmo seguinte.
Exemplo 3.8 Desenvolver um algoritmo para simular uma calculadora bsica de

nmeros inteiros sem utilizar o comando escolha caso.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
char op;
inteiro x,y;
imprima ("Digite o operador: ");

leia ("%c",&op);
imprima ("Entre com os operandos: ");
leia ("%d%d",&x,&y);
se (op == +)
inicio
imprima ("Soma = %d\n",x + y);
fim
senao
inicio
se (op == -)
inicio
imprima ("Subtracao = %d\n",x - y);
fim
senao
inicio
44
se (op == * || op == x || op == X)
inicio
imprima ("Produto = %d\n",x * y);
fim
senao
inicio
se (op == /)
inicio
imprima ("Divisao = %d\n",x / y);
fim
senao
inicio
imprima ("Operador invalido!\n");
fim
fim
fim
fim

retorno (0);
fim
Para compreender melhor o comando pare em todas ou algumas clusulas

caso do comando escolha, veja a figura (fig. 3.3) a seguir.
A expressao avaliada e o valor obtido comparado com os valores
associados s clusulas caso em seqncia.
Quando o valor associado a uma clusula igual ao valor do escolha os
respectivos comandos so executados at encontrar um pare.
Se no existir um pare na clusula selecionada, os comandos das clusulas
seguintes so executados em ordem at encontrar um pare ou esgotarem-se as
clusulas do escolha.
Se nenhuma das clusulas contm o valor de seleo a clusula padrao, se
existir, ser executada.
O exemplo (ex. 3.9) a seguir ilustra o que acontece quando no so utilizados
comandos pare em cada uma das clusulas caso, partindo do princpio que este no
foi o desejo do programador. Mas, por que o comando escolha caso tem este
comportamento?
H casos onde esta caracterstica importante para que no seja necessrio
repetir comandos a serem executados por diversas clusulas caso. Sendo assim,
agrupam-se dois ou mais casos e suas respectivas constantes e somente ao final coloca-
se o comando referente aos casos anteriores, sem esquecer, se este for o desejo, o
comando pare. No Exemplo (ex. 3.7) anterior possvel observar que para no repetir
o mesmo comando para multiplicar os valores para as constantes * ,x ,X ,
optou-se por no utilizar comandos pare nestes casos.
Exemplo 3.9 Desenvolver um algoritmo para identificar os caracteres de 0 9

mostrando-os na tela. Utilize o comando escolha caso.
45
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
char digito;
imprima ("Digite um caractere de 0 a 9\n");

leia ("%c",&digito);
escolha (digito)
inicio
caso 0 : imprima ("0");
pare;
fim
retorno (0);
fim
escolha

caso :
pare;
caso :
caso :
pare;
Figura 3.3 Fluxograma para estrutura ESCOLHA CASO.
Ao executar o algoritmo do exemplo (ex. 3.9) anterior, tm-se a tela abaixo.

Supondo que o usurio fornea o valor 4 obtm-se a seguinte sada: 456789. Uma vez
que o caractere encontrado em uma das constantes (caso) e no h comandos pare,
toda a seqncia atual mostrada. Isto para o caso apresentado constitui-se de um erro
de lgica.
46
Vdeo
Digite um caractere de 0 a 9
_4 <enter>
456789
Exerccio 3.1 Faa um algoritmo que leia um nmero inteiro e que determine o seu
mdulo sem usar nenhuma funo disponvel em C para essa
finalidade.
Exerccio 3.2 Faa um algoritmo que determine se um ano introduzido pelo usurio
ou no bissexto. Um ano bissexto se for mltiplo de 4 sem ser de 100
ou se for mltiplo de 400.
Exerccio 3.3 Faa um algoritmo que calcule o salrio semanal de um funcionrio.

Deve ser lido o nmero total de horas (valor inteiro) de trabalho desse
funcionrio durante a semana, o custo de uma hora normal e o custo
de uma hora extraordinria. Para calcular o salrio, deve-se considerar
como horas normais as 40 primeiras e como horas extraordinrias (se
existirem) as restantes horas de trabalho.
Exerccio 3.4 Escreva um algoritmo que leia um nmero inteiro e determine se ele
par ou mpar.
Exerccio 3.5 Deseja-se calcular a conta de consumo de energia eltrica de um

consumidor. Para isto, escreva um algoritmo que leia o cdigo do
consumidor, o preo do Kw e a quantidade de Kw consumido, e exiba
o cdigo do consumidor e o total a pagar.
total a pagar = preco x quantidade

total a pagar minimo = R$ 13,20
Exerccio 3.6 Escreva um algoritmo para ler trs nmeros inteiros distintos e
determinar o menor deles.
Exerccio 3.7 Faa um algoritmo que, dado as trs notas de um aluno, determine e
exiba a sua mdia final e o seu conceito, sabendo-se que:
A mdia final calculada pela mdia aritmtica simples das 3 notas;

O conceito determinado de com base na tabela a seguir:
47
Mdia Final Conceito
8,0 A
6,0 e < 8,0 B
< 6,0 C
Exerccio 3.8 Faa um algoritmo que leia a idade de uma pessoa. Para cada faixa de
idades escreva uma mensagem diferente, conforme indicado pela tabela
abaixo:
Faixa Etria Mensagem

0 ano Hello Baby
de1 5 anos Hello Little Boy / Little Girl
de 6 10 anos Hello Boy / Girl
de 11 15 anos Hello Little Men / Little Woman
de 16 25 anos Hi
de 26 45 anos Hello
de 46 60 anos Hello Mister / Madam
de 61 120 anos Hello Old Men / Old Woman
Acima de 120 anos Hello World... can you hear me?
Exerccio 3.9 Escreva um algoritmo que determine o grau de obesidade de uma

pessoa, sendo fornecido o peso e a altura da pessoa. O grau de
obesidade determinado pelo ndice da massa corprea (Massa =
Peso/Altura2) seguindo a tabela abaixo:
Massa Corprea Grau De Obesidade

< 26 Normal
26 e < 30 Obeso
30 Obeso Mrbido
Exerccio 3.10 O Cricima Futebol Clube deseja aumentar o salrio de seus jogadores.
O reajuste deve obedecer a seguinte tabela:
Salrio Atual (R$) Aumento

0,00 a 1.000,00 20%
1.000,01 a 5.000,00 10%
acima de 5.000,00 0%
Escrever um algoritmo que leia o salrio atual de um jogador, e exiba o

salrio atual e o salrio reajustado.
Exerccio 3.11 Faa um algoritmo para calcular a conta final de um hspede de um

hotel, considerando que:
a) Sero lidos os tipos de apartamentos utilizados (A, B, C ou D), o

nmero de dirias utilizadas pelo hspede e o valor do consumo
interno do hspede;
48
b) O valor da diria determinado pela seguinte tabela:
Tipo Do Apto Valor Da Diria (R$)

A 150,00
B 100,00
C 75,00
D 50,00
c) O valor total das dirias calculado pela multiplicao do nmero

de dirias utilizadas pelo valor da diria;
d) O subtotal calculado pela soma do valor total das dirias e o valor

do consumo interno;
e) O valor da taxa de servio equivale a 10% do subtotal;
f) O total geral resulta da soma do subtotal com a taxa de servio;
g) Escreva a conta final contendo: o tipo do apartamento, o nmero de

dirias utilizadas, o valor unitrio da diria, o valor total das dirias, o
valor do consumo interno, o subtotal, o valor da taxa de servios e o
total geral.
Exerccio 3.12 Deseja-se calcular o imposto de renda de um contribuinte. Para isto,

escreva um algoritmo que:
a) Leia os seguintes dados do contribuinte: CPF, rendimento anual,

imposto retido na fonte, contribuio previdenciria, despesas mdicas,
nmero de dependentes;
b) deduzido o valor de R$ 1.080,00 por cada dependente;
c) Clculo do valor total das dedues: contribuio previdenciria +

despesas mdicas + deduo dos dependentes;
d) Clculo da base de clculo: rendimento anual total das dedues;
e) Com base na tabela a seguir:
Base de Clculo Alquota Parcela a Deduzir

at 10.800,00 Isento -
De 10.800,01 at 21.600,00 15% 1.620,00
acima de 21.600,00 25% 3.780,00
Clculo do imposto devido: ((base de clculo * alquota) - parcela a

deduzir)
f) Haver imposto a pagar se a diferena entre o imposto devido e o
49
imposto retido na fonte for positiva; caso contrrio, haver imposto a
restituir;
g) Exiba todos os dados lidos e calculados.
Exerccio 3.13 Os comandos (i) e (ii) so equivalentes? Explique sua resposta.
(i) a = b == c
(ii) se a == b
inicio
a = TRUE;
fim
senao
inicio
a = FALSE;
fim
Exerccio 3.14 Observe o trecho de algoritmo abaixo, considerando L1, L2 e L3 como

variveis lgicas.
...
se (L1)
inicio
imprima ('A')
fim
senao
inicio
se (L2)
inicio
se (L3)
inicio
imprima ('B')
fim
senao
inicio
imprima ('C');
imprima ('D');
fim
fim
senao
inicio
imprima ('E');
fim
fim
...
Agora, responda as seguintes questes:
a) Se forem lidos V, V e V, o que ser escrito pelo algoritmo?

b) Se forem lidos F, V e V, o que ser escrito pelo algoritmo?
c) Se forem lidos F, V e F, o que ser escrito pelo algoritmo?
d) Que valores deveriam ser lidos para que fosse escrito apenas "E"?
50
3.5 Estruturas de repetio
Serve para efetuar um conjunto de aes repetidas vezes. Existem trs tipos
bsicos de repeties, sendo elas: enquanto, faca enquanto e para.
3.5.1 Enquanto
A instruo enquanto (em pseudocdigo enquanto-faa) utilizada quando

se deseja executar vrias vezes o mesmo trecho de um algoritmo ou programa, enquanto
a expressao for verdadeira.
Sintaxe:
enquanto (expressao)
inicio
comando;
[ou seqncia;]
fim
A figura (fig. 3.4) abaixo mostra a seqncia de execuo da instruo

enquanto.
enquanto
F V
Figura 3.4 Fluxograma para estrutura ENQUANTO.
O passo inicial a ser executado na instruo enquanto, a verificao se a

expressao verdadeira ou falsa. Sendo esta verdadeira, a ao (comando ou
seqncia de comandos) executada e o controle do algoritmo ou programa retorna
para o topo do ciclo (loop). Novamente a expressao testada e se ela ainda
continuar sendo verdadeira o comando ou seqncia de comandos executado mais uma
vez e, o controle do algoritmo retorna novamente para o topo do ciclo (loop). Esse
processo se repete at que o teste da expressao seja falso. Quando isto acontece, a
ao ou comando saltado (no executado), e o controle do algoritmo prossegue fora
do enquanto. importante notar que a expressao s se tornar falsa se alguma ao
entre o inicio e fim dos comandos do enquanto atuar sobre alguma varivel da
expressao, modificando seu valor. Os colchetes [...] delimitam uma parte
opcional da estrutura.
51
O comando enquanto analisa a expressao e enquanto o seu resultado for
verdadeiro, o comando ou a seqncia de comandos executada. Esta estrutura
recomendada para um nmero de repeties desconhecidas, podendo repetir de
nenhuma vez at n vezes.
Exemplo 3.9 Desenvolver um algoritmo para calcular e mostrar o dobro de um

nmero aps solicitar do usurio este nmero. Utilize a estrutura de
repetio enquanto. Sendo que, o algoritmo termina somente quando
o usurio fornecer o valor zero (0) como nmero de entrada.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro num, dobro;
imprima ("Digite um numero inteiro: ");

leia ("%d",&num);
enquanto (num != 0)
inicio
dobro = num * 2;
imprima ("%d, e seu Dobro: %d\n",num,dobro);

leia ("%d",&num);
fim

retorno (0);
fim
3.5.2 Faca enquanto
Uma outra maneira de fazer com que um conjunto de instrues seja executado
uma ou mais vezes, utilizar a estrutura faca enquanto, conhecido tambm como
repita at, em pseudocdigo. Sua forma geral mostrada a seguir.
Sintaxe:
faca
inicio
comando;
[ou seqncia;]
fim
enquanto (expressao) ;
A figura (fig. 3.5) a seguir mostra a seqncia de execuo da instruo faca
52
enquanto.
A execuo da estrutura faca enquanto ocorre da seguinte forma: quando o
fluxo de execuo chega no incio da estrutura (faca), o comando ou seqncia de
comandos internos estrutura so executados. Quando o fluxo de execuo chega no
enquanto, a expressao avaliada. Se o resultado da avaliao for verdadeiro, a
execuo retorna ao faca e, novamente, os comandos ou seqncia de comandos so
executados. Porm se o resultado for falso, ento a execuo sair do ciclo (loop) e
passar para a primeira instruo imediatamente aps o enquanto. Os colchetes
[...] delimitam uma parte opcional da estrutura.
faca
enquanto
V
F
Figura 3.5 Fluxograma para estrutura FACA ENQUANTO.
possvel notar que a instruo faca enquanto similar instruo

enquanto, apresentada anteriormente. A nica diferena que a expressao de
controle do ciclo testada ao final deste. Desta maneira, os comandos ou seqncia de
comandos internos ao ciclo, sempre sero executados ao menos uma vez.
A estrutura faca enquanto executa o comando ou a seqncia de comandos at
que o valor retornado pela expressao seja falso. Assim como o enquanto, esta
estrutura tambm recomendada para um nmero de repeties desconhecidas, porm
com a diferena de repetir pelo menos uma vez at n vezes.
Exemplo 3.10 Desenvolver um algoritmo para calcular e mostrar o dobro de um

nmero aps solicitar do usurio este nmero. Utilize a estrutura de
repetio faca enquanto. Sendo que, o algoritmo termina somente
quando o usurio fornecer o valor zero (0).
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro num, dobro;
faca
53
inicio
leia ("%d",&num);
dobro = num * 2;
imprima ("%d, e seu Dobro: %d\n",num,dobro);
fim
enquanto (num != 0);

retorno (0);
fim
3.5.3 Para
A estrutura para (fig. 3.6) executa uma seqncia ou um bloco, de uma ou mais
declaraes, um certo nmero de vezes. Em pseudocdigo, o comando para
corresponde estrutura de repetio para faa.
Sintaxe:
para (inicializacoes ; condicao ; incrementos)

inicio
comando;
[ou seqncia;]
fim
Quando uma declarao para encontrada durante a execuo de um

programa, ocorrem os seguintes eventos:
i) A expresso inicializacao executada. Essa expresso , geralmente,

uma atribuio que configura uma varivel para um determinado valor.
ii) A expresso condicao executada. A condicao , tipicamente, uma
expresso relacional de comparao.
iii) Se a condicao for falsa (zero) o comando para termina, e a execuo do
programa passa para a primeira declarao aps a seqncia ou bloco de
comandos do para.
iv) Se a condicao for verdadeira (diferente de zero), a seqncia ou bloco de
comandos do para executado.
v) A expresso incrementos executada, e a execuo volta ao passo ii.
Exemplo 3.11 Desenvolver um algoritmo para imprimir na tela os nmeros de 1 10.
#incluir <stdio.h>
#incluir <conio.h>
54
principal ()
inicio
inteiro contador;
para (contador = 1; contador <= 10; contador++)

inicio
imprima ("%d\n",contador);
fim

retorno (0);
fim
para inicializacao
teste
V
F
bloco
incremento
Figura 3.6 Fluxograma para estrutura PARA.
Variaes do comando para
O comando para usa, freqentemente, um contador que tem seu valor

incrementado (aumentado) como no exemplo (ex. 3.11) apresentado anteriormente. Mas
pode-se tambm fazer contagem regressiva, decrementando o contador, veja a seguir.
...
para (contador = 10; contador > 0; contador--)

inicio
...
fim
...
55
O incremento (ou decremento) pode tambm ser diferente de 1, como ilustra a
estrutura abaixo.
...
para (contador = 0; contador < 50; contador += 5)

inicio
... /* contador += 5 equivalente a contador = contador + 5 */
fim
...
Se pode ainda executar mltiplas aes na instruo para, separando-as por

vrgula. Alguns exemplos a seguir.
...
para (z = 10; z <= 10 && z != 5; z++)

inicio
...
fim
para (z = 0, y = 2; z <= 5 && y < 10; z++, y += 2)

inicio
...
fim
...
Exemplo 3.12 Criar um algoritmo que a cada nmero digitado pelo usurio seja
calculado o seu fatorial e exibido na tela o resultado.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro n, i, fatorial;
imprima ("Entre com um numero inteiro: ");

leia ("%d",&n);
fatorial = 1;
para (i = n; i > 1; i--)

inicio
fatorial = fatorial * i;
fim
imprima ("Fatorial de %d e = %d\n",n,fatorial);

retorno (0);
fim
56
Para se calcular o fatorial de um nmero, necessrio multiplic-lo pelos seus
predecessores at se chegar ao valor 1. Portanto, o fatorial de 5 5*4*3*2*1. Assim,
chega-se concluso de que uma estrutura para resolve o problema, visto que temos o
valor de inicializao e o ponto de parada (expresso na condio).
Exemplo 3.13 Desenvolver um algoritmo para calcular a potncia N de um nmero

X. Ambos sero inteiros e fornecidos pelo usurio. Imprima na tela o
seu resultado.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro base, expoente, resultado, i;
imprima ("Entre com a base: ");

leia ("%d",&base);
imprima ("Entre com o expoente: ");
leia ("%d",&expoente);
resultado = base;
se (expoente == 0)
inicio
resultado = 1;
fim
senao
inicio
se (base == 0)
inicio
resultado = 0;
fim
senao
inicio
para (i = 1; i < expoente; i++)
inicio
resultado = resultado * base;
fim
fim
fim
imprima ("Base %d elevado ao expoente %d e =

%d\n",base,expoente,resultado);

retorno (0);
fim
O clculo da exponenciao se d como xn de modo que para se obter o
resultado final deve-se multiplicar X por ele mesmo N vezes. Ento, conhecendo o valor
de inicializao (1) e o valor final da condio ser dado pelo usurio. A estrutura para
a mais indicada.
57
Montar a expresso fcil, mas em algoritmo necessrio mostrar todos os
passos para a mquina (computador), pois voc o est ensinando a fazer algo. Ento,
deve prever todas as situaes possveis. Por isso, testa-se a entrada do expoente 0 e da
base 0.
Comparando para e enquanto

Seja a estrutura para:
para (inicializacao ; condicao ; incremento)

inicio
comando;
[ou seqncia;]
fim
O trecho do cdigo acima poderia ser substitudo pelo trecho abaixo com a
seguinte construo:
inicializacao;
enquanto (condicao)
inicio
comando;
[ou seqncia;]
incremento;
fim
Exemplo 3.14 Desenvolver um algoritmo para imprimir na tela os nmeros de 1 a 10

usando a estrutura de repetio para e em seguida com enquanto.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro contador;
para (contador = 1; contador <= 10; contador++)

inicio
fim

retorno (0);
fim
A soluo a seguir, usando enquanto, equivalente ao exemplo acima com a
estrutura para.
#incluir <stdio.h>
#incluir <conio.h>
58
principal ()
inicio
inteiro contador;
contador = 1;
enquanto (contador <= 10)

inicio
contador++;
fim

retorno (0);
fim
Exerccio 3.15 Faa um algoritmo que calcule todos os divisores de um nmero.

Exemplo do algoritmo ao ser executado:
Entre com um numero: _24 <enter>

Os divisores de 24 so 1 2 3 4 6 8 12 24
Exerccio 3.16 Faa um algoritmo para ver se um nmero primo ou no (um nmero
s primo se apenas for divisvel por 1 e por si prprio). Exemplo do
algoritmo ao ser executado:
Entre com um numero: _4

4 no primo
Exerccio 3.17 Desenvolver um algoritmo que calcule a rea de um crculo, de modo a

que o programa funcione ininterruptamente at o usurio digitar o
valor zero para o raio. Nessa altura, o algoritmo deve dizer que a rea
zero e terminar com um "At logo". Exemplo do algoritmo ao ser
executado:
Digite o raio: 3
A area 28.27
Digite o raio: 2.5
A area 19.63
Digite o raio: -2
Esse raio invlido
Digite o raio: 1
A area 3.14
Digite o raio: 0
A area 0.00
Ate logo.
59
Exerccio 3.18 Faa um algoritmo que escreve na tela uma tabela de converso de
graus Celcius para Fahrenheit. A tabela deve apresentar os graus
Celcius de 0 40 com intervalos de 2 em 2. Exemplo do algoritmo ao
ser executado:
Celcius Fahrenheit
0.0 32.0
2.0 35.6
4.0 39.2
6.0 42.8
... ...
40.0 104.0
Exerccio 3.19 Faa um algoritmo que escreva a tabuada de um determinado nmero.

Exemplo do algoritmo ao ser executado:
Digite um numero: _9
9 x 1 = 9
9 x 2 = 18
9 x 3 = 27
9 x 4 = 36
9 x 5 = 45
9 x 6 = 54
9 x 7 = 63
9 x 8 = 72
9 x 9 = 81
9 x 10 = 90
Exerccio 3.20 Escreva um algoritmo que leia dois nmeros e exiba o maior deles.
Exerccio 3.21 Escreva um algoritmo que leia dois nmeros e exiba-os em ordem
crescente.
Exerccio 3.22 Faa um algoritmo que mostre todos os nmeros inteiros pares de 2
100.
Exerccio 3.23 Faa um algoritmo para gerar e exibir os nmeros inteiros de 20 at

10, decrescendo de 1 em 1.
Exerccio 3.24 Faa um algoritmo que leia um nmero N, some todos os nmeros
inteiros de 1 N, e mostre o resultado obtido.
Exerccio 3.25 Escreva um algoritmo que calcule o fatorial de um nmero inteiro lido,
sabendo-se que: N! = 1 x 2 x 3 x ... x N-1 x N e que
0! = 1.
Exerccio 3.26 Faa um algoritmo que leia 3 nmeros inteiros (N, X, Y) e mostre
todos os nmeros mltiplos de N entre X e Y.
60
Exerccio 3.27 Faa um algoritmo que leia dois valores inteiros (X e Y) e mostre
todos os nmeros primos entre X e Y.
Exerccio 3.28 Faa um algoritmo que, para um nmero indeterminado de pessoas:

Leia a idade de cada pessoa, sendo que a leitura da idade 0 (zero)
indica o fim dos dados (flag) e no deve ser considerada;
calcule e escreva o nmero de pessoas;

calcule e escreva a idade mdia do grupo;
calcule e escreva a menor e a maior idade;
Exerccio 3.29 Faa um algoritmo que leia a altura de um grupo de 20 pessoas, calcule
e exiba:
a maior altura do grupo;
a altura mdia;
o nmero de pessoas com altura superior 2
metros.
Exerccio 3.30 Em um frigorfico existem 90 bois. Cada boi traz preso em seu pescoo
um carto contendo seu nmero de identificao e seu peso. Faa um
algoritmo que escreva o nmero e o peso do boi mais gordo e do boi
mais magro (supondo que no haja empates).
Exerccio 3.31 Foi feita uma pesquisa de audincia de canal de TV em vrias casas de
uma certa cidade, num determinado dia. Para cada casa visitada
fornecido o nmero do canal (5, 7, 10 ou 12) e o nmero de pessoas
que estavam assistindo o canal naquela casa. Fazer um algoritmo que:
Leia um nmero indeterminado de dados, sendo que o flag
corresponde ao canal igual a 0 (zero);
calcule e escreva a porcentagem de audincia de

cada emissora.
Exerccio 3.32 O cardpio de uma casa de lanches, especializada em sanduches,

dado abaixo. Escreva um algoritmo que leia o cdigo e a quantidade
de cada item comprado por um fregus, calcule e exiba o total a pagar.
Obs: A leitura do cdigo "X" indica o fim dos itens.
Cdigo Produto Preo (R$)

H Hamburger 3,50
C Cheeseburger 3,00
Q QueijoQuente 2,40
Exerccio 3.33 O Cricima Futebol Clube deseja aumentar o salrio de seus 22

jogadores. O reajuste deve obedecer a seguinte tabela:
Salrio Atual (R$) Aumento

0,00 a 1.000,00 20%
1.000,01 a 5.000,00 10%
61
acima de 5.000,00 0%
Escrever um algoritmo que:
Leia o salrio atual de cada jogador;

Exiba o salrio atual e o salrio reajustado de
cada jogador;
Exiba o total da folha de salrios do clube,
antes do reajuste.
Exiba o total da folha de salrios do clube,
aps o reajuste.
Exiba o percentual de reajuste sobre o total da
folha de salrios.
Exerccio 3.34 Uma certa firma fez uma pesquisa de mercado para saber se as pessoas
gostaram ou no de um novo produto lanado no mercado. Para isto,
forneceu o sexo do entrevistado (M-masculino ou F-feminino) e sua
resposta (S-sim ou N-no). Sabendo-se que foram entrevistadas 2.000
pessoas, fazer um algoritmo que calcule e escreva:
nmero de pessoas que responderam sim (S);

nmero de pessoas que responderam no (N);
a porcentagem de pessoas do sexo feminino (F);
a porcentagem de pessoas do sexo masculino (M);
Exerccio 3.35 Escreva um algoritmo que leia o nmero de andares de um prdio e, a

seguir, para cada andar do prdio, leia o nmero de pessoas que
entraram e saram do elevador. Considere que o elevador est vazio e
est subindo, os dados se referem a apenas uma subida do elevador e
que o nmero de pessoas dentro do elevador ser sempre maior ou
igual a zero. Se o nmero de pessoas, aps a entrada e sada, for maior
que 15, deve ser mostrada a mensagem "Excesso de passageiros.
Devem sair X", sendo X o nmero de pessoas que devem sair do
elevador, de modo que seja obedecido o limite de 15 passageiros. Aps
a entrada e sada no ltimo andar, o programa deve mostrar quantas
pessoas permaneceram no elevador para descer.
Exerccio 3.36 Faa um algoritmo que leia vrios cdigos do jogador (1 ou 2) que
ganhou o ponto em uma partida de pingue-pongue, e responda quem
ganha a partida. A partida chega ao final se um dos jogadores chega a
21 pontos e a diferena de pontos entre os jogadores maior ou igual
a dois. Caso contrrio, ganha aquele que, com mais de 21 pontos,
consiga colocar uma vantagem de dois pontos sobre o adversrio.
62
4 Modularizao
A modularizao consiste em um mtodo para facilitar a construo de grandes

programas, por meio de sua diviso em pequenas etapas, que so: mdulos, rotinas, sub-
rotinas ou subprogramas. Permitindo o reaproveitamento de cdigo, uma vez que se
pode utilizar um mdulo quantas vezes for necessrio, eliminando assim a necessidade de
reescrever o mesmo cdigo em situaes repetitivas.
4.1 Funes
Uma funo um bloco de cdigo precedido de um cabealho que contm o tipo

de retorno, o nome da funo e sua lista de parmetros. Com esta, pode-se fazer
referncia ao bloco de cdigo de qualquer ponto do algoritmo por meio do seu nome e
passando os seus parmetros. O nome da funo nada mais alm do que um
identificador nico desta funo que a diferencia de todos os demais identificadores,
como: variveis, constantes e at de outras funes. A forma genrica de se construir
uma funo apresentada a seguir.
Sintaxe:
tipo_de_retorno nome_da_funcao ([lista_de_parmetros])

inicio
/* Declarao das variveis locais */
Comandos;
retorno (expressao);
fim
Referncia, chamada ou invocao da funo na seo de comandos do

algoritmo:
variavel = nome_da_funcao (variaveis) ;
O tipo de retorno da funo corresponde aos tipos de variveis utilizados at

este momento, tais como: inteiro, real, caractere, etc, presentes na maioria das
linguagens de programao. possvel tambm que uma funo no devolva ou retorne
63
nenhum valor, sendo considerada de retorno vazio. Em algumas linguagens de
programao, tal como a linguagem Pascal este mtodo implementado na forma de
procedimentos.
O nome da funo dado pelo programador e precisa seguir as mesmas regras
utilizadas para nomear as variveis e as constantes.
Na lista de parmetros encontram-se as variveis que devem ser passadas a
funo no momento de sua chamada ou invocao. Esta lista apresenta-se da seguinte
maneira.
tipo variavel1, tipo variavel2, ..., tipo variavelN
As variveis passadas as funes so associadas aos parmetros da funo de

acordo com a ordem das variveis e da lista de parmetros. Os [ ] na sintaxe do
cabealho da funo indicam que a lista de parmetros opcional, permitindo assim a
criao de funes que no recebem variveis de entrada via lista de parmetros. Esta
dever ainda assim conter a palavra vazio indicando a inteno da no existncia de
parmetros.
Os comandos da funo, bem como as declaraes de variveis locais a funo,
so delimitados pelos marcadores de inicio e fim. Todos os comandos apresentados
at o presente momento podero ser utilizados nas funes. neste local que realizada
a tarefa para qual funo foi projetada.
Desde modo tem um algoritmo, com a existncia de uma funo, a seguinte
aparncia.
#incluir biblioteca
/* Declarao das bibliotecas utilizadas */
#definir constante ou macro

/* Declarao de constantes, entre outras */
tipo_de_retorno nome_da_funcao ([lista_de_parametros])

inicio
Comandos;
fim
...
principal( ) /* Funo principal do algoritmo */

inicio /* Inicio do escopo / bloco principal */
/* Declarao de variveis locais */

/* Comandos */
/* chamadas ou invocaes de funes */
64
variavel = nome_da_funcao (variaveis) ;
/* Retorno de erro ou Ok */
fim /* Final do escopo / bloco principal */
A declarao de variveis locais da funo permanece idntica s declaraes no

algoritmo principal. Assim, podem ser definidas variveis do tipo: inteiro, real ou
caractere para citar apenas trs, da mesma forma que no algoritmo. A diferena est no
acesso, uma vez que, as variveis definidas internamente na funo so de uso exclusivo
da mesma. Sendo assim, nenhuma outra funo poder ter acesso a estas variveis, nem
mesmo o algoritmo principal.
Exemplo 4.1 - Criar um algoritmo com uma funo capaz de calcular o quadrado de um
nmero.
#incluir <stdio.h>
#incluir <conio.h>
inteiro quadrado (inteiro n)

inicio
retorno (n * n);
fim
principal ()
inicio
inteiro num,q;

leia ("%d",&num);
q = quadrado (num);
imprima ("\nQuadrado do numero %d e = %d",num,q);

retorno (0);
fim
Exemplo 4.2 - Tomando o exemplo anterior (ex. 4.1), crie um algoritmo que utilize uma
outra funo para calcular o cubo de um nmero.
#incluir <stdio.h>
#incluir <conio.h>
inteiro cubo (inteiro x)

inicio
retorno (x * x * x);
fim
principal ()
inicio
65
inteiro num,c;

leia ("%d",&num);
c = cubo (num);
imprima ("\nCubo do numero %d e = %d",num,c);

retorno (0);
fim
Exemplo 4.3 - Tomando os exemplos anteriores (ex. 4.1 e 4.2), crie um algoritmo que
utilize duas funes para calcular o cubo de um nmero. Se possvel
tambm calcule o quadrado no mesmo algoritmo.
#incluir <stdio.h>
#incluir <conio.h>
inteiro cubo (inteiro x)

inicio
retorno (quadrado(x) * x);
fim
inteiro quadrado (inteiro n)

inicio
retorno (n * n);
fim
principal ()
inicio
inteiro num,r;

leia ("%d",&num);
r = quadrado (num);
imprima ("\nQuadrado do numero %d e = %d",num,r);
r = cubo (num);
imprima ("\nCubo do numero %d e = %d\n",num,r);

retorno (0);
fim
O comando retorno presente em cada funo a maneira que a funo tem para
devolver um valor ao algoritmo ou a outra funo que a tenha invocado. O comando
returno aparece nas funes da seguinte forma.
66
retorno(valor_de_retorno);
ou
retorno();
Suponha que uma funo est sendo executada. Quando se chega a uma
declarao retorno a funo encerrada imediatamente e, se o valor de retorno
informado, a funo devolve este valor. importante lembrar que o valor de retorno
fornecido tem que ser compatvel com o tipo de retorno declarado para a funo. Assim
como a varivel ou a expresso onde a funo est inserida deve ser capaz de armazenar
ou utilizar corretamente o valor recebido da funo.
Uma funo pode ter mais de uma declarao retorno. Uma vez que a funo
terminada quando o algoritmo chega primeira declarao retorno, podem-se ter
vrias declaraes de retorno em uma mesma funo sem no entanto comprometer
seu funcionamento lgico.
A seguir outro exemplo de uso do comando retorno.
Exemplo 4.4 - Criar um algoritmo que utilize uma funo para determinar se um nmero
fornecido pelo usurio par ou mpar.
#incluir <stdio.h>
#incluir <conio.h>
inteiro ePar (inteiro n)

inicio
se (n resto 2) /* verifica se e divisivel por 2 */

inicio
retorno (0); /* 0 se NAO for divisvel */
fim
senao
inicio
retorno (1); /* 1 se for divisvel */
fim
fim
principal ()
inicio
inteiro num;

leia ("%d",&num);
se (ePar(num))
inicio
imprima ("\nNumero %d e Par",num);
fim
senao
inicio
imprima ("\nNumero %d e Impar",num);
67
fim
retorno (0);
fim
importante notar que, como as funes retornam valores, podemos aproveit-

los para fazer atribuies, ou mesmo para que estes valores participem de expresses.
No exemplo anterior (ex. 4.4) v-se o uso de mais de um comando retorno em uma
funo.
Exerccio 4.1 -Escreva a funo eDivisivel (inteiro a, inteiro b), tenha

o exemplo anterior (ex. 4.4) como modelo. A funo dever retornar 1
(um) se o resto da diviso de a por b for zero. Caso contrrio, a funo
dever retornar 0 (zero).
Exemplo 4.5 - Criar um algoritmo que utilize funes para calcular a seguinte seqncia.
2 3 n
S(x,n) = x/1! + x /2! + x /3! + ... + x /n!
#incluir <stdio.h>
#incluir <conio.h>
inteiro fat (inteiro n)

inicio
inteiro i, resultado = 1;
para (i = 1; i <= n; i++)

inicio
resultado = resultado * i;
fim
retorno (resultado);
fim
real pot (real base, inteiro expo)

inicio
inteiro i;
real resultado = 1.0;
se (expo == 1)
inicio
retorno (base);
fim
para (i = 1; i <= expo; i++)

inicio
resultado = resultado * base;
fim
fim
68
real serie (real x, inteiro n)
inicio
inteiro i;
real resultado = 0.0;
para (i = 1; i <= n; i++)

inicio
resultado = resultado + pot(x,i) / fat(i);
fim
fim
principal ()
inicio
real x;
inteiro termos;
imprima ("Entre com o numero de termos: ");

leia ("%d",&termos);
imprima ("Entre com o valor de x: ");
leia ("%f",&x);
imprima ("\nO valor da serie = %f", serie(x,termos));

retorno (0);
fim
4.1.1 Exerccios propostos
Exerccio 4.2 Faa um algoritmo que leia um nmero inteiro e crie uma funo que
devolva o seu mdulo sem usar nenhuma funo disponvel em C para
essa finalidade.
Exerccio 4.3 Faa um algoritmo que possua uma funo que determine se um ano
introduzido pelo usurio ou no bissexto. Um ano bissexto se for
mltiplo de 4 sem ser de 100 ou se for mltiplo de 400. A funo deve
retornar 1 se o ano bissexto e 0 (zero) caso contrrio.
Exerccio 4.4 - Criar um algoritmo com uma funo que verifica se um nmero
fornecido pelo usurio mpar.
Exerccio 4.5 - Desenvolver um algoritmo com uma funo que calcule a Hipotenusa
de um tringulo retngulo a partir da leitura de seus Catetos na parte
principal do algoritmo. Estes sero passados a funo por meio de
parmetros.
69
Exerccio 4.6 - Faa um algoritmo com uma funo que devolver 1 se o nmero
passado por parmetro for primo e 0 (zero) se no for.
Exerccio 4.7 Faa um algoritmo com uma funo que calcule o salrio semanal de
um funcionrio. Deve ser lido o nmero total de horas (valor inteiro)
de trabalho desse funcionrio durante a semana, o custo de uma hora
normal e o custo de uma hora extraordinria. Para calcular o salrio,
deve-se considerar como horas normais as 40 primeiras e como horas
extraordinrias (se existirem) as restantes horas de trabalho.
Exerccio 4.8 Deseja-se calcular a conta de consumo de energia eltrica de um

consumidor. Para isto, escreva um algoritmo que leia o cdigo do
consumidor, o preo do Kw e a quantidade de Kw consumido, e exiba
o cdigo do consumidor e o total a pagar. Calcule este ltimo usando
uma funo. Mostre os dados a seguir no algoritmo principal.
total a pagar = preco x quantidade

total a pagar minimo = R$ 13,20
Exerccio 4.9 Escreva um algoritmo para ler trs nmeros inteiros distintos e com
uma funo para determinar o menor deles.
Exerccio 4.10 Faa um algoritmo que, dado as trs notas de um aluno, determine e
exiba a sua mdia final (uma funo) e o seu conceito (outra funo),
sabendo-se que: a mdia final calculada pela mdia aritmtica das 3
notas; o conceito determinado de com base na tabela abaixo:
Mdia Final Conceito

8,0 A
6,0 e < 8,0 B
< 6,0 C
Exerccio 4.11 - Desenvolver um algoritmo que leia dois valores e chame uma sub-
rotina (funo) que receba estas duas variveis e troque o seu
contedo, ou seja, esta rotina chamada passando duas variveis A e
B por exemplo, e aps a execuo da rotina A conter o valor de B e
B conter o valor de A. Lembre-se de utilizar a passagem de
parmetros por referncia.
Exerccio 4.12 - Crie uma funo fatorial, como dado em aula anterior. Testar essa
funo fazendo um algoritmo que calcule o fatorial de um nmero
fornecido pelo usurio.
Exerccio 4.13 - Utilizando a funo criada no exemplo anterior (ex. 4.4) faa um
programa que ir solicitar nmeros inteiros ao usurio at que este
introduza um nmero negativo. Para cada valor introduzido, o
programa deve indicar se o nmero par ou mpar.
Exerccio 4.14 - Faa uma funo que devolva nmeros aleatrios inteiros. A funo
70
dever receber um parmetro n que indique a gama de valores
pretendidos e, a cada vez que for chamada, devolva um nmero
aleatrio inteiro no intervalo [0 .. n-1].
Por exemplo, se a funo for chamada com o parmetro 6, dever devolver um nmero
aleatrio compreendido entre 0 e 5 (inclusive).
Exerccio 4.15 - Utilizar a funo que acabastes de criar no exerccio anterior para fazer
um programa que simule atirar uma moeda ao ar 1000 vezes. O
programa deve contar quantas vezes saram "cara" e quantas vezes
saram "coroa".
Exerccio 4.16 - Faa um algoritmo que gere 1000 nmeros reais aleatrios no intervalo
[0,1]. O programa deve contar quantos nmeros caem no intervalo
[0.0, 0.5], quantos caem no intervalo [0.5, 0.8] e quantos
caem no intervalo [0.8, 1.0].
Obs.: Para os exerccios 4.14, 4.15 e 4.16 ver as dicas a seguir.
Dicas para gerar nmeros aleatrios:
A linguagem C tem as funes randomize ( ), rand ( ), random ( ) e srand ( )

para gerar nmeros inteiros pseudo-aleatrios. Estas funes geram os ditos nmeros a
partir de algoritmos mais ou menos elaborados e cuja implementao varia ligeiramente
de compilador para compilador. A funo rand ( ) gera nmeros aleatrios do tipo
inteiro pertencentes ao intervalo [0 .. 32767], veja a constante RAND_MAX.
Para gerar nmeros aleatrios a pedido (por exemplo, apenas dentro de um

determinado intervalo, ou nmeros reais em vez de inteiros) temos que trabalhar com
estes elementos, fornecendo-lhes os parmetros adequados.
As funes randomize ( ), rand ( ), random ( ) e srand ( ) esto definidas na

biblioteca <stdlib.h> e alguns parmetros dependem da biblioteca <time.h>.
4.2 Funes sem retorno
Uma funo sem retorno um bloco de cdigo precedido de um cabealho que

contm a palavra vazio, o nome da funo e sua lista de parmetros. Desta forma,
pode-se fazer referncia ao bloco de cdigo de qualquer ponto do algoritmo por meio do
seu nome e passando os seus parmetros. Em relao ao nome da funo, sua lista de
parmetros e variveis locais, todos esto sujeitos s mesmas regras aplicadas s funes
com retorno.
Uma funo sem retorno distingui-se de outra funo com retorno por no
devolver valor algum ao algoritmo principal ou ao outro mdulo que tenha invocado sua
chamada.
Sintaxe:
71
vazio nome_da_funcao ([lista_de_parametros])
inicio
Comandos;
fim
Referncia, chamada ou invocao da funo na seo de comandos do

algoritmo:
nome_da_funcao (variaveis) ;
O nome da funo sem retorno dado pelo programador e precisa seguir as

mesmas regras utilizadas para nomear as variveis e as constantes.
Na lista de parmetros encontram-se as variveis que devem ser passadas a
funo no momento de sua chamada ou invocao. Esta lista apresenta-se da seguinte
maneira.
tipo variavel1, tipo variavel2, ... , tipo variavelN
As variveis passadas as funes sem retorno so associadas aos parmetros da

funo de acordo com a ordem das variveis e da lista de parmetros. Os [ ] na sintaxe
do cabealho da funo sem retorno indicam que a lista de parmetros opcional,
permitindo assim a criao de funes que no recebem variveis de entrada via lista de
parmetros. Esta dever ainda assim conter a palavra vazio indicando a inteno da
no existncia de parmetros.
Os comandos da funo sem retorno, bem como as declaraes de variveis
locais a funo, so delimitados pelos marcadores de inicio e fim. Todos os
comandos apresentados at o presente momento podero ser utilizados nas funes sem
retorno. neste local que realizada a tarefa para qual funo foi projetada.
Desde modo tem um algoritmo, com a existncia de uma funo sem retorno, a
seguinte aparncia.
#incluir biblioteca
/* Declarao das bibliotecas utilizadas */
#definir constante ou macro

/* Declarao de constantes, entre outras */
vazio nome_da_funcao ([lista_de_parmetros])

inicio
Comandos;
fim
...
72
principal( ) /* Funo principal do algoritmo */
inicio /* Inicio do escopo / bloco principal */
/* Declarao de variveis locais */
/* Comandos */
/* chamadas ou invocaes de funes */
nome_da_funcao (variaveis) ;
/* Retorno de erro ou Ok */
fim /* Final do escopo / bloco principal */
Em uma funo sem retorno no necessrio utilizar o comando retorno no

interior da mesma.
Exemplo 4.6 - Faa um algoritmo que possua uma funo para mostrar mensagem
Aprendendo a programar com VAZIO na tela.
#incluir <stdio.h>
#incluir <conio.h>
vazio mensagem (vazio)

inicio
imprima ("Aprendendo a programar com VAZIO\n");
fim
principal ()
inicio
mensagem();

retorno (0);
fim
V-se acima uma funo sem retorno e sem parmetros. Para que uma funo
retorne algo, deve-se usar a comando retorno, bem como especificar o seu tipo de
retorno. Para funes sem retorno, basta declarar a funo como tendo tipo de retorno
vazio.
Deve-se lembrar que a funo principal( ) uma funo e como tal deve-
se trat-la. O C Quietly e por conseqncia o compilador C assume que a funo
principal( ) deve retornar um valor inteiro. Isto d ao sistema operacional um
valor de retorno da funo principal( ). Deve-se lembrar da seguinte conveno:
se o algoritmo retornar 0 (zero), significa que ele terminou normalmente, e, se o
algoritmo retornar um valor diferente de zero, significa que o algoritmo teve um trmino
anormal. H ainda a possibilidade de a funo principal( ) no devolver nada ao
SO (Sistema Operacional) se este for o seu desejo, veja como proceder a seguir.
vazio principal(vazio)
73
inicio
/* Comandos */
fim
ou
principal(vazio)
inicio
/* Comandos */
retorno (0);
fim
A segunda forma vlida porque, as funes em linguagem C tm, por padro, o

tipo de retorno inteiro. Isto pode no ser compatvel com alguns compiladores C,
sendo assim, tenha por hbito explicitar o valor de retorno sempre.
Exerccio 4.17 - Criar uma funo sem parmetros que exiba na tela um menu com as
seguintes opes: Incluir, Remover, Alterar e Sair. Cada opo deve
estar em uma linha separada.
Exerccio 4.18 - Criar uma funo sem parmetros que desenhe uma moldura na tela do
microcomputador. Faa no algoritmo principal uma chamada a esta
funo, desenhando a moldura e aps escrevendo "Hello World"
da tela. Para desenhar a moldura use os caracteres especiais da tabela
ASCII estendida.
Exemplos:
Pressione a tecla ALT e ao mesmo tempo um dos seguintes nmeros
no teclado numrico - ALT + 200, ALT + 201, ALT + 205, ALT +
186, ALT + 187, ALT + 188.
Exerccio 4.19 - Tendo como dados de entrada a altura e o sexo (M ou F) de uma

pessoa, construa um algoritmo que possua uma funo sem retorno
para calcular e mostrar seu peso ideal, utilizando as seguintes frmulas:
Para Homens: ( 72.7 * altura ) - 58

Para Mulheres: ( 62.1 * altura) - 44.7
Exerccio 4.20 - Altere o algoritmo anterior de maneira que quando o usurio apertar
uma tecla (tecla = getch()), seja escrito "Bye-Bye World
na tela. O programa deve terminar automaticamente aps um atraso
(sleep ou delay) de 5 segundos.
74
5 Estruturas e classes
A seguir, apresentam-se os conceitos de estruturas de armazenamento e o uso de

classes para definio e criao de objetos, ou seja, novos tipos para a linguagem de
programao.
5.1 Estruturas
Por meio de estruturas, as linguagens C/C++ oferecem um mecanismo uniforme

para a definio de unidades de informaes organizadas em grupos ou campos. A forma
geral de definio de uma estrutura em algoritmo e no C Quietly a seguinte:
Sintaxe:
estrutura nome
inicio
/* declaracao de componentes */
...
fim [variavel1, varariavel2, ..., variavelN] ;
A palavra chave estrutura inicia a definio da estrutura. O nome opcional,

porm deve estar presente caso se deseje referenciar esta estrutura em algum momento
posterior. Da mesma forma, a lista de variveis declaradas variavel1,
varariavel2, ..., variavelN tambm no precisa estar presente, a no ser
que o nome no esteja presente. Quando o nome est presente, as variveis com essa
mesma estrutura podem ser definidas posteriormente, como na declarao a seguir,
estrutura nome_da_estrutura nome_da_variavel;
que define nome_da_variavel como sendo uma varivel do tipo estrutura

nome_da_estrutura.
Uma estrutura uma coleo de um ou mais variveis agrupadas sob um mesmo

nome o que facilita a manipulao destes dados. As variveis na estrutura, diferentes dos
vetores, podem conter diferentes tipos de variveis. Uma estrutura pode conter
quaisquer tipos de dados da linguagem C, como inteiros, fracionrios, caracteres, vetores
e outras estruturas. Cada varivel na estrutura chamada de membro da estrutura.
75
5.1.1 Definindo e declarando estruturas
Formas geomtricas necessitam de coordenadas que as delimitam. Um ponto no

espao representado pelas coordenada x e y. O valor de x representa a posio
horizontal e o valor de y a posio vertical. Assim quadrados, retngulos e outras formas
geomtricas precisam de coordenadas para serem representados. Pode-se definir uma
estrutura chamada coord (coordenada) que contm ambos os valores de x e y. Como
apresentado (ex. 5.1) a seguir:
Exemplo 5.1 Criando as estruturas para sua utilizao no algoritmo.
#incluir <stdio.h>
#incluir <conio.h>
principal ( )
inicio
/* definio da estrutura */
estrutura coord
inicio
inteiro x;
inteiro y;
fim ;

getch (); /* Aguarda uma tecla para finalizar */
retorno (0);
fim
A palavra reservada estrutura, a qual identifica o incio da definio da

estrutura, deve ser seguida pelo nome da estrutura (o qual segue as mesmas regras de
nomes de outras variveis em linguagem C). Entre as palavras inicio e fim est
lista de variveis membros da estrutura. necessrio dar um tipo e um nome para cada
varivel membro.
O exemplo anterior (ex. 5.1) define a estrutura chamada coord que contm duas
variveis inteiras, x e y. Isto, no entanto, no cria nenhuma instncia da estrutura
coord. A estrutura est apenas definida e ainda no foram declaradas variveis para
esta estrutura. Existem duas formas de se declarar variveis para as estruturas. A
primeira, segue a definio da estrutura com uma lista de uma ou mais nomes de
variveis, como mostrado (ex. 5.2) logo a seguir.
Exemplo 5.2 Criando as estruturas e definindo as variveis para sua utilizao no

algoritmo.
#incluir <stdio.h>
#incluir <conio.h>
76
principal()
inicio
/* definio da estrutura e declarao de variveis */
estrutura coord
inicio
inteiro x;
inteiro y;
fim primeira, segunda;

retorno (0);
fim
O exemplo (ex. 5.2) define a estrutura chamada coord e declara duas estruturas,
primeira e segunda , do tipo coord. primeira e segunda so cada uma, uma
instncia do tipo coord. primeira contm dois membros inteiros chamados, x e y,
assim como segunda.
Este mtodo de declarao de estruturas combina a declarao com a definio.
O segundo mtodo consiste em declarar as variveis de estruturas em uma localizao
diferente no cdigo fonte da definio. O exemplo (ex. 5.3) a seguir tambm declara
duas instncias do tipo coord.
Exemplo 5.3 Criando as estruturas e definindo as variveis para sua utilizao no

algoritmo, segundo mtodo.
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
/* definio da estrutura */
estrutura coord
inicio
inteiro x;
inteiro y;
fim ;
/* declarao das variveis da estrutura */
estrutura coord primeira, segunda ;

retorno (0);
fim
77
5.1.2 Acessando os membros de estruturas
Cada membro da estrutura pode ser utilizado como outras variveis do mesmo
tipo. Os membros da estrutura so acessados atravs do operador (.), tambm chamado
de operador ponto, entre o nome da varivel da estrutura e o nome de cada membro.
Para atribuir a varivel primeira as coordenadas x = 2 e y = 3, deve-se escrever o
cdigo a seguir.
primeira.x = 2;
primeira.y = 3;
Logo a seguir, v-se como mostrar o contedo armazenado na varivel segunda.
imprima ("%d,%d",primeira.x, primeira.y);
Uma vantagem de utilizarem-se estruturas ao invs de variveis declaradas

separadamente est em poder copiar informaes entre estruturas em uma nica
operao como mostrado a seguir.
segunda = primeira;
equivalente a
segunda.x = primeira.x;
segunda.y = primeira.y;
Quando o algoritmo utiliza complexas estruturas com muitos membros, esta

notao pode economizar um bom tempo. Outra vantagem a possibilidade de tratar
diferentes tipos de variveis em um grupo nico, como os dados de uma pessoa.
Exemplo 5.4 Criando as estruturas data e hora e definindo as variveis para sua
utilizao no algoritmo.
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
/* definio da estrutura e declarao da varivel */
estrutura data
inicio
inteiro mes;
inteiro dia;
inteiro ano;
fim data_atual ;
/* definio da estrutura, declarao da varivel

com inicializao */
78
estrutura hora
inicio
inteiro h;
inteiro min;
inteiro seg;
fim hora_do_nascimento = { 22, 20, 0 } ;

retorno (0);
fim
5.1.3 Estruturas mais complexas
So estruturas que contm outras estruturas como membros e estruturas que

contm vetores como membros. Assim, alm dos tipos primitivos uma estrutura pode
conter outras estruturas, como demonstra o prximo exemplo (ex. 5.5). O exemplo
anterior (ex. 5.3) foi estendido para ilustrar est uma estrutura complexa.
Imagine que voc deseje representar um retngulo. Um retngulo pode ser
representado pelas duas coordenadas diagonais dos cantos opostos. Tm-se at este
momento uma forma de representar um ponto por meio de duas coordenadas (x,y). O
exemplo (ex. 5.5) a seguir define a estrutura para representar estruturas de retngulos. A
estrutura de coordenadas de ponto tambm se faz presente neste exemplo, uma vez que
sua definio imprescindvel.
Exemplo 5.5 Criando as estruturas mais complexas e definindo as variveis para sua
utilizao no algoritmo.
#incluir <stdio.h>
#incluir <conio.h>
principal( )
inicio
/* definio das estruturas */
estrutura coord
inicio
inteiro x;
inteiro y;
fim ;
estrutura retangulo
inicio
estrutura coord infEsquerdo;
estrutura coord supDireito;
fim ;
/* declarao da varivel da estrutura */
79
estrutura retangulo caixa ;

retorno (0);
fim
Figura 5.1 Um retngulo representado no plano cartesiano1.
O algoritmo (ex. 5.5) anterior define a estrutura do tipo retangulo que

contm duas estruturas do tipo coord. Estas duas estruturas coord so chamadas de
infEsquerdo e supDireito. A declarao da estrutura aparece no algoritmo logo
aps sua definio e chamada de caixa.
Para combinar a definio com a declarao como realizado com a estrutura
coord, siga o modelo seguinte.
estrutura retangulo
inicio
fim caixa ;
Para se ter acesso localizao dos dados (membros do tipo inteiro),

necessrio aplicar o operador (.) duas vezes. Assim,
caixa.infEsquerdo.x
refere-se ao membro x do membro infEsquerdo (canto inferior esquerdo) do tipo

estrutura retangulo chamada caixa.
Para definir um retngulo com coordenadas (5,10) e (50, 30), escreve-se:
caixa.infEsquerdo.x = 5;
caixa.infEsquerdo.y = 10;
caixa.supDireito.x = 50;
caixa.supDireito.y = 30
A figura anterior (fig. 5.1) mostra a relao entre a estrutura retangulo, as

duas coordenadas, que neste caso so (0,0) e um ponto P qualquer maior que este que a
estrutura retangulo contm e as duas variveis inteiras que a estrutura coord
possui.
A seguir um exemplo (ex. 5.6) de um algoritmo para realizar o clculo da rea de
1
Considere um plano e duas retas perpendiculares, sendo uma delas horizontal e a outra vertical. A
horizontal ser denominada Eixo das Abscissas (eixo OX) e a Vertical ser denominada Eixo das
Ordenadas (eixo OY). Os pares ordenados de pontos do plano so indicados na forma P = (x,y) onde x
ser a abscissa do ponto P e y a ordenada do ponto P.
80
um retngulo a partir da solicitao de coordenadas ao usurio.
Exemplo 5.6 Desenvolver um algoritmo que solicite ao usurio a entrada de duas

coordenadas referentes aos cantos inferior esquerdo e superior direto
da diagonal de um retngulo. Calcular e mostrar a rea total do
retngulo formado pelas coordenadas obtidas.
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
inteiro compto, largura;
real area;
estrutura coord
inicio
inteiro x;
inteiro y;
fim ;
estrutura retangulo
inicio
fim ;
estrutura retangulo caixa ;
imprima ("Entre com a coordenada x inf esq:");

leia ("%d",&caixa.infEsquerdo.x);
imprima ("Entre com a coordenada y inf esq:");

leia ("%d",&caixa.infEsquerdo.y);
imprima ("Entre com a coordenada x sup dir:");
leia ("%d",&caixa.supDireito.x);
imprima ("Entre com a coordenada y sup dir:");

leia ("%d",&caixa. supDireito.y);
compto = caixa.supDireito.x - caixa.infEsquerdo.x;

largura = caixa.supDireito.y - caixa.infEsquerdo.y;
area = compto * largura;
imprima ("\nArea = %.2f",area);

retorno (0);
fim
81
Exerccio 5.1 Faa um algoritmo que calcule a hipotenusa entre dois pontos a partir
das coordenadas da diagonal de tringulo retngulo.
Exerccio 5.2 Faa um algoritmo que calcule a rea de tringulo retngulo a partir
das coordenadas da diagonal de dois pontos.
5.2 Classes
Um algoritmo que utiliza classes apresenta caractersticas de programas

orientados a objetos, foco das prximas sees. Antes porm, veja alguns conceitos de
programao que antecedem a programao orientada a objetos. Estes conceitos ainda
so utilizados freqentemente, uma vez que todas essas formas de programao so
tcnicas e podem ser utilizadas livremente, dependendo da necessidade de representao
da soluo do problema a enfrentar.
5.2.1 Programas desestruturados
Normalmente, as pessoas iniciam a criao de pequenos algoritmos ou programas

que consiste de um nico programa principal. O algoritmo principal contm a seqncia
de comandos e estruturas de decises e repeties, alm dos dados que de acesso global
ou seja, quaisquer partes do algoritmo podem modificar o contedo das variveis.
Esta tcnica apresenta desvantagens, uma vez que grandes algoritmos/programas
acabam necessitando de cpias de seqncias ou de estruturas em vrias partes do
algoritmo, alm de o algoritmo principal ter acesso aos dados globais como mostra a
figura (fig. 5.2) a seguir. Uma forma de minimizar este fato utilizando chamada de
mdulos e seu retorno.
principal(){
Algoritmo
dados
}
Figura 5.2 Algoritmo desestruturado.
5.2.2 Programas estruturados
Com algoritmos estruturados possvel combinar retorno de resultados em um

nico lugar, a sada da funo. Para chamar a funo basta invocar seu nome e passar a
sua lista de parmetros, caso exista. Aps a seqncia de execuo da funo o fluxo
retorna para a instruo seguinte de onde foi chamada a funo.
Uma vez que o cdigo de uma funo e os seus parmetros foram testados e
estando estes livres de erros, eles estaro corretos para cada invocao da funo. Agora
82
o algoritmo consiste de uma seqncia (fig. 5.3) de chamadas s funes e que facilita a
reutilizao do cdigo inclusive em outros algoritmos e a localizao e identificao de
erros em cada mdulo em separado. Cada mdulo pode possuir seus prprios dados,
tambm.
principal () {
dados
}
Algoritmo
funao1 funao2 funaoN
Figura 5.3 Algoritmo modular.
5.2.3 Programas orientados a objetos
Obejto1 Obejto3
dados1 dados3
Algoritmo
Obejto2
dados2
Figura 5.4 Algoritmo orientados a objetos.
A definio de classes bem como a criao de instncias de objetos (fig. 5.4)

difere um pouco da definio de dados em programas estruturados.
Criar a soluo de um problema usando o conceito de abstrao, ou seja, usando
classes pode se tornar uma tarefa simples ou no dependendo da complexidade da
soluo a representar. Trate o problema com sendo um objeto do mundo real, levante
suas caractersticas (dados) e suas aes (mtodos).
5.2.4 Declarando classes
83
No C Quietly com a opo do compilador C/C++ (marcada) possvel
definio e declarao de classes. Uma instncia de uma classe chamada de objeto.
Para definir uma nova classe utiliza-se a palavra reservada classe seguida de um nome
(mesmas regras para nomes de variveis e constantes simblicas). inicio e fim
delimitam os dados (atributos) e funes (mtodos) da classe. publico, privado e
protegido caracterizam o tipo de acesso externo aos atributos e mtodos da
classe.Sintaxe a seguir.
classe nome_da_classe
inicio
/* declaraes de variveis e mtodos privados */;
publico:
/* declaraes de variveis e mtodos publicos */;
fim
Uma classe se parece com uma estrutura em termos de atributos ou dados, assim
como uma estrutura construda para agrupar algumas variveis em um mesmo local de
fcil acesso, tambm as classes permitem a abstrao de dados, por meio de variveis de
diversos tipos.
Em um programa que utiliza uma interface controladora de um motor eltrico
provavelmente definiria-se uma classe chamada motor. Os atributos desta classe seriam:
temperatura, velocidade, tenso_aplicada. Estes provavelmente seriam
representados na classe por tipos como real ou inteiro. As funes membro ou
mtodos desta classe seriam funes para alterar a velocidade, ler a temperatura, etc.
Outro programa de contas a pagar e contas a receber definiria-se a classe
conta_bancaria. Os atributos seriam: saldo, limite_de_saque,
taxa_de_juros, etc, representados como variveis do tipo real. Dentre as funes
membros desta classe estariam s funes para: efetuar saques, depsitos e computar
juros. Estes so alguns exemplos de abstraes de situaes encontradas no mundo real
por meio da definio classes para represent-los.
Objetos so instncias de uma classe. Quando um objeto criado ele precisa ser
inicializado, ou seja, para uma nica classe. A classe Estudante de graduao
pode ter vrios objetos em um mesmo algoritmo. Estudante de graduao Joo,
Matrcula 567418, Curso Engenharia Mecnica; Estudante de graduao
Mrcia, Matrcula 982349, Curso Engenharia Eltrica... A classe representa
somente o molde para a criao dos objetos, estes sim contm a informao.
Exemplo 5.7 Definir a classe Ponto e sua interface (no h necessidade de

implement-la neste instante). Declare ainda dois objetos para esta
classe.
#incluir <iostream.h>
classe Ponto
inicio
inteiro x, y;
publico:
84
vazio setaX (inteiro vx);
vazio setaY (inteiro vy);
inteiro obtemX ( );
inteiro obtemY ( );
fim;
principal ( )
inicio
Ponto p1, p2;
retorno (0);
fim
As funes complementam e compem a interface da classe. A terminologia

usada para design-las bastante variada: funes membro, mtodos, etc. Quando uma
funo membro chamada, se diz que o objeto est recebendo uma mensagem (para
executar uma ao).
A sintaxe para declarao de funes membro dentro de uma classe a mesma
sintaxe de declarao de funes comuns, exceto pelo :: precedido do nome da classe:
tipo_de_retorno nome_classe :: nome_funcao ([parmetros])

inicio
Comandos;
fim
Exemplo 5.8 Definir a classe Ponto e sua interface. Declare ainda dois objetos para
esta classe.
#incluir <conio.h>
classe Ponto
inicio
inteiro x, y;
publico:
vazio setaX (inteiro vx);
vazio setaY (inteiro vy);
inteiro obtemX ( ) inicio retorno (x); fim
inteiro obtemY ( ) inicio retorno (y); fim
fim;
vazio Ponto::setaX (inteiro vx)
inicio
x = vx;
fim
85
vazio Ponto::setaY (inteiro vy)
inicio
y = vy;
fim
principal ()
inicio
Ponto p1, p2;
retorno (0);
fim
A diferena que como a funo membro est definida na classe, ela ganha
acesso direto aos dados membros ou atributos, sem precisar usar o "ponto", exemplo:
um_objeto.dadomembro
As funes setaX e setaY foram definidas fora da classe, j as funes

obtemX e obtemY so definidas inline, ou seja, dentro da prpria definio da classe,
uma vez que seu cdigo no prejudica a clareza da definio da classe.
5.2.5 Permitindo o acesso aos membros da classe
privado e publico qualificam os dados membro e funes membro de uma

classe quanto ao tipo de acesso (onde eles so visveis), isto chamado de
encapsulamento. Suponha que voc instanciou (criou) um objeto do tipo ponto em seu
algoritmo:
Ponto p; /* instanciacao */
Segundo o uso de qualquer uma das definies da classe Ponto dada

anteriormente no se pode escrever no algoritmo:
p.x = 2; /* Erro! */
mas da forma seguinteest correto,
p.setaX (2); /* Correto! */
Aplicando encapsulamento a classe Ponto definida anteriormente.
esta classe. Represente as coordenadas de um retngulo.
#incluir <conio.h>
classe Ponto
86
inicio
privado:
inteiro x;
inteiro y;
publico:
vazio setaX (inteiro vx) inicio x = vx; fim;
vazio setaY (inteiro vy) inicio y = vy; fim;
vazio coordXY (inteiro vx, inteiro vy);
inteiro obtemX( ) inicio retorno (x); fim
inteiro obtemY( ) inicio retorno (y); fim
vazio mostraXY ( );
fim;
vazio Ponto::coordXY (inteiro vx, inteiro vy)

inicio
x = vx;
y = vy;
fim
vazio Ponto::mostraXY ( )
inicio
csaida << "X = " << x <<" , Y: " << y << "\n";
fim
principal ()
inicio
Ponto p1, p2; /* instanciao */
p1.setaX(2);
p1.setaY(3);
p2.coordXY (10,12);
p1.mostraXY();
p2.mostraXY();
getch();
retorno(0);
fim
esta classe. Represente as coordenadas de um retngulo e calcule sua
rea.
#incluir <conio.h>
classe Ponto
inicio
privado:
inteiro x;
87
inteiro y;
publico:
Ponto (inteiro vx, inteiro vy); /* construtor */
inteiro obtemX( ) inicio retorno (x); fim
inteiro obtemY( ) inicio retorno (y); fim
vazio mostraXY ( );
privado:
vazio setaX (inteiro vx) inicio x = vx; fim
vazio setaY (inteiro vy) inicio y = vy; fim
fim;
Ponto::Ponto (inteiro vx, inteiro vy)

inicio
setaX (vx);
setaY (vy);
fim
vazio Ponto::mostraXY ( )
inicio
csaida <<"X = "<< obtemX()<<",Y: "<<obtemY()<<"\n";
fim
principal()
inicio
inteiro area, comprimento, largura;
/* instanciao usando construtor */

Ponto p1(1,1), p2(10,10);
p1.mostraXY();
p2.mostraXY();
comprimento = p2.obtemX( ) p1.obtemX( );

largura = p2.obtemY( ) p1.obtemY( );
area = comprimento * largura;
csaida <<"\nArea = " << area;
getch();
retorno(0);
fim
Exerccio 5.3 Definir a classe Ponto e sua interface. Declare ainda dois objetos para
esta classe. Represente as coordenadas de um retngulo e a medida da
diagonal do mesmo a partir da origem (0,0).
Exerccio 5.4 Definir a classe Ponto e sua interface. Declare ainda dois objetos para
esta classe. Represente as coordenadas de um retngulo e a medida da
diagonal do mesmo.
88
Exerccio 5.5 Uma representao para nmeros racionais (numerador, denominador)
que possua as operaes aritmticas bsicas.
Exerccio 5.6 Uma representao para ngulos na forma (Graus, Minutos,

Segundos). Tambm com as operaes relacionadas, bem como as
operaes para converter para radianos, entre outras.
89
6 Tipos de dados estruturados
Estruturas formadas por um conjunto de variveis, permitindo modelar de forma

mais natural os dados.
6.1 Vetores
Estrutura formada por um conjunto unidimensional de dados de mesmo tipo

(homogneo) e possuindo nmero fixo de elementos (Esttico). Na declarao dos
vetores devemos informar o seu nome, seu tipo (inteiro, real, caractere,
...), e seu tamanho (quantidade de elementos). Cada elemento do vetor identificado
por um ndice (unidimensional), o qual indica a sua posio no vetor.
Sintaxe:
tipo_da_variavel nome_do_vetor [ TAMANHO ] ;
Referncia na seo de comandos do algoritmo:
nome_do_vetor [indice] ;
Exemplo 6.1 - Criar um algoritmo que armazene nmeros inteiros em dois vetores com
trs elementos cada. Gerar e imprimir o vetor soma.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
inteiro vetor1[3], vetor2[3], vetorSoma[3];
/* Entrada de elementos do vetor1 */
imprima ("Entre com o 1o elemento do vetor 1: ");

leia ("%d",&vetor1[0]);
90

/* Calculo do vetor soma */
vetorSoma[0] = vetor1[0] + vetor2[0];

/* Exibindo o vetor soma */
imprima ("\nVetor Soma [1] = %d", vetorSoma[0]);


retorno (0);
fim
Exemplo 6.2 - Criar um algoritmo que armazene nmeros inteiros em dois vetores com
dez elementos cada. Gerar e imprimir o vetor soma.
#incluir <stdio.h>
#incluir <conio.h>
#definir MAX 10
principal()
inicio
inteiro vet1[MAX], vet2[MAX];
inteiro vetSoma[MAX];
inteiro i;
/* Entrada de elementos do vet1 */
para (i = 0; i < MAX; i++)

inicio
imprima ("Entre com o %do elem do vetor 1: ", i + 1);
leia ("%d",&vet1[i]);
fim
para (i = 0; i < MAX; i++)

inicio
imprima ("Entre com o %do elem do vetor 2: ", i + 1);
91
leia ("%d",&vet2[i]);
fim
/* Calcula e Exibe o vetor soma */
para (i = 0; i < MAX; i++)

inicio
vetSoma[i] = vet1[i] + vet2[i];
imprima ("\nVetor Soma [%d] = %d", i+1, vetSoma[i]);
fim

retorno (0);
fim
Exerccio 6.1 Faa um algoritmo que leia N (mximo 50) e uma lista de N nmeros e
mostre a soma de todos os nmeros da lista.
Exerccio 6.2 Escreva um algoritmo que leia um conjunto de 100 nmeros inteiros
positivos e determine o maior deles.
Exerccio 6.3 Escreva um algoritmo que leia um nmero inteiro N (mximo 500) e
uma lista de N nmeros inteiros positivos e determine o maior nmero
da lista.
Exerccio 6.4 Escreva um algoritmo que leia um conjunto de nmeros inteiros

positivos e determine o maior deles. A leitura do valor 0 (zero) ou no
mximo 100 nmeros lidos indicam o fim dos dados (flag).
Exerccio 6.5 Faa um algoritmo que leia uma lista de nmeros inteiros positivos
terminada pelo nmero 0 (zero) ou no mximo 1000 nmeros lidos.
Ao final, o algoritmo deve mostrar a mdia aritmtica de todos os
nmeros lidos (excluindo o zero).
Exerccio 6.6 Faa um algoritmo que leia uma lista (mximo 50) de letras terminada
pela letra z. Ao final, o algoritmo deve mostrar a quantidade lida de
cada vogal.
Exerccio 6.7 Faa um algoritmo que crie um vetor de inteiros de 100 posies, leia
os valores deste vetor e exiba o vetor na tela de trs para frente.
Exerccio 6.8 Faa um algoritmo que crie um vetor de 26 elementos do tipo

caractere. Cada elemento do vetor deve conter uma letra do alfabeto,
onde o seu ndice dado pela ordem da letra no alfabeto. Exibir os
elementos com ndices pares na tela, e depois os elementos com ndices
mpares.
92
Exerccio 6.9 Faa um algoritmo que leia dois vetores de nmeros compostos por 5
elementos que so fornecidos de maneira ordenada (nmeros em
ordem crescente). Crie um terceiro vetor que a unio dos dois
primeiros vetores, sendo que este novo vetor de 10 elementos tambm
deve ser um vetor onde os seus elementos esto ordenados. Exiba a
soma total dos elementos contidos nos trs vetores.
6.2 Vetores de caracteres
Manipular variveis contendo uma seqncia ou cadeia de caracteres poderia ser

tratado da mesma forma que outras variveis numricas. Algumas linguagens de
programao e entre elas a linguagem C o fazem de maneira idntica as quaisquer outras
variveis. Porm, para que o C trabalhe com variveis de seqncia de caracteres (o tipo
string) preciso utilizar a biblioteca <string.h>, a qual no parte do ANSI C, ainda
que presente no C Quietly.
Sendo assim, uma varivel string em ANSI C um vetor de caracteres terminado
com um caractere nulo. O caractere nulo um caractere com valor inteiro igual a zero
(cdigo ASCII igual a 0). O terminador nulo tambm pode ser escrito usando a
conveno de barra invertida do C como sendo `\0`. Embora o assunto vetores tenha
sido discutido anteriormente, apresentam-se aqui os fundamentos necessrios para que se
possa utilizar as seqncias de caracteres ou strings.
Para declarar uma string, pode-se utilizar a seguinte forma:
char nome_da_varivel_string [ TAMANHO ] ;
Isto declara um vetor de caracteres (uma string) com nmero de posies igual a
TAMANHO. Como mostrado anteriormente necessrio reservar um caractere para ser o
terminador nulo, o que determina declarar o comprimento da varivel string como sendo,
no mnimo, um caractere a mais do que a maior cadeia de caracteres que se deseja
armazenar.
Ao declarar uma varivel chamada nome de 13 posies por meio de um vetor
de caracteres e inicializ-la com a palavra "Algoritmo", o programador utiliza a
seguinte sintaxe:
char nome[13] = "Algoritmo";
Na memria os caracteres so armazenados com mostrado a seguir.
Memria (RAM)
A l g o r i t m o \0
No caso anterior, as trs clulas de memria no usadas tm valores

indeterminados. Isto ocorre porque o C Quietly no inicializa as variveis, cabendo ao
93
programador realizar esta tarefa. Portanto as nicas clulas de memria que so
inicializadas so as que contm os caracteres A, l, g, o, r, i,
t, m, o e \0.
Para ler uma string fornecida pelo usurio pode-se utilizar a funo leia( ).
Um exemplo do uso desta funo apresentado logo a seguir. A funo leia( )
coloca o terminador nulo no final do texto da string, quando o usurio pressiona a tecla
<enter>.
Exemplo 6.3 - Criar um algoritmo que leia o primeiro nome e o ltimo sobrenome de um
aluno. Logo aps escrev-lo em ordem de: sobrenome, nome.
#incluir <stdio.h>
#incluir <conio.h>
principal ()
inicio
char nome[15],
sobrenome[15];
imprima("Digite seu nome: ");

leia("%s",nome);
imprima("Agora seu sobre nome: ");
leia("%s",sobrenome);
imprima("\nObrigado!\n");
imprima("Sr(a): %s, %s\n",&sobrenome, &nome);

retorno (0);
fim
No algoritmo anterior (ex. 5.3), o tamanho mximo das cadeias de caracteres ou

string que voc pode fornecer uma seqncia de 14 caracteres. Se voc entrar com
uma seqncia de comprimento maior, o algoritmo ir aceitar, mas os resultados podem
ser desastrosos.
Como as seqncias so vetores de caracteres, para se acessar um determinado
caractere de uma cadeia de caracteres, basta indexar, ou seja, usar um ndice para acessar
o caractere desejado dentro da seqncia. Suponha uma seqncia chamada nome,
como no exemplo anterior (char nome [13] = "Algoritmo";). Pode-se ter
acesso a quarta e stima letra da varivel nome da seguinte forma.
nome [3] = a;
nome [6] = s;
Por qu se est acessando a segunda letra e no a primeira?
Na linguagem C, o ndice comea em zero. Assim, a primeira letra da string

sempre estar na posio 0. A segunda letra sempre estar na posio 1 e assim
sucessivamente. Segue um exemplo que imprimir a segunda letra da string "Joao",
apresentada acima. Em seguida, ele mudar esta letra e apresentar a string no final.
94
Exemplo 6.4 - Criar um algoritmo com uma varivel chamada nome que contenha
inicialmente a palavra "Algoritmo" e em seguida altere o contedo da
mesma para "Algarismo", utilize o acesso a cada caractere (ndice).
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
char nome[15] = "Algoritmo";
imprima("Palavra inicial: %s\n",&nome);

imprima("A quarta letra: %c\n",nome[3]);
imprima("A setima letra: %c\n",nome[6]);
nome [3] = a;
nome [6] = s;
imprima("Palavra atual: %s\n",&nome);

imprima("A quarta letra: %c\n",nome[3]);
imprima("A setima letra: %c\n",nome[6]);

retorno (0);
fim
Nesta cadeia de caracteres, o terminador nulo (\0) est na posio 9. Das

posies 0 a 8, tm-se caracteres vlidos, e portanto pode-se escrev-los. Note a forma
como foi inicializado a seqncia de caracteres nome com os caracteres A, l,
g, o, r, i, t, m, o e \0 simplesmente declarando
char nome[15] = "Algoritmo". Observe que "Algoritmo" (uma cadeia de
caracteres entre aspas) uma cadeia de caracteres constante, isto , uma cadeia de
caracteres que est pr-carregada com valores que no podem ser modificados. J a
varivel nome, pode sofrer alteraes em seu contedo armazenado, como de fato foi
realizado.
No algoritmo (ex 5.4) anterior, %s indica que imprima() deve colocar uma
seqncia de caracteres (string) na tela.
Cadeias de caracteres (string) so vetores de caracteres (char). Nada mais e nada
menos. Deve-se apenas ficar atento para o fato de que as strings tm o seu ltimo
elemento como um \0.
Assim, deve-se lembrar que o tamanho da string deve incluir o \0 final. A
biblioteca padro do C possui diversas funes que manipulam strings. Estas funes so
teis pois no se pode, por exemplo, igualar duas strings, da forma mostrada a seguir.
string1 = string2; /* No faa isto */
Quando se desenvolve algoritmos que tratam de cadeias de caracteres muitas

vezes pode-se fazer bom proveito do fato de que uma cadeia termina com \0 (isto ,
95
o nmero inteiro 0). Veja o algoritmo (ex. 5.5) a seguir que serve para igualar duas
cadeias de caracteres (isto , copia os caracteres de uma string para o vetor da outra).
Exemplo 6.5 - Criar um algoritmo para copiar uma cadeia de caracteres em uma outra.
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
inteiro i;
char nome[10], copia[10];

leia ("%s",&nome);
para (i = 0;nome[i];i++)
inicio
copia[i] = nome[i];
fim
copia[i] = \0;
imprima("Esta e uma copia: %s\n",copia);

retorno (0);
fim
A condio na estrutura de repetio para anterior (ex. 5.5) baseada no fato

de que a seqncia de caracteres que est sendo copiada termina em \0. Quando o
elemento encontrado em nome[i] o \0, o valor retornado para o teste
condicional falso (nulo). Desta forma a expresso que vinha sendo verdadeira (no
zero) continuamente, torna-se falsa terminado a estrutura de repetio.
6.2.1 Funes para manipulao de vetores de caracteres
Uma outra funo para a leitura de uma cadeia de caracteres, bem como uma
srie de funes que manipulam seqncias de caracteres ou strings, so apresentadas a
seguir.
leias()
A funo leias(), assim como a funo leia(), l ou obtm uma seqncia

de caracteres do teclado. Sua sintaxe :
leias ( nome_da_varivel_string ) ;
96
Exemplo 6.6 - Criar um algoritmo para copiar uma cadeia de caracteres em uma outra,
usando leias() para leitura da seqncia de caracteres.
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
inteiro i;
char nome[40], copia[40];

leias (nome);
para (i = 0;nome[i];i++)
inicio
copia[i] = nome[i];
fim
copia[i] = \0;
imprima("Esta e uma copia: %s\n",copia);

retorno(0);
fim
No exemplo anterior (ex. 5.5) a funo leia() termina a seqncia de

caracteres digitados pelo usurio, quando este digita um <enter>, porm armazena
somente os caracteres diferentes de espao em branco, ou seja, armazena todos os
caracteres digitados at encontrar o primeiro espao ou chegar ao <enter>. J com
leias() (ex. 5.6) isto no acontece. Toda a cadeia armazenada.
strcopia()
A funo strcopia() copia uma cadeia de caracteres (string_origem)

para uma outra cadeia de caracteres (string_destino). Seu funcionamento
semelhante ao da rotina apresentada anteriormente (ex. 5.5). Esta e as demais funes
apresentadas na seqncia esto definidas na biblioteca <stdio.h>, fazendo-se
necessrio a incluso da mesma em cada algoritmo que as utilize. Abaixo, tem-se a
sintaxe da funo strcopia() e a seguir apresentado um exemplo de uso desta
funo.
strcopia ( string_destino , string_origem ) ;
Exemplo 6.7 - Criar um algoritmo para copiar uma cadeia de caracteres em uma outra,
usando strcopia().
#incluir <stdio.h>
#incluir <conio.h>
97
principal()
inicio
char nome[40], copia[40], mensagem[20];

leias (nome);
strcopia (copia, nome); /* copia nome em copia */

strcopia (mensagem, "Obrigado Sr(a)");
/* copia "Obrigado Sr(a)" em mensagem */
imprima("\n%s: %s\n",mensagem,copia);

retorno (0);
fim
strconcat()
Esta funo une (concatena) duas cadeias de caracteres. Aps a execuo da

funo, a cadeia de caracteres (string_destino) ter o seu contedo acrescido do
contedo da cadeia de caracteres (string_origem) que permanecer inalterada. A
funo strconcat() apresenta a seguinte sintaxe:
strconcat ( string_destino , string_origem ) ;
Exemplo 6.8 - Criar um algoritmo que leia um nome e um sobrenome, logo a seguir unir
uma cadeia de caracteres a outra usando strconcat() e uma nova
varivel para armazen-la.
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
char nome[15],
sobrenome[15],
nomecompleto[30] = "",
mensagem[20];

leias (nome);
imprima("Digite seu sobrenome: ");
leias (sobrenome);
strconcat(nomecompleto, nome);
/* acrescenta nome em nomecompleto */
strconcat(nomecompleto, sobrenome);
/* acrescenta sobrenome em nomecompleto */
98
strcopia (mensagem, "Obrigado Sr(a)");
/* copia "Obrigado Sr(a)" em mensagem */
imprima("\n%s: %s\n",mensagem,nomecompleto);

retorno (0);
fim
strtam()
A funo strtam() retorna o comprimento da cadeia de caracteres (string)

fornecida. O terminador nulo no contado. Isto quer dizer que, de fato, o comprimento
do vetor de caracteres deve ser um a mais que o inteiro retornado pela funo
strtam(). Sua sintaxe a seguinte:
strtam ( string ) ;
Exemplo 6.9 - Criar um algoritmo que leia um nome e um sobrenome, una as cadeia de
caracteres usando strconcat() em uma nova varivel e encontre a
quantidade de caracteres (tamanho) esta varivel possui usando a funo
strtam().
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
inteiro tamanho;
char nome[15],
sobrenome[15],
nomecompleto[30] = "";

leias (nome);
imprima("Digite seu sobrenome: ");
leias (sobrenome);
strconcat(nomecompleto, nome);
/* acrescenta nome em nomecompleto */
strconcat(nomecompleto, sobrenome);
/* acrescenta sobrenome em nomecompleto */
tamanho = strtam(nomecompleto);
imprima("\nSeu nome completo e: %s\n",nomecompleto);

imprima("Numero de caracteres = %d\n",tamanho);

99
retorno(0);
fim
strcomp()
A funo strcomp() compara a cadeia de caracteres (string_1) com a segunda

cadeia de caracteres (string_2). Se as duas forem idnticas funo retorna o valo 0
(zero). Se elas forem diferentes a funo retorna algo diferente do valor 0 (no-zero).
Sua sintaxe mostrada abaixo:
strcomp ( string_1 , string_2 ) ;
Exemplo 6.10 - Criar um algoritmo que compare duas strings e mostre a mensagem
So Iguais ou So diferentes dependendo da condio da funo
strtam().
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
char str1[15], str2[15];
imprima("Digite uma string: ");

leias (str1);
imprima("Digite outra string: ");
leias (str2);
se (strcomp(str1, str2))
inicio
imprima("\nSao diferentes\n");
fim
senao
inicio
imprima("\nSao iguais\n");
fim

retorno (0);
fim
Exerccio 6.10 - Criar um algoritmo que leia um nome e um sobrenome, una as cadeia
de caracteres usando strconcat() em uma nova varivel,
certifique-se que o nome e sobrenome esteja separado corretamente
por espaos em branco. O algoritmo deve verificar a existncia do
espao em branco e caso este no esteja presente, deve ser acrescido
100
ao nome antes de exibir o nome completo.
Exerccio 6.11 - Faa um algoritmo que leia quatro palavras pelo teclado, e armazene
cada palavra em uma string. Depois, concatene todas as strings lidas
numa nica string. Por fim apresente esta como resultado ao final do
algoritmo.
Exerccio 6.12 - Crie um algoritmo que mostre o tamanho de cada varivel, inclindo a
varivel que armazena todas as palavras do exerccio anterior.
Exerccio 6.13 - Desenvolver um programa de criptografia (codificao de dados

visando privacidade de acesso as informaes), onde dada uma
String este programa codifique os dados atravs de um processo de
substituio de letras (voc pode definir o seu prprio mtodo). Fazer
um outro programa complementar a este que deve ser capaz de
descriptografar a String, ou seja, deve pegar uma String codificada e
retorn-la ao texto original.
6.3 Matrizes
Estrutura semelhante ao vetor, sendo que, pode possuir n dimenses. Desta

forma para fazer referncia aos elementos de uma matriz, precisa-se de tantos ndices
quanto for suas dimenses.
6.3.1 Matrizes bidimensionais
Nas sees anteriores viu-se como declarar matrizes unidimensionais (vetores).

Agora de matrizes bidimensionais. A forma geral da declarao de uma matriz
bidimensional muito parecida com a declarao de um vetor.
Sintaxe:
tipo_da_variavel nome_da_matriz [ altura ] [ largura ] ;
Referncia na seo de comandos do algoritmo:
nome_da_matriz [indice_1] [indice_2];
muito importante ressaltar que, nesta estrutura, o ndice da esquerda (altura)

indexa as linhas e o da direita (largura) indexa as colunas. Ao preencher ou ler uma
matriz no C o ndice mais direita varia mais rapidamente que o ndice esquerda. Mais
uma vez bom lembrar que, na linguagem C, os ndices variam de zero ao valor
declarado, menos um; mas o C no vai verificar isto para o usurio. Manter os ndices na
faixa permitida tarefa do programador. A seguir tem-se um exemplo (ex. 6.11) do uso
de uma matriz para armazenar valores inteiros.
Exemplo 6.11 - Criar um algoritmo com uma matriz de 10 linhas e 5 colunas,
101
preenchendo-as com valores seqncias de 1 at 50.
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
inteiro matriz[10][5];
inteiro i,j,valor = 1;
imprima("\n Colunas ...");
para (i = 0; i < 10; i++)

inicio
imprima("\nLinha %d: ",i);
para (j = 0; j < 5; j++)
inicio
matriz[i][j] = valor;
valor++;
imprima(" %d",matriz[i][j]);
/* Experimente tambem %2d e %02d */
fim
fim

retorno (0);
fim
Exemplo 6.12 - Criar um algoritmo que leia os elementos de uma matriz inteira 6x6 e
escreva os elementos da diagonal principal.
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
inteiro matriz[6][6];
inteiro i,j;
para (i = 0; i < 6; i++)

inicio
para (j = 0; j < 6; j++)
inicio
imprima ("Entre com M[%d,%d] = ",i,j);
leia ("%d",&matriz[i][j]);
fim
fim
imprima ("\nDiagonal principal...");
para (i = 0; i < 6; i++)

inicio
102
imprima ("\nM[%d,%d] = %d",i,i,matriz[i][i]);
fim

retorno (0);
fim
6.3.2 Matrizes de cadeias de caracteres
As matrizes de cadeia de caracteres (strings) so matrizes bidimensionais. Uma

string um vetor de caracteres. Ao declarar uma matriz de vetores de caracteres cria-se
uma lista de vetores de caracteres. Esta estrutura uma matriz bidimensional de chars. A
seguir v-se a definio geral uma matriz de cadeias de caracteres (strings).
Sintaxe:
char nome_do_variavel [ num_de_strings ] [ compr_das_strings ] ;
Pode ento surgir pergunta: como acessar cada string individual? Simples.
Utilizando apenas o primeiro ndice. Assim, para acessar uma determinada string faa:
nome_da_variavel [indice];
Exemplo 6.13 - Criar um algoritmo que leia uma lista de 5 nomes de alunos. Aps a
leitura apresent-lo em ordem inversa entrada.
#incluir <stdio.h>
#incluir <conio.h>
principal()
inicio
char nome[5][50];
inteiro i;
para (i = 0; i < 5; i++)

inicio
imprima ("Entre com Nome do Aluno[%d]:",i);
leias (nome[i]);
fim
imprima ("\nNomes em ordem inversa");
para (i = 4; i > -1; i--)

inicio
imprima ("\nNome do Aluno[%d] = %s",i+1,nome[i]);
fim

retorno (0);
103
fim
6.3.3 Inicializaes de matrizes
Pode-se inicializar matrizes, assim como se pode inicializar variveis comuns. A

forma geral de uma matriz com inicializao :
Sintaxe:
tipo_da_variavel nome_do_variavel [ tam1 ] [ tam2 ] = { lista_de_valores};
A lista_de_valores composta por valores do mesmo tipo_d_

variavel separados por vrgula. Os valores devem ser dados na ordem em que sero
inseridos na matriz. A seguir apresentado alguns exemplos de inicializaes de
matrizes:
Exemplo 6.14 - Inicializando matrizes.
real vetor [6] = {2.3, 3.5, 3.4, 5.9, 1.0, 103.1};

inteiro matriz [2][5] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
char str [13] = {'J', 'o', 'a', 'o', '\0'};
char str [13] = "Joao";
char str_vetor [3][10] = {"Jesus", "Maria", "Jose"};
O primeiro (ex. 5.14) demonstra inicializao de vetores de nmeros fracionrios.

O segundo exemplo demonstra a inicializao de matrizes multidimensionais, onde
matriz est sendo inicializada com 1 e 2 em sua primeira linha, 3 e 4 na segunda linha e 5
e 6 na terceira linha, 7 e 8 na quarta linha e 9 e 10 na ltima linha. No terceiro exemplo
v-se como inicializar uma cadeia de caracteres e, no quarto exemplo, um modo mais
compacto de tambm inicializar uma seqncia de caracteres (string). O quinto exemplo
combina as duas tcnicas para inicializar uma matriz de vetores de caracteres. Lembre-se
de incluir o ; (ponto e vrgula) no final da cada um dos exemplos de inicializao
apresentados anteriormente (ex. 5.14).
6.3.4 Inicializaes sem a especificao de tamanho
Pode-se, em alguns casos, inicializar matrizes das quais no se sabe exatamente o

tamanho a priori. O compilador C ir, neste caso verificar o contedo de inicializao e
considerar como sendo este o tamanho da matriz. Isto ocorre no momento da
compilao e no poder mais ser mudado durante a execuo do algoritmo/programa,
sendo muito til, por exemplo, quando inicializ-se uma string e sem no entanto precisar
contar quantos caracteres sero necessrios para armazen-la. Alguns exemplos a seguir.
Exemplo 6.15 - Inicializando vetores e matrizes sem especificar o tamanho destes.
inteiro matriz [][5] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

char str[] = "O compilador C determinarah o tamanho!";
No primeiro exemplo o valor no especificado ser 2. No segundo exemplo, a
104
string str ter o tamanho 39. Veja que o artifcio para realizar a inicializao sem
especificar o tamanho no especificar o tamanho.
Exerccio 6.14 Faa um algoritmo que crie uma matriz de inteiros de 5 linhas por 10
colunas. Leia os valores desta matriz linha aps linha e exiba a matriz
na tela coluna por coluna.
Exerccio 6.15 Faa um algoritmo que crie uma matriz 3x3x3 onde cada elemento da
matriz seja igual soma dos seus ndices. Obtenha a soma de todos
elementos da matriz, soma dos elementos cujos valores so pares e a
soma dos elementos cujos valores so mpares.
Exerccio 6.16 Faa um algoritmo que leia trs vetores independentes compostos por
5 nmeros reais que so fornecidos pelo usurio. Crie uma matriz que
rena estes trs vetores em uma nica estrutura. Exibir na tela o
contedo da matriz. Encontre o maior valor contido nesta matriz.
105
7 Mini Manual do C Quietly
O C Quietly (CQ) uma ferramenta livre (Freeware) para ajudar os iniciantes no

mundo da programao em algoritmo e linguagem C. Sua proposta permitir a
desenvolvimento de pseudocdigo e automaticamente, traduzi-lo para a linguagem C.
Utilizando esta ferramenta, os alunos podem representar suas solues de problemas em
uma linguagem muito prxima da lngua natural na forma de algoritmos, no
necessitando inicialmente o domnio dos comandos da linguagem C.
A seguir (fig 7.1) apresentada tela inicial do CQ, com seu modelo de
algoritmo padro. Ele acaba poupando ao programador algum tempo de digitao
oferecendo este recurso inicial. O cdigo fonte (fig. 7.2) equivalente em c apresentado
logo a seguir. Na seqncia, outras partes da ferramenta sero exploradas.
Figura 7.1 Iniciando o C Quietly com um novo algoritmo.
106
Figura 7.2 Novo cdigo-fonte em linguagem C.
Um novo algoritmo poder ser introduzido no editor do CQ de trs formas. A

primeira, digitando-se os comandos (pseudocdigo) que representem a soluo
previamente proposta de determinado problema. A segunda, compreende na abertura de
algoritmos exemplos ou anteriormente digitados para alteraes, trazendo um ganho no
tempo de digitao. A outra, consiste na importao de cdigo fonte j escrito em
linguagem C, do qual o CQ extrai o pseudocdigo dos comandos em C (ainda no
disponvel na verso 0.9.3-1a).
Aps o trmino do algoritmo, ou a qualquer momento durante a digitao do
algoritmo, possvel compil-lo (fig. 7.3) a fim de verificar a existncia ou no de erros
de digitao ou sintaxe da linguagem C. Enquanto persistirem os erros, mensagens
indicando cada um dos erros e o local destes, sero exibidos na janela abaixo do editor
do CQ sob o ttulo: Mensagem. No havendo erros, o que impede o funcionamento do
algoritmo/programa, a execuo do algoritmo (fig. 7.6) ocorre.
O exemplo utilizado neste manual o clculo da mdia aritmtica simples entre
trs notas. O Algoritmo (fig. 7.3) traduzido para o cdigo-fonte em linguagem C,
compilado (fig. 7.4) e executado (fig. 7.5). Uma vez inseridos os valores, por parte do
usurio, a mdia exibida (fig. 7.6). Terminado a execuo (fig. 7.6) o programador tm
novamente ao seu dispor o editor do CQ.
107
Figura 7.3 Compilando um cdigo-fonte.
Figura 7.4 Trmino da compilao do cdigo-fonte.
108
Figura 7.5 Executando o programa.
Figura 7.6 Sada de execuo do programa.
109
Figura 7.7 Inserindo novas palavras-chave.
Totalmente flexvel, o CQ permite ao programador criar sua prpria lista de

palavras-chave (fig. 7.7). Cadastrando seus respectivos significados na linguagem C.
Dessa maneira os iniciantes no vo ter grandes problemas em migrar do sistema de
pseudocdigo para a linguagem C, excluindo totalmente a necessidade de se utilizar
papel.
110
Bibliografia
HOLZNER, Steven, GROUP, The Peter Norton Computing . Programando em

C++: um guia prtico para programao profissional. Traduo de Sylvio
Carlos Montenegro Branco. Rio de Janeiro: Campus, 1993.
HUBBARD, John R. Teoria e problemas de programao em C++ / John R.

Hubbard; Trad. Edson Furmankigwicz. 2. ed. Porto Alegre : Bookman, 2003.
JAMSA, Kris. Programando em C++ - A bblia / Kris Jamsa e Lars Klander.

Traduo: e reviso Tcnica: Jeremias Ren D. Pereira dos Santos So Paulo :
Makron Books, 1999.
KERNIGHAN, Brian W., RITCHIE, Dennis M. Ritchie. C a linguagem de

programao: Padro ANSI. Traduo Daniel Viera. Rio de Janeiro: Campus,
1989.
LOPES, Anita, GARCIA, Guto. Introduo programao. Rio de Janeiro:

Campus, 2002.
MANZANO, Jos Augusto N. G., OLIVEIRA, Jayr Figueiredo de. Estudo

Dirigido de Algoritmos. So Paulo: rica, 1997.
PEREIRA, Silvio do Lago. Estruturas de dados fundamentais: conceitos e

aplicaes / Silvio do Lago Pereira. So Paulo : rica, 1996.
TREMBLAY, Jaen-Paul, BUNT Richard B.. Cincia dos Computadores: Uma

Abordagem Algortmica. Traduo Moacir Souza Prado; So Paulo: McGraw
Hill do Brasil, 1993.
111

Apostila Tec I Algoritmos

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apostila Tec I Algoritmos

Cargado por

Copyright:

Formatos disponibles

Faculdade SATC

Engenharias Eltrica e Mecnica

Prof.: Giovani Martins Cascaes

HAWKING e MLODINOW Uma nova histria do tempo

Obs.: Os exerccios presentes nas listas em cada captulo

Figura 1.1 Etapas que antecedem o desenvolvimento de programas...................... 7

Tabela 2.1 Exemplos de nomes de variveis.............................................................16

A automatizao de tarefas um aspecto marcante da sociedade moderna. O

Figura 1.1 Etapas que antecedem o desenvolvimento de programas.

O programa escrito em uma linguagem de programao no nada mais do que a

1.1 Definio de algoritmo

O conceito central da programao o conceito de algoritmos, isto ,

1.2 Formas de representaes de algoritmos

Existem diversas formas de representao de algoritmos, mas no h um

Dentre as formas de representao de algoritmos mais conhecidas pode-se citar:

Nesta forma de representao os algoritmos so expressos diretamente em

Exemplo 1.1 Algoritmos em linguagem natural.

Algoritmo 1 - Troca de um pneu furado

Afrouxar ligeiramente as porcas

Algoritmo 2 - Clculo da mdia de um aluno

Obter as suas trs notas de provas

Algoritmo 3 - Troca de lmpadas queimadas

Se (lmpada estiver fora de alcance)

Algoritmo 4 Realizar uma prova

Esta representao pouco usada na prtica porque o uso da linguagem natural

a utilizao de smbolos grficos para representar algoritmos. Nos fluxogramas

Exemplo 1.2 Fluxograma para calcular o triplo de um nmero qualquer, fornecido

Figura 1.2 Fluxograma clculo do Triplo de um Nmero.

1.2.3 Portugus estruturado ou pseudocdigo

Esta forma de representao de algoritmos rica em detalhes, como a definio

A forma geral da representao de um algoritmo na forma de pseudocdigo

#definir constantes ou macros

/* 5. Declarao e classificao de variveis */

fim /* 12. Final do escopo / bloco principal */

incluir uma palavra que indica a incluso de bibliotecas no algoritmo;

definir consiste em uma poro opcional onde so declaradas as constantes

principal uma palavra que indica o incio da execuo de um algoritmo em

variveis consistem em uma poro opcional onde so declaradas as

inicio e fim so respectivamente as palavras que delimitam o incio e o

Comentrios /*...*/ utilizados ao longo do algoritmo, servem como

O algoritmo do clculo da mdia de um aluno, na forma de um pseudocdigo,

inteiro nota1, nota2;

media <- (nota1 + nota2)/2;

Situao 2: Visto como algoritmo com a sintaxe da linguagem C e podendo ser

inteiro nota1, nota2;

media = (nota1 + nota2)/2.0;

se (media >= 7.0)

getch(); /* Aguarda uma tecla para finalizar */

Desenvolver algoritmos requer o conhecimento do conceito de alguns itens

Toda varivel identificada por um nome ou identificador. Assim, por

Exemplo 2.1 - Declaraes de variveis.

Os identificadores representam os nomes escolhidos para rotular as variveis, as

i) O primeiro caractere deve ser uma letra;

A seguir (tab. 2.1), alguns exemplos de nomes de variveis permitidos, alm de

Tabela 2.1 Exemplos de nomes de variveis

Declarar uma varivel consiste em reservar espao na memria principal (RAM)

2.1.1 Tipos de variveis

Os tipos de variveis utilizados no algoritmo (representao da soluo do

So variveis que armazenam dados numricos e esto divididas em duas classes.

Os nmeros inteiros so aqueles que no possuem casas decimais, somente a

Os nmeros reais so aqueles que possuem alm da parte inteira do nmero,

Os caracteres podem armazenar letras (a..z; A..Z), nmeros (0..9) ou

Uma varivel do tipo char, pode armazenar um nico caractere e o mesmo

char ch; /* ch pode armazenar um nico

Comentrios /.../ utilizados ao longo do algoritmo, servem como