Algoritmos

Simone Maria Viana

simone_viana@yahoo.com.br

2006
Algoritmos pág. 2

ÍNDICE
INTRODUÇÃO.................................................................................................................6
LÓGICA........................................................................................................................6
COMPUTADOR...........................................................................................................6
PROGRAMA................................................................................................................7
LINGUAGENS DE PROGRAMAÇÃO.......................................................................7
TÉCNICAS ATUAIS DE PROGRAMAÇÃO.............................................................7
AÇÃO............................................................................................................................7
ESTADO.......................................................................................................................7
PROCESSO OU EVENTO...........................................................................................7
PADRÕES DE COMPORTAMENTO.........................................................................7
EXERCÍCIO..................................................................................................................7
CONCEITOS BÁSICOS...................................................................................................8
DEFINIÇÕES................................................................................................................8
COMO FAZER UM ALGORITMO.............................................................................8
TESTE DE MESA.........................................................................................................8
CLASSIFICAÇÃO DOS ALGORITMOS....................................................................8
DESCRIÇÃO NARRATIVA....................................................................................8
FLUXOGRAMA.......................................................................................................9
PSEUDOCÓDIGO ou PORTUGOL.........................................................................9
SIMBOLOGIA BÁSICA PARA FLUXOGRAMA.................................................9
TIPOS DE DADOS.................................................................................................10
VARIÁVEIS............................................................................................................10
CONSTANTES.......................................................................................................11
IDENTIFICADORES..............................................................................................11
EXEMPLOS............................................................................................................11
EXERCÍCIOS..............................................................................................................12
LINGUAGEM C/C++.....................................................................................................13
BIBLIOTECAS.......................................................................................................13
ETAPAS DA IMPLEMENTAÇÃO............................................................................14
include.....................................................................................................................14
DIRETIVAS define e undef.....................................................................................14
EXEMPLO..............................................................................................................15
Dev-C++......................................................................................................................15
LISTA DE RECURSOS..........................................................................................15
INSTALAÇÃO E CONFIGURAÇÃO DO DEV-C++...........................................16
ESTRUTURA SEQÜENCIAL.......................................................................................16
DECLARAÇÃO DE VARIÁVEIS EM ALGORITMOS...........................................16
COMANDO DE ATRIBUIÇÃO EM ALGORITMOS..............................................16
COMANDO DE ENTRADA EM ALGORITMOS....................................................16
COMANDO DE SAÍDA EM ALGORITMOS...........................................................16
REQUERIMENTOS NECESSÁRIOS...................................................................16
TIPOS DE DADOS.....................................................................................................16
ESTRUTURA SEQÜENCIAL EM C/C++................................................................17
DECLARAÇÃO DE VARIÁVEIS EM C/C++..........................................................17
STRINGS................................................................................................................17
getche()....................................................................................................................18
Exemplos.................................................................................................................18
COMANDO DE ATRIBUIÇÃO EM C/C++.............................................................18
COMANDOS DE ENTRADA EM C/C++.................................................................18
cin............................................................................................................................18
Algoritmos pág. 3
gets...........................................................................................................................19
scanf.........................................................................................................................19
COMANDOS DE SAÍDA EM C/C++........................................................................19
cout..........................................................................................................................19
printf........................................................................................................................19
puts..........................................................................................................................20
COMENTÁRIOS EM C/C++.....................................................................................20
OPERADORES E FUNÇÕES PREDEFINIDAS EM C/C++....................................20
Matemáticos............................................................................................................20
Relacionais..............................................................................................................20
Matemáticas.............................................................................................................21
Lógicos....................................................................................................................21
EXEMPLO..................................................................................................................21
EXERCÍCIOS..............................................................................................................22
RECURSIVIDADE.........................................................................................................24
ESTRUTURA CONDICIONAL (Controle de Fluxo)....................................................25
ALGORITMOS...........................................................................................................25
ESTRUTURA CONDICIONAL COMPOSTA......................................................25
C/C++..........................................................................................................................25
SIMPLES - IF..........................................................................................................25
COMPOSTA – IF/ELSE.........................................................................................26
ESTRUTURA CASE - SWITCH............................................................................26
OPERADORES LÓGICOS.....................................................................................27
EXEMPLO..................................................................................................................27
EXERCÍCIOS..............................................................................................................28
ESTRUTURA DE REPETIÇÃO....................................................................................31
ALGORITMOS...........................................................................................................31
NÚMERO DEFINIDO DE REPETIÇÕES (ESTRUTURA PARA)......................31
NÚMERO INDEFINIDO DE REPETIÇÕES E TESTE DE INÍCIO
(ESTRUTURA ENQUANTO)................................................................................31
NÚMERO INDEFINIDO DE REPETIÇÕES E TESTE NO FINAL
(ESTRUTURA REPITA)........................................................................................31
C/C++..........................................................................................................................32
for............................................................................................................................32
break........................................................................................................................33
continue...................................................................................................................33
while........................................................................................................................33
do-while...................................................................................................................33
EXEMPLOS................................................................................................................34
EXERCÍCIOS..............................................................................................................34
VETORES.......................................................................................................................37
ALGORITMOS...........................................................................................................37
DECLARAÇÃO DO VETOR.................................................................................37
ATRIBUINDO VALORES AO VETOR................................................................37
CARREGANDO UM VETOR................................................................................37
C/C++..........................................................................................................................37
DECLARAÇÃO DO VETOR.................................................................................37
ATRIBUINDO VALORES AO VETOR................................................................37
CARREGANDO UM VETOR................................................................................38
IMPRIMINDO UM VETOR...................................................................................38
EXEMPLO..................................................................................................................38
EXERCÍCIOS..............................................................................................................40
MATRIZ..........................................................................................................................42
Algoritmos pág. 4
DEFINIÇÃO................................................................................................................42
DECLARAÇÃO DE MATRIZ...............................................................................42
EXEMPLO DE MATRIZ........................................................................................42
ATRIBUINDO VALORES À MATRIZ.................................................................42
CARREGANDO UMA MATRIZ...........................................................................42
EXIBINDO OS ELEMENTOS DE UMA MATRIZ..............................................43
C/C++..........................................................................................................................43
DECLARAÇÃO DE MATRIZ...............................................................................43
ATRIBUINDO VALORES.....................................................................................43
EXIBINDO ELEMENTOS DA MATRIZ..............................................................44
EXEMPLOS................................................................................................................44
EXERCÍCIOS..............................................................................................................46
MANIPULANDO CARACTERES EM C/C++.............................................................47
FUNÇÃO strcpy()...................................................................................................47
FUNÇÃO strcat()....................................................................................................47
FUNÇÃO strlen()....................................................................................................47
FUNÇÃO strchr()....................................................................................................48
FUNÇÃO strstr().....................................................................................................48
FUNÇÃO strcmp()..................................................................................................48
EXERCÍCIO............................................................................................................48
REGISTROS (Estruturas)...............................................................................................49
DECLARAÇÃO - ALGORITMOS............................................................................49
DECLARAÇÃO DE REGISTROS EM C/C++..........................................................49
DECLARAÇÃO DE VARIÁVEIS DO TIPO REGISTRO EM C/C++.....................49
ACESSO A MEMBROS DE ESTRUTURAS............................................................49
EXEMPLOS................................................................................................................50
EXERCÍCIOS..............................................................................................................50
ARQUIVOS....................................................................................................................52
DECLARAÇÃO EM C/C++.......................................................................................52
COMANDOS DE ARQUIVOS EM C/C++...............................................................52
fopen().....................................................................................................................52
fclose().....................................................................................................................53
ferror().....................................................................................................................53
fputc()......................................................................................................................53
fgetc()......................................................................................................................53
fputs()......................................................................................................................53
fgets().......................................................................................................................53
fwrite().....................................................................................................................53
fread()......................................................................................................................53
fseek()......................................................................................................................53
feof()........................................................................................................................54
rewind()...................................................................................................................54
remove()..................................................................................................................54
fflush().....................................................................................................................54
exit()........................................................................................................................54
LENDO E ESCREVENDO CARACTER EM ARQUIVOS EM C/C++...................54
putc..........................................................................................................................54
getc..........................................................................................................................55
feof...........................................................................................................................55
FLUXOS PADRÃO....................................................................................................55
fprintf.......................................................................................................................55
fscanf.......................................................................................................................55
EXEMPLOS................................................................................................................56
Algoritmos pág. 5
EXERCÍCIOS..............................................................................................................57
SUB-ROTINAS...............................................................................................................58
ALGORITMO:............................................................................................................58
SUB-ROTINAS (FUNÇÕES) EM C/C++......................................................................58
COMANDO RETURN...........................................................................................58
EXERCÍCIOS..........................................................................................................59
Algoritmos pág. 6

INTRODUÇÃO
Você sabe usar o raciocínio lógico?
Isto depende de vários fatores: calma, conhecimento, vivência, versatilidade,
experiência, criatividade, ponderação, responsabilidade etc.
Para utilizar a lógica é preciso ter domínio do pensamento e saber pensar.
Então, o que é raciocínio lógico?
Conjunto de estudos que visa determinar os processos intelectuais que são as
condições gerais do conhecimento verdadeiro.
Ou ainda:
Seqüências coerentes, regulares e necessárias dos acontecimentos, das coisas
ou dos fatos, até mesmo, que é à maneira do raciocínio particular que cabe a um
indivíduo ou a um grupo.
Mas os profissionais de Tecnologia de Informação acreditam que seja um
esquema sistemático que define as interações de sinais no equipamento automático
do processamento de dados ou computador científico com o critério e princípios
formais de raciocínio e pensamento.

LÓGICA

Concluímos que lógica é a ciência que estuda as leis e critérios de validade

que regem o pensamento e a demonstração, ou seja, ciência dos princípios formais
do raciocínio.
Usar a lógica é um fator importante na área de tecnologia de informação, pois
os profissionais no dia-a-dia solucionam problemas e atingem os objetivos
apresentados por seus usuários com eficiência e eficácia, utilizando recursos
computacionais e/ou automatizados. Porém, ninguém ensina ninguém a pensar,
pois todas as pessoas “normais” possuem esse dom.

COMPUTADOR

Sua finalidade é auxiliar em qualquer coisa que lhe seja solicitada. E para
isso, recebe, manipula e armazenar dados. Sua finalidade e realizar o
processamento dos dados. Formado por:
 ENTRADA: dados de entrada do algoritmo;
 PROCESSAMENTO: procedimentos realizados para atingir um resultado;
 SAÍDA: dados já processados.
Algoritmos pág. 7

PROGRAMA

Um programa é um algoritmo escrito em uma linguagem computacional.

LINGUAGENS DE PROGRAMAÇÃO

São Softwares que permitem o desenvolvimento de programas. Possuem um

poder de criação ilimitado, desde jogos, editores de texto, sistemas empresariais
até sistemas operacionais.
Existem várias linguagens de programação, cada uma com suas
características próprias. Exemplos: Pascal, Clipper, C, Visual Basic, Delphi e etc.

TÉCNICAS ATUAIS DE PROGRAMAÇÃO

 Programação Seqüencial;
 Programação Estruturada;
 Programação Orientada a Eventos e Objetos.

AÇÃO

Evento que ocorre num período de tempo finito, estabelecendo um efeito

intencionado e bem definido. Exemplos:
 Caminhar até a próxima esquina.
 Colocar um livro em cima de uma mesa.
 Atribuir o valor 3.14 a uma variável.
Estamos interessados primeiramente nos efeitos que as ações produzem.
 Ações de efeito imprevisíveis não nos interessam.
 Algoritmos determinísticos.

ESTADO

Conjunto de propriedades do objeto que são relevantes para nós na situação

desejada. Exemplos:
 Batatas com casca ou descascadas.
 Valor de uma variável em um certo instante de execução.

PROCESSO OU EVENTO
Uma seqüência temporal de ações. Exemplos:
 Trazer a cesta com batatas;
 Pegar a panela do armário;
 Descascar as batatas;
 Guardar a cesta;

PADRÕES DE COMPORTAMENTO
Vamos supor que no dia seguinte a um evento, alguém o repita.
Podemos dizer que temos o mesmo evento?
Não, pois ocorreram em MOMENTOS DIFERENTES.
O que então, eles têm em comum?
O mesmo PADRÃO DE COMPORTAMENTO.

EXERCÍCIO

1. Qual é o padrão de comportamento utilizado para gerar essa seqüência:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55
Algoritmos pág. 8

CONCEITOS BÁSICOS
DEFINIÇÕES

Algoritmo é uma seqüência de passos que visa atingir um objetivo bem

definido (FORBELLONE, 1999).
Algoritmo é a descrição de uma seqüência de passos que deve ser seguida
para a realização de uma tarefa (ASCENCIO, 1999).
Algoritmo é uma seqüência finita de instruções ou operações cuja execução,
em tempo finito, resolve um problema computacional, qualquer que seja sua
instância (SALVETTI, 1999).
Algoritmo são regras formais para a obtenção de um resultado, ou a solução
de um problema, englobando fórmulas de expressões aritméticas (MANZANO,
1997).
Concluímos que, no nosso dia-a-dia, executamos vários algoritmos como:
fazer um café da manhã, trocar a lâmpada, ir à faculdade etc.

COMO FAZER UM ALGORITMO

Precisamos ler atentamente o enunciado, definir os dados de entrada 1, o

processamento2 e os dados de saída3, utilizar um dos tipos de algoritmo e testar
através de simulações.

TESTE DE MESA

Seguir as instruções do algoritmo de maneira precisa para verificar se o

procedimento utilizado está correto ou não. Exemplo:
 Nota da Prova 1
 Nota da Prova 2
 Nota da Prova 3
 Nota da Prova 4
Utilize a tabela abaixo:

PROVA1 PROVA2 PROVA3 PROVA4 MÉDIA

CLASSIFICAÇÃO DOS ALGORITMOS

DESCRIÇÃO NARRATIVA

Após analisar o enunciado do problema o mesmo é escrito, utilizando uma

linguagem natural para descrever os passos para solucionar o problema.
VANTAGEM: não é necessário aprender nenhum conceito.
DESVANTAGEM: como utiliza uma linguagem natural pode haver várias
interpretações.

1
Dados que serão fornecidos ao sistema.
2
Transformação dos dados de entrada em dados de saída.
3
Dados gerados após serem processados.
Algoritmos pág. 9

DIAGRAMA DE BLOCOS
Também chamado de diagrama de fluxo usado na programação com o
objetivo de descrever o método e a seqüência do processo dos planos num
computador.
Após analisar o enunciado do problema o mesmo é escrito utilizando gráficos
predefinidos para descrever os passos para solucionar o problema.
VANTAGEM: o entendimento é mais padronizado.
DESVANTAGEM: é necessário conhecimento da simbologia.

FLUXOGRAMA
Usada por analistas de sistemas tem a finalidade de descrever o fluxo,
especificando os suportes usados para os dados e as informações.

PSEUDOCÓDIGO ou PORTUGOL
Após analisar o enunciado do problema o mesmo é escrito com regras
predefinidas para descrever os passos para solucionar o problema.
VANTAGEM: a passagem do algoritmo para uma linguagem de programação é
praticamente imediata.
DESVANTAGEM: aprender as regras do pseudocódigo.

SIMBOLOGIA BÁSICA PARA DIAGRAMA DE BLOCOS

Símbolo Descrição
Terminal – símbolo utilizado como ponto de início/fim
de um fluxograma.

Seta de fluxo de dados – permite indicar o sentido do

fluxo de dados. Conecta símbolos e blocos existentes.
Processamento – símbolo ou bloco que se utiliza para
indicar cálculos a serem efetuados, atribuições de
valores ou qualquer manipulação de dados.
Entrada de dados/Operação Manual – lê os dados
necessários ao programa forma de linha sem
intervenção de dispositivos eletrônicos.
Entrada e saída de dados – símbolo em função de
dispositivo qualquer de entrada ou saída de dados.
Saída de dados em vídeo – exibe os dados no
monitor.
Saída de dados na impressora – dados serão
impressos.

Decisão – possibilita desvios de acordo com a

comparação.

Conector - particiona o diagrama. É colocado uma

letra ou número dentro do símbolo de conexão.
Conector – indica que o fluxograma continua em
outra página.

Disco magnético – armazenamento de dados.

Algoritmos pág. 10

Teclado – informações recebidas ou fornecidas por

um computador.

Cartão Perfurado.

Preparação – grupo de operações não incluídas no

fluxograma, bem como na elaboração de uma chave
que modificará a execução de um programa.

Fita magnética – armazenamento de dados.

Tambor magnético – armazenamento de dados.

Disquete – armazenamento de dados.

TIPOS DE DADOS
Todos os dados possuem um tipo que pode ser classificado como:
 NUMÉRICO
Divididos em dois grupos: inteiros e reais.
INTEIROS: podem ser positivos ou negativos e não possuem parte decimal.
Quando armazenado na memória, ocupa 2 bytes por isso temos 2 8 x 28 = 216
= 65.536 possibilidades de representação dos números inteiros. A faixa de
valores varia de – 32.767 à 32.768. Exemplos: -15, 9, 0, -357, 2500.

REAIS: podem ser positivos ou negativos e possuem parte decimal. Esse tipo de
dado, quando armazenado na memória do computador, ocupa 4 bytes, por isso
temos 28 x 28 x 28x 28 = 232 = possibilidades de representação dos números
reais. A faixa de valores é maior tendo de 6 a 11 dígitos com sinal. Exemplos:
23,45, 9541,89, -78,98, -852,0. Os números reais seguem a notação inglesa
onde a parte decimal é separada da parte inteira por um ponto.

 LÓGICO
Também conhecidos como booleanos4 e assume verdadeiro ou falso, ocupando
somente 1 byte, pois possui somente duas possibilidades.

 LITERAL ou CARACTERE
Formados por um único caractere ou por vários. Podem ser letras, números 5 e
caracteres especiais: $, @, #,* e ?. Na memória, ocupa 1 byte que corresponde
a um caractere. Exemplos: ‘aluno’, ‘951’, ‘@ informática’.

VARIÁVEIS

Os algoritmos recebem dados que serão processados, para

isso, armazena os dados na memória.
Os computadores trabalham no sistema numérico do tipo
binário6 e tudo que há nele (letra, número e caracteres
especiais), é formado para este sistema numérico e cada dígito
binário ocupa uma parte da memória chamada de bytes 7 e
acessado por um endereço. Todos os caracteres possuem um

4
Álgebra de Boole
5
Não poderão ser utilizados para cálculos
6
Formado pelos dígitos 0 e 1
7
Formado por um conjunto de 8 bits
Algoritmos pág. 11
correspondente da tabela ASCII que é transformado em binário pelo método da
divisão.
Então, variável representa uma posição de memória, possuindo nome e tipo,
com conteúdo variando ao longo do tempo, durante a execução de um programa.
Ela pode assumir diversos valores, mas somente um valor por vez.

CONSTANTES

É um determinado valor fixo que não se modifica ao longo do tempo, durante

a execução de um programa. Conforme o seu tipo, a constante é classificada como
sendo numérica, lógica e literal. Exemplo: NOTA = 7;

IDENTIFICADORES
Nomes dos programas, das variáveis, das constantes, das rotinas etc. Como:
 Podemos utilizar números, letras e o caractere sublinhado (_);
 O primeiro caractere só pode ser uma letra;
 Não são permitidos caracteres especiais e espaço em branco;
 Não é permitido usar palavras reservadas8.
Exemplos: A, NOTA1, NOME, ENDERECO, X10.

EXEMPLOS
1. Faça um algoritmo que exiba o resultado da multiplicação de dois números.

DESCRIÇÃO NARRATIVA
Passo 1 – Receber dois números que serão multiplicados.
Passo 2 – Multiplicar os dois números.
Passo 3 – Exibir o resultado.

FLUXOGRAMA

M = N1 * N2
INÍCIO
N1, N2

FIM

PSEUDOCÓDICO
ALGORITMO
DECLARE N1, N2, M NUMÉRICO
ESCREVA “Digite dois números”
LEIA N1, N2
M  N1 * N2
ESCREVA “Multiplicação = ” , M
FIM_ALGORITMO.

8
Palavras que pertencem a uma linguagem de programação. Exemplo: PRINTF.
Algoritmos pág. 12

EXERCÍCIOS

1. Crie um algoritmo para sacar dinheiro no banco 24 horas.

2. Crie um algoritmo para assistir um filme no cinema.
3. Crie um algoritmo de um assunto escolhido por você.
4. Diferencie variável de constante e dê um exemplo de cada.
5. Quais são os tipos de dados e dê um exemplo de cada um.
6. Como estão classificados os algoritmos?
7. Quais são as vantagens e desvantagens do pseudocódigo?
8. Quais são as vantagens e desvantagens da descrição narrativa?
9. Crie um algoritmo (pseudocódigo, descrição narrativa e fluxograma) que entre
com o nome e exiba.
10. Crie um algoritmo (pseudocódigo, descrição narrativa e fluxograma) que entre
com quatro notas bimestrais e exiba a média aritmética.
11. Faça um teste de mesa de acordo com o fluxograma abaixo:
Algoritmos pág. 13

LINGUAGEM C/C++
Em 1970, Dennis Ritchie inventou a linguagem C e foi o primeiro a
implementá-la em um sistema operacional UNIX. É o resultado de um processo
evolutivo de linguagens. Durante anos, o padrão da linguagem C foi o fornecido
com a versão 5 do sistema operacional UNIX. Com os microcomputadores sendo
popularizados, vários outros C’s foram criados e para resolver este problema, o
ANSI9, em 1983 estabeleceu um padrão para todas as implementações da
linguagem C. A C++ é uma extensão da linguagem C e as instruções desta, são um
subconjunto do C++ e sua sintaxe é praticamente a mesma, somente
acrescentando comandos para dar suporte à programação orientada a objetos.
A linguagem C/C++ é “case-sensitive” ou seja, faz distinção entre maiúsculas
e minúsculas, portanto, todos os seus comandos são escritos em letras minúsculas
e todos os comandos são finalizados com ponto-e-vírgula (;).
Todos os programas em C têm que ter uma (e somente uma) função main
(principal), pois é esta função (em C só existem funções) que será chamada
quando o programa for executado.
A primeira etapa da implementação consiste em escrever o algoritmo
estudado na etapa anterior numa linguagem de programação, por exemplo a
linguagem C. Para essa tarefa utilizamos um editor de textos disponível no
compilador da linguagem C. O texto escrito é chamado de arquivo ou programa
fonte.
A segunda etapa, a compilação, é realizada para traduzir programas escritos
em linguagens de programação tal como C, em instruções que podem ser
executadas pela CPU do computador. O software utilizado é chamado de
compilador. A saída produzida pelo compilador é denominada arquivo-objeto.

O arquivo objeto deve ser processado pelo linker antes de ser executado. O
linker toma como entrada arquivos objeto e rotinas de biblioteca e liga-os em um
único arquivo chamado arquivo executável. Esse arquivo pode ser diretamente
executado pelo computador.

BIBLIOTECAS
Conjunto padrão de funções que realizam as tarefas necessárias mais
comuns, como por exemplo escrever no vídeo (printf), ler um caractere do teclado
(getch), entre outras. O padrão ANSI C (American National Standards Institute)
especifica o conjunto mínimo de funções que estará contido na biblioteca. No
entanto seu compilador provavelmente conterá outras funções que podem não
estar incluída em um compilador de outro fabricante.

9
American National Standards Institute
Algoritmos pág. 14

ETAPAS DA IMPLEMENTAÇÃO

include
Informa ao compilador que deve incluir no momento da compilação o arquivo
especificado. Sintaxe: #include <biblioteca> ou #include “biblioteca” (essa última
deve informar o caminho que deseja buscar o arquivo)
Como exemplo, temos as seguintes bibliotecas:
 Funções de entrada e saída  stdio.h;
 Funções padrão  stdlib.h;
 Funções matemáticas  math.h;
 Funções do sistema  system.h;
 Funções de string  string.h

DIRETIVAS define e undef

#define
Informa ao compilador para que toda vez que ele encontrar o nome do macro
no programa a ser compilado, ele deve substituí-lo pela seqüência de caracteres
fornecida.
Sintaxe: #define nome_macro seqüência_caracteres
Exemplo:
#include <stdio.h>
#define PI 3.1416
#define VERSAO "2.02"
int main()
{ printf("Programa versão %s ", VERSAO);
printf("O numero pi vale: %f ", PI);
getch(); }
Algoritmos pág. 15

#undef
Apaga a macro informada da tabela interna que armazena os macros. O
compilador passa a partir deste ponto a não conhecer mais este macro.
Sintaxe: #undef nome_macro

EXEMPLO
#include <stdio.h>
/* exemplo */
int main()
{
printf(“Bem vindo ao curso de Algoritmos!\n”);
return(0);
}

Analisando o programa temos:

 #include <stdio.h> informa ao compilador que deve incluir o arquivo-
cabeçalho informado, onde existem declarações de funções úteis para entrada e
saída de dados (std = Standard (padrão) e io =Input/Output (entrada/saída);
 /* Exemplo */ linha de comentário;
 int main() todos os programas têm essa função que será chamada quando for
executado, precisa ter um par parêntese , seu conteúdo é delimitado por chaves
{}; int indica que retorna um inteiro.
 return(0) indica o número inteiro que está sendo retornado pela função (0).

Dev-C++
Ambiente integrado de desenvolvimento para as linguagens C e C++. Ele usa
a implementação Mingw do GCC (GNU Compiler Collection) como seu compilador.
Foi desenvolvido por Colin Laplace, Mike Berg e Hongli Lai e é "Free Software" (sob
GNU General Public License). Isso significa, entre outras coisas, que ele pode ser
distribuído e copiado à vontade. O programa cria executáveis nativas no Win32,
console ou GUI. Dev-C++ também pode ser usado juntamente com Cygwin. Dev-
C++ é gratuito e de código aberto e é totalmente escrito em Delphi, que ironia
não? Por ser um trabalho em constante desenvolvimento, as versões disponíveis no
site Bloodshed Dev-C++ mudam constantemente. O compilador que é usado – o
gcc é capaz de identificar muitos erros de sintaxe nos programas. (menu
EXECUTAR – COMPILAR). Os arquivos devem ser salvos com extensão .c (c sources
files).

LISTA DE RECURSOS
 Suporte a compiladores baseados em GCC.
 Depuração integrada (usando GDB).
 Navegador de classes.
 Recurso de completar códigos.
 Navegador de depuração de variáveis.
 Gerenciador de Projetos.
 Editor com destaque de sintaxe personalizável.
 Suporte a modelos para criação dos seus próprios projetos.
 Edição e compilação de arquivos de recursos.
 Gerenciador de Ferramentas.
 Suporte a impressão.
 Facilidades de encontrar e substituir.
 Gerenciador de pacotes para facilitar a instalação e adição de bibliotecas.
 Suporte CVS.
 Lista de coisas a fazer.
 Janela de CPU.
Algoritmos pág. 16

INSTALAÇÃO E CONFIGURAÇÃO DO DEV-C++

Baixe o arquivo de instalação
devcpp-4.9.9.2_setup.exe
[9326468 bytes ou 9108 kb ou
8.9M] para uma pasta temporária.
Esse arquivo pode ser removido
depois da instalação.
Para começar a instalação,
basta clicar (duas vezes) no nome
do arquivo usando o "Windows
Explorer" e seguir os passos,
escolha o idioma Portuguese(Brasil)
e selecionar o item “No, I prefer to
use Dev C++ without it”.
Escolha o menu
FERRAMENTAS  OPÇÕES DO
COMPILADOR e em ADICIONAR OS
SEGUINTES COMANDOS QUANDO
CHAMAR O COMPILADOR, digite –
Wall –ansi-O2.

ESTRUTURA SEQÜENCIAL
ALGORITMO
DECLARE
Bloco de comandos
FIM_ALGORITMO.

DECLARAÇÃO DE VARIÁVEIS EM ALGORITMOS

São declaradas após a palavra DECLARE e os tipos mais usados são o

numérico, literal e lógico. Exemplo: X NUMERICO;

COMANDO DE ATRIBUIÇÃO EM ALGORITMOS

Atribui valores ou operações a variáveis ( ). Exemplo: X  4.

COMANDO DE ENTRADA EM ALGORITMOS

Recebe dados digitados pelo usuário e armazenados em variáveis (LEIA).

Exemplo: LEIA (X).

COMANDO DE SAÍDA EM ALGORITMOS

Exibe dados no monitor ou na impressora (ESCREVA).
Exemplo: ESCREVA X.
ESCREVA “Conteúdo de X = “ , X

REQUERIMENTOS NECESSÁRIOS

Arquivo MSVCRT.DLL (vem com o Windows 95 OSR 2 ou superior).

TIPOS DE DADOS
O C/C++ possui cinco tipos: int, float, double, void e char, com base
temos:
Algoritmos pág. 17

TIPO VALORES
Char -127 a 127
Unsigned char 0 a 255
signed char -127 a 127
Int -32.767 a 32.767
Unsigned int 0 a 65.535
Signed int -32.767 a 32.767
Short int -32.767 a 32.767
Unsigned Short Int 0 a 65,535
Signed Short Int -32.767 a 32.767
Long Int -2.147.483.647 a 2.147.483.647
Unsigned Long Int 0 a 4.294.967.295
Signed Long Int -2.147.483.647 a 2.147.483.647
Float 3.4E – 38 a 3.4E + 38
Double 1.7E – 308 a 1.7E + 308
Long double 3.4E – 4.932 a 1.1E + 4.932

Obs.: de acordo com a versão do compilador a faixa de valores pode variar. A faixa
acima está de acordo com o padrão ANSI (valor mínimo).

ESTRUTURA SEQÜENCIAL EM C/C++

#include <nome da biblioteca>
void main()
{
bloco de comandos
}

BIBLIOTECAS são arquivos contendo várias funções que podem ser

incorporadas aos programas escritos em C/C++.
#include faz com que o texto contido dentro da biblioteca seja inserido no
programa.
Exemplo: iostream.h e conio.h são bibliotecas utilizadas em comandos de
entrada e saída.

DECLARAÇÃO DE VARIÁVEIS EM C/C++

São declaradas após a especificação do seu tipo. Os tipos de dados são:

 int – números inteiros;
 float – números reais;
 char – um caractere.
Não existe o tipo de dados booleano (que assume verdadeiro ou falso), pois
qualquer valor diferente de 0 como sendo verdadeiro.
Não existe um tipo para guardar uma seqüência de caracteres (string).
Quando necessário utilizar um vetor contendo vários elementos do tipo char.
Exemplos: float x; char NOME[40]; char SEXO;

STRINGS

String é um vetor de caracteres terminado com um caractere nulo. O nulo é

um caractere com valor inteiro igual a zero(código ASCII), podendo ser escrito
assim ‘\0’. Sintaxe: char nome_string[tamanho];
Declara um vetor de caracteres(string) com número de posições (tamanho),
sempre tendo um caractere nulo reservado.
Para ler uma string fornecida pelo usuário usamos a função gets():
#include <stdio.h>
int main()
{ char string[100];
Algoritmos pág. 18
printf ("Digite uma string: ");
gets(string);
printf("\n\nFoi digitado: %s",string);
getch(); }

getche()
Usado para entrada de apenas um caracter pelo teclado e exibição na tela.
Exemplo:
#include <stdio.h>
int main(void)
{ int resposta = 0;
puts (" MENU ");
puts ("");
puts ("1. Editar");
puts ("2. Ler");
puts ("3. Gravar");
puts ("");
puts ("Resposta ");
resposta = getche();
getch();
}

OBS.: quando queremos ler um resultado, usamos as funções (encontradas

na biblioteca conio.h) getch() e getche(), e ambas retornam o caractere
pressionado, porém getche() imprime o caractere na tela antes de retorná-lo e
getch() apenas retorna o caractere pressionado sem imprimi-lo na tela. Elas não
fazem parte do padrão ANSI e podem ser substituídas pela função scanf() sem as
mesmas funcionalidades.

Exemplos

1) Podemos usar o tipo char com números inteiros, que, quando colocado %d
representa o código ASCII e quando colocado %c surge a letra propriamente
dita.
#include <stdio.h>
int main()
{
char Ch;
Ch = ‘D’;
printf (“%d”, Ch); /* Imprime o caractere como inteiro */
return(0);
}

COMANDO DE ATRIBUIÇÃO EM C/C++

A atribuição em C/C++ é feita com o sinal de igualdade (=). Os caracteres
são apresentados entre apóstrofos (‘) e a cadeira de caracteres entre aspas duplas
(“). Exemplo: x = 6; sexo = ‘M’;

COMANDOS DE ENTRADA EM C/C++

Como já visto anteriormente, recebe dados digitados pelo usuário que são
armazenados em variáveis, e, em C/C++ usamos os seguintes comandos:

cin
Armazena um valor digitado a uma variável. Exemplo: cin >> y;
Os valores são armazenados até que seja encontrado o primeiro espaço em
branco (os posteriores serão desprezados).
Algoritmos pág. 19

gets
Um ou vários caracteres digitados a uma variável. Exemplo: gets(NOME);
Utilizamos quando temos uma cadeira de caracteres contendo espaço em
branco.

scanf
Armazena um valor digitado a variável. Exemplo: scanf(&Y);
Obs.: & na frente da variável indica o seu endereço.
Tanto o comando gets quanto o scanf armazena TODA a cadeia de
caracteres até ser teclado o [ENTER].
Exemplo:
#include <stdio.h>
int main()
{
int A;
printf("Entre com valor para A: ");
scanf("%d", &A);
printf("O valor digitado foi %d", A);
getch();
}

COMANDOS DE SAÍDA EM C/C++

Como também já foi dito, é usado para exibir os dados (tanto na tela como na
impressora) e são usados os seguintes comandos:

cout
Exibe o valor que está armazenado na variável.
Exemplo: cout << Y;
cout << “Conteúdo de Y = “ << Y;

printf
Exibe o número inteiro ou real armazenado em uma variável.
Sintaxe:
printf(“%d”,Y); (número inteiro)
printf(“%f”, Y);(número real).
Argumentos
Entradas que a função recebe. É através dos argumentos que passamos
parâmetros para a função.
O primeiro argumento é uma string (seqüência de caracteres) entre aspas,
que pode ou não conter comando de formato (representado pelo % na frente da
letra):
Algoritmos pág. 20
Exemplo:
printf(“Conteúdo: %d”, Y);
printf(“%7.8f”, Y);

puts
Exibe somente textos.
Sintaxe: puts(char *string);
Exemplo:
#include <stdio.h>
void main()
{
puts("Exemplo de utilizacao");
puts("da funcao");
puts("puts...");
getch();
}

COMENTÁRIOS EM C/C++
São textos que servem para documentar o programa e totalmente ignorados
pelo compilador. Podem ocupar uma (//) ou várias linhas (/* ..... */) inserindo
estes símbolos na frente ou entre os textos comentados.
Exemplos: // comentário
/*
comentário1
*/

OPERADORES E FUNÇÕES PREDEFINIDAS EM C/C++

Possui operadores e funções predefinidas destinadas a cálculos matemáticos e
à manipulação de caracteres.

Matemáticos

OPERADOR EXEMPLO EXPLICAÇÃO

+ a+b Soma o conteúdo de a com b.
- a–b Subtrai o conteúdo de a pelo valor de b.
* a*b Multiplica o conteúdo de a pelo valor b.
/ a/b Divide o valor de a pelo valor de b.
% a%b Resto da divisão de a por b.
Somente usado em valores inteiros.
++ a++ Aumenta o conteúdo de a em um valor.
-- a-- Diminui o conteúdo de a em um valor.
+= a += b a=a+b
-= a -= b a=a–b
*= a *= b a=a*b
/= a /= b a=a/ b
%= a %= b a= a % b
^ a ^b a exponenciação em b.

Os +=, -=, *=, /= e %= são chamados de operadores matemáticos de

atribuição representa de uma maneira sintética uma operação aritmética(+, -, /,
*, %) e posteriormente uma de atribuição (=).

Relacionais

OPERADOR EXEMPLO EXPLICAÇÃO

== a == b O conteúdo de a é igual ao conteúdo de b.
Algoritmos pág. 21
!= a != b O conteúdo de a é diferente do conteúdo de b.
<= a <= b O conteúdo de a é menor ou igual ao conteúdo de b.
>= a >= b O conteúdo de a é maior ou igual ao conteúdo de b.
< a < b O conteúdo de a é menor que o conteúdo de b.
> a>b O conteúdo de a é maior que o conteúdo de b.

Matemáticas

FUNÇÃO SINTAXE EXPLICAÇÃO

ceil ceil(a) Arredonda um número real para cima.
ceil(3.2) fica 4
cos cos(a) Calcula o cosseno de a (radianos).
exp exp(a) Obtém o logaritmo natural elevado a potência de a.
fabs fabs(a) Valor absoluto de a.
floor floor(a) Arredonda um número real para baixo.
floor(3.2) é 3
log log(a) Logaritmo natural de a.
log10 log10(a) Logaritmo de base 10 de a.
modf modf(a, b) Decompõe um determinado número real em duas
partes: a (parte fracionária) e b (parte inteira).
pow pow(a, b) Potência de a elevado a b.
sin sen(a) Calcula seno de a (radianos).
sqrt sqrt(a) Calcula a raiz quadrada de a.
tan tan(a) Calcula a tangente de a (radianos).

Lógicos
Permitem que mais de uma condição seja testada em uma única expressão,
ou seja, pode-se fazer mais de uma comparação (teste) ao mesmo tempo. Temos:
NÃO, E, OU e XOR (lê-se OU EXCLUSIVO), apresentados em ordem de prioridade,
ou seja, se na mesma expressão tivermos o operador OU e depois o operador NÃO,
primeiro será executado o NÃO e depois o OU.

Operadores: AND (E)  &&

OR (OU)  ||
NOT (NÃO)  !
XOR (OU EXCLUSIVO)  ^

TABELA DA VERDADE

A B AeB A ou B não A A xou B

F F F F V F

F V F V V V

V F F V F V

V V V V F F

EXEMPLO

Faça um algoritmo que calcule em graus Celsius e apresentá-la convertida em

graus Fahrenheit. A fórmula de conversão é F  (9 * C + 160)/5 (F é em
Fahrenheit e C em Celsius).

ALGORITMO Início

C
 F (9 * C +160)/5

Algoritmos pág. 22
F
DECLARE C, F : real
LEIA C
F  ( 9 * C + 160)/ 5
ESCREVA F Fim
FIM_ALGORITMO.

#include <stdio.h>
main()
{
int C, F;
printf("Entre com a temperatura em graus Celsius: ");
scanf("%d",&C);
F = ((9 * C + 160)) /5;
printf("Temperatura em Fahrenheit = %d", F);
getch(); }

EXERCÍCIOS
1. Resolva as expressões abaixo de acordo com os tipos e valores das variáveis.
int a = 3, char carac = ‘A’

 a++ _________________________________________
 ++a _________________________________________
 a += 10 _________________________________________
 a = a++ * 10 ______________________________________
 a = ++a * 10 ______________________________________
 carac++ _________________________________________
2. Encontre o valor de A para cada passo a seguir:
#include <stdio.h>
Int main(void)
{
int A = 0; /* -----------CALCULO------------ Valor A /*
A++; ______________________________________
A +=100; ______________________________________
A *= 2; ______________________________________
A = --A – 200; ______________________________________
A = !A ; ______________________________________

A = A++ + ++A; ______________________________________

A = A; ______________________________________
A = (A > 3); ______________________________________

A = A++ + A++ + A++; ______________________________________

A = ++A + ++A + ++A; ______________________________________

}
3. O que faz o seguinte programa?
#include <stdio.h>
int main()
{ int x;
scanf(“%d”, &x);
printf(“%d”, x);
return(0); }
Algoritmos pág. 23
4. Escreva um programa que leia um caractere digitado pelo usuário, imprima este
caractere e o código ASCII correspondente.
5. Faça um programa (pseudocódigo e C/C++) que receba quatro números
inteiros, calcule e mostra a soma desses números.
6. Faça um programa (pseudocódigo e C/C++) receba três notas, calcule e
mostre a média aritmética entre elas.
7. Faça um programa (pseudocódigo e C/C++) que receba três notas e seus
respectivos pesos, calcule e exiba a média ponderada.
8. Faça um programa (pseudocódigo e C/C++) que receba o salário de um
funcionário, calcule e exiba o novo salário com um aumento de 25%.
9. Faça um programa (pseudocódigo e C/C++) que receba o salário de um
funcionário e o percentual de aumento, calcule e exiba o valor do aumento e o
novo salário.
10. Faça um programa (pseudocódigo e C/C++) que receba o salário-base de um
funcionário, calcule e mostre o salário a receber, sabendo-se que esse
funcionário tem gratificação de 5% sobre o salário-base e paga imposto de 7%
sobre o salário-base.
11. Faça um programa (pseudocódigo e C/C++) que receba o salário-base de um
funcionário, calcule e mostre o seu salário a receber, sabendo-se que esse
funcionário tem gratificação de R$ 50,00 e paga imposto de 10% sobre o
salário-base.
12. Faça um programa (pseudocódigo e C/C++) que receba o valor de um depósito
e o valor da taxa de juros e calcule e exiba o valor do rendimento e o valor total
depois do rendimento.
13. Faça um programa que calcule e exiba a área de um triângulo (AREA = (BASE *
ALTURA) / 2.

14. Faça um programa que calcule e mostre a área de um círculo. (AREA = ∏R2).
15. Faça um programa que receba um número positivo e maior que zero, calcule e
exiba:
a) número digitado ao quadrado;
b) número digitado ao cubo;
c) raiz quadrada do número digitado;
d) raiz cúbica do número digitado.
16. Faça um programa (pseudocódigo e C/C++) que receba dois números maiores
que zero, calcule e mostre um elevado ao outro.
17. Faça um programa (pseudocódigo e C/C++) que receba uma medida de pés,
faça as conversões e exiba os resultados:
a) polegadas10;
b) jardas11;
c) milhas12.
18. Faça um programa (pseudocódigo e C/C++) que receba o ano de nascimento de
uma pessoa e o ano atual, calcule e exiba:
a) idade da pessoa;
b) quantos anos essa pessoa terá em 2009.
19. Faça um programa (pseudocódigo e C/C++) que receba o preço de fábrica de
um veículo13, o percentual de lucro do distribuidor e o percentual de impostos.
Calcule e exiba:
a) valor correspondente ao lucro do distribuidor;
b) valor correspondente aos impostos;

10
1 pé = 12 polegadas
11
1 jarda = 3 pés
12
1 milha = 1.760 jardas
13
O custo ao consumidor de um carro novo é a soma do preço de fábrica com o percentual de lucro do
distribuidor e dos impostos aplicados ao preço de fábrica.
Algoritmos pág. 24
c) preço final do veículo.
20. Faça um programa (pseudocódigo e C/C++) que receba o número de horas
trabalhadas e o valor do salário mínimo. Calcule e exiba o salário a receber e
seguir as regras:
a) hora trabalhada vale a metade do salário mínimo;
b) salário bruto equivale ao número de horas trabalhadas multiplicado pelo
valor da hora trabalhada;
c) imposto equivale a 3% do salário bruto;
d) salário a receber equivale ao salário bruto menos o imposto.
21. Um trabalhador recebeu seu salário e depositou em conta bancária. Emitiu dois
cheques e agora deseja saber qual o saldo atual. Sabe-se que cada retirada
bancária paga CPMF de 0,38% e o saldo inicial da conta está zerado.
22. Porsidônio comprou um saco de ração com peso em quilos. Possui dois gatos
para os quais fornece a quantidade de ração em gramas. Faça um programa
(pseudocódigo e C/C++) que receba o peso do saco de ração e a quantidade de
ração fornecida para cada gato. Calcule e exiba quanto restará de ração no saco
após cinco dias.
23. Cada degrau de uma escada tem n de altura. Faça um programa (pseudocódigo
e C/C++) que receba essa altura e a altura que o usuário deseja alcançar
subindo essa escada. Calcule e exiba quantos degraus o usuário deverá subir
para atingir seu objetivo, sem se preocupar com a altura do usuário.
24. Faça um programa (pseudocódigo e C/C++) que receba o custo de um
espetáculo teatral e o preço do convívio desse espetáculo. Deve calcular e exibir
a quantidade de convites que devem ser vendidos para que pelo menos o custo
do espetáculo seja alcançado.

RECURSIVIDADE
Podemos fazer com que uma função chame a si própria, a isto, chamamos de
função recursiva. Precisamos sempre, ter um critério de parada, pois este,
determina quando a função deve parar de chamar a si mesma, impedindo que a
função fique infinita.
Exemplo: Crie uma função que calcule o fatorial de um número inteiro:
#include <stdio.h>
int fat(int n)
{
if (n)
return n*fat(n-1);
else return 1;
}
int main()
{
int n;
printf("\n\nDigite um valor para n: ");
scanf("%d", &n);
printf("\nO fatorial de %d e %d", n, fat(n));
getch();
}

Interpretando: Enquanto n não for igual a 0, a função fat chama a si mesma

cada vez com um valor menor e, n=0 é o critério de parada da função.
Algoritmos pág. 25

ESTRUTURA CONDICIONAL (Controle de Fluxo)

ALGORITMOS

SE condição
ENTÃO comando

Se a condição for verdadeira o comando é executado. Essa condição será uma

comparação que possui dois valores: verdadeiro ou falso.
SE condição
ENTÃO INICIO
Comando1
Comando2
Comando3
FIM

ESTRUTURA CONDICIONAL COMPOSTA

SE condição
ENTÃO INICIO
comando1
comando2
FIM
SENÃO INÍCIO
comando3
comando4
FIM

C/C++
SIMPLES - IF

IF (condição)
{
comando1;
comando2;
}

Se a condição for verdadeira o comando será executado.

Quando há mais de um comando é obrigatório utilizar as chaves ({}).
Ex.: Entre com um número e verifique se é igual, menor ou maior que 10.
#include <stdio.h>
int main()
{
int num;
printf("Digite um numero: ");
scanf("%d",&num);
if (num>10) printf("\n\nNumero maior que 10");
if (num==10)
{
printf("\n\Acertou!\n");
printf("Numero igual a 10.");
}
if (num<10) printf("\n\nNumero menor que 10");
getch();
}
Algoritmos pág. 26

COMPOSTA – IF/ELSE
if (condição)
{
comando1;
comando2;
}
else
{
comando3;
comando4;
}
Se a condição for verdadeira o comando será executado, caso contrário (se
for falso) será executado a segunda rotina. As condições devem estar entre
parênteses.
Exemplo: Criar um menu
#include <stdio.h>
void main()
{
char opcao;
puts ("MENU");
puts ("");
puts ("1. Incluir ");
puts ("2. Excluir ");
puts ("3. Alterar ");
puts ("4. Sair ");
printf("Entre com a opção: [ ]\b\b");

opcao = getche();
if (opcao == '1')
printf ("\n INCLUSAO");
else if (opcao == '2')
printf ("\n EXCLUSAO");
else if (opcao == '3')
printf ("\n ALTERACAO");
else if (opcao == '4')
printf ("\n SAIR");
else
puts("\nEscolha opção correta");
getch();
}

ESTRUTURA CASE - SWITCH

switch (variável)
{
case valor1 : lista de comandos;
break;
case valor2: lista de comandos;
break;
...
default: lista de comandos;
}

O comando switch acima avalia o valor de uma variável para decidir qual
case será executado. E cada case é associado a uma variável.
O comando break é utilizado para impedir que sejam executados os
comandos definidos nos cases seguintes.
Quando o valor da variável não coincidir com aqueles especificados nos cases
será executado em default.
Algoritmos pág. 27
Exemplo: Criação de menus
#include <stdio.h>
void main()
{
char opcao;
puts ("MENU");
puts ("");
puts ("1. Incluir ");
puts ("2. Excluir ");
puts ("3. Alterar ");
puts ("4. Sair ");
printf("Entre com a opção: [ ]\b\b");

opcao = getche();
switch (opcao)
{
case '1' : printf("\nInclusao"); break;
case '2' : printf("\nExclusao"); break;
case '3' : printf("\nAlteracao"); break;
case '4' : printf("\nSair"); break;
default : puts("\nEscolha uma opcao correta"); break;
}
getch();
}

OPERADORES LÓGICOS
Podem ser: &&, || e ! significam respectivamente e, ou e não (conjunção,
disjunção e negação).

EXEMPLO
1. Faça um programa que receba as quatro notas bimestrais de um aluno e
imprima uma mensagem dizendo se está aprovado ou reprovado, se a média
for maior ou igual a 4. Apresentar junto, a mensagem a média do aluno.

ALGORITMO
DECLARE bim1, bim2, bim3, bim4, media : real
LEIA bim1, bim2, bim3, bim4
media  (bim1 + bim2 + bim3 + bim4)/ 4
SE (media >= 5) ENTÃO
ESCREVA “Aluno aprovado com média: ”, media
SENÃO
ESCREVA “Aluno reprovado com média: ”, media
FIM_SE
FIM_ALGORITMO.

#include <stdio.h>
int main()
{

int media, bim1, bim2,bim3, bim4;

printf("Entre com as 4 notas bimestrais: ");
scanf("%d",&bim1);
scanf("%d",&bim2);
scanf("%d",&bim3);
scanf("%d",&bim4);
media = (bim1 + bim2 + bim3 + bim4)/4;
if (media >= 5)
printf("Aluno aprovado com media %d", media);
else
printf("Aluno reprovado com media %d", media);
getch();
}
Algoritmos pág. 28

Início

bim1, bim2, bim3, bim4

media = (bim1+bim2+bim3+bim4)/4

media >= 5

“Reprovado”, media “Aprovado”, media

Fim

EXERCÍCIOS
1. A média final de um estudante é calculada com base em três notas atribuídas a um
trabalho prático (peso 2), avaliação semestral (peso 3) e exame final (peso 5). A média
das três notas é dada com base nos pesos.
Faça um programa (pseudocódigo e C/C++) que receba as três notas, calcule, exiba a
média ponderada e a conceito:
MÉDIA PONDERADA CONCEITO
8,0  10,0 A
7,0  8,0 B
6,0  7,0 C
5,0  6,0 D
0,0  5,0 E
2. Faça um programa (pseudocódigo e C/C++) que receba três notas de um aluno, calcule
e exiba a média aritmética de acordo com a tabela. Para alunos de exame calcule e exiba
a nota que deverá ser tirada no exame para aprovação, considerando que a média no
exame é 6,0.
MÉDIA PONDERADA MENSAGEM
0,0  3,0 Reprovado
3,0  7,0 Exame
7,0  10,0 Aprovado
3. Faça um programa (pseudocódigo e C/C++) que receba dois números e mostre o maior.
4. Faça um programa (pseudocódigo e C/C++) que receba três números e mostre em
ordem crescente.
5. Faça um programa (pseudocódigo e C/C++) que receba três números obrigatoriamente
em ordem crescente um quarto número que não siga esta regra. Exiba os quatro
números em ordem decrescente.
6. Faça um programa (pseudocódigo e C/C++) que receba um número inteiro e verifique se
esse número é par ou ímpar.
Algoritmos pág. 29
7. Faça um programa (pseudocódigo e C/C++) que receba quatro valores: I, A, B e C, onde
I é um valor inteiro positivo e os outros são valores reais. Escreva os números reais de
acordo com a tabela abaixo
VALOR DE I FORMA DE ESCREVER
1 A,B,C em ordem crescente
2 A,B,C em ordem decrescente
3 O maior fica entre os outros dois n’s.
8. Faça um programa (pseudocódigo e C/C++) que exiba um menu de opções e receba a
opção do usuário e os dados necessários para executar cada operação:
MENU DE OPÇÕES
1. Somar dois números;
2. Raiz quadrada de um número;
Digite a opção desejada.
9. Faça um programa (pseudocódigo e C/C++) que exiba a data e a hora do sistema nos
formatos: dia/mês/ano – mês por extenso e hora:minuto.
10. Faça um programa (pseudocódigo e C/C++) que determine a data cronologicamente
maior de duas datas fornecidas pelo usuário. Cada data deve ser fornecida por três
valores inteiros, onde o primeiro representa o dia, o segundo o mês e o terceiro o ano.
11. Faça um programa (pseudocódigo e C/C++) que receba a hora de início de um jogo e a
hora final do jogo (cada hora é composta por duas variáveis inteiras: hora e minuto).
Calcule e exiba a duração do jogo (horas e minutos) sabendo-se que o tempo máximo de
duração do jogo é de 24 horas e que o jogo pode iniciar em um dia e terminar no dia
seguinte.
12. Faça um programa (pseudocódigo e C/C++) que receba o código correspondente ao
cargo de um funcionário e seu salário atual e exiba o cargo, o valor do aumento e o seu
novo salário. Os cargos estão abaixo:
CODIGO CARGO PERCENTUAL
1 Escriturário 50%
2 Secretário 35%
3 Caixa 20%
4 Gerente 10%
5 Diretor Não tem aumento
13. Faça um programa (pseudocódigo e C/C++) que apresente o menu de opções a seguir,
permita ao usuário escolher a opção desejada, receba os dados necessários para
executar a operação e exibir o resultado. Verifique a possibilidade de opção inválida e
não se preocupe com restrições como salário negativo.
MENU DE OPÇÕES:
1. Imposto
2. Novo salário
3. Classificação
Digite a opção desejada.
TEM TRÊS OPÇÕES
SALÁRIO PERCENTUAL DO IMPOSTO
Menor que R$ 500,00 5%
De R$ 500,00 a R$ 850,00 10%
Acima de R$ 850,00 15%
SALÁRIO AUMENTO
Maiores que R$ 1.500,00 R$ 25,00
De R$ 750,00 a R$ 1.500,00 (inclusive) R$ 50,00
De R$ 450,00 a R$ 750,00 R$ 75,00
Menores que R$ 450,00 R$ 100,00
SALÁRIO CLASSIFICAÇÃO
Até R$ 700,00 (inclusive) Mal remunerado
Maiores que R$ 700,00 Bem remunerado
14. Faça um programa (pseudocódigo e C/C++) que receba o salário de um funcionário,
calcule e exiba o novo salário desse funcionário com a bonificação e o auxílio-escola
SALÁRIO BONIFICAÇÃO
Até R$ 500,00 5%
Entre R$ 500,01 e R$ 1.200,00 12%
Acima de R$ 1.200,00 Sem bonificação
SALÁRIO AUXILIO-ESCOLA
Até R$ 600,00 R$ 150,00
Mais de R$ 600,00 R$ 100,00
15. Faça um programa (pseudocódigo e C/C++) que receba o valor do salário mínimo, o
número de horas trabalhadas, o número de dependentes do funcionário e quantidade de
horas extras trabalhadas. Calcule e exiba o salário a receber do funcionário de acordo
com as regras:
Algoritmos pág. 30
- valor da hora trabalhada é igual a 1/5 do salário mínimo;
- salário do mês é igual ao número de horas trabalhadas multiplicado pelo valor da hora
trabalhada.
16. Um supermercado deseja reajustar os preços de seus produtos usando o seguinte
critério: o produto poderá ter seu preço elevado ou reduzido. Para alterar o preço o
produto deve preencher pelo menos um dos requisitos a seguir:
VENDA MÉDIA MENSAL PREÇO TOTAL %AUMENTO %DESCONTO
< 500 < R$ 30,00 10 -
>= 500 E < 1200 >= R$ 30,00 e < R$ 800 15 -
>= 1200 >= R$ 80,00 - 20
17. Com três valores dados: A, B, e C, verifique se eles podem ser os comprimentos dos
lados de um triângulo e, se forem, verificar se é um triângulo eqüilátero, isósceles ou
escaleno. Se não formarem um triangulo deve escrever uma mensagem. OBS.:
- comprimento de cada lado de um triângulo é menor que a soma dos outros dois lados;
- chama-se triângulo eqüilátero, o triângulo que tem três lados iguais.
18. Faça um programa que receba a altura e o peso de uma pessoa. De acordo com a tabela
abaixo e exiba a classificação da pessoa:

ALTURA PESO
ATÉ 60 Entre 60 a 90 Acima de 90
Menores que 1,20 A D G
De 1,20 a 1,70 B E H
Maiores que 1,70 C F I
Algoritmos pág. 31

ESTRUTURA DE REPETIÇÃO
ALGORITMOS
NÚMERO DEFINIDO DE REPETIÇÕES (ESTRUTURA PARA)

Utilizada quando sabemos o número de vezes em que um trecho do algoritmo

deve ser repetido (incrementando de um em um automaticamente).

PARA I  valor inicial ATÉ valor final FAÇA

INICIO
comando1
comando2
comando3
FIM

Exemplo: PARA I  1 ATÉ 10 FAÇA

comando1 // será executado 10 vezes.

NÚMERO INDEFINIDO DE REPETIÇÕES E TESTE DE INÍCIO

(ESTRUTURA ENQUANTO)

Utilizada quando não se sabe o número de vezes em que um trecho do

algoritmo deve ser repetido, embora também possa ser utilizada quando se sabe
esse número. Há situações que o teste condicional no início da estrutura repetição
resulta em valor falso na primeira comparação sendo assim os comandos não são
executados.

ENQUANTO condição FAÇA

INICIO
comando1
comando2
FIM

Exemplo: x  1
y5
ENQUANTO x < y FAÇA
INÍCIO
xx+2
yy+1
FIM
Simulação
X Y
1 5 Iniciais
3 6
5 7
7 8
9 9

NÚMERO INDEFINIDO DE REPETIÇÕES E TESTE NO FINAL

(ESTRUTURA REPITA)
Utilizada quando não se sabe o número de vezes em que um trecho do
algoritmo deve ser repetido, embora também possa ser utilizada quando se sabe
esse número.
Algoritmos pág. 32
A diferença entre ENQUANTO e REPITA é que na última os comandos serão
repetidos pelo menos uma vez, já que a condição se encontra no final.
REPITA
Comandos
ATÉ condição

Os comandos são repetidos enquanto a condição for verdadeira.

Exemplo: x1
y5
REPITA
xx+2
yy+1
ATÉ x >= y
Simulação
X Y
1 5 Iniciais
3 6
5 7
7 8
9 9

C/C++
for
Utilizada quando conhecemos o número de vezes que um trecho deverá ser
repetido.
Sintaxe: for (i=valor inicial; condição; incremento ou decremento de i)
comando;

É atribuído um valor inicial à variável i que controla o número de repetições.

Depois uma expressão relacional que quando for falso, finaliza a repetição. Por
último, altera o valor da variável i (incrementando ou decrementando).
Exemplo1: for (a=1;a<=20;a++)
printf("Digite um número %d", a);

Exemplo prático: Lê um string e conta quantos caracteres desta string:

#include <stdio.h>
int main()
{
char string[100]; /* string ate 99 caracteres */
int i, cont;
printf("\nDigite uma frase: ");
gets(string); /* Le a string */
printf("\n\nFrase digitada: \n%s", string);
cont = 0;
for (i = 0; string[i] |= '\0'; i=i+1)
{
if (string[i] == 'c') /* se for a letra 'c' */
cont = cont + 1; /* incrementa contador */
}
printf("\nNumero de caracteres c= %d", cont);
getch();
}

Exercício: Crie um programa que imprima o alfabeto de A até Z.

Algoritmos pág. 33

break
Utilizado para interrompe qualquer tipo de repetição.

continue
Permite que não se execute o restante do bloco, passando para o próximo.
Não interrompe o loop apenas para para o próximo sem completar o atual.

while
Utilizada quando o número de repetição não é fixo. Os comandos serão
repetidos até a condição assumir o valor falso. Quando o teste condicional ocorre
no início, a possibilidade da repetição não ser executada, quando a condição for
falsa. Sintaxe: WHILE (condição)
{
comando1;
N
comando2;
……………..
} S
Exemplo: soma todos números inteiros entre 1 e 1000
#include <stdio.h>
main()
{
long i = 1000, soma = 0;
while (i)
soma += i--;
printf("\nSoma encontrada foi %ld", soma);
getch();
}

do-while
Utilizada quanto o número de repetições necessárias não é fixo. Os
comandos serão repetidos até a condição assumir valor falso. Nesse tipo de
estrutura o teste condicional ocorre no fim, garantindo a execução de pelo menos
uma vez. Sintaxe: do
{
comandos;
}
while (condição);
Exemplo: Some todos os números inteiros entre 1 e 100:
#include <stdio.h>
main()
{
long i = 1000, soma = 0; N
do
soma += i--; S
while (i);
printf("\nSoma encontrada foi %ld", soma);
getch();
}
Algoritmos pág. 34

EXEMPLOS

Apresentar o total da soma dos cem primeiros números inteiros

(1+2+3+4+5+6+7+…+97+98+100).

ALGORITMO Início
DECLARE soma, contador : inteiro
soma  0
PARA contador de 1 até 100 passo 1 FAÇA Soma 0
soma  soma + contador
FIM_PARA
FIM_ALGORITMO

#include <stdio.h>
int main(void) Contador1,100,1
{
int soma, contador;
soma = 0;
for (contador=1;contador<=100;contador++) Soma Soma + Contador
{
soma = soma + contador;
}
printf("%d", soma);
getch();
} Soma

fim
EXERCÍCIOS
1. Um funcionário de uma empresa recebe aumento salarial anualmente. Sabe-se
que:
a) esse funcionário foi contratado em 1995 com salário inicial de R$ 1.000,00;
b) em 1996 recebeu aumento de 1,5% sobre seu salário inicial;
c) a partir de 1997 (inclusive), os elementos salariais sempre corresponderam
ao dobro do percentual do ano anterior. Faça um programa que determine o
salário atual desse funcionário.
2. Faça um programa que leia N e que indique quantos valores inteiros e positivos
devem ser lidos a seguir. Para cada número lido, mostre uma tabela contendo o
valor lido e o fatorial desse valor.
3. Faça um programa que leia cinco pares de valores (a, b), todos inteiros e
positivos, um de cada vez. Mostre os números inteiros pares de a até b
(inclusive).
4. Faça um programa que leia dez conjuntos de dois valores, o primeiro
representando o número do aluno e o segundo representando a sua altura em
centímetros. Encontre o aluno mais alto e o mais baixo. Exiba o número do
aluno mais alto e o número do aluno mais baixo junto com suas alturas.
5. Foi feita uma estatística em cinco cidades brasileiras para coletar dados sobre
acidentes de trânsito. Foram obtidos os seguintes dados:
a) código da cidade;
b) número de veículos de passeio (1999);
c) número de acidentes de trânsito com vítimas (1999).
Deseja-se saber:
a) maior e o menor índice de acidentes de trânsito e a que cidades pertencem;
b) média de veículos nas cinco cidades unidas;
c) média de acidentes de trânsito nas cidades com menos de 2.000 veículos de
passeio.
6. Uma empresa possui dez funcionários com as seguintes características: código,
número de horas trabalhadas no mês, turno de trabalho (matutino, vespertino
ou noturno), categoria (operária ou gerente), valor da hora trabalhada.
Algoritmos pág. 35
Sabendo-se que essa empresa deseja informatizar sua folha de pagamento,
faça um programa que:
a) Leia as informações dos funcionários, exceto o valor da hora trabalhada, não
permitindo que sejam informados turnos nem categorias inexistentes. Trabalhar
sempre com a digitação de letras maiúsculas;
b) calcule o valor da hora trabalhada, conforme abaixo:

CATEGORIA TURNO VALOR DA HORA TRABALHADA

G N 18% do salário mínimo
G M ou V 15% do salário mínimo
O N 13% do salário mínimo
O M ou V 10% do salário mínimo

Adote o valor de R$ 350,00 para o salário mínimo.

c) calcule o salário mínimo dos funcionários com base no valor da hora
trabalhada e no número de horas trabalhadas.
d) calcule o valor do auxílio-alimentação recebido por funcionário de acordo com
o seu salário inicial, conforme a tabela a seguir:
SALÁRIO INICIAL AUXILIO-ALIMENTAÇÃO
Até R$ 300,00 20% do salário inicial
Entre R$ 300,00 e R$ 600,00 15% do salário inicial
Acima de R$ 600,00 5% do salário inicial

7. uma empresa contratou 15 funcionários temporários. De acordo com o valor das

vendas mensais, os funcionários adquirem pontos que determinarão seus
salários ao final de cada mês. Sabemos que esses funcionários trabalharão nos
meses de novembro a janeiro do ano subseqüente. Faça um programa que:
a) leia as pontuações nos três meses de cada funcionário;
b) calcule e exiba a pontuação geral de cada funcionário nos três meses;
c) calcule e exiba a média das pontuações de cada funcionário nos três meses;
d) determine e exiba a maior pontuação atingida entre todos os funcionários
nos três meses.
8. Faça um programa que monte os oito primeiros termos da seqüência de
Fibonacci: 0-1-1-2-3-5-8-13-21-34-55-....
9. Faça um programa que receba duas notas de seis alunos, calcule e exiba:
a) média aritmética das duas notas de cada aluno;
b) mensagem de acordo com a tabela:
MÉDIA ARITMÉTICA MENSAGEM
Até 3,0 Reprovado
Entre 3,0 e 7,0 Exame
Acima de 7,0 Aprovado
10. Faça um programa que calcule a soma dos primeiros 50 números pares. Esse
programa não recebe valor do teclado. Os primeiros números são: 2, 4, 6,...
11. Um campeonato de futebol existem cinco times e cada time possui onze
jogadores. Faça um programa que receba a idade, o peso e a altura de cada um
dos jogadores, calcule e exiba:
- quantidade de jogadores com idade inferior a 18 anos;
- média das idades dos jogadores de cada time;
- média das alturas de todos os jogadores do campeonato;
- percentagem de jogadores com mais de 80 quilos entre todos os jogadores do
campeonato.
12. Faça um programa que receba dois números, calcule e exiba:
a) soma dos números pares desse intervalo de números, incluindo os números
digitados;
b) multiplicação dos números ímpares desse intervalo de números, incluindo os
números digitados.
13. Faça um programa que receba um número inteiro maior que 1 e verifique se o
número fornecido é primo ou não. Exibir mensagem de número primo ou de
número não primo. OBS. Número primo quando é divisível apenas pelo próprio
número e por ele mesmo.
Algoritmos pág. 36
14. Em uma fábrica trabalham homens e mulheres divididos em três classes:
a) trabalhadores que fazem até 30 peças por mês – classe 1;
b) trabalhadores que fazem de 31 a 35 peças por mês – classe 2;
c) trabalhadores que fazem mais de 35 peças por mês – classe 3.
A classe 1 recebe salário mínimo. A classe 2 recebe salário mínimo mais 3% do
salário mínimo por peça, acima das 30 peças iniciais. A classe 3 recebe salário
mínimo mais 5% do salário mínimo por peça, acima das 30 peças iniciais.
Faça um programa que receba o número do operário, número de peças
fabricadas no mês, o sexo do operário e que também calcule e mostre:
- o número do operário e seu salário;
- total da folha de pagamento da fábrica;
- o número total de peças fabricadas no mês;
- a média de peças fabricadas pelos homens;
- a média de peças fabricadas pelas mulheres;
- o número do operário ou operária de maior salário.
A fábrica tem 15 operários.
15. Foi feita uma pesquisa para determinar o índice de mortalidade infantil em um
certo período. Faça um programa que:
a) leia o número de crianças nascidas no período;
b) o sexo (M ou F) e o tempo de vida para cada criança nascida.
Calcule e exiba:
a) percentagem de crianças do sexo feminino mortas no período;
b) percentagem de crianças do sexo masculino mortas no período;
c) percentagem de crianças que viveram 24 meses ou menos no período.
16. Faça um programa que receba o valor de uma dívida e exiba uma tabela com os
seguintes dados: valor da dívida, valor dos juros, quantidade de parcelas e o
valor da parcela. Os juros e a quantidade de parcelas seguem-se abaixo:

QUANTIDADE DE PARCELAS % JUROS SOBRE O VALOR INICIAL DA DÍVIDA

1 0
3 10
6 15
9 20
12 25

Exemplos de saída do programa:

VALOR DA DÍVIDA JUROS QTDE PARCELAS VALOR DA PARCELA
R$ 1000,00 0 1 R$ 1000.00
R$ 1100,00 100 3 R$ 366,67
R$ 1150,00 150 6 R$ 191,67
17. Faça um programa que determine e exiba os cincos primeiros múltiplos de 3,
considerando números maiores que 0.
18. Faça um programa para calcular a área de um triângulo. Esse programa não
pode permitir a entrada de dados inválidos, ou seja, medidas menores ou iguais
a 0.
19. Faça um programa que receba o salário de um funcionário chamado Porsidonio.
Sabe-se que o funcionário Godofredo tem um salário equivalente a um terço do
salário de Porsidonio e ele aplicará seu salário integralmente na caderneta de
poupança, que está rendendo 2% ao mês e Godofredo aplicará seu salário
integralmente no fundo de renda fixa, que está rendendo 5% ao mês. Calcule e
exiba a quantidade de meses necessários para que o valor pertencente a João
iguale ou ultrapasse o valor pertencente a Carlos.
Algoritmos pág. 37

VETORES
ALGORITMOS

Vetor ou array é uma variável composta homogênea unidimensional formada

por uma seqüência de variáveis, todas do mesmo tipo, mesmo identificados (nome)
e alocadas seqüencialmente na memória. Uma vez que as variáveis têm o mesmo
nome, o que as distingue é um índice que referencia sua localização dentro da
estrutura.

DECLARAÇÃO DO VETOR

Declare nome [tamanho] tipo

Exemplo: DECLARE x[5] NUMÉRICO

X
1 2 3 4 5
x[1]

ATRIBUINDO VALORES AO VETOR

X[1]  50
X[4]  9

X 50 9
1 2 3 4 5

CARREGANDO UM VETOR

PARA i  1 ATÉ 5 FAÇA

INÍCIO
ESCREVA “Digite o ”, i, “º número”
LEIA X[i]
FIM

C/C++
DECLARAÇÃO DO VETOR

Os vetores são identificados pela existência de colchetes logo após o nome da

variável no momento da declaração. Dentro dos colchetes deve-se colocar o
número de posições do vetor.
Exemplos:

int ver[10];
Este vetor possui 10 posições iniciando com 0 e terminando em 9 em cada
posição podemos armazenar números inteiros (int)

char x[5];
Este, possui cinco posições, começando pela posição 0 e indo até a 4.

ATRIBUINDO VALORES AO VETOR

Exemplos:
vet[0] = 1; /*Atribui valor 1 ao primeiro elemento do vetor.*/
Algoritmos pág. 38

strcpy(nome, “Genoveva”);
Atribui o nome Genoveva ao vetor nome, declarado assim: char nome[6].

CARREGANDO UM VETOR
Lê os dados do teclado, atribuindo a um vetor.
for (i = 0; i <10;i++)
cin >> vetor[i];

IMPRIMINDO UM VETOR
for (i=0; i<10;i++)
cout << vetor[i];

Exemplo: Receber cinco notas de aluno, calcular a média e exibir o resultado:

#include <stdio.h>
#include <conio.h>
int main(void)
{
int i;
float media;
float nota[5];
for (i=0; i<5; i++)
{
printf("\nEntre com a %d nota: ", i+1);
scanf("%f", &nota[i]);
}
media = (nota[0]+nota[1]+nota[2]+nota[3]+nota[4])/5;
printf ("\nMedia das notas: %3.1f", media);
getch();
}

EXEMPLO
1. Criar um programa que efetue a leitura dos nomes de 20 pessoas e em seguida
apresentar na mesma ordem em que foram informados.
ALGORITMO
DECLARE nome[20] : caractere início
i : inteiro
PARA i de 1 até 20 passo 1 FAÇA
LEIA nome[i]
FIM_PARA i1,20,1
PARA i de 1 até 20 passo 1 FAÇA
ESCREVA nome[i]
FIM_PARA
FIM_ALGORITMO. nome[i]

#include <stdio.h>
main()
{
i1,20,1
char nome[20];
int i;
for (i=0;i<=20;i++)
printf("\nEntre com o %d nome: %s", i,nome[i]);
scanf("%s",&nome[i]); nome[i]
for (i=0;i<=20;i++)
printf("\Nome: %s", nome[i]);
getch(); } fim
Algoritmos pág. 39
2. Receber as notas de cinco alunos, calcular a média geral da turma e verificar
quantos conseguiram ficar acima da média:

ALGORITMO
DECLARE soma, media, conta NUMERICO
PARA x de 1 ATÉ 5 FAÇA
INICIO
LER nota[x]
soma  soma + nota[x]
FIM
FIM_PARA
Media  soma / 10
PARA n de 1 ATÉ 5 FAÇA
SE nota[n] > media Então
Conta  conta + 1
FIM_SE
FIM_PARA
FIM_ALGORITMO.

#include <stdio.h>
#include <string.h>
int main()
{
int x, conta;
double nota[5];
double soma, media;
soma = 0.0;
media = 0.0;
conta = 0;
for (x=0;x<5;x++)
{
scanf("%lf",&nota[x]);
soma = soma + nota[x];
}
media = soma / x;
for (x=0;x<5;x++)
{
if (nota[x] > media)
conta = conta + 1;
}
printf("%lf %d\n", media);
printf("%lf %d\n", conta);
getch();
}

3) Exemplo de ordenação de valores (ascendente) utilizando o define.

#include <stdio.h>
#define tamanho 10
main()
{
int a[tamanho] = {2, 4, 5, 6, 7, 89, 10, 12, 11,50};
int i, pass, hold;

printf ("Itens na ordem original\n");

for (i=0;i<=tamanho-1;i++)
printf("%4d",a[i]);

for (pass=1;pass<=tamanho-1;pass++) /* passadas */

for (i=0;i<=tamanho-2;i++) /*uma passada*/
if (a[i] > a[i+1]) /* comparação*/
Algoritmos pág. 40
{
hold = a[i];
a[i] = a[i +1];
a[i + 1]= hold;
}
printf("\nItens de dados na ordem ascendente\n");
for (i=0;i<=tamanho-1;i++)
printf("%4d",a[i]);
printf("\n");
getch();
}

EXERCÍCIOS

1. Faça um programa que carregue um vetor de nove elementos numéricos

inteiros, calcule e exiba os números primos e suas respectivas posições.
2. Faça um programa que receba a quantidade de peças vendidas por vendedor e
armazene essas quantidades em um vetor. Recebe também o preço da peça
vendida de cada vendedor e armazene esses preços em outro vetor. Existem
apenas 10 vendedores e cada vendedor pode vender apenas um tipo de peça,
isto é, para cada vendedor existe apenas um preço. Calcule e exiba a
quantidade total de peças vendidas por todos os vendedores e para cada
vendedor calcule e exiba o valor total da venda (quantidade de peças * preço
de peça).
3. Faça um programa que carregue dois vetores de dez elementos numéricos cada
um e exiba um vetor resultante da intercalação desses dois vetores.
Vetor1 3 5 4 2 2 5 3 2 5 9
1 2 3 4 5 6 7 8 9 10

Vetor2 3 5 4 2 2 5 3 2 5 9
1 2 3 4 5 6 7 8 9 10

4. Faça um programa que carregue um vetor com oito números inteiros, calcule e
exiba dois vetores resultantes. O primeiro vetor resultante deve contar os
números positivos e o segundo, os números negativos. Cada vetor resultante
vai ter no máximo oito posições, sendo que nem todas devem ser
obrigatoriamente utilizadas.
5. Faça um programa que carrega um vetor com 10 números inteiros. Calcule e
exiba um vetor resultante ordenando de maneira decrescente.

X 3 5 4 2 1 6 8 7 11 9
1 2 3 4 5 6 7 8 9 10

Ordenado 11 9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 10

6. Faça um programa que no momento de carregar um vetor com oito números

inteiros já o carregue de maneira ordenada crescente.
7. Faça um programa que efetue reserva de passagens aéreas de uma certa
companhia. O programa deverá ler informações sobre os vôos (número, origem
e destino) juntamente com o número de lugares disponíveis para 12 aviões (um
vetor para cada um desses dados). O programa deverá apresentar um menu
com as seguintes opções:
 Consultar;
 Efetuar reserva;
 Sair
Quando a opção escolhida for Consultar deverá ser disponibilizado mais um
menu com as seguintes opções:
 Número de vôo;
Algoritmos pág. 41
 Origem;
 Destino.
Quando a opção escolhida for EFETUAR RESERVA deverá ser perguntado o
número do vôo no qual a pessoa deseja viajar. O programa deverá dar as
seguintes respostas:
 Reserva confirmada – caso exista o vôo e lugar disponível dando baixa nos
lugares disponíveis;
 Vôo lotado – caso não exista lugar disponível nesse vôo;
 Vôo inexistente – caso o código do vôo não exista.
A opção Sair é a única que permite sair do programa.
8. Faça um programa para corrigir provas de múltipla escolha. Cada prova tem dez
questões e cada questão vale 1 ponto. O primeiro conjunto de dados a ser lido é
o gabarito da prova. Os outros dados serão os números dos alunos e suas
respectivas respostas. Existem 15 matriculados. Calcule e exiba:
 Para cada aluno seu número e sua nota;
 A percentagem de aprovação, sabendo-se que a nota mínima é 6,0.
9. Faça um programa que receba a temperatura média de cada mês do ano e
armazene-as em um vetor. Calcule e exiba a maior e a menor temperatura do
ano em que mês elas ocorreram (exiba o mês por extenso: 1 – Janeiro, 2 –
Fevereiro, ...).
10. Faça um programa que carregue um vetor com os modelos de cinco carros
(exemplos de modelos: FUSCA, GOL, VECTRA etc). Carregue um outro vetor
com o consumo desses carros, isto é, quantos quilômetros cada um desses
carros faz com um litro de combustível. Calcule e exiba:
 Modelo do carro mais econômico;
 Quantos litros de combustível cada um dos carros cadastrados consome
para percorrer uma distância de 1000 quilômetros.
11. Faça um programa que carregue um vetor com dez números inteiros. Calcule e
exiba os números superiores a 50 e suas respectivas posições. Exiba a
mensagem se não existir nenhum número nessa condição.
12. Faça um programa que receba seis números inteiros, calcule e exiba a soma dos
números pares e a quantidade dos números ímpares, exiba o relatório a seguir:
Vetor 2 4 5 6 3 7
1 2 3 4 5 6

Relatório
Os números pares são:
Número 2 na posição 1
Número 4 na posição 2
Número 6 na posição 4
Soma dos pares = 12
Os números impares são:
Número 5 na posição 3
Número 3 na posição 5
Número 7 na posição 6
Quantidade de números ímpares = 3
Algoritmos pág. 42

MATRIZ
DEFINIÇÃO
Variável composta homogênea bidimensional formada por uma seqüência de
variáveis, todas do mesmo tipo com o mesmo identificador (mesmo nome),
alocadas seqüencialmente na memória. Uma vez que as variáveis têm o mesmo
nome, o que as distingue são os índices que referenciam sua localização dentro da
estrutura. Uma variável do tipo matriz é composta por linhas e colunas.

DECLARAÇÃO DE MATRIZ

DECLARE nome[linha,coluna] tipo

Onde nome é o nome da variável, linha é a quantidade de linhas que vão
compor a matriz, coluna a quantidade de colunas que vão compor a matriz e tipo é
o nome do tipo de dados.

EXEMPLO DE MATRIZ

DECLARE a[3, 5] NUMÉRICO

1 2 3 4 5
1
a 2
3
a[1,1] a[3,4]

ATRIBUINDO VALORES À MATRIZ

Exemplos: a[1,1]  45 a[2,1]  13 a[2,5]  0 a[3,3/  -4

1 2 3 4 5
1 45
a 2 13 0
3 -4

CARREGANDO UMA MATRIZ

PARA i  1 ATÉ 3 FAÇA

INÍCIO
PARA j  1 ATÉ 5 FAÇA
INICIO
ESCREVA “Digite o número da linha ”, i, “ e coluna ”, j
LEIA x[i,j]
FIM
FIM

Ficaria assim:

1 2 3 4 5
1 12 9 3 7 -23
X 2 15 4 2 34 -4
3 3 45 3 0 -3
Algoritmos pág. 43

EXIBINDO OS ELEMENTOS DE UMA MATRIZ

PARA i  1 ATÉ 3 FAÇA

INCIO
PARA j  1 ATÉ 5 FAÇA
INICIO
ESCREVA x[i,j]
FIM
FIM

C/C++

Podemos declarar matrizes unidimensionais (vetores), bidimensionais e

multidimensionais. O padrão ANSI prevê, no mínimo, 12 dimensões, entretanto, o
limite de dimensões fica por conta da quantidade de recursos disponível ao
compilador. Apesar disso, as mais utilizadas são de duas dimensões.

DECLARAÇÃO DE MATRIZ

Sintaxe: tipo_dados nome_variável [dimensao1] [dimensao2] [...]

Exemplo: float x[2] [6];

Como os vetores, os índices iniciam em 0. temos então, duas linhas (0 e 1) e

seis colunas (0 a 5):

0 1 2 3 4 5
x 0
1

ATRIBUINDO VALORES

x[1] [4] = 5

0 1 2 3 4 5
x 0
1 5

Carregando uma matriz

Para ler dados do teclado e atribuir a uma matriz já declarada como int
mat[7] [3]:

for (i=0; i<7; i++)

{
for (j=0; j<3; j++)
cin >> mat[i] [j]
}

Interpretando: a matriz possui 7 linhas, o for externo deve variar de 0 a 6 e o

for interno deve variar de 0 a 2.
Algoritmos pág. 44

EXIBINDO ELEMENTOS DA MATRIZ

Para exibir uma matriz declarada como por exemplo, float x[10] [6]:
for (i=0;i<10;i++)
{
for (j=0;j<6;j++)
cout << x[i] [j];
}

Exemplo: Criar uma matriz de caracteres

#include <stdio.h>
void main()
{
int i;
char lista_time[][12]={"SANTOS",
"CORINTHIANS",
"PALMEIRAS",
"SAO PAULO",
"FLAMENGO"};
for (i=0; i<5; i++)
{
printf("\nO time de indice %d e: %s", i, lista_time[i]);
}
getch();
}

EXEMPLOS
1. Ler duas matrizes do tipo vetor, sendo A com 20 elementos e B com 30
elementos. Construir uma matriz C, sendo esta a junção das duas outras
matrizes. Desta forma, C deverá ter a capacidade de armazenar 50 elementos.
Apresentar a matriz C.

ALGORITMO
DECLARE a[1,20], b,[1,30], c[1,50], i NUMÉRICO
PARA i  1 até 20 FAÇA
LEIA a[i]
FIM_PARA
PARA i  1 até 30 FAÇA
LEIA b[i]
FIM_PARA
PARA i  1 até 50 FAÇA

SE (i <= 20) ENTÃO

c[i]  a[i]
SENÃO
c[i]  b[i - 20]
FIM_SE
FIM_PARA
PARA i 1 ATÉ 50 FAÇA
ESCREVA c[i]
FIM_PARA
FIM_ALGORITMO
Algoritmos pág. 45

#include <stdio.h>
int main() Início
{
int i; I 1,20
double a[20], b[30], c[50];
for (i=0;i<20;i++)
{
scanf("%lf",&a[i]); } a[ I ]
for (i=0;i<30;i++)
{ scanf("%lf",&b[i]); }
for (i=0;i<50;i++)
{ I 1,30
if (i <=20)
c[i] = a[i];
else
c[i] = b[i-20]; b[ I ]
}
for (i=0;i<50;i++)
{ printf("%lf",c[i]); }
getch(); I 1,50
}

N S
i<=20

c[i] b[i-20] c[i] a[i]

I 1,50

c[i]

Fim
2. Lê 5 strings e exibe na tela:
#include <stdio.h>
int main()
{ char strings [5] [100];
int conta;
for (conta = 0; conta<5;conta++)
{
printf ("\n\nDigite a string numero: ");
gets (strings[conta]); }
printf("\n\n\nAs strings que digitadas foram:\n\n");
for (conta=0;conta<5;conta++)
printf("%s\n", strings[conta]);
getch();
}
Algoritmos pág. 46

EXERCÍCIOS

1. Faça um programa que carregue uma matriz 2 x 2, calcule e exiba uma matriz
resultante que será a matriz digitada multiplicada pelo maior elemento da
matriz.
2. Faça um programa que carregue uma matriz 10 x 3 com as notas de dez alunos
em três provas. Exiba um relatório com o número do aluno (linha) e a prova em
que cada aluno obteve menor nota. Ao final do relatório, exiba quantos alunos
tiveram menor nota na prova1, quantos tiveram menor nota na prova2 e
quantos tiveram menor nota na prova3.
3. Faça um programa que carregue:
a) um vetor com oito posições com os nomes das lojas;
b) um vetor com quatro posições com os nomes dos produtos;
c) uma matriz com os preços de todos os produtos em cada loja.
4. Faça um programa que carregue uma matriz 10 x 20 com números inteiros e
some cada uma das linhas, armazenando o resultado das somes em um vetor.
A seguir, multiplique cada elemento da matriz pela soma da linha e exiba a
matriz resultante.
5. Faça um programa que carregue a primeira matriz de ordem 4 x 5 e uma
segunda com ordem 5 x 2, calcule e exiba a matriz resultante do produto
matricial das duas matrizes anteriores, armazenando em uma terceira matriz de
ordem 4 x 2.
6. faça um programa que carregue uma matriz 15 x 5 com números inteiros,
calcule e exiba quais os elementos da matriz que se repetem e quantas vezes
cada um está repetido.
7. faça um programa que carregue:
- vetor com os nomes de cinco produtos;
- matriz 5 x 4 com os preços dos cinco produtos em quatro lojas diferentes;
- vetor com o custo do transporte dos cinco produtos.
Calcule a segunda matriz 5 x 4 com os valores dos impostos de cada produto de
acordo com a tabela?
PREÇO % DE IMPOSTO
Até R$ 50,00 5
Entre R$ 50,01 e R$ 100,00 10
Acima de R$ 100,00 20

8. Faça um programa que carregue uma matriz 7 x 7 de números inteiros e crie

dois vetores de sete posições cada um e que contenham, respectivamente, o
maior elemento de cada uma das linhas e o menor elemento de cada uma das
colunas. Escreva a matriz A e os dois vetores.
9. faça um programa que receba as vendas semanais (de um mês) de cinco
vendedores de uma loja e armazene essas vendas em uma matriz. Calcule e
exiba:
- total de vendas por mês de cada vendedor;
- total de vendas de cada semana (todos os vendedores juntos);
- total de vendas do mês.
10. Faça um programa que carregue:
- um vetor com cinco números inteiros;
- um outro vetor com dez números inteiros;
- uma matriz 4 x 3, também com números inteiros.
Calcule e mostre:
- maior elemento do primeiro vetor multiplicado pelo menor elemento do se
vetor. O resultado dessa multiplicação adicionado aos elementos digitados na
matriz dará origem a uma segunda matriz (resultante);
- soma dos elementos pares de cada linha da matriz resultante;
- a quantidade de elementos entre l e 5 em cada coluna da matriz resultante.
Algoritmos pág. 47

MANIPULANDO CARACTERES EM C/C++

Em C/C++ não existe um tipo de dados similar à string da linguagem
PASCAL. Em vez disso, para armazenar uma cadeia de caracteres utilize vetores
(matrizes unidimensionais), onde cada posição representa um caractere.
Os compiladores em C/CC++ identificam o fim de uma cadeira de caracteres
por meio do caractere nulo, ou seja ‘\0’, deve-se declarar sempre o vetor com uma
posição a mais para armazenar o caracteres nulo. Exemplo: ALGORITMO, devemos
declarar um vetor do tipo char com 9 posições: char palavra[9]

Índice ... 0 1 2 3 4 5 6 7 8 ...

Valor ... A L G O R I T M O ...
Posição ... 863 864 865 866 867 86 869 870 871 ...
memória 8

FUNÇÃO strcpy()

Para armazenar uma cadeira de caracteres em uma variável, usamos uma

função strcpy (variável, valor), que faz parte da biblioteca string.h.
Copia a string origem para a string destino.
Exemplo: strcpy(disciplina, “Algoritmos”);
Sintaxe: strcpy(string_destino, string_origem);
Exemplo prático:
#include <stdio.h>
#include <string.h>
int main()
{
char str1[100], str2[100], str3[100];
printf("Entre com uma string: ");
gets(str1);
strcpy(str2,str1); /* copia str1 em str2 */
strcpy(str3,"Você digitou a string "); /* copia o texto para str3*/
printf("\n\n%s%s",str3,str2);
getch();
}

FUNÇÃO strcat()
Sintaxe: strcat(string_destino, string_origem);
A origem continuará inalterada e será anexada ao fim da string destino.
Exemplo prático:
#include <stdio.h>
#include <string.h>
int main()
{
char str1[100], str2[100];
printf("Entre com uma string: ");
gets(str1);
strcpy(str2,"Você digitou a string "); /* copia o texto para str3*/
strcat(str2,str1); /* str2 armazena o texto mais o conteúdo */
printf("\n\n%s",str2);
getch();
}

FUNÇÃO strlen()
Sintaxe: strlen(string);
Retorna o comprimento da string fornecida. O terminador nulo não é contado.
Exemplo prático:
#include <stdio.h>
Algoritmos pág. 48
#include <string.h>
int main()
{ int size;
char str[100];
printf("Entre com uma string: ");
gets (str);
size = strlen(str);
printf("\n\nA string que voce digitou tem tamanho %d", size);
getch(); }

FUNÇÃO strchr()
Sintaxe: strchr(str1, ch)
Retorna um ponteiro para a posição da cadeia str1, onde o ch é o caractere
encontrado pela primeira vez.

FUNÇÃO strstr()
Sintaxe: strstr(string1,string2);
Retorna um ponteiro para a posição da cadeia str1, onde a cadeia str2 é
encontrada pela primeira vez.

FUNÇÃO strcmp()
Sintaxe: strcmp(string1,string2);
Compara a string1 com a string2, se ambas forem idênticas a função retorna
0, caso contrário retorna não-zero.
Exemplo prático:
#include <stdio.h>
#include <string.h>
int main()
{
char str1[100],str2[100];
printf("Entre com uma string: ");
gets (str1);
printf("\n\nEntre com outra string: ");
gets(str2);
if (strcmp(str1,str2))
printf("\n\nAs duas strings são diferentes.");
else
printf("\n\nA duas strings são iguais.");
getch();
}

EXERCÍCIO
1. Faça um programa 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 final.
2. Faça um programa que receba uma frase, calcule e exiba a quantidade de
palavras na frase digitada.
3. Faça um programa que receba o nome completo de uma pessoa e exiba os
nomes intermediários abreviados. Exemplo: SIMONE MARIA VIANA  SIMONE
M. VIANA.
4. Faça um programa que receba o nome completo de uma pessoa e reescreva
conforme o exemplo: SIMONE MARIA VIANA  VIANA, S. M.
5. Faça um programa que receba duas frases e gere uma terceira que representa a
combinação das palavras das duas frases lidas.
6. Faça um programa que receba uma frase e coloque as palavras em ordem
crescente.
Algoritmos pág. 49

REGISTROS (Estruturas)
São estruturas que podem agregas diferentes informações. Assim, são feitas
de diferentes combinações, gerando novos tipos de dados. Um registro é uma
coleção de campos, em que cada campo pode ser de um tipo de dado diferente. Por
isso são conhecidos como variáveis compostas heterogêneas.

DECLARAÇÃO - ALGORITMOS

DECLARE nome_variável REGISTRO (campo TIPO_CAMPO)

Exemplo: DECLARE conta REGISTRO (num, saldo NUMERICO, nome LITERAL)

O registro declarado é chamado de conta e possui três campos: num, saldo

(NUMÉRICO) e nome (literal).

Conta num conta.num

saldo conta.saldo
nome conta.nome

DECLARAÇÃO DE REGISTROS EM C/C++

São definidos pela palavra struct. Sintaxe:

struct nome_do_tipo_da_estrutura
{
tipo_1 nome_1;
tipo_2 nome_2;
...
tipo_n nome_n;
} variáveis_estrutura;

A partir desta estrutura definida podemos considerar a existência de um novo

tipo de dado para ser utilizado. Esse novo tipo é capaz de armazenar os campos
definidos chamados de campos de estrutura. Exemplo:
struct produto
{
int código;
char descrição[30];
}

DECLARAÇÃO DE VARIÁVEIS DO TIPO REGISTRO EM C/C++

Para o programa usar esse novo tipo de dados é necessário declarar uma
variável, por exemplo, produto x ou produto char[10] [6] (matriz bidimensional
com 10 linhas e seis colunas).
Podemos definir a variável junto com a estrutura. Exemplo:
struct produto
{
int código;
char descrição[30];
} x[8] [5];

ACESSO A MEMBROS DE ESTRUTURAS

Algoritmos pág. 50
Após a declaração da variável podemos manipular seu conteúdo, ou seja,
valores armazenados em cada membro da estrutura, para isso, informamos o nome
da variável e o campo que será manipulado. Exemplo:
produto x;
x.codigo = 1;
strcpy(x.descricao, “geladeira”);

EXEMPLOS

1. Utilizar as estruturas declaradas na seção anterior para escrever um programa

que preencha uma ficha. Leitura

#include <stdio.h>
#include <string.h>
struct tipo_endereco
{
char rua [50];
int numero;
char bairro [20];
char cidade [30];
char sigla_estado [3];
long int CEP;
};

struct ficha_pessoal
{ Escrita
char nome [50];
long int telefone;
struct tipo_endereco endereco;
};

main (void)
{
struct ficha_pessoal ficha;
strcpy (ficha.nome,"Luiz Osvaldo Silva");
ficha.telefone=4921234;
strcpy (ficha.endereco.rua,"Rua das Flores");
ficha.endereco.numero=10;
strcpy (ficha.endereco.bairro,"Cidade Velha");
strcpy (ficha.endereco.cidade,"Belo Horizonte");
strcpy (ficha.endereco.sigla_estado,"MG");
ficha.endereco.CEP=31340230;
getch();
}

EXERCÍCIOS

1. Faça um programa que realize o cadastro de contas bancárias com as

seguintes informações: número da conta, nome do cliente e saldo. O banco
permitirá o cadastramento de apenas 15 contas e não pode haver mais de
uma conta com o mesmo número. Crie o menu de opções:
MENU DE OPÇÕES
1. CADASTRAR CONTAS
2. VISUALIZAR TODAS AS CONTAS DE UM DETERMINADO CLIENTE
3. EXCLUIR CONTA COM MENOR SALDO (não pode haver saldos iguais)
4. SAIR
Algoritmos pág. 51
2. Faça um programa que utilize os registros a seguir:
CLIENTE DOCUMENTOS
cod_cli num_doc
nome cód_cli
fone data_venc
endereço data_pag
valor
juros
Sabe-se que um documento só pode ser cadastrado para um cliente que já
exista. Considere que podem existir no máximo 15 clientes e 10
documentos. Crie um vetor para clientes e outro para documentos. Crie um
menu para a realização de cada uma das operações especificadas a seguir.
a) Cadastrar clientes - não pode existir mais de um cliente com o mesmo
código.
b) Cadastrar documentos - ao cadastrar um documento, se a data de
pagamento for maior que a data de vencimento, calcular o campo 'juros' do
registro documentos (5% sobre o valor original do documento).
c) Excluir clientes - um cliente só pode ser excluído se não existir documento
algum associado a ele.
d) Excluir documentos individuais - por meio de seu número. Caso o
documento não exista, mostre a mensagem Documento não encontrado.
e) Excluir documentos por cliente — informar o código do cliente e excluir
todos os seus documentos. Caso o cliente não exista, mostre a mensagem
Cliente não encontrado.
f) Excluir documentos por período - informar a data inicial e a data final e
excluir todos os documentos que possuírem data de vencimento nesse
período.
g) Alterar as informações sobre os clientes - só não pode ser alterado o
código do cliente, h) Mostrar o total de documentos de um determinado
cliente.
Quando forem excluídos clientes ou documentos, os vetores devem ser
reorganizados, ou seja, todas as posições não preenchidas dos vetores
devem ficar no final. Exemplo: se for necessário excluir o número 8 do vetor
a seguir, tanto o 9 quanto o I devem ser movidos uma casa para a esquerda
e a última posição deve ficar livre para uma nova inclusão.
Vetor inicial

12 5 8 9 1

Vetor reordenado com uma posição livre ao final

12 5 9 1

3. ma empresa contratou J 5 funcionários temporários. De acordo com o valor das

vendas mensais, os funcionários adquirem pontos que determinarão seus
salários ao final de cada mês. Sabe-se que esses funcionários trabalharão nos
meses de novembro de 2000 a janeiro de 2001. Faça um programa que:
a) cadastre os nomes dos funcionários e suas respectivas vendas mensais;
b) calcule e mostre a pontuação geral de cada funcionário nos três meses. Sabe-
se que R$ 100,00 equivalem a l ponto;
c) calcule e mostre a pontuação geral de todos os funcionários a cada mês;
d) determine e mostre a maior pontuação atingida nos três meses, mostrando o
nome do funcionário. Desconsiderar empates;
e) determine e mostre o valor total vendido.
Algoritmos pág. 52

ARQUIVOS
Estruturas de dados manipuladas fora do ambiente do programa são
conhecidas como arquivos. Considera-se como ambiente do programa a memória
principal, onde nem sempre é possível ou conveniente manter certas estruturas de
dados.
Um arquivo que é armazenado em um dispositivo de memória secundária,
como discos, por exemplo, pode ser lido ou escrito por um programa.
Um arquivo é formado por uma coleção de registros,e cada registro é formado
por campos e cada campo possui suas características específicas. Uma ou mais
campos desse registro é considerado campo-chave – campo que diferencia um
registro dos demais, evitando duplicidade de informações.
Um sistema de banco de dados é composto por um ou vários arquivos, onde
cada arquivo possui programas de manutenção: inclusão, exclusão lógica ou física,
alteração, consulta geral e específica e relatórios.
Exclusão física é que após eliminar o registro, os demais são deslocados e a
exclusão lógica, é quando os registros possuem um campo adicional identificando
se os mesmo estão ou não ativos (excluídos possui valor 0).

DECLARAÇÃO EM C/C++
Um arquivo pode representar várias coisas: arquivos em disco, impressora,
teclado ou qualquer dispositivo. Vamos ver somente arquivos em disco.
Para utilizar, precisamos usar a biblioteca stdlib.h que fornece funções de
manipulação de arquivos e definição de novos tipos de dados para serem usados.
Os tipos de dados definidos na biblioteca são: size_t, fpos_t e FILE.
O FILE identifica um arquivo no disco, direcionando todas as operações.
Exemplo: FILE *arquivo, *ponteiro;

COMANDOS DE ARQUIVOS EM C/C++

fopen()
Abre um arquivo retornando o ponteiro associado a esse arquivo.
Sintaxe: FILE * fopen(char * arquivo, char *modo_abertura);
Modo de Abertura
r  abre um arquivo de teto onde são realizadas apenas leituras;
w  cria um arquivo de texto onde realiza apenas de escrita;
a  anexa novos dados a um arquivo texto;
rb  arquivo binário realiza apenas leituras;
wb  arquivo binário realiza apenas escritas;
ab  novos dados a um arquivo binário;
r+  abre um arquivo texto onde são realizadas leitura e escrita;
w+  abre um arquivo texto onde são realizadas escrita e leitura;
a+  anexa novos dados ou cria um arquivo texto onde são
realizadas escrita e leitura;
rb+  abre um arquivo binário onde são realizadas escrita e leitura;
wb+  cria um arquivo binário onde são realizadas escrita e leitura;
ab+  anexa novos dados a um arquivo binário de leitura e escrita.

Exemplo: FILE *arquivo;

arquivo = fopen(“arquivo1.dat”, “w”);
if (arquivo == NULL)
{ printf(“\nOcorreu um erro, arquivo não foi aberto.”
getch();}
else { /* outras instruções */}
Obs.: Quando usamos os modos w e wb, se o arquivo não existir será criado
ou, se já existir será sobreposto por um arquivo vazio.
Algoritmos pág. 53

fclose()
Fecha um arquivo aberto, se ocorrer um erro poderá haver perda de dados.
Sintaxe: int fclose(FILE *arquivo14);

ferror()
Detecta se ocorreu algum erro durante uma operação com arquivos.
Sintaxe: int ferror(FILE *arquivo15);
Retorna um número inteiro, se esse número for diferente de zero significa que
ocorreu um erro durante a última operação realizada com o arquivo apontado por
arquivo. Se for 0 não ocorreu erro.

fputc()
Escreve um caractere em um arquivo. Se for bem sucedida retorna o
caractere escrito caso contrário, retorna EOF.
Sintaxe: int fputc(char ch, FILE *arquivo);

fgetc()
Lê um caractere em um arquivo. Se for bem sucedida retorna o caractere lido
caso contrário, retorna EOF.
Sintaxe: int fgetc (FILE *arquivo);

fputs()
Escreve uma cadeira de caracteres em um arquivo.
Sintaxe: int fputs(char *cadeira, FILE *arquivo);

fgets()
Lê uma cadeira de caracteres armazenada em um arquivo.
Sintaxe: int fgets(char *cadeia, int tamanho, FILE *arquivo);

fwrite()
Escreve qualquer tipo dado e não apenas caracteres ou cadeias de caracteres.
Sintaxe: int fwrite(&var, sizeof(double), 1, arquivo);

fread()
Lê qualquer tipo dado e não apenas caracteres ou cadeia de caracteres.
Quando for bem sucedida vai gerar como retorno um valor igual ao número de
leituras realizadas, caso contrário, quando ocorrer um erro ou quando o final do
arquivo for encontrado.
Sintaxe: int fread(&var, sizeof(double), 1, arquivo);

fseek()
posiciona o ponteiro em um endereço específico, tornando possível leituras e
escritas aleatórias.
Sintaxe: int fseek (FILE *arquivo, long quantidade_bytes, int posição);
Posição:
 SEEK_SET: movimentação de qtde_bytes a partir da posição inicial do
arquivo;
 SEEK_CUR: movimentação de qtde_bytes a partir da posição atual do
arquivo;

14
É o ponteiro obtido quando o arquivo for aberto com a função fopen().
15
É o ponteiro obtido quando o arquivo for aberto com a função fopen().
Algoritmos pág. 54
 SEEK_END: movimentação de qtde_bytes a partir da posição final do
arquivo.

feof()
Retorna um número inteiro. Quando esse número for 0 significa que o fim do
arquivo ainda não foi atingido e qualquer outro valor significa que foi encontrado.

rewind()
Posiciona o cursor (posição atual) de volta ao início do arquivo.
Sintaxe: void rewind(file *arquivo);

remove()
Apaga um arquivo. Se for executada com êxito retorna o número 0.
Sintaxe: int remove(char *arquivo);

fflush()
Escreva o conteúdo armazenado no buffer dentro de um arquivo.
Sintaxe: int fflush(FILE *arquivo);

exit()
Aborta a execução do programa. Podemos chamar de qualquer ponto e faz
com que o programa termine e retorna para o sistema operacional, o código de
retorno.
Sintaxe: void exit (int código_retorno);
Exemplo: Garante que o programa não deixará de abrir o arquivo.
#include <stdio.h>
#include <stdlib.h>
main (void)
{
FILE *fp;
fp=fopen ("exemplo.bin","wb");
printf("Arquivo aberto com sucesso!");
if (!fp)
{
printf("Erro na abertura do arquivo. Fim de programa!");
exit(1);
}
getch(0); }

LENDO E ESCREVENDO CARACTER EM ARQUIVOS EM C/C++

putc
Função de escrita que escreve um caractere no arquivo informado.
Sintaxe: int putc(int ch, FILE *arquivo)
Exemplo: Lê uma string e escreve em um arquivo em disco (arquivo.txt):
#include <stdio.h>
#include <stdlib.h>
main (void)
{
FILE *fp;
char string[100];
int i;
fp = fopen("arquivo.txt","w"); /* arquivo ASCII para escrita*/
Algoritmos pág. 55
if (!fp)
{
printf("Erro na abertura do arquivo.");
exit(0);
}
printf("Entre com a string a ser gravada no arquivo: ");
gets(string);
for (i=0;string[i]; i++)
putc(string[i], fp); /* grava a string, caractere a caractere*/
fclose(fp);
getch(0); }

getc
Retorna um caractere lido do arquivo.
Sintaxe: int getc (FILE *arquivo);

feof
EOF (end of file – fim de arquivo). Usado para verificar se o arquivo chegou
ao fim, retornando diferente de zero, caso contrário retorna zero. Outra forma é
comparar o caractere lido por getc com o EOF.
Sintaxe: int feof (FILE *arquivo);
Exemplo: abre um arquivo já existente e o lê, caractere a caractere até que o
final do arquivo seja encontrado e apresenta-os na tela:
/* le os caracteres de uma arquivo e exibe na tela*/
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fp;
char c;
fp = fopen("arquivo.txt","r"); /* arquivo ASCII para leitura*/
if (!fp)
{
printf("Erro na abertura do arquivo.");
exit(0);
}
while ((c = getc(fp)) != EOF); /* enquanto não for o final do arquivo*/
printf("%c", c); /*imprime o caractere lido */
fclose(fp);
getch(0);
}

FLUXOS PADRÃO

Permitem ao programador ler e escrever em arquivos da maneira padrão com

a qual já o havíamos lido e escrevidos na tela.

fprintf
Semelhante a função printf() porém a saída é em um arquivo e não no
monitor. Especificando um arquivo através de um ponteiro.
Sintaxe: int fprintf(FILE *arquivo, char *str,...)

fscanf
Semelhante a função scanf(), lê de um arquivo e não de um teclado.
Sintaxe: int fscanf(FILE *arquivo, char *str,...)
Algoritmos pág. 56

EXEMPLOS
1) Crie um programa que abra um arquivo para escrita, feche-o e o abra
novamente para leitura:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
FILE *p;
char c, str[30], frase[80] = "este é um arquivo chamado: ";
int i;
/* Lê um nome para o arquivo a ser aberto */
printf("\n\nEntre com um nome para o arquivo: \n");
gets(str);
if (!(p = fopen(str,"w"))) /* caso haja erro na abertura do arquivo*/
{
printf ("Erro! Impossível abrir o arquivo!\n");
exit(1);
}
/* se não houver erro, imprime no arquivo e feche-o*/
strcat(frase, str);
for (i=0; frase[i];i++)
putc(frase[i],p);
fclose(p);

/*abre novamente o arquivo para leitura*/

p = fopen(str,"r");
c = getc(p); /* le o primeiro caracter*/
while (!feof(p)) /* enquanto não for o fim do arquivo */
{
printf("%c", c); /* imprime o caracter na tela*/
c = getc(p); /* le um novo caracter no arquivo */
}
fclose(p); /* fecha o arquivo*/
getch();
}

2) Exemplifique a utilização dos comandos fprint e fscanf:

#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *p;
char str[80],c;
/* le um nome para o arquivo a ser aberto*/
printf("\n\n Entre com um nome para o arquivo: \n");
gets(str);
if(!(p = fopen(str,"w"))) /* caso ocorra algum erro na abertura*/
{
printf("Erro! Impossível abrir o arquivo!\n");
exit(1); /* aborta automaticamente */
}
/* se não houver erro, prime no arquivo, fecha...*/
fprintf(p, "Este e um arquivo chamado:\n%s\n", str);
fclose(p);
/* abrir novamente para leitura */
p = fopen(str, "r");
while (!feof(p))
Algoritmos pág. 57
{
fscanf(p,"%c",&c);
printf("%c",c);
}
fclose(p);
getch();
}

EXERCÍCIOS

1. Faça um programa que crie um arquivo chamado ALUNOS.DAT onde cada

registro será composto pelos seguintes campos: número, nome, curso, nota1,
nota2.
2. Faça um programa para incluir alunos no arquivo criado no exercício anterior.
Não podem existir dois alunos com o mesmo número.
3. Faça um programa para alterar as notas dos alunos criado no exercício 1.
4. Faça um programa para alterar o curso dos alunos do arquivo criado no
exercício 1.
5. Faça um programa para excluir os alunos do arquivo criado no exercício 1.
6. Faça um programa para consultar o número, nome e a média de todos os
alunos cadastrados no arquivo do exercício 1.
7. Faça um programa para consultar o número, o nome e a média de todos os
alunos cadastrados no arquivo do exercício 1 e que estejam aprovados, ou seja,
com a média igual ou maior que 7,0.
8. Faça um programa para consultar o número, o nome e o curso de todos os
alunos cadastrados no arquivo do exercício 1 e que estejam reprovados ou seja,
com média inferior a 3,0.
9. Faça um programa para consultar o nome de todos os alunos cadastrados no
arquivo do exercício 1 e que estejam de exame, ou seja, com média entre 3,0 e
7,0.
10. Faça um programa para consultar o nome de todos os alunos de um
determinado curso.
11. Faça um programa para criar um arquivo chamado VENDAS.DAT onde cada
registro será composto pelos seguintes campos: código do vendedor, nome do
vendedor, valor de venda e mês.
12. Faça um programa para incluir um vendedor no arquivo criado no exercício
anterior que não podem existir dois vendedores com o mesmo código e mesmo
mês de vendas.
13. Faça um programa para alterar o valor de uma venda no arquivo VENDAS.DAT.
14. Faça um programa para excluir um vendedor no arquivo VENDAS.DAT.
15. Faça um programa para consultar o valor da venda de um vendedor em um
determinado mês no arquivo VENDAS.DAT.
16. Faça um programa para consultar o total das vendas de um determinado
vendedor do arquivo VENDAS.DAT.
17. Faça um programa para consultar o nome e o código do vendedor que mais
vendeu em um determinado mês no arquivo VENDAS.DAT.
18. Faça um programa para consultar o mês com o maior valor de vendas e qual o
nome do vendedor que efetuou essas vendas no arquivo VENDAS.DAT.
Algoritmos pág. 58

SUB-ROTINAS
Também conhecidas como subprogramas, são blocos de instruções que
realizam tarefas específicas. O código de uma sub-rotina é carregado uma vez e
podem ser executadas quantas vezes for necessário. Dessa maneira, os programas
tendem a ficar menores e mais organizados, uma vez que o programa pode ser
subdividido em pequenas tarefas.
São executados linearmente até o final. Quando executamos sub-rotinas
podemos realizar desvios na execução natural dos programas através da chamada
da função pelo programa principal.

ALGORITMO:

Exemplo: recebe o valor do salário de um funcionário e calcula o novo salário.

ALGORITMO
DECLARE sal NUMERICO
LEIA sal
aum  calculo (sal)
novo_sal  sal + aum
ESCREVA “Novo salário: “, novo_sal
FIM_AGORTIMO

SUB_ROTINA calculo(sal NUMERICO)

DECLARE perc, valor
LEIA perc
valor  sal * perc/100
RETORNE valor
FIM_SUBROTINA calculo

SUB-ROTINAS (FUNÇÕES) EM C/C++

Utiliza recursos de modularização, o qual podemos particionar em sub-rotinas.
Estruturas que permitem ao usuário separar seus programas em blocos. Se
não as tivéssemos, os programas teriam que ser curtos e de pequena
complexidade.
Sintaxe: tipo_retorno nome_função(declaração dos argumentos)
{
corpor_da_função
}
Onde:
 o tipo de retorno é o tipo de variável que a função vai retornar. O default é int.
 argumentos são declarados assim: tipo nome1, tipo nome2,..., tipo nomeN.
 No corpo é feita todas as entradas a serem processadas e as saídas.
Exemplo: int soma(int a, int b)
{
s = a + b;
return s;
}

COMANDO RETURN
Algoritmos pág. 59
Encerra a execução da função e, se o valor de retorno for informado, a função
retorna essa valor (precisa ser compatível com o tipo de retorno declarada para a
função). Pode ter mais de um return.
Sintaxe: return valor_retorno ou somente return;
Exemplo: Criar uma função que calcule a área de um quadrado.
#include <stdio.h>
int quadrado(int a)
{
return (a * a);
}
int main()
{
int num;
printf("Entre com um numero: ");
scanf("%d", &num);
num=quadrado(num);
printf("\n\nO quadrado vale: %d\n", num);
getch();
}

EXERCÍCIOS

1. Faça uma função que retorne 1 se o número digitado for positivo ou 0 se o

número for negativo.
2. Faça uma função que receba dois números positivos por parâmetro e retorna a
soma dos N números inteiros existentes entre eles.
3. Faça uma função que receba três números inteiros: A, B e C, onde A é maior
que 1. A função deve somar todos os inteiros entre B e C que sejam divisíveis
por A (inclusive B e C) e retornar o resultado para a função principal.
4. Faça uma função que transforme e exiba segundos em horas, minutos e
segundos. Todas as variáveis devem ser passadas como parâmetro, não
havendo variáveis globais.
5. Faça um procedimento que receba três notas de um aluno como parâmetros e
uma letra. Se a letra for A o procedimento calcula a média aritmética das notas
do aluno, se for P o procedimento calcula a média ponderada, com pesos 5, 3 r
2. A média calculada deve ser devolvida ao programa principal para então, ser
exibida.
6. Faça um procedimento que leia cinco valores e retorne o maior e o menor deles.
7. Faça uma função que receba, por parâmetro, dois vetores de dez elementos
inteiros positivos e exiba o vetor união dos dois primeiros.
8. Faça uma função que receba, por parâmetro, um vetor A com cinco números
reais e retorne esses números ordenados em ordem crescente.
9. Faça uma função que receba dois vetores A e B de dez elementos inteiros, por
parâmetro. O procedimento deve determinar e exibir um vetor C que contenha
os elementos de A e B em ordem decrescente.
10. Faça uma função que receba por parâmetros, uma matriz A(5,5) e retorne a
soma dos elementos.
11. Faça uma função que receba por parâmetros, uma matriz A(6,6) e retorne o
menor elemento da sua diagonal secundária.
12. Faça uma função que receba por parâmetros, uma matriz A(6,6) e multiplique
cada linha pelo elemento da diagonal principal daquela linha. A função deve
retornar a matriz alterada para ser exibida no programa principal.