Linguagem C-2009

Kesede R Julio
Apostila de
Linguagem
versão: 2009
Prof. Kesede R Julio
Índice
1 - Introdução.....................................................................................................................4
1.1 Recomendações ao Aluno...........................................................................................4
1.2 Ferramenta de programação: Linguagem C..............................................................4
1.3 Estrutura de um Programa.........................................................................................6
1.4 Inserção de Arquivos de Função...............................................................................7
1.5 Tipos e Variáveis......................................................................................................9
1.6 Operadores Básicos...................................................................................................9
1.7 Exercícios Propostos...............................................................................................10
2 - Comandos de Decisão..................................................................................................13
2.1 Comando If/else........................................................................................................13
2.2 Switch........................................................................................................................14
2.3 Exercícios..................................................................................................................16
3 - Comandos de Repetição..............................................................................................18
3.1 Comando while.........................................................................................................18
3.2 Comando do-while....................................................................................................19
3.3 Teste de mesa............................................................................................................20
3.4 Exercícios..................................................................................................................24
4 - Vetor.............................................................................................................................26
4.1 Comando For.............................................................................................................27
4.2 Exercícios..................................................................................................................28
5 - String............................................................................................................................30
5.1 Exercícios..................................................................................................................33
6 - Matriz...........................................................................................................................34
6.1 Exercícios..................................................................................................................35
7 - Funções.........................................................................................................................37
7.1 Passagem de Parâmetros por Valor e Retorno de Valor...........................................38
7.6 Passagem de Parâmetros por Referência................................................................40
7.5 Recursão....................................................................................................................41
7.6 – Exercícios.............................................................................................................44
8 - Métodos de Classificação e Busca..............................................................................46
8.1 Classificação por Seleção..........................................................................................46
8.2 Classificação QuikSort..............................................................................................47
8.3 Busca Linear.............................................................................................................50
8.4 Busca Binária............................................................................................................51
8.5 Exercícios..................................................................................................................54
9 - Ponteiros.......................................................................................................................55
Linguagem de Programação C - versão 2009 2

9.1 Vetores de Ponteiros.................................................................................................57

9.2 Matrizes de Ponteiro................................................................................................58
9.3 Exercícios.................................................................................................................59
10 - Arquivo.......................................................................................................................61
10.1 Armazenamento em disco.......................................................................................61
10.2 Exercícios................................................................................................................70
10.3 Indexação de Arquivo............................................................................................71
10.4 Exercícios...............................................................................................................72
11 Algumas Bibliotecas Gráficas.....................................................................................73
11.1 BGI.........................................................................................................................73
11.2 Allegro...................................................................................................................75
11.3 Exercícios ..............................................................................................................76
Apêndices A – Algoritmos e Fluxogramas......................................................................78
Apêndices B – Resumo de comandos e funções..............................................................82
Apêndices C – Acesso a Porta Paralela...........................................................................85
Apêndices D – Exercícios Resolvidos..............................................................................88
1 Seção 2.3......................................................................................................................88
2 Seção 3.3......................................................................................................................90
3 Seção 7.6......................................................................................................................90
4 Seção 9.3......................................................................................................................91
Bibliografia........................................................................................................................92

1 - Introdução
1.1Recomendações ao Aluno
O estudo de programação requer uma boa dose de

concentração na teoria e dedicação na execução dos exercícios práticos.
Por isso, é de fundamental importância a digitação de todos os
exemplos e o desenvolvimento de todos os exercícios propostos. Suas
dúvidas devem ser resolvidas assim que surgirem, não as adie, pois isto
se tornará uma "bola de neve", fatal para a compreensão e motivação
da continuidade do aprendizado. NÃO ESTUDE PARA A PROVA, estude
sempre. O estudo deve ser feito periodicamente. Seja disciplinado em
seus estudos para que você possa colher bons frutos. Leia a teoria,
digite os exemplos, releie a teoria e encare os exercícios propostos. Não
desanime nunca, persevere.
1.2 Ferramenta de programação: Linguagem C
Para fazer nossos programas, usaremos a linguagem C. Para

isso precisamos de um compilador (programa que interpretará nossas
instruções) e de um IDE (Interface Development Environment, ou seja,
um programa que permita escrever nossas instruções, corrigí-las e
executá-las). Existe uma certa influência do compilador escolhido nas
funções oferecidas pela linguagem. Por isso, esta apostila estará sendo
direcionada para o C-Padrão ANSI (American National Standards
Institute), pois suas funções são aceitas por todos os compiladores que
seguem este padrão. O compilador escolhido pelo curso é o gcc, este
compilador já está embutido no IDE que usaremos chamado Dev-c++
(ou Dev-cpp), o qual pode ser baixado gratuitamente através do site
“http://kent.dl.sourceforge.net/sourceforge/dev-cpp/devcpp-
4.9.9.2_setup.exe”. Após a instalação do IDE, você poderá, caso queira,
baixar a documentação do compilador. Com o IDE aberto:
1. Clique em Ferramentas/Atualizações.
2. Na janela WebUpdate, na opção “Select devpack
server”, selecione “devpaks.org” e clique em “Check for Updates”.
3. Agora , selecione Documentations em “Groups” e
selecione “C++ Reference and Man pages”.
4. Clique agora no botão “Download Selected”. Termine a
instalação através das mensagens indicadas nas janelas
seguintes. Isto fará o download de alguns arquivos .chm, os quais
poderão ser incorporados ao ambiente de programação afim de

serem executados a partir do próprio ambiente.

5. Para incorporá-lo ao ambiente, selecione
Ajuda/Personalizar Menu de Ajuda.
6. Clique em “Adicionar” e escolha o arquivo cpp.chm (se
a sua instalação for default)
c:\devcpp\docs\cpp_manpages\cpp.chm. Selecione “Designar
atalho para F1” e clique em OK.
7. Pronto! Quando estiver editando o programa, sempre
que teclar F1 o programa de ajuda com todas as funções de C/C+
+ serão apresentadas, inclusive com exemplos.
Através da digitação dos exemplos deste capítulo, você

poderá praticar os recursos do ambiente de programação que você
utilizará durante o curso, além de aprender alguns conceitos básicos da
própria linguagem, como: estrutura de um programa, inserção de
bibliotecas de função, tipo de variáveis, entrada e saída de dados em
tela, operadores aritméticos básicos. Para começar a digitar um
exemplo, basta selecionar “Arquivo/Novo/Arquivo Fonte. Digite o
programa linha-a-linha. Salve-o com a extensão .c (Arquivo/Salvar
Como...). Agora você precisa compilar (verificar erros de escrita) o
programa. Clique em “Executar/Compilar”. Caso o programa apresente
algum erro, ele indicará a linha do erro através de um destaque
colorido. Na aba “Compilador” (parte inferior do IDE) aparecerão a linha
e a descrição do erro ocorrido. Tente corrigí-lo e compile novamente. O
programa só poderá ser executado se todos os erros de compilação
forem retirados do programa. Após a compilação sem erros, você
poderá executar o programa. Clique em “Executar/Executar”. Aparecerá
um console (janelinha preta) com a execução do programa em
andamento.
Após conferir que o programa está correto, ou seja, fez
exatamente o que você pediu que fizesse, você poderá abrir uma nova
aba (Arquivo/Novo/Arquivo fonte) para digitar o próximo exemplo.
Digite o Exemplo 1.1:- Faça um programa que escreva seu nome na tela.
1 #include <stdio.h> Permite o uso das funções printf().Não precisam ser
incluídos para arquivos .c.
2 #include <conio.h> Permite o uso da função getch(). Não precisam ser incluídos
para arquivos .c
3 int main(){ Abre a função principal do programa
4 printf("Kesede R Julio"); Imprime a mensagem na tela
5 getch(); Pára a execução do programa
6 } Fecha a função principal

Digite o Exemplo 1.2:- Faça um programa que mostre uma mensagem de Olá personalizada.
Permita que o usuário digite seu nome.
1 #include <stdio.h> Permite o uso das funções printf() e scanf().Não precisam ser
2 #include <conio.h> Permite o uso da função conio(). Não precisam ser incluídos
para arquivos .c
char nome[30]; Reserva um espaço na memória para guardar até 29
caracteres.
4 scanf(“%s”,nome); Recebe o nome do usuário e guarda na variável nome
5 printf("Ola, %s“, nome); Imprime a mensagem na tela substituindo o formato (%s)
pelo conteúdo da variável nome
Digite o Exemplo 1.3:- Um empregado da empresa Alfa tem dois vencimentos: salário e
gratificação. Faça um programa que receba os vencimentos do empregado, e mostre o salário
que ele irá receber.
1 #include <stdio.h> Permite o uso das funções printf() e scanf().Não precisam ser
2 #include <conio.h> Permite o uso da função conio(). Não precisam ser incluídos
para arquivos .c
4 float salario; Define espaço de memória chamado salario
5 float grat; Define espaço de memória chamado grat
6 float soma; Define espaço de memória chamado soma
7 printf(“Digite o salario: "); Imprime uma mensagem na tela
8 scanf(“%f”,&salario); Recebe o que o usuário digitou e guarda em salario
9 printf("\nDigite a gratificacao: "); Imprime uma mensagem na tela
10 scanf(“%f”,&grat); Recebe o que o usuário digitou e guarda em salario
11 soma = salario + grat; Soma o conteúdo de salário e grat e guarda em soma
12 printf("\n\nO resultado eh: %f", soma); Imprime a mensagem na tela substituindo o formato %f pelo
conteúdo de soma

1.3 Estrutura de um Programa
A estrutura de um programa C é, basicamente, realizada em

funções. A princípio, não se escreve nenhum comando que não esteja
dentro de uma função. No exemplo 1.1, a função começa na linha “int
main(){” e termina em “}”. Por isso, a estrutura de programa
apresentada é a própria estrutura da função main().
<tipo de retorno> <nome da função> (<argumento>,...){

<comandos e funções>
}
Onde:
Tipo de retorno: é o tipo da informação que uma função
pode retornar. Em nosso exemplo o retorno é “int”. Voce poderá
encontrar o tipo de retorno da main() como “void”.
Nome da função: é o que identificará a função. Se houver
apenas uma função (como no exemplo 1.1) no programa, esta deverá
se chamar, obrigatoriamente, “main” (principal).
Argumentos: são entradas de informações recebidas por
outras funções. No exemplo 1.1, não há entrada de argumentos.
Comandos e funções: é a própria lógica do programa.
Comandos, chamada de funções pré-definidas, chamada de funções
escritas pelo programador, colocadas em uma seqüência lógica para ser
obedecida pelo compilador.
1.4 Inserção de Arquivos de Função
São arquivos texto contendo os cabeçalhos das funções

fornecidas pelo próprio compilador. Para usar qualquer função pré-
definida, você deve declarar o nome do arquivo entre aspas, através da
declaração “include” precedida pelo caractere “#”. No Apêndice A,
listamos o nome de alguns desses arquivos e suas respectivas funções.
Em nosso exemplo utilizamos apenas o arquivo “stdio.h”, que contem
as funções de entrada e saída de dados: printf() e scanf(). Devido a
importância destas funções replicamos aqui uma explicação de como
usar estas funções.
printf():- função que permite a saída de dados para o
usuário.
Sintaxe simplificada:
printf(“<formatação da saída>”, <variavel>,...<variavel>);

Onde:
“formatação da saída” é tudo que queremos escrever na tela
para o usuário. Quando quisermos mostrar conteúdo de variáveis no
meio do texto, colocamos os formatos dos tipos (vide tabela abaixo),
que serão substituídos pelas variáveis.
“variável” é o nome da variável que queremos mostrar ao
usuário. Seu conteúdo será substituído nos formatos de tipo colocados
na formatação da saída.
Exemplo:
printf(“Resultado da soma: %d.”, soma);
Caso a variável “soma” seja 10, a mensagem mostrada para
o usuário será: “Resultado da soma: 10.” (sem aspas).
scanf():- função que permite a digitação de dados pelo

usuário.
scanf(“<formatação da entrada>”, <endereço da
variavel>);
Onde:
“formatação da entrada” é apenas o formato do tipo (vide
tabela abaixo) da variável onde será alocada a informação digitada pelo
usuário.
“endereço da variável” é o endereço de onde será alocada a
informação. Para informar o endereço de uma variável, basta colocar o
caractere “&” antes do nome da variável.
Exemplo:
scanf(“%f”, &valor);
Neste exemplo, o programa será interrompido para que o

usuário digite uma informação, que deverá ser um número real. Este
número será alocado em um espaço de memória chamado valor,
declarado previamente como float (conjunto dos números reais).
Tanto para o printf() como para o scanf(), temos que usar
formatos para as variáveis que desejamos digitar (entrada) ou mostrar
(saída). Estes formatos correspondem ao tipo de cada variável. A tabela
abaixo mostra os tipos mais comuns.
Formato Tipo
%d, %i Inteiro
%f Float

%c Caractere
%lf Double
%s Cadeia de caracteres (string)
1.5 Tipos e Variáveis
Sempre que preciso manipular alguma informação, tenho

que reservar um espaço para armazená-la na memória, determinando
também o tipo e tamanho da informação a ser armazenada. Os tipos
básicos, são:
int: 2 bytes com sinal (4 bytes para computadores 32bits) –

conjunto dos números inteiros – Ex.: 5, 37,1005
char: 1 byte com sinal – qualquer caractere – Ex.: 'a', 'F', ';'
float: 4 bytes com sinal – conjunto dos números reais – Ex.:

5.1, 89.3
double: 8 bytes com sinal - conjunto dos números reais – Ex.:

5.1, 89.3
Assim: float salario;
Reserva um espaço de memória chamado “salario” do tipo

float (isso já define o tamanho e o tipo da informação), na memória.
1.6 Operadores Básicos
Existem 4 tipos de operadores: Aritmético, Lógico,

Condicional, bit-a-bit. A tabela abaixo mostra estes operadores.
Operador Tipo Descrição

+ Aritmético Soma
- Aritmético Subtração
* Aritmético Multiplicação
/ Aritmético Divisão

% Aritmético Resto da divisão

++ Aritmético Incremento
-- Aritmético Decremento
== Lógico Igualdade
!= Lógico Diferente
< Lógico Menor
<= Lógico Menor ou igual
> Lógico Maior
>= Lógico Maior ou igual
&& Condicional E
|| Condicional Ou
& Bit-a-bit E
| Bit-a-bit Ou
1.7 Exercícios Propostos
1.7.1 Faça um programa que imprima “Ola” na tela.

1.7.2 Faça um programa que imprima seu nome na tela.
1.7.3 Faça um programa que imprima um nome, escolhido pelo usuário, na tela. Você deverá
permitir que o usuário digite (função scanf()) este nome, definindo uma variável para guardar
este nome na memória.
1.7.4 Faça um programa que receba o nome e a idade do usuário e depois mostre-os na tela.
Devem ser definidas duas variáveis para guardar nome e idade na memória.
1.7.5 Faça um programa que receba o nome do usuário, quantas horas ele trabalhou no mês e o
valor da sua hora trabalhada. Mostre seu nome e o valor do seu salário. Neste caso, você deve
reservar variáveis para o nome, quant. de horas trabalhadas, valor da hora e para o salario (que
será calculado).
1.7.6 Os funcionários da empresa “ABC Xtal”, recebem para cada hora extra, 50% a mais do
valor da hora normal. Faça um programa que receba o nome de um funcionário, quantas horas
normais e quantas horas extras ele trabalhou, assim como o valor da hora normal. Mostre, no
final do programa, o salario líquido deste funcionário.
1.7.7 Faça um programa que receba do usuário um numero qualquer e mostre o quadrado deste
número.
1.7.8 Faça um programa que permita que o usuário digite dois valores inteiros. Multiplique estes
valores guardando o produto em uma terceira variável. Mostre o resultado da multiplicação.
1.7.9 Faça um programa de uma calculadora simples que permita que o usuário digite dois
valores inteiros. A calculadora, logo após a digitação dos números, deverá mostrar o valor da
soma, da subtração, da multiplicação e da divisão dos valores digitados.
1.7.10 Faça um programa que calcule a media da temperatura ocorrida em um dia. O usuário

deverá digitar 5 temperaturas e o programa deverá mostrar em tela a média das temperaturas.
1.7.11 A tabela abaixo mostra o valor do câmbio de moedas estrangeiras para cada real. Faça
um programa onde o usuário entre com uma quantia em real e o programa mostre este valor em
outras moedas.
Moeda Valor (R$)

1 Dolar 1,9
1 Euro 3,1
1.7.10 Faça um programa que calcule e mostre o salário líquido de um funcionário. O programa
deve receber o salário bruto e considerar que todo funcionário tem um desconto de 10% de IR
no salário bruto.
1.7.11Para calcular a área de um retângulo, podemos multiplicar sua largura pelo seu
comprimento. Permita que o usuário entre com a largura e comprimento de um retângulo
qualquer e mostre sua área.
1.7.12Supondo que um engenheiro deseja saber qual a distância entre 2 pontos em um terreno.
Porém ele sabe apenas as coordenadas (x,y) de cada ponto. Faça um programa que resolva este
problema para o engenheiro, sabendo que o cálculo da distância é dado por:
d =  x 2 −x 12 y 2− y 1 2
Dica: Use sqrt() (math.h) para calcular a raiz quadrada.
1.7.13 Uma empresa de engenharia vai lotear uma fazenda e deseja dividi-la em 3 categorias
(A, B e C) de acordo com o tamanho do lote. Toda a fazenda será dividido da seguinte forma:
20% para a Categoria A, 30% para a Categoria B e 50% para a Categoria C. A Categoria A terá
4 lotes, a Categoria B terá 10 lotes e a Categoria C terá 20 lotes. Você foi designado para
desenvolver um programa que mostre a área de cada lote, das categorias A, B e C.. Receba do
usuário a área total da fazenda, e para um bom entendimento do problema, considere a fazenda
com formato retangular.
1.7.14 Uma empresa de transporte rodoviário precisa saber o tempo exato que um ônibus
demorou para sair da sua cidade origem e chegar na sua cidade destino. Para isso, pediu que
voce fizesse um programa (faça primeiro o algoritmo e o fluxograma) que recebesse o horário de
saída (HH:MM:SS) e o horário de chegada (HH:MM:SS), e mostrasse o tempo exato gasto na
viagem. Exemplo:
Horário de Saída : 14:28:32

Horário de Chegada: 17:47:52
Tempo de Viagem : 03:19:20
Dica: Receba as entradas em variáveis inteiras separadas. Converta todas para segundos,
execute a diferença e converta o resultado para horas, minutos e segundos.

2 - Comandos de Decisão
2.1Comando if/else
Definição: Usado para executar um ou mais comandos

dependentes de condições.
if (<condição> &&/|| <condição> ...){

<comandos e/ou funções>
}
else{
<comandos e/ou funções>
}
A palavra “if” é obrigatória. Tudo que estiver entre “<” e “>”

deve ser substituído pela informação pertinente, neste caso, uma
condição.
O else é usado quando queremos executar algum comando
caso a condição do if seja falsa. Ele é opcional.
O “{” e “}” pode ser dispensado quando temos apenas uma
linha de código dentro da estrutura de decisão, porém caso você
sempre use, nunca errará, terá uma regra a menos para guardar e terá
seu programa mais organizado (esta é apenas minha opinião).
Digite o Exemplo 2.1:- Entre com o valor da nota de uma determinada disciplina de um aluno e
mostre a mensagem de “Aprovado”, se sua nota for maior ou igual a 6, ou “Reprovado”, se sua
nota for menor que 6.
1 #include <stdio.h> Permite o uso das funções printf() e scanf()
2 #include <conio.h> Permite o uso da função getch()
4 float nota; Define espaço de memória chamado nota
5 scanf(“%f”, &nota); Recebe a nota do usuário
6 if (nota>=6){ Verifica se nota é maior ou igual a 6

7 printf(“Aprovado”); Caso seja, imprime mensagem na tela
8 } Fecha o if
9 else{ Verifica se nota é menor que 6 (caso contrário do if)
10 printf(“Reprovado”); Caso seja menor que 6. imprime mensagem
11 } Fecha else
13 } Fecha função principal
No exemplo 2.1, o programa recebe do usuário um valor e

atribui este valor à variável nota, depois disso, testa se o valor digitado
é maior ou igual a 6, se for verdadeira esta condição, o programa
mostra “Aprovado” na tela, caso contrário, mostra “Reprovado”. Note
que apenas uma das mensagens será mostrada, pois o “else” é a
negação da condição.
2.2Switch
Definição: Usado para executar um ou mais comandos caso

o conteúdo da variável testada seja igual ao valor de algum dos casos.
switch (<variavel testada>){

case <valor>:
break;
case <valor>:
break;
default:
}
Como última função para cada caso, utilizamos a função

"break" para que o programa não precise testar o restante das
condições.
O default (similar ao else do if) é usado quando queremos
executar algum comando, caso o valor da variável seja diferente de
todos os valores testados. Ele é opcional.
Podemos substituir qualquer switch por if´s, porém nem
todo if pode ser substituído por switch´s. Isto acontece porque o switch
não verifica intervalos de valores, apenas igualdade.
O switch organiza melhor o programa quando temos uma

determinada variável para ser verificada sua igualdade com diversos

valores.
Digite o exemplo 2.1: Faça um programa que permite que o usuário entre com o código do
produto e o programa mostre o nome deste produto. Os produtos são: cod. 1 – cd, cod. 2 – livro,
cod. 3 – revista, cod. 4 – jornal.
4 int codigo; Define espaço de memória chamado salario
5 printf(“Digite o codigo: ”); Mostra mensagem na tela
6 scanf(“%d”,&codigo); Recebe o valor do código do usuário
7 switch (codigo){ Abre o comando switch para verificação do código
8 case 1: Verifica se o código é igual a 1
9 printf(“CD”); Caso seja, mostra mensagem
10 break; Sai o switch
12 printf(“Livro”); Caso seja, mostra mensagem
15 printf(“Revista”); Caso seja, mostra mensagem
18 printf(“Jornal”); Caso seja, mostra mensagem
20 default: Verifica se é diferente de todos os cases
21 printf(“Opção Inválida”); Caso seja, mostra mensagem
22 } Fecha switch()
23 getch(); Pára execução do programa

2.3Exercícios
Switch
2.3.1Faça um programa que permita que o usuário entre com um numero num intervalo de 0 a
6, equivalendo cada um deles a um dia da semana (domingo = 0). Imprima o dia da semana
equivalente ao numero digitado pelo usuário. Caso o usuário digite um numero invalido, dê uma
mensagem informando-o. Use o comando "switch" para os testes.
2.3.2 Em uma empresa de saneamento básico os serviços recebem uma numeração de acordo com
sua natureza: 1 para troca de tubulação, 2 para verificação de problemas de vazamento, 3 para
ligação de água e esgoto. De acordo com o problema, o serviço é agendado para um determinado
horário do dia. 8h da manhã são agendados os serviços 1, para às 11h são agendados os serviços
2 e para às 15h são agendados os serviços 3. Você, como programador de sistemas da empresa,
foi designado para fazer um programa que agende os serviços em seus respectivos horários. O
programa deve receber o numero do serviço e mostrar o seu horário de agendamento. Use o
comando switch, com mensagem de erro caso o usuário digite um numero invalido. Faça o
algoritmo e o fluxograma antes do programa.
If-else
2.3.3Permita que o usuário digite um valor inteiro, teste se este valor é maior que 10, caso seja,
imprima “Maior que 10”; caso contrário, imprima “Menor ou igual a 10”.
2.3.4Uma empresa não pretende contratar candidatos com mais de 40 anos. Faça um programa
que receba a idade do candidato e mostre uma mensagem se ele está apto ou não para a vaga.
2.3.5Um restaurante oferece um desconto de 7% para todos os clientes que gastarem mais que
R$ 250,00 no fechamento da conta. Faça um programa que pergunte ao usuário qual o valor da
conta e mostre o valor real a ser pago.
2.3.1Uma empresa deseja bonificar seus funcionários de acordo com a quantidade de vendas do
mês. O gerente lhe entregou uma tabela para que você faça um programa que mostre o valor das
bonificações.
Valor Vendido (R$) Bonificação (%)

< 1.500,00 5
Entre 1.500,00 e 3.500,00 7
> 3.500,00 10
2.3.7 O IMC (Índice de Massa Corpórea) é um bom sinalizador para o controle do nosso peso. A
fórmula é simples:
IMC = peso / (altura2)
através da tabela abaixo podemos saber se precisamos emagrecer, engordar ou manter o nosso
peso.

IMC Situação
Abaixo de 20 (exclusive) Abaixo do peso normal
Entre 20 e 24,9 (inclusive) Peso normal
Entre 25 e 35 (inclusive) Acima do peso normal
Acima de 35 (exclusive) Obeso
Faça um programa que receba a altura e o peso do usuário. De acordo com a fórmula do IMC,
mostre a situação do usuário.
2.3.9 Dados 3 valores representando os lados de um triângulo, verifique se este triângulo é
escaleno (3 lados diferentes), isósceles (2 lados iguais) ou eqüilátero (3 lados iguais).
2.3.10 Faça um programa que receba 3 valores correspondentes aos lados de um triângulo.
Verifique e dê mensagens para as seguintes condições, sendo A o maior lado:
Se A >= B + C Nenhum triangulo é formado
Se A2 = B2 + C2 Um triangulo retangulo é formado
Se A2 > B2 + C2 Um triangulo obtusangulo é formado
Se A2 < B2 + C2 Um triangulo acutangulo é formado
Faça o algoritmo e o fluxograma antes do programa.

2.3.11 Dados 3 valores quaisquer, verifique se eles podem ser lados de um triângulo. Lembre
que, em um triângulo, a soma de dois lados deve ser maior que o maior lado.
2.3.12 Receba 3 números inteiros e distintos, a partir do usuário, e mostre-os em ordem crescente.
2.3.13 Faça um programa que, leia os 3 números, a partir do usuário, correspondentes aos
coeficientes de uma equação do 2o grau. Através de Bascara, calcule, se possível, as raízes da
equação, realizando todas as consistências necessárias. Faça o algoritmo e o fluxograma antes
do programa.

3 - Comandos de Repetição
3.1Comando while
while (<condição>){
}
Este comando executa os comandos e funções internos a ele

enquanto a condição for verdadeira. Diferente do if que, caso a
condição seja verdadeira, executa os comandos internos e segue
adiante, o while volta a executar a primeira linha do laço, ou seja, o
teste da condição. Ele continua testando e executando os comandos
internos até que a condição seja falsa. Existem outros comandos de
looping (for e do-while) , porém se você souber bem o while poderá
usá-lo em qualquer situação.
Digite o Exemplo 3.1:- Mostre os números inteiros de 1 a 100.

4 int i=1; Define espaço de memória chamado i
5 printf(“Imprimindo os números de 1 a 100”); Imprime mensagem na tela
6 while (i<=100){ Verifica se i é menor ou igual a 100
7 printf(“%d\n”, i); Imprime o conteúdo da variável i
8 i++; Soma 1 em i
9 } Fecha o while
10 getch(); Páara a execução do programa
No exemplo 3.1, a variável i é inicializada com o valor 1 e

incrementada dentro do laço do while. A condição do comando while
testa se o valor de i é menor ou igual a 100 e enquanto isso for
verdade, a variável é mostrada na tela. O “i++” equivale a “i=i+1” e
chamamos de contador. O contador é um conceito importante na
programação, pois através dele podemos alterar o valor de uma

variável através de um “passo” determinado. Podemos ter contadores

que somem com passo de 1 em 1 (como no caso do exemplo), de 2 em
2, de 5 em 5, ou seja, como nos convier. Uma variação deste conceito é
o acumulador. A diferença é que, ao invés de contarmos
(acumularmos) constantes numéricas (1, 2, 3 etc), acumulamos
variáveis, como: salários, notas, idades, prestações etc.. O exemplo 3.2
mostra o uso de um contador (cont) e de um acumulador (somaid).
Digite o Exemplo 3.2:- Faça um programa que receba a idade de 10 alunos de uma academia e
mostre a média das idades.
4 int idade, cont=1, somaid=0; Define espaços de memória inteiros para guardar as
idades, o contador (cont) e o acumulador (somaid). O
contador e acumulador devem ser inicializados.
5 float media; Define espaço de memória float para guardar a media
6 printf(“Digite as idades\n”); Imprime mensagem na tela
7 while (cont<=10){ Verifica se o contador é menor ou igual a 10
8 scanf(“%d”, &idade); Recebe a idade do usuário e guarda seu valor na
variável “idade”
9 somaid=somaid+idade; Soma a idade ao acumulador (que vale zero da
primeira vez) e guarda o resultado no próprio
acumulador. Na próxima iteração o acumulador já
estará atualizado.
10 cont=cont+1; Soma 1 ao contador (que vale 1 da primeira vez) e
guarda o resultado no próprio contador. Na próxima
iteração o contador já estará atualizado.
11 } Fecha o while
12 media=somaid/10; Calcula a media.
13 printf(“A media eh %f”,media); Mostra a media na tela
14 getch(); Páara a execução do programa
3.2Comando do-while
Assim como o comando while, este comando permite a

execução de comandos enquanto uma determinada condição for
verdadeira. Porém, a diferença é que a condição é testada no final do
bloco de comando e não no início, permitindo assim, que pelo menos

uma vez, os comandos internos ao bloco de comandos sejam

executados, diferentemente do while, onde existe a possibilidade dos
comandos internos ao bloco de comandos nunca serem executados,
caso a condição seja falsa logo no primeiro teste.
Digite o Exemplo 3.3:- Faça um programa que receba o nome, a quantidade de horas
trabalhadas e o valor da hora de vários funcionários de uma empresa. Mostre, para cada
funcionário, o seu salário. Pergunte ao usuário se ele deseja continuar digitando dados de mais
funcionários.
4 char nome[30], resp; Declara a variável nome do tipo string de 30 caracteres e
a variável resp com 1 caractere
5 float horas, valor_h, sal; Declara variaveis do tipo float
6 do{ Abre o do-while
7 printf(“Nome:”); Imprime mensagem (rotulo do que será digitado)
8 fflush(stdin); Limpa buffer do teclado
9 gets(nome); Recebe string toda do usuário
10 printf(“Horas trabalhadas:”); Imprime mensagem (rotulo do que será digitado)
11 scanf(“%f”, &horas); Recebe horas trabalhadas do usuário
12 printf(“Valor hora:”); Imprime mensagem (rotulo do que será digitado)
13 scanf(“%f”,&valor_h); Recebe valor das horas trabalhadas do usuário
14 sal=horas * valor_h; Multiplica quant de horas pelo valor e guarda na
variavel sal
15 printf(“Salario : %.2f\n”, sal); Imprime a variavel sal
16 printf(“Deseja continuar <s/n>?”); Pergunta ao usuário se deseja continuar
17 fflush(stdin); Limpa buffer do teclado
18 resp=toupper(getchar()); Recebe a resposta do usuário e converte sua resposta
para maúscula
19 }while (resp=='S'); Verifica se a resposta é igual a S, caso seja, volta no “do”
para executar os comandos novamente
A função gets() é utilizada para receber strings (cadeia de

caracteres), a partir do usuário.
Muitas vezes, quando utilizamos funções de entrada para
receber caracteres (getchar()) ou strings (gets()), alguns códigos
permanecem na memória (buffer) do teclado. Utilizamos a função
fflush() para limpar este buffer e permitir que o programa pare para

receber novas informações.

A função toupper() transforma qualquer letra em letra
maúscula. Quando usamos a função getchar() como parâmetro, apenas
deixamos de usar uma variável para receber a eventual letra minuscula
digitada pelo usuário..
3.3Teste de mesa
Este tipo de teste é muito útil quando queremos verificar se
a lógica do nosso programa está correta. A compilação de um programa
verifica apenas erros de sintaxe, o que não significa que o nosso
programa funcione conforme planejamos que funcionasse. Bem, um
teste de mesa é tarefa simples, porém requer cuidados. Você assumirá
o papel do compilador quando da execução do programa, por isso não
podemos perder de vista a linha do programa que está sendo executada
em cada momento.
Começamos um teste de mesa montando uma única tabela
contendo uma coluna para cada variável declarada e mais uma coluna
para o que for escrito na tela, de acordo com o modelo abaixo. Os
valores das variáveis estarão sendo colocadas na tabela a medida que o
programa for requerendo. Assim como também, as mensagens que
serão impressas na tela. Sempre que colocamos um novo valor em uma
variável devemos riscar o anterior, dizendo a nós mesmos que o valor
mudou. Nunca apague os valores apenas risque-os.
Teste de mesa
Memória Tela
<var. 1> <var. 2> <var. 3> <var. 4>
<val. 1> <val. 4> <val. 5> <val. 7> <mensagem 1>
<val. 2> <val. 6> <val. 8> <mensagem 2>
<val. 3>
Vamos agora verificar como acontece na prática. Para isso,

usaremos a lógica do exemplo 3.3.4, modificado para 5 funcionários.
Reproduziremos a tabela a cada passo para que você entenda melhor.
1 int idade, somaid, qtd;

2 qtd=1;
3 somaid=0;
4 while (qtd<=5){

5 scanf("%i",&idade);
6 somaid=somaid+idade;
7 qtd=qtd+1;
8 }
9 printf("A soma das idades eh %i", somaid);
Linha 1 – cria a coluna das variáveis e a da 20 0 1

tela. 20
Teste de mesa
Memória tela Linha 7 – soma 1 em qtd
Idade somaid qtd Teste de mesa
Memória tela
Linha 2 e 3 – atribui 1 e 0 para as respectivas Idade somaid qtd
variáveis.
20 0 1
Teste de mesa 20 2
Memória tela
Idade somaid qtd Linha 8 – fecha o looping e volta para linha
4
0 1
linha 4 – Verifica se qtd é menor ou igual a
linha 4 – Verifica se qtd é menor ou igual a 5. O retorno é verdadeiro. Isto não gera
5. O retorno é verdadeiro. Isto não gera alteração na tabela, apenas define que
alteração na tabela, apenas define que executaremos a linha 5.
executaremos a linha 5.
linha 5 – Simulamos um valor digitado pelo
linha 5 – Simulamos um valor digitado pelo usuário.
usuário. Teste de mesa
Teste de mesa
Memória tela
Memória tela
Idade somaid qtd
Idade somaid qtd
20 0 1
20 0 1 25 20 2
Linha 6 – soma idade a somaid e guarda em

somaid
Teste de mesa
Linha 6 – soma idade a somaid e guarda em Memória tela
somaid Idade somaid qtd
Teste de mesa 20 0 1
Memória tela 25 20 2
45
Idade somaid qtd

Linha 7 – soma 1 em qtd

Teste de mesa Linha 8 – fecha o looping e volta para linha
4
Memória tela
Idade somaid qtd linha 4 – Verifica se qtd é menor ou igual a
5. O retorno é verdadeiro. Isto não gera
20 0 1
alteração na tabela, apenas define que
25 20 2
executaremos a linha 5.
45 3
linha 5 – Simulamos um valor digitado pelo
Linha 8 – fecha o looping e volta para linha usuário.
4
Teste de mesa
linha 4 – Verifica se qtd é menor ou igual a Memória tela
5. O retorno é verdadeiro. Isto não gera Idade somaid qtd
alteração na tabela, apenas define que
executaremos a linha 5. 20 0 1
25 20 2
linha 5 – Simulamos um valor digitado pelo 23 45 3
usuário. 30 68 4
Teste de mesa Linha 6 – soma idade a somaid e guarda em

somaid
Memória tela
Teste de mesa
Idade somaid qtd
Memória tela
20 0 1
25 20 2 Idade somaid qtd
23 45 3 20 0 1
25 20 2
Linha 6 – soma idade a somaid e guarda em 23 45 3
somaid 30 68 4
Teste de mesa 98
Memória tela
Idade somaid qtd
20 0 1
25 20 2
23 45 3
68
Teste de mesa Linha 7 – soma 1 em qtd
Memória tela Teste de mesa
Idade somaid qtd Memória tela
25 20 2 20 0 1
23 45 3 25 20 2
68 4 23 45 3


98 5 20 0 1
25 20 2
Linha 8 – fecha o looping e volta para linha 23 45 3
4 30 68 4
28 98 5
linha 4 – Verifica se qtd é menor ou igual a 126 6
5. O retorno é verdadeiro. Isto não gera
alteração na tabela, apenas define que Linha 8 – fecha o looping e volta para linha
executaremos a linha 5. 4
linha 5 – Simulamos um valor digitado pelo linha 4 – Verifica se qtd é menor ou igual a
usuário. 5. O retorno é falso. Isto não gera alteração
na tabela, apenas define que executaremos a
Teste de mesa linha 9.
Memória tela
Idade somaid qtd linha 9 – Imprime a somatória na tela.
20 0 1 Teste de mesa
25 20 2
23 45 3 Memória tela
28 98 5 20 0 1 A soma das idades eh
25 20 2 126
Linha 6 – soma idade a somaid e guarda em 23 45 3
somaid 30 68 4
Teste de mesa 28 98 5
Memória tela 126 6
Idade somaid qtd

20 0 1
25 20 2
23 45 3
30 68 4
28 98 5
126
Teste de mesa
Memória tela
Aprenda a fazer teste de mesa em todos os programas que

desenvolver, isto fará com que você se certifique que seu programa
está correto e o ajudará a solidificar o aprendizado lógico.
3.4Exercícios

3.3.1Imprima os 10 primeiros números inteiros na tela.

3.3.2Imprima o quadrado dos 10 primeiros números inteiros.
3.3.3Faça um programa que permita que o usuário digite a idade de 10 funcionários.
3.3.4Faça um programa que permita que o usuário digite a idade de 10 funcionários e após a
digitação, mostre a somatória das idades. A soma das idades deve ser feita dentro do looping e
apenas a exibição fora dele.
3.3.5Um usuário tem em suas mãos 100 Notas Fiscais. Faça um programa que receba seus
valores e calcule o total de todas as Notas.
3.3.6 Implementar um programa que imprima a tabuada de um número digitado pelo usuário.
3.3.7 Faça um programa que calcule e mostre o quadrado de um número N inteiro positivo,
digitado pelo usuário. O cálculo deve ser feito através da soma dos N primeiros números ímpares.
3.3.8 Em uma loja, todos os clientes que comprarem mais de R$ 300,00 receberão um desconto
proporcional ao valor de sua compra, de acordo com a tabela abaixo:
Valor da compra (R$) Desconto (%)

Até 500,00 5
De 501,00 a 1000,00 10
Acima de 1000,00 12
Você foi incumbido de fazer um programa que permita que o cliente entre com o valor dos
produtos comprados e mostre o total da compra, o valor do desconto e o preço a pagar. Pergunte
ao usuário se deseja terminar a digitação dos produtos e também se deseja finalizar o programa.
3.3.9 A CPFL deseja saber quantos usuários de um bairro de classe média ultrapassa o consumo
mensal ideal. Para isso a empresa tem em suas mãos o consumo mensal ideal, que deve ser
recebido pelo programa uma única vez, e as medidas do mês anterior e do mês atual das 5000
residências do bairro, para verificar o consumo calculado pela diferença entre eles.
3.3.10Faça um programa que calcule o fatorial de qualquer número digitado pelo usuário,
sabendo que o fatorial de um número é o produtório dos números inteiros entre 1 e ele mesmo.
5
3.3.11Calcule a seguinte expressão: ∑
i= 1
xi
Onde: x é digitado pelo usuário.
3.3.12 Faça um programa que leia uma coleção de números inteiros e calcule sua média
quadrática. A média quadrática é dada pela fórmula:
MQ = x12 + x22 + x32 + x42 +  + xn2
O programa encerra-se quando o valor de x for 0.
3.3.13 Calcule a expressão, sem utilizar a função pow() da math.h: X Y
Onde: X e Y são digitados pelo usuário
3.3.14Faça um programa que calcule o fatorial de qualquer número digitado pelo usuário,
sabendo que o fatorial de um número é o produtório dos números inteiros entre 1 e ele mesmo
3.3.15A seqüência de Fibonacci segue a seguinte ordem:
0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , 55 , 89 , ...
Repare que cada termo é a somatória dos dois anteriores, sendo que os dois primeiros são 0 (zero)
e o 1 (um). Faça um programa que receba um valor do usuário e imprima os termos da seqüência
de Fibonacci menores que o valor digitado.

3.3.13Uma das primeiras aplicações de computadores foi o cálculo de trajetória de projéteis. Se

um projétil é atirado com uma velocidade inicial V (m/s) a um ângulo de inclinação θ (radianos),
sua posição no plano vertical (x,y) no tempo t (segundos) é calculada pelas fórmulas:
x=Vcosθ t
1
y=Vsenθ t− g t 2
2
π m
Onde: 0θ e g =9.8 2
2 s
Faça um programa que, dados os parâmetros θ e V, liste as coordenadas x e y em intervalos de
0.01 segundos para um tiro em particular, terminando a listagem quando o projétil atingir o
solo.

4 - Vetor
Até agora utilizamos estruturas únicas na memória, ou seja,

um único espaço foi alocado de cada vez. Porém, existem situações nas
quais queremos agrupar seqüencialmente na memória os nossos dados,
de forma a resgatá-los de maneira mais fácil. Podemos fazer a seguinte
analogia: geralmente, alocamos uma única casa e damos um nome
para ela. Quando queremos alocar um vetor, alocamos uma rua inteira e
damos um único nome para ela. Como a rua tem várias casas (neste
caso do mesmo tamanho), o compilador, automaticamente, atribui um
numero para cada casa, começando do zero. Chamamos este número
de índice. Assim:
int vet[5];
Aloca 5 espaços contíguos na memória, chamado vet, com

seu índice variando de 0 à 4. A figura 4.1 mostra alguns elementos
alocados através desta definição.
10 15 7 4 34
0 1 2 3 4
Figura 4.1 - Alocação de elementos em um vetor de 5 posições
Para manipular as informações armazenadas no vetor,

devemos especificar o nome da variável e o índice referente ao espaço
que queremos tratar, entre colchetes. Assim,
int a[10];
alocará 10 espaços de inteiros na memória e para acessá-los

basta escrever o nome da variável juntamente com o índice da posição
a qual quer acessar. Ou seja,
a[0], para acessar o índice 0,

e assim por diante.
Quando nosso vetor é muito grande, fica inviável a utilização

de constantes numéricas como índice (0, 1, 2, 3 etc), ao invés disso,
usamos variáveis. Aliás, esta é a grande vantagem dos vetores:
manipularmos as variáveis nos loopings para acessar as posições sem
precisar escrever cada posição. Um comando de looping muito utilizado
juntamente com vetores é o “FOR”, pois através dele podemos controlar

melhor as variáveis de controle dos índices.
4.1Comando For
Sintaxe:
for (<inicialização>;<condição>;<incremento>){
<comando>
}
Este comando permite repetir a execução de um ou mais

comandos que estarão dentro do seu “bloco de comandos”. Como
podemos ver, tem a mesma função que os comandos while e do-while.
Ele permite 3 argumentos; o 1º é geralmente usado para inicialização
da variável de controle (contador) do looping e é executado apenas da
primeira vez; o 2º para a condição de execução dos comandos e é
testado todas as vezes e o 3º para incremento da variável de controle e
é executado todas as vezes. Ele geralmente é usado quando sabemos
quantas repetições teremos.
Assim,
for (i=0;i<10;i++){
a[i]=0;
}
fará a inicialização da variável i com 0; testará se i é menor

que 10; enquanto for menor, atribui 0 para a posição do vetor a[i]
(onde i tem um valor a cada looping); incrementa i e testa novamente
até que a condição seja falsa, ou seja, o valor de i seja 10 (posição
inválida no vetor).
Digite o Exemplo 4.1:- Faça um programa que receba as notas dos alunos de uma classe de 30
alunos e calcule a média da classe. A média deve ser retornada por uma função que receba o
vetor de notas como parâmetro.
1 /*-------------------------------------------------------- O “/*” e o “*/”, abre e fecha um bloco de
Descrição: Calcula media das notas de 30 alunos comentários. Estes comentários ajudam muito
de uma classe em seus estudos. Faça isso em todos os seus
Data : Agosto/2004
programas.
Autor : Kesede R Julio
---------------------------------------------------------*/
2 #include <stdio.h> Permite inclusão de funções de i/o
3 #include <conio.h> Permite inclusão da função getch()
4 void main(){ Abre função principal

5 float notas[30], media, soma=0; Declara o vetor notas com 30 posições do tipo
float, assim como media e soma (inicializada
com 0)
6 int i; Declara variável i
7 for (i=0;i<30;i++){ Abre comando for. Inicializa i com 0, verifica
se i é menor que 30, na primeira vez. Nas
outras vezes, soma 1 em i e torna a verificar se
i é menor que 30
8 printf("Entre com a %d ª nota", i+1); Mostra uma mensagem na tela
9 scanf(“%f”,&notas[i]); Recebe valor digitado pelo usuário e guarda na
iésima posição de “notas”. Da primeira vez i é
igual a zero.
10 soma=soma+notas[i]; Acumula a nota recebida na variável “soma”
(inicializada com zero) .
11 } Fecha o comando for, fazendo o programa
voltar na linha 7
12 media= soma/i; Divide “soma” por “i” (sai do looping valendo
30) e guarda o resultado em “media”
13 printf("A media da classe eh: %.1f", media); Imprime o valor de “media”
4.2Exercícios
4.2.1Faça um programa que receba 5 valores inteiros em um vetor e mostre na tela, os valores
na ordem inversa.
4.2.2Faça um programa que receba as notas de 10 alunos de uma classe em um vetor e mostre a
média das notas.
4.2.3Faça um programa que receba, em um vetor, 200 valores inteiros, a partir do usuário. Após
o carregamento, mostre para o usuário apenas o conteúdo dos índices pares.
4.2.4Faça uma função que receba um vetor de inteiros, seu tamanho e o elemento a ser
procurado como parâmetro e retorne quantas vezes o elemento aparece no vetor.
4.2.5Cadastre em um vetor os índices de inflação dos 12 meses de 2008 (cada índice fará

referência a um mês do ano).
a)Mostrar a inflação e o mês (numericamente) de menor índice
b)Mostrar a inflação e o mês (numericamente) de maior índice
4.2.6Calcule o desvio padrão do vetor carregado no exercício 5.2.3.
DP =
 ∑  x i −x 2
n−1
Onde xi é cada posição do vetor, x traço é a média dos elementos do vetor e n é o total de
elementos.
4.2.7Faça um programa que receba do usuário um número inteiro N e um vetor X com N

números reais. Mostre o resultado da função abaixo.
N −1
S= ∑ x ii 2
i=0
Onde xi é cada posição do vetor e N é o total de elementos.
4.2.8Faça um programa que crie um vetor, digitado pelo usuário, com a idade de 100 pessoas.
Mostrar a media aritmética e a freqüência absoluta de uma determinada idade digitada pelo
usuário. Freqüência absoluta de um valor é o número de vezes que o mesmo aparece no conjunto
de valores (vetor).
4.2.9Cadastre em um vetor, 50 números de cheques que foram recebidos por uma loja em um dia
de trabalho. Permita que o usuário faça uma busca neste vetor, afim de verificar se um
determinado número de cheque foi ou não cadastrado. Dê mensagem ao usuário mostrando se o
número consta ou não no cadastro de cheques.
4.2.10. Em uma estrada, foi fixado um sistema de radar móvel contendo dois radares (r1 e r2) a
uma distancia de 10m um do outro. Considere que a velocidade máxima da estrada seja de 80
Km/h e o calculo da velocidade seja V=ds/dt, onde V é velocidade, ds é o espaço percorrido e dt
é o tempo gasto para atravessar este espaço. O programa deve receber o tempo em segundos de
cada veículo captado pelo sensor (em nosso caso, pelo usuário). Caso o veículo ultrapasse o

limite de velocidade o programa também receberá do sensor (do usuário), a placa do veículo. Crie
dois vetores (Placas e Velocidades) para armazenar a placa (apenas os 4 digitos finais) e a
velocidade de cada veículo multado. Quando o sensor (usuário) captar (digitar) 0(zero) no
tempo, significa que o radar foi retirado da estrada e o programa deve ser encerrado.
4.2.11 Em um depósito de pisos usados, o gerente deseja um programa onde o cliente possa dizer
quantos metros quadrados deseja cobrir de piso e ele possa dizer qual dos pisos (padrão 0,2 x 0,2
m) ele tem quantidade suficiente disponível. O programa deve carregar em cada posição do vetor
“Pisos” a quantidade disponível de cada tipo de piso (o índice será o código do piso). Para cada
cliente deverá ser digitado a quantidade em metros quadrados da área a ser coberta e o
programa mostrará o código de todos os pisos com quantidades suficientes.
4.2.12 Considere um sistema de sensoriamento de aquecimento de telhas em um determinado dia

(24 horas). Duas telhas são expostas ao sol com sensores sobre elas, uma com uma tinta especial
(telha 1) e outra não (telha 2 ). A cada 15 minutos o sensor capta (usuário digita) a temperatura
das telhas as quais são registradas em dois vetores distintos (TempTelha1 e TempTelha2).
Mostre qual das telhas teve menor aquecimento médio durante todo o dia.
4.2.13Um sistema de verificação de gastos elétricos foi implantado em uma residência. A

princípio, apenas dois aparelhos estão sendo medidos: ferro elétrico (codigo 1) e chuveiro (codigo
2). Sempre que um destes aparelhos é usado, o sensor capta o código (guardando-o em um vetor)
e o quanto gastou em KW (guardando-o em um outro vetor de índice correspondente). Mostre
ao final do dia (sensor capta código 0), quanto foi gasto por cada um dos aparelhos.
4.2.14Foi realizada uma pesquisa quanto a religião da população de uma determinada cidade.
Receba do usuário, os códigos ((P) protestante, (B) budista ou (C) católica) da religião dos 1000
moradores desta cidade, guardando-os em um vetor. Mostre o percentual de budistas,
protestantes e de católicos existentes na cidade.
4.2.15Um elevador tem sua carga máxima estipulada em 600 Kg. Um sensor foi instalado para
controlar este limite e avisar aos usuários sobre o perigo de excesso de peso. O sensor capta
código 1 quando uma pessoa entra, código 2 quando sai e código zero quando o dia termina. A
cada pessoa que entra seu peso é registrado em um vetor como valor positivo e quando a pessoa
sai seu peso é registrado como valor negativo. Sempre que o elevador ultrapassar sua carga

máxima, é mostrado em um monitor um aviso de “Peso Excedido”. Faça um programa que

execute a simulação de pessoas entrando e saindo do elevador. Os valores devem ser digitados
pelo usuário.
4.2.16Um sistema de auditoria foi instalado para verificar a movimentação diária de uma
determinada conta bancária suspeita. Toda movimentação é registrada em um vetor. Os créditos
são valores positivos e os débitos negativos. O sistema emite alerta se a movimentação foi ou
não zerada (créditos = débitos) ao final do dia. A movimentação termina com valor 0.

5 - String
String é uma cadeia de caracteres, ou seja, um sequência

de caracteres que são alocados na memória de forma contígua. Uma
característica particular da string é o seu terminador (‘\0’), que é
colocado na última posição da cadeia. Dessa forma, quando o printf()
imprime um string, ele imprime todos os caracteres até que encontre
um ‘\0’. Nós podemos declarar um string da seguinte forma:
char nome[10];
quando fazemos esta declaração, o compilador reserva um

espaço em memória chamado nome com tamanho de 10 caracteres, e
vincula a cada posição um numero de identificação o qual chamamos de
índice. O índice da primeira posição será sempre 0 (zero).
Quando pedimos para o usuário digitar algo em um string, o
compilador automaticamente aloca o terminador '\0' para a posição que
sucede o último caractere digitado pelo usuário. Geralmente, utilizamos
a função gets() para receber strings do usuário, pois esta função
permite a digitação de várias palavras no string, diferente do scanf()
que permite apenas uma. Assim:
gets(nome);
recebe um string do usuário e coloca, automaticamente, um

terminador no final.
Cada posição do string pode ser acessada separadamente,
assim:
strcpy(nome,”Isto e um string");
printf(“%c”,nome[2]); // imprimirá o caractere 't'
A linguagem C/C++ fornece uma biblioteca de funções para

manipulação de strings. Para utiliza-la, você deve incluir em seu
programa o header string.h. Algumas dessas funções são:
strcpy(): copia o conteúdo de um string para outro.

strcmp(): compara o conteúdo de duas strings.
strlen(): devolve o tamanho da string
strcat(): concatena duas strings
Para verificar a relação de todas elas assim como sua
sintaxe, verifique a documentação do header string.h.
Digite o Exemplo 5.1:- Faça um programa que atribua o conteúdo de uma string para outra

string e mostre-a na tela.

2 #include <string.h> Permite inclusão de funções para manipulação de string
4 int main(){ Abre função principal
5 char string[10]; Declara variavel “string” de 10 posições
6 char str1[10] = "abcdefghi"; Declara variável “str1” de 10 posições e inicializa com “abcdefghi”
7 strcpy(string, str1); Copia conteúdo de “str1” para “string”
8 printf(“%s”, string); Imprime o conteúdo de “string”
Digite o Exemplo 5.2:- Faça um programa que compare o conteúdo de strings e dê mensagens
indicando o resultado da comparação.
5 char buf1[4] = "aaa", buf2[4] = "bbb", Declara e inicializa variáveis
buf3[4] = "ccc";
6 int ptr; Declara variável “ptr”
7 ptr = strcmp(buf2, buf1); Compara conteúdo de “buf2” com conteúdo de “buf1”.
Atribui para “ptr” 0, 1 ou -1,caso sejam iguais, buf2 maior
que buf1 ou buf2 menor que buf1, respectivamente.
8 if (ptr > 0){ Verifica se “ptr” é maior que 0 (buf2 maior que buf1)
9 printf("buffer 2 eh maior que Caso seja, mostra mensagem
buffer 1\n");
10 } Fecha if
11 else{ Abre else
12 if (ptr == 0){ Verifica se “ptr” é igual a 0 (buf2 igual buf1)
13 printf("buffer 2 eh igual ao Caso seja, mostra mensagem
buffer 1\n");
14 } Fecha if
15 else{ Abre else
16 printf("buffer 2 eh menor que o Mostra mensagem, pois se entrou aqui é porque negou as
buffer 1\n"); duas condiões acima (com certeza buf2 é menor que buf1)
17 } Fecha else
18 } Fecha else
19 ptr = strcmp(buf2, buf3); Compara conteúdo de “buf2” com conteúdo de “buf3”.
Atribui para “ptr” 0, 1 ou -1,caso sejam iguais, buf2 maior

que buf1 ou buf2 menor que buf1, respectivamente.

20 if (ptr > 0){ Verifica se “ptr” é maior que 0 (buf2 maior que buf3)
21 printf("buffer 2 eh maior que Caso seja, mostra mensagem
buffer 3\n");
22 } Fecha if
23 else{ Abre else
24 if (ptr == 0){ Verifica se “ptr” é igual a 0 (buf2 igual buf3)
25 printf("buffer 2 eh igual ao Caso seja, mostra mensagem
buffer 3\n");
26 } Fecha if
27 else{ Abre else
28 printf("buffer 2 eh menor que o Mostra mensagem, pois se entrou aqui é porque negou as
buffer 3\n"); duas condiões acima (com certeza buf2 é menor que buf3)
29 } Fecha else
30 } Fecha else
31 getch(); Pará a execução do programa
Digite o Exemplo 5.3- Faça um programa que mostre a quantidade de caracteres de uma string.
2 #include <string.h> Permite inclusão de funções para manipulação de
string
5 #include <string.h> Permite inclusão de funções para manipulação de
string
7 char string[25] = "Kesede Rodrigues Julio"; Declara e inicializa variavel“string” de 25 posições
8 printf(“%d”,strlen(string)); Strlen() retorna a quantidade de caracteres que a
variável string contém. O resultado é mostrado na
tela
Digite o Exemplo 5.4:- Faça um programa que concatene duas strings e mostre o resultado da
concatenação na tela.

4 #include <string.h> Permite inclusão de funções para manipulação de strings

7 char destino[25]; Declara e inicializa variavel “destino” de 25 posições
8 char espaco[2] = " ", sobrenome[10] = Declara variáveis strings
"Rodrigues", nome[10] = "Kesede";
9 strcpy(destino, nome); Copia nome para destino
10 strcat(destino, espaco); Concatena (junta) espaço com destino
11 strcat(destino, sobrenome); Concatena (junta) sobrenome com destino
12 printf(“%s”, destino); Imprime destino
13 getch(); Pará a execução do programa
5.1Exercícios
5.1.1Faça um programa que receba uma frase do usuário e mostre quantas vogais a frase
contem.
5.1.2Faça um programa que mostre o número de palavras contidas em um string. O string deve
ser fornecido pelo usuário.
5.1.3 Um programa de criptografia codifica as vogais a, e, i, o, u como 1, 2 ,3, 4, 5,
respectivamente. Faça um programa que receba uma frase codificada do usuário e mostre-a
decodificada.
5.1.4 Faça um programa que receba o nome completo do usuário e mostre a abreviatura do seu
nome.
5.1.5 Faça uma função que receba um string como parâmetro e devolva o conteúdo da string em
ordem alfabética. Um string é um vetor de caracteres contendo '\0' como finalizador.
void stralf(char *s1);
5.1.6 Faça um programa que receba uma frase do usuário. Construa outra string contendo a
primeira letra de cada palavra, da última até a primeira, separados por espaços em branco. Ex.:
Frase : Nesta prova vou tirar um dez.
Iniciais: d u t v p N
5.1.7 Faça um programa que receba um string do usuário e guarde em um vetor os índices da
string que contem a letra 'a'.
5.1.8 Faça um programa que receba o nome completo do usuário, construa outra string com o
primeiro nome completo e os outros abreviados, separados por espaços em branco.
Ex.:
Nome Completo : Kesede Rodrigues Julio
Nome Abreviado: Kesede R J
5.1.9Faça um programa que receba do usuário em duas strings distintas, uma frase e uma
sequencia de duas letras, supostamente contida na frase. Mostre quantas vezes a sequencia
aparece na frase. Ex.:
Frase: Descobertos mais ossos de polêmica espécie de hominídeos

Sequencia: es
Resultado: 2
5.1.10Faça um programa que receba uma frase do usuário e mostre a quantidade de ditongos
e/ou hiatos (duas vogais consecutivas) encontrados.
5.1.11 Faça um programa que mostre para o usuário uma string contendo o primeiro e o último
nome de uma pessoa. O programa deve receber do usuário uma string contendo o nome completo
da pessoa.
5.1.12 Faça um programa que receba o nome completo da pessoa e devolva este nome na forma
bibliográfica.
5.1.13Faça um programa que receba uma frase do usuário. Logo em seguida receba também uma
palavra. O programa deve mostrar uma mensagem dizendo se a palavra digitada esta contida ou
não na frase.
5.1.14Faça um Jogo da Forca.

6 - Matriz
São vetores multi-dimensionais. Ao invés de trabalharmos

com um único índice, trabalhamos com vários. Em nossa analogia com
ruas e casas, no caso dos vetores, teríamos aqui a comparação com um
quarteirão. Assim, além dos números das casas teremos que saber o
número da rua onde ela se localiza. Desta forma,
a[3][3];
reserva 9 posições na memória, podendo, conceitualmente,

considerar o 1º índice como linha e o segundo como coluna.
0 1 2
0 10 20 43
1 27 8 78
2 82 3 7
Figura 6.1 - Alocação de elementos em uma matriz 3x3.
Para acessarmos qualquer posição, basta escrever o nome

da variável juntamente com o número do índice da linha e o da coluna.
Assim,
a[1][2] = 78;
colocará o valor 78 para a 2ª linha da 3ª coluna. (o índice

começa em 0).
Geralmente, temos um número grande de posições e
precisamos de um comando de looping para nos ajudar a modificar os
índices sem muita escrita de código. Portanto,
for (i=0;i<10;i++){
for (j=0;j<10;j++){
a[i][j] = 0;
}
}
colocará o valor 0 (zero) para toda a matriz, percorrendo

todas as colunas de todas as linhas.

Digite o exemplo 6.1: Faça um programa que carregue, a partir do usuário, uma matriz 10x10
representando o centro de uma cidade. Cada índice, contém o número de acidentes anual
ocorridos em cada cruzamento. O programa deve mostrar a esquina (linha e coluna) que ocorreu
o maior número de acidentes.
1 #include <stdio.h> Include arquivo de cabeçalho
3 int ac[10][10], int i_maior, int j_maior, i, j, maior; tot=0; Declara variáveis.
4 for(i=0; i<10; i++){ Carrega a matriz a partir do usuário
for(j=0; j<10;j++){
scanf(“%d”, &ac[i][j]);
}
}
5 maior=ac[0][0]; Incializa a variavel auxiliar “maior”
for(i=0; i<10; i++){ com o primeiro elemento da matriz. Em
for(j=0; j<10;j++){
if(ac[i][j] > maior){ seguida, percorre a matriz verificando
i_maior=i; se existe algum elemento maior que o
j_maior=j;
maior=ac[i][j]; primeiro, guardado na variavel “maior”.
} Caso exista, atualiza “maior” e guarda
}
} os índices (esquina) deste elemento. Ao
getch(); final, pára o programa.
6 } Fecha main()
6.1Exercícios
6.1.1- Faça um programa que carregue em uma matriz as notas dos 30 alunos das 3 turmas que
um professor leciona. Mostre a media de cada turma. Faça um programa para carregar a matriz
e uma para o cálculo das médias.
6.1.2- Faça um programa que mostre o menor valor de uma matriz. Receba os valores e a ordem
da matriz, a partir do usuário.
6.1.3- Faça um programa em C que receba do usuário uma matriz NxM (N é o número de linhas
e M o número de colunas) de números inteiros, e armazene na linha N-1 o somatório dos
elementos de cada coluna (linhas de 0 a N-2). Exibir os resultados. Como exemplo, considere a
matriz 4 x 2 a seguir. A última linha conterá o somatório das linhas anteriores. Ex.:
0 1
0 4 2
1 5 9
2 8 20

3 17 31
6.1.4- Faça a multiplicação de duas matrizes. Receba os valores e as ordens das matrizes, a
partir do usuário. Faça todas as consistências necessárias.
6.1.5 - Preencha uma matriz quadrada da seguinte forma:
se i <> j, m[i, j] = 0 e
se i = j, m[i, j] = 1
A ordem e seus valores devem ser recebidos pelo usuário.
6.1.6- Mostre quantos elementos diferentes de zero existem em uma matriz. A ordem e seus
valores devem ser recebidos pelo usuário.
6.1.7– Verifique se uma determinada matriz é simétrica. A ordem e seus valores devem ser
recebidos pelo usuário.
6.1.8Faça um programa que carregue uma matriz de inteiros 5x5, a partir do usuário. Mostre
na tela a somatória de todos os valores, exceto os valores da diagonal principal.
6.1.9Faça um programa que carregue uma matriz de inteiros 10x10, a partir do usuário.
Carregue um vetor com os valores da diagonal secundária da matriz.
Mostre na tela a somatória de todos os valores, exceto os valores das linhas pares.
Carregue um vetor com os valores da diagonal secundária da matriz.
6.1.12Em uma auto-pecas, o proprietário deseja manter uma tabela de custos de suas peças.
Nesta tabela, cada coluna representa uma peca e cada linha o preço de custo de cada fornecedor.
Faça um programa que permita ao proprietário carregar esta tabela e logo em seguida digitar o
código de uma peça (índice da coluna) para que o programa possa mostrar qual o código do
fornecedor (índice da linha) que tem o preço de custo mais barato.
6.1.13Em uma transportadora, as distâncias entre cidades, são dadas por uma tabela, onde as
linhas são as cidades de origem, e as colunas de destino, e portanto os valores da diagonal
principal desta matriz é zero. Os índices da matriz são os códigos das cidades. Permita que seu
programa mostre qual o destino mais distante, dado uma origem. O programa deve receber a
tabela de distancias (100 x 100), e logo em seguida, receber o código da origem.
6.1.14Considere que um engenheiro deseja saber qual a distância entre diversas localizações em
uma área. Para isto ele tem em mãos apenas as coordenadas x,y de cada localização. Faça um
programa que permita que o engenheiro carregue uma tabela (nx5) onde as colunas representem
as coordenadas x,y de cada ponto, assim como a distância entre eles. O cálculo da distância é
dado por: 2 . O valor de n será dado pelo usuário.
d= ( x 2 − x1) + ( y 2 − y1)
2
6.1.15Escreva um programa que receba uma matriz (10x10) do usuário e mostre quantos
elementos diferentes de zero existem na matriz.
6.1.16Considere uma imagem nivel de cinza representada por uma matriz (512x512), onde cada
posição contem um valor inteiro equivalendo a tonalidade da cor (0..255) naquele ponto.
Carregue as tonalidades de cor de uma linha (vetor de 512) desta imagem através do usuário.
Após o carregamento , faça a suavização desta imagem da seguinte forma: o valor da posição
será igual a média do seu valor e de seus vizinhos Vi = (Vi-1 + Vi + Vi+1) / 3.
7 - Estruturas Heterogêneas
Uma estrutura heterogênea permitir agrupar variáveis de

tipos diferentes em um espaço contíguo na memória, facilitando assim a
manipulação destas informações.
Informações pertencentes a mesma entidade são passíveis
de serem agrupadas em uma estrutura heterogênea, como:
coordenadas de um ponto, descrições de uma máquina, score de um
jogador etc.
Para construirmos estruturas heterogêneas em linguagem C,
usamos uma “struct”. Ex.:
struct jogador{
char nome[40];
int scoreMensal;
int scoreDiario;
};
para podermos utilizar (incluir e consultar) estes

informações, devemos declarar uma variável do tipo struct, usando o
nome da struct, neste caso, jogador. Ex.:
jogador jog1, jog2;
Neste caso, instanciamos (declaramos) dois jogadores com

a mesma estrutura de dados. Agora, podemos atribuir valores para
nossas duas instâncias. Ex.:
gets(jog1.nome);
jog1.scoreMensal=2500;
jog1.scoreDiario=150;
gets(jog2.nome);
jog2.scoreMensal=3400;
jog2.scoreDiario=100;
Note que temos que usar o “.” (ponto) para separar o nome
da variável estrutura (variável declarada do tipo estrutura) da variável
membro (variáveis internas).
Como uma estrutura funciona como um tipo, podemos
declarar vetores e até matrizes de estruturas. Por exemplo, se
tivéssemos 10 ou 100 jogadores, não seria prático declararmos uma

variável para cada jogador, assim poderíamos declarar uma variável

vetor do tipo estrutura. Ex.:
jogador jog[100];
Desta forma, fica fácil executar um looping que carregue, a

partir do usuário, o nome de todos os jogadores. Ex.:
for (c=0;c<100;c++){
gets(jog[c].nome);
}
Algumas considerações devem ser relevadas, assim como:
1. Variável estrutura pode receber, de uma só

vez, todo o conteúdo de outra variável estrutura.
2. Uma estrutura pode conter outras estruturas,

ou seja, podemos ter estruturas aninhadas./
3. Podem ser passadas como parâmetro, por

valor ou por referência.
4. Variável do tipo estrutura pode ser retornada

de funções.
O Exemplo abaixo mostra um uso prático.
Digite o exemplo 7.1: Faça um programa que carregue, a partir do usuário, os dados geográficos
das cidades do Brasil. Inclua estas informações em um vetor de estrutura. Os dados são: nome
da cidade, x e y (a origem 0,0 deste sistema é Brasília). Após a inclusão destes dados, o
programa deve permitir ao usuário a digitação de um cidade qualquer, sua referência x e y, e
listar a distância desta cidade em relação a cada cidade cadastrada.
1 #include <stdio.h> Include arquivos de cabeçalho
#include <stdlib.h>
#include <conio.h>
#include <ctype.h>
#include <math.h>
3 typedef struct DadosGeo{ Declara uma struct como tipo contendo
char nome[50]; 3 informações: nome, x, y
int x, y;
};

int i=0, xRef, yRef, qtdcid; Declara variáveis, inclusive o vetor

DadosGeo cidades[1000]; “cidades” do tipo DadosGeo
char nomeRef[50], resp;
float dist;
4 do{ Carrega o vetor, a partir do usuário
system("cls");
printf("Nome: ");
fflush(stdin);
gets(cidades[i].nome);
printf("\nPosicao X: ");
scanf("%i",&cidades[i].x);
printf("\nPosicao Y: ");
scanf("%i",&cidades[i].y);
i++;
printf("Existem mais cidades? <S/N> ");
fflush(stdin);
resp=toupper(getch());
}while (resp=='S');
5 qtdcid=i; Guarda a quantidade de cidades
digitadas pelo usuário, para usar no
controle do FOR.
6 printf("\nEntre com o nome da cidade referencia: "); Recebe do usuário os dados da cidade
gets(nomeRef); que será referência para o cálculo das
printf("\nPosicao X: ");
scanf("%i",&xRef); distâncias
printf("\nPosicao Y: ");
scanf("%i",&yRef);
7 printf("\n\nListagem das distancias\n"); Percorre todo o vetor, calculando a
for (i=0;i<qtdcid;i++){ distância para cada cidade. Mostra o
dist=sqrt(pow(xRef-cidades[i].x,2)+pow(yRef-
cidades[i].y,2)); nome da cidade e a distância.
printf("%-10s - %.1f Km\n", cidades[i].nome, dist);
}
getch();
8 } Fecha main()
7.1 Exercícios
7.1.1 Faça um programa que receba, do usuário, o código, o nome, a população, o

tamanho em metros quadrados, posição x e posição y de todas as cidades do estado.
Guarde as informações em um vetor de structda struct. A inclusão termina quando o
código for igual a 9999.
7.1.2 Faça um programa que receba do usuário, as coordenadas x e y e o nome de cada
peça de um jogo de xadrez. Após o carregamento dois dois vetores de struct (um para
peças brancas e outro para as pretas), permita que o usuário faça alterações da posição
de qualquer peça, digitando o nome da peça, sua cor, novo x e novo y. Não precisa fazer
consistência.

8 - Funções
Até agora todos os nossos os comandos e funções pré-

definidas (printf(), scanf(), system(), pow(), sqrt() etc) que usamos
estavam dentro de uma única função (main()), que é chamada de
função principal. No entanto, podemos construir as nossas próprias
funções e montarmos nosso programa como sendo um conjunto de
funções. Até agora os nossos programas continham uma única função
chamada “main()”, onde fazíamos as chamadas das funções pré-
definidas, juntamente com os comandos (if, while etc) para compormos
a nossa lógica de programação. Para criarmos nossas próprias funções,
seguimos a mesma sintaxe da função principal main(). Sempre que
escrevermos uma função, é uma boa prática colocarmos o seu protótipo
(cabeçalho da função seguido de ponto-e-vírgula) logo abaixo dos
includes. Abaixo segue um exemplo de estrutura de uma função.
<tipo de retorno> <nome da função>(<parametros>){

<declaração de variáveis>
<comandos e chamadas de funções pré-definidas ou não>
}
Onde:
tipo de retorno: pode ser void, float, int, char
nome da função: nome que será usado ao chamarmos a
função para executá-la.
parâmetros: variáveis que são recebidas de uma outra
função.
declaração de variáveis: onde, geralmente, criam-se as
variáveis (alocação de espaço na memória)
<comandos e chamadas de funções pré-definidas ou não>:
onde a lógica é codificada
}: fecha a função
Digite o Exemplo 8.1: Faça um programa que execute e mostre a soma de números inteiros,
mostrando uma mensagem de saudação no início do programa e uma mensagem de despedida
no final. Use funções para as mensagens.
1 #include <stdio.h> Declara os protótipos das funções pré-definidas
2 #include <conio.h>
3 void BemVindo(); Declara os protótipos das funções escritas pelo
programador
4 void Despedida();

6 int a,b,c;
7 BemVindo(); Chama a função BemVindo() para execução
8 scanf(“%i”,&a); Usuário digita valores para “a” e “b”
9 scanf(“%i”,&b);
10 c=a+b; Soma “a” e “b” e guarda em “c”
11 printf(“%i”,c); Imprime “c”
12 Despedida(); Chama a função Despedida() para execução
15 void BemVindo(){ Abre a função BemVindo()
16 printf(“BemVindo ao programa!!”); Mostra mensagem
17 } Fecha a função BemVindo()
18 void Despedida(){ Abre a função Despedida()
19 printf(“Tchau!!!!!”); Mostra mensagem
20 } Fecha a função Despedida()
No exemplo 8.1, a função principal “main()” chama a função

BemVindo() no início do programa e chama a função despedida() ao
final dele. Quando a função BemVindo() é chamada, a execução é
desviada para a linha 15. Assim que termina a execução da função
BemVindo() (linha 17), o compilador volta a execução para a linha da
função que chamou, ou seja, linha 7, e continua a execução a partir daí.
O mesmo acontece com a chamada da função Despedida().
8.1Passagem de Parâmetros por Valor e Retorno de Valor

Quando precisamos enviar valores para a função, esses
valores são enviados através de parâmetros. Ao chamarmos a função,
enviamos os valores que queremos como entrada da função chamada, e
no cabeçalho da implementação da função, declaramos variáveis para
recebê-los. Quando precisamos retornar um valor a partir de uma
função, podemos usar o comando return e declarar o tipo do valor
retornado antes do nome da função (ao invés de void).
Digite o Exemplo 8.2: Faça uma função que posicione o cursor na tela. A função deve receber
os parâmetros de coluna e linha para posicionamento. Faça também a função principal para
apresentar uma mensagem posicionada na tela.
1 #include <stdio.h> Permite o uso da função printf()


3 void poscur(int col, int lin){ Abre a função poscur() e recebe seus parâmetros
4 int i; Declara variável i
5 i=1; Inicializa i com o valor 1
6 while(i<lin){ Verifica se i é menor que lin (recebido como parâmetro)
7 printf("\n"); Caso seja, pula uma linha na tela
8 i++; Soma 1 à variável i
9 } Fecha o while e volta para linha 6. Enquanto i for menor que lin
permanece pulando linha.
10 i=1; Inicializa i com o valor 1
11 while(i<col){ Verifica se i é menor que col (recebido como parâmetro)
12 printf(" "); Caso seja, imprime um espaço em branco na tela
13 i++; Soma 1 à variável i
14 } Fecha o while e volta para linha 11. Enquanto i for menor que col
permanece imprimindo espaço em branco.
15 } Fecha a função poscur()
16 void main(){ Abre a função principal
17 poscur(10,20); Chama a função poscur para a execução, enviando os valores 10 para a
variável col e o valor 20 para a variável lin
18 printf("Oi!"); Imprime uma mensagem na posição atual do cursor na tela.
A função (poscur()) do Exemplo 8.2, pode também ser

usada para scanf(), quando quiser receber uma informação do usuário
em um local definido na tela.
Digite o Exemplo 8.3: Faça um programa que receba dois valores, some-os e mostre o
resultado. A função principal (main) deve apenas receber os valores e mostrar o resultado na
tela.
#include <stdio.h> Inclui os protótipos (cabeçalhos de funções) pré-definidos
#include <conio.h>
1 int soma(int x, int y); Declara o protótipo da função soma()
2 int main(){ Abre a função principal, a primeira linha a ser executada no programa
3 int a,b,s; Declara variáveis “a”, “b” e “s”
4 scanf(“%d”,&a); Recebe o valor da variável a, digitada pelo usuário
5 scanf(“%d”,&b); Recebe o valor da variável b, digitada pelo usuário
6 s=soma(a,b); Chama a função soma() e atribui o valores de “a” e “b” para “x “ e “y” da linha 9,
respectivamente. Após a execução da função, o retorno de soma é atribuído para a
variável “s”.

7 printf(“%d”,s); Imprime o conteúdo da variável s.

10 int soma(int x, int y){ Abre a função soma() do tipo int (tipo do valor do retorno) e recebe o valor de “a”
em “x” e “b” em “y”.
11 int res; Declara variável local “res”
12 res=x+y; Soma os conteúdos de “x” e “y” e atribui para a variável “res”
13 return res; Retorna o conteúdo de “res” para a função chamadora (linha 6).
14 } Fecha a função soma()
No exemplo 8.3, chamamos a função soma() e enviamos

para ela os valores das variáveis “a” e “b”. Na implementação da função
soma(), declaramos as variáveis “x” e “y”, do mesmo tipo de “a” e “b”,
para receber estes valores. Esta é a forma de atribuirmos valores
externos para dentro da nossa função. A função soma() faz o cálculo e
retorna (return(res)) o valor da variável que contém o resultado para a
chamada da função, por isso que, na chamada da função temos uma
atribuição deste valor para a variável s. Resumindo, o recebimento dos
valores é realizado na função principal, o cálculo na função soma() e o
resultado mostrado na função principal.
8.2 Passagem de Parâmetros por Referência
Quando precisamos retornar mais de um valor, o return não

é suficiente, pois ele só consegue retornar um único valor. Nestes
casos, utilizamos a passagem de parâmetro por referência, que permite
a alteração do valor da variável enviada à função. Ao invés de
mandarmos o valor da variável, mandamos o seu endereço. Isto faz
com possamos alterar o valor da variável dentro da função, ou seja, o
que fizermos com a referencia (endereço) da variável dentro da função,
é refletido fora dela.
Digite o Exemplo 8.4: Faça uma função que receba o valor do lado de um quadrado e devolva
sua área e seu perímetro.

3 void area_per(float l, float *a, float *p); Declara o protótipo da função
5 float lado, perimetro, area; Declaração da variáveis locais
6 scanf(“%f”,&lado); Recebe valor de lado do usuário

7 area_per(lado, &area, &perimetro); Chama a função area_per() e envia o valor de

“lado”, o endereço de “area” e o endereço de
“perimetro”.
8 printf(“área = %.2f perímetro = %.2f“, area, Imprime o valor de area e perimetro, alterados na
perimetro); função area_per()
11 void area_per(float l, float *a, float *p){ Abre função area_per() e recebe o valor enviado de
“lado” (linha 7) em “l”, o endereço enviado de “area”
(linha 7) em “a” e o endereço enviado de “perimetro”
(linha 7) em “p”
12 *p = l * 4; Calcula o perímetro e atribue o resultado no
conteúdo do endereço p (variável perímetro)
13 *a = l * l; Calcula a área e atribue o resultado no conteúdo do
endereço a (variável area)
14 } Fecha a função area_per()
No exemplo 8.4, uma função "área_per()" é chamada e são

enviados 3 parâmetros: lado, área e perímetro. A variável "lado" está
sendo enviada como parâmetro por valor, ou seja, seu valor é enviado
à função e não seu endereço. Uma variável está declarada, na
implementação da função, para receber este valor: "l". Já as variáveis
"area" e "perimetro" estão sendo enviadas como parâmetro por
referência (símbolo & antes do nome da variável), e portanto, os seus
endereços estão sendo enviados. Declaramos duas variáveis para
receber estes endereços: "a" e "p". Estas variáveis são do tipo "ponteiro
para float". Este tipo de variável é próprio para guardar endereço.
Quando calculamos a área e o perímetro, atribuímos seus resultados
em "*a" e "*p", respectivamente. Isto significa que, quem estão
recebendo os valores são as variáveis que foram enviadas ("area" e
"perimetro") e não as variáveis "a" e "p", pois "a" e "p" são apenas
referências (endereços) de “a” e “p”.
8.3 Exercícios
8.3.1 Escreva uma função capaz de retornar a média aritmética de três parâmetros passados.
8.3.2 Escreva uma função capaz de escrever mensagens em uma posição (x,y) da tela.
8.3.3 Escreva uma função que receba a base e a altura de um triângulo como parâmetro e
retorne a área desse triângulo. Area = (base * altura) / 2

8.3.4 Escreva uma função receba dois valores inteiros e um operador (+, -, * ou /). Faça o
cálculo de acordo com o operador e retorne o resultado. Os valores e o operador devem ser
digitados pelo usuário na main(), onde também será impresso o resultado da operação.
8.3.5 Escreva uma função que receba os três coeficientes de uma equação de 2º grau e devolva
as raízes da equação, caso existam. Retorne 0 se não existir raiz, 1 se existir uma única raiz, e 2
se existirem duas raízes. O protótipo da função será: int bascara(float ax, float bx, float cx,
float *raiz1, float *raiz2);

9 - Arquivo
9.1Armazenamento em disco
Podemos armazenar informações em disco de duas formas:

em modo binário ou em modo texto.
No modo binário o arquivamento é feito em bytes, ou seja,
guardamos um inteiro, float ou até mesmo um struct, que é o mais
comum.
No modo texto o arquivamento é feito em caracteres, ou
seja, guardamos dígito a dígito.
Podemos entender um arquivo de dados como um tabela
onde as linhas são os registros e as colunas, os campos. Ex.: Considere
o arquivo dos alunos da disciplina Cálculo.
Campo
RA Nome Nota
1231 Carlos 5,1 Registro
5432 Mônica 7,8
4533 Tânia 3,4
8754 Aurelio 6,9
Este caso, seria um típico caso para usar arquivo binário e

não texto, devido a natureza das informações.
Para armazenarmos as nossas informações em disco,
independente de ser binário ou texto, devemos declarar uma variável
ponteiro para uma estrutura FILE. Assim:
FILE *arq;
define a variável que manipulará o arquivo (pode ser tratada

também como nome interno do arquivo).
Algumas funções para manipulação de arquivo são
fornecidas pelo compilador. Apresentamos abaixo algumas funções para
arquivo binário:
fopen: Abre o arquivo e vincula o arquivo externo ao

interno.
<nome interno do arquivo>=fopen(“<nome externo do
arquivo>”,”<tipo de abertura>”)

fread: Lê uma estrutura do arquivo e aloca na memória.

fread(<endereço da estrutura>,<tamanho em bytes da
estrutura>,<qtd de estruturas a serem lidas>,<nome interno do
arquivo>)
fwrite: Grava uma estrutura no arquivo a partir da memória.

fwrite(<endereço da estrutura>,<tamanho em bytes da
estrutura>,<qtd de estruturas>,<nome interno do arquivo>)
fseek: Reposiciona o ponteiro do arquivo.

fseek(<nome interno do arquivo>,<deslocamento em
bytes>,<origem do deslocamento>)
ftell: Retorna quantidade de bytes do arquivo.

ftell(<arquivo>)
feof: Retorna true se o ponteiro estiver no final do arquivo e

false, caso contrário.
feof(<nome interno do arquivo>)
fclose: Fecha o arquivo.:

fclose(<nome interno do arquivo>);
Na abertura do arquivo, devemos definir como este arquivo

será manipulado (“tipo de abertura”). Para isso nós temos os seguintes
valores:
r :- abre apenas para leitura
w :- cria para gravação. Se o arquivo já existir ele será
sobreposto.
a :- Abre para gravação no fim do arquivo, ou cria para
gravação se o arquivo não existir.
r+ :- abre um arquivo existente para alteração.(leitura e
gravação)
w+ :- cria um novo arquivo para alteração. (leitura e
gravação). Caso o arquivo já exista ele será sobreposto.
a+ :- abre para alteração no fim do arquivo ou cria se o
arquivo não existir.
Para especificar se o arquivo será manipulado como texto ou
binário, acrescente a letra “t” ou ”b” na string, respectivamente. (rt,
w+b etc).
O exemplo 10.1 deve ser digitado em um único arquivo, pois
é composto por várias funções, cada uma para uma manipulação
específica do arquivo.

Digite o Exemplo 9.1: Faça a manutenção (Inclusão, Consulta Geral, Consulta por Código,
Alteração e Exclusão) de um arquivo de brinquedos de uma fabrica.
1 #include <string.h> Inclui protótipos pré-definidos
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
2 void inclusao(); Inclui protótipos das funções que foram criadas pelo
int consulta_geral(); programador
int consulta_cod();
int alteracao();
int exclusao();
char menu();
3 struct Reg_brinq{ Define uma estrutura chamada Reg-brinq, contendo 4
char cod_prod[5]; variáveis de dados e mais uma variável flag (“exc”) para
char descricao[30]; marcar ou não o registro para exclusão.
float preco;
int qtd_vend;
char exc;
};
4 int main(){ Abre main()
5 char opcao='0'; Inicializa opcao com zero para forçar a primeira entrada no
looping.
while (opcao!='6'){ Verifica se a variavel opcao é 6. Usuário deseja encerrar o
programa.
opcao=menu(); Chama a função menu() e atribui o retorno para a variável
“opcao”
switch(opcao){ Verifica se a variável “opcao” é 1,2,3,4,5 ou 6 e chama a
case '1': respectiva função. Caso seja opcao 6, o programa se encerra.
inclusao(); O break fará com que o programa saia do switch.
break;
case '2':
consulta_geral();
break;
case '3':
consulta_cod();
break;
case '4':
alteracao();

break;
case '5':
exclusao();
break;
case '6':
exit(1);
}
}
6 } Fecha main()
7 char menu(){ Abre menu()

8 system(“cls”); Mostra todas as opcoes de manipulação de arquivo para o
printf(“MENU PRINCIPAL\n\n"); usuário, permitindo que ele escolha qual opção deseja.
printf("1 – Inclusao\n"); Retorna a opcao escolhida.
printf("2 - Consulta Geral\n");
printf("3 - Consulta por Codigo\n");
printf("4 – Alteracao\n");
printf("5 – Exclusao\n");
printf("6 – Sai\n");
return getchar();
9 } Fecha menu()
10 void inclusao(){ Abre inclusao()

11 FILE *Arq_brinq; Define uma variável ponteiro para FILE (estrutura pr-e-
definida para controlar o arquivo)
12 Reg_brinq brinq; Define uma variavel do tipo estrutura Reg_brinq. Esta
variável será usada para acessar as variáveis internas a
estrutura.
13 char resp; Declara variavel para receber a resposta do usuário
14 Arq_brinq=fopen("brinq.dat","ab"); abre o arquivo para escrita, criando-o caso nao exista (“ab”).
Voce deve mudar o diretório para um diretório que exista em
seu computador.
15 do{ Abre o looping do-while
16 system(“cls”); Recebe as variáveis para inclusão. Todas as variáveis da
17 printf("INCLUSAO\n\n"); estrutura deverão ser antecedidas pela variavel brinq.Caso
18 printf("Codigo: "); aconteça um erro de execução na entrada do codigo ou da
19 gets(brinq.cod_prod); descrição, acrescente a função fflush(stdin) antes de cada
20 printf("Descricao: "); gets(). Esta função limpa o buffer do teclado.
21 gets(brinq.descricao);
22 printf("Preco: ");

23 scanf(“%f”,&brinq.preco);
24 pritnf(“Qtd_Vendida: ");
25 scanf(“%d”.&brinq.qtd_vend);
26 brinq.exc='n'; inicializacao do campo exclusao
27 fwrite(&brinq,sizeof(brinq),1,Arq_brinq grava 1 registro no arquivo e move o ponteiro do arquivo,
); preparando para próxima gravação.
28 printf("Desejar continuar a inclusao Pergunta ao usuário se deseja continuar. Recebe a resposta,
<s/n>? "); converte para maiúscula (toupper()) e guarda na variavel
29 resp=toupper(getchar()); resp. Testa se “resp” é igual a 'S' e, caso seja retorna para o
30 }while (resp=='S'); “do” (linha 15)
31 fclose(Arq_brinq); Fecha o arquivo
32 } Fecha a inclusao()
33 int consulta_geral(){ Abrea consulta Geral

34 FILE *Arq_brinq; Declara variável ponteiro para FILE
35 Reg_brinq brinq; Declara variável brinq do tipo estrutura
36 Arq_brinq=fopen("brinq.dat","rb"); Abre o arquivo para leitura (“rb”)
37 if (Arq_brinq==NULL){ Verifica se o arquivo conseguiu ser aberto. Caso nao consiga
38 printf("Erro de abertura!"); (diretorio errado, problema na midia etc), mostra um erro e
39 getchar(); volta ao menu principal.
40 return 0;
41 }
42 system(“cls”); Mostra um cabeçalho para o relatório do brinquedos
printf("CONSULTA GERAL\n\n");
printf(" Codigo Descricao
Preco Qtd Vendida\n");
43 while Lê um registro do arquivo e atribui para a estrutura da
(fread(&brinq,sizeof(brinq),1,Arq_brinq)){ memoria. O fread() retorna 1 caso tenha conseguido ler e
zero, caso contrario. Portanto, ele entrará no looping se
conseguir ler e sairá dele se não tiver mais nada para ser lido
no arquivo
44 printf(" %s %s %.2f Mostra todos os campos que foram carregados para a
%d”, brinq.cod_prod , brinq.descricao,
estrutura a partir do arquivo.
brinq.preco, brinq.qtd_vend);
45 getchar(); Para o programa para mostrar dados.
46 } Fecha while
47 fclose(Arq_brinq); Fecha arquivo
48 } Fecha consulta geral
49 int consulta_cod(){ Abre Consulta por Código

50 FILE *Arq_brinq; Declara variável do tipo arquivo

51 Reg_brinq brinq; Declara variável do tipo registro

52 char xcod_prod[5]; Declara varaivel auxiliar para receber o codigo a ser
procurado no arquivo
53 int achou; Declara flag “achou” (valerá zero ou um)
54 char resp; Declara variavel para receber resposta do usuário
55 Arq_brinq=fopen("brinq.dat","rb"); Abre o arquivo para leitura
56 if (Arq_brinq==NULL){ Verifica se ocorreu erro de abertura. Caso tenha ocorrido
57 printf("Erro de abertura. Talvez o retorna ao menu principal
arquivo nao exista!");
58 getchar();
59 return 0;
60 }
61 do{ Abre looping do-while
62 system(“cls”); Recebe o codigo do brinquedo que o usuário deseja encontrar.
63 printf("CONSULTA POR
CODIGO\n\n");
64 printf("Digite o Codigo: ");
65 gets(xcod_prod);
66 achou=0; Inicializa flag com zero
67 fseek(Arq_brinq,0,SEEK_SET); Envia ponteiro do aruivo p/ o primeiro registro
68 while (fread(&brinq,sizeof(brinq), 1, Lê um registro do arquivo e atribui para a estrutura da
Arq_brinq)){ memoria. O fread() retorna 1 caso tenha conseguido ler e
no arquivo
69 if (!strcmp(xcod_prod, Verifica se o campo cogido do registro que acabou de ser lido
brinq.cod_prod ) ){ é o codigo que o usuário está procurando. O strcmp retorna
zero caso as duas variáveis sejam iguais, por isso negamos
(“!”) o retorno para que entre no if caso seja igual.
70 printf("Descricao: "); Caso sejam iguais, mostra o restante dos campos do registro
printf(“%s\n”, brinq.descricao);
printf("Preco: ");
printf(“%.2f\n”, brinq.preco);
printf("Qtd Vendida: ");
printf(“%d\n”, brinq.qtd_vend);
71 achou=1; Seta variavel flag para um (achou o registro)
72 getchar(); Pára o programa
73 break; Sai do looping
74 } Fecha if
75 } Fecha while
76 if (achou==0){ Mostra mensagem caso o brinquedo não seja encontrado

printf("\nEste brinquedo nao esta

cadastrado!!");
}
77 printf("\nDesejar continuar a consulta Pergunta se deseja continuar e retorna para o “do” (linha 61)
<s/n>? "); caso deseje.
78 resp=toupper(getchar());
79 }while (resp=='S');
80 fclose(Arq_brinq); Fecha o arquivo
81 } Fecha a consulta por codigo
82 int alteracao(){ Abre alteração

83 FILE *Arq_brinq; Declara variável arquivo
84 Reg_brinq brinq; Declara variável registro
85 char xcod_prod[5]; Declara variáveis auxiliares
int achou;
char resp;
86 Arq_brinq=fopen("brinq.dat","rb+"); //abre o arquivo para leitura e gravação
printf("Erro de abertura. Talvez o retorna ao menu principal
getchar();
return 0;
}
88 do{ Abre do-while
89 system(“cls”); Recebe o codigo do brinquedo que o usuário deseja encontrar
printf("ALTERACAO POR para alteração
CODIGO\n\n");
printf("Digite o Codigo: ");
gets(xcod_prod);
90 achou=0; Incializa flag com zero
91
92 fseek(Arq_brinq,0,SEEK_SET); Coloca o ponteiro do arquivo apontando para o primeiro
registro.
93 while (fread(&brinq,sizeof(brinq), 1, Lê um registro do arquivo e atribui para a estrutura da
no arquivo
94 if (!strcmp(xcod_prod, Verifica se o campo cogido do registro que acabou de ser lido
brinq.cod_prod )){ é o codigo que o usuário está procurando. O strcmp retorna


95 printf("Descricao: "); Caso sejam iguais, mostra o restante dos campos do registro
96 printf(“%s\n”, brinq.descricao);
98 printf(“%.2f\n”, brinq.preco);
99 printf("Qtd Vendida: ");
100 printf(“%d\n”, brinq.qtd_vend);
101 printf("Campos para alterar:\n"); Disponibiliza todos os campos para eventual alteração do
102 pritnf("Descricao: "); usuário
103 gets(brinq.descricao);
105 scanf(“%f”,&brinq.preco);
106 pritnf("Qtd Vendida: ");
107 scanf(“%d”,&brinq.qtd_vend);
108 fseek(Arq_brinq,ftell(Arq_brinq)- Retorna o ponteiro do arquivo para o registro que foi lido,
sizeof(brinq),SEEK_SET); pois o mesmo foi deslocado na leitura.
109 fwrite(&brinq,sizeof(brinq),1,Arq_b Grava sobre o registro que foi lido, alterando-o
rinq);
110 achou=1; Seta flag para 1
111 break; Sai do while
112 } Fim do if
113 } Fim do while
114 if (achou==0){ Mostra mensagem caso nao tenha encontrado o codigo do
printf("\nO brinquedo nao esta brinquedo no arquivo
cadastrado!!";
}
115 pritnf("\nDesejar continuar a alteracao Pergunta se deseja continuar e retorna para o “do” (linha 88)
<s/n>? "; caso deseje.
116 resp=toupper(getchar());
117 }while (resp=='S');
118 fclose(Arq_brinq); Fecha arquivo
119 } Fecha alteração
120 int exclusao(){ Abre exclusão

121 FILE *Arq_brinq, *xArq_brinq; Declara variavel arquivo (principal e auxiliar)
122 Reg_brinq brinq, xbrinq; Declara variavel registro (principal e auxiliar)
123 char xcod_prod[5]; Declara variáveis auxiliares
int achou;
char resp;
124 Arq_brinq=fopen("brinq.dat","rb+"); Abre o arquivo para leitura

printf("Erro de abertura. Talvez o retorna ao menu principal

getchar();
return 0;
}
126 do{ Abre looping do-while
127 system(“cls”); Recebe o codigo do brinquedo que o usuário deseja encontrar.
printf("EXCLUSAO POR CODIGO\n \
n");
printf("Digite o Codigo: ");
gets(xcod_prod);
128 achou=0; Inicializa flag com zero
129 fseek(Arq_brinq,0,SEEK_SET); Coloca o ponteiro do arquivo apontando para o primeiro
registro.
130 while (fread( &brinq,sizeof(brinq), 1, Lê um registro do arquivo e atribui para a estrutura da
no arquivo
131 if (!strcmp( xcod_prod, Verifica se o campo cogido do registro que acabou de ser lido
brinq.cod_prod) && (brinq.exc=='n')){ é o codigo que o usuário está procurando. O strcmp retorna
132 printf(“%s\n”, brinq.descricao); Caso sejam iguais, mostra o restante dos campos do registro
printf("Preco: ");
printf(“%.2f\n”, brinq.preco);
printf("Qtd Vendida: ");
printf(“%d\n”, brinq.qtd_vend);
133 printf("Confirma exclusao <s/n>? \ Pergunta para o usuário se deseja realmente excluir
n";
134 resp=toupper(getchar()); Recebe a resposta do usuário
135 if (resp=='S'){ Verifica se a resposta é afirmativa
136 brinq.exc='s'; Marca o registro p/ exclusao
137 fseek(Arq_brinq,ftell(Arq_brinq)- Retorna o ponteiro do arquivo para o registro que foi lido,
sizeof(brinq),SEEK_SET); pois o mesmo foi deslocado na leitura.
138 fwrite(&brinq,sizeof(brinq),1,Arq Grava sobre o registro que foi lido, alterando-o
_brinq);
139 } Fecha if
140 achou=1; Muda flag
141 break; Sai do while
142 } Fecha while

143 } Fecha do-while

144 if (achou==0){ Mostra mensagem se não encontrou o código procurado
printf("\nO brinquedo nao esta

cadastrado!!";
}
145 printf("\nDesejar continuar a exclusao Pergunta ao usuário se deseja continuar, recebe resposta e
<s/n>? "; retorna ao “do” caso a resposta seja afirmativa
resp=toupper(getchar());
}while (resp=='S');
146 fclose(Arq_brinq); Fecha arquivo principal
147 Arq_brinq=fopen("brinq.dat","rb"); Abre o arquivo principal p/ leitura e o auxiliar p/ gravacao
xArq_brinq=fopen("brinq1.dat","wb");
148 while (fread(&brinq,sizeof(brinq), 1, Lê um registro do arquivo principal e atribui para a
Arq_brinq)){ estrutura da memoria.
149 if (brinq.exc=='n'){ Verifica se o flag de exclusão é 'n' (registro não excluído)
150 xbrinq=brinq; Atribui todo o registro principal para auxiliar
151 fwrite(&xbrinq,sizeof(xbrinq),1,xArq_ Grava registro no arquivo auxiliar
brinq);
152 } Fecha if
153 } Fecha while
154 fclose(Arq_brinq); Fecha arquivo principal
155 fclose(xArq_brinq); Fecha arquivo auxiliar
156 remove("brinq.dat"); Apaga o arquivo principal
157 rename("brinq1.dat","brinq.dat"); Muda o nome do arquivo auxiliar para que este seja o
principal
158 } Fecha exclusão
O exemplo 9.1, mostra algumas rotinas básicas de

manipulação de arquivo. A inclusão permite incluir produtos enquanto o
usuário decidir incluir. Existem também duas consultas, uma geral, que
mostra do primeiro ao último registro cadastrado no arquivo, e uma
consulta por código de produto, onde o usuário digita qual o produto
que deseja consultar. Na alteração, o usuário escolhe o produto através
de seu código e assim, seus dados são mostrados na tela. Em seguida,
todos os campos são liberados para alteração. Na exclusão, o usuário
escolhe o produto que deseja excluir, o programa mostra seus dados,
pedi confirmação da exclusão e caso o pedido seja confirmado, o
registro é excluído (marcado para exclusão, através do flag "exc").
Assim que o usuário resolver não mais excluir, existe uma rotina que
gerará um arquivo auxiliar contendo apenas os registros não excluídos
(exc='n'). Logo após a criação deste arquivo o principal é apagado e o
auxiliar é renomeado, passando então a ser o principal.

9.2Exercícios
Considere uma empresa de Informática que deseja controlar suas vendas e emitir alguns
relatórios em tela. Para isso, algumas rotinas são necessárias:
9.2.1Uma rotina que cadastre e consulte seus produtos. O arquivo tem o seguinte lay-out:
Produtos: Código do produto(alfanum.), descricao do produto(alfanum.), preço (moeda) e quant.
em estoque (numérico). Faça menu de opção. Use funções separadas para incluir, consultar e
apresentar o menu.
9.2.2Uma rotina que cadastre seus clientes. O arquivo tem o seguinte lay-out:
Clientes: Código do cliente(alfanum.), razao social(alfanum.), cnpj (alfanum.),
endereço(alfanum.), cidade(alfanum.), estado(alfanum.), telefone(alfanum.).
9.2.3Uma rotina que cadastre as vendas dos produtos. O arquivo tem o seguinte lay-out:
Vendas: Código do cliente(alfanum.), Código do produto(alfanum.), quantidade vendida (num.).
Uma rotina que mostre todos os produtos de um determinado cliente digitado pelo usuário. O
usuário entrará com o código do cliente.
9.2.4Todos os clientes do estado de São Paulo em ordem alfabética por razão social.
9.2.5Uma Consulta Geral de todos os produtos.
9.2.6Uma rotina que mostre a quantidade de produtos em estoque.
9.2.7Uma rotina que mostre o valor total do estoque.
9.2.8Uma rotina que mostre o valor médio do estoque.
9.2.9Faça uma função que receba, do usuário, o código, o nome, o nr de mortes, de todos os
bairros de Campinas. Guarde as informações digitadas em arquivo.
9.2.10Faça uma função que leia um arquivo já gravado (na questão 9.2.9) e guarde em uma
matriz (definido por parâmetro), o código, o nr de mortes dos bairros com mais de 10 mortes no
mês. O tamanho (qtd de linhas) da matriz deve ser retornado.

10 - Allegro
Existem duas formas de se trabalhar com o vídeo: em modo

texto e em modo gráfico. No modo texto, o vídeo é visto como uma
matriz de caracteres (conforme trabalhamos nos capítulos anteriores) e
no modo gráfico, como uma matriz de pontos (pixels). Existem diversas
bibliotecas que fornecem funções para manipulação em C do modo
gráfico do video, algumas com download gratuito e documentação
extensa nos sites dos desenvolvedores. Alguns exemplos, são:
– BGI :- Biblioteca da Borland, bastante antiga e muito
usada para manipulação de gráficos simples em 2D.
– Allegro :- Muito boa e muito utilizada para confecção de
jogos.
– OpenGl :- Excelente biblioteca para manipulação gráfica
2D e 3D. Os recursos são primários, possibilitando assim, o estudo
de conceitos básicos da teoria de computação gráfica.
Neste curso, trabalharemos com a biblioteca Allegro, por ser

mais completa que a BGI, mais simples que a OpenGL, e por servir
plenamente aos nossos objetivos. A instalação da Allegro no Dev-cpp já
é prevista pelo ambiente, portanto basta alguns cliques para que você
começar a usá-la. Abaixo listo um passo-a-passo para download e
instalação.
1. Abra o Dev-cpp e acesse “Tools”/”Check for
updates/packages”.
2. Selecione o servidor “devpaks.org”
3. Clique no botão “Check for updates”. A lista de
pacotes disponíveis no servidor será atualizada.
4. Em “Groups” selecione “Allegro”.
5. Na lista que aparece abaixo, dê um tick em “Allegro” e
clique no botão “Download selected”. Aguarde o download.
6. Clique em Ok para iniciar a instalação.
7. Nas próximas janelas dê next -> next -> install ->
finish.
8. Clique no botão “Close”. Pronto! O Allegro já está
instalado.
Agora que já instalamos o Allegro, vamos testá-lo. Configure

o Dev para carregar a biblioteca Allegro acessando “Tools”/”Compiler
options”, tick “Add these commands ... line” e escreva -lalleg na caixa
de texto logo abaixo. Dê OK e abra uma página em branco para
digitação do exemplo abaixo.

Digite o Exemplo 10.1 :- Faça um programa em modo gráfico que mostre um retângulo, um
retângulo preenchido, uma reta, um circulo e 5 pontos na tela.
1 #include <allegro.h> Inclui arquivo de protótipos para
funções do Allegro
3 allegro_init(); inicializa Allegro
4 install_keyboard(); Inicializa teclado
5 set_gfx_mode(GFX_AUTODETECT_WINDOWE define o modo grafico, abrindo uma
D, 640, 480, 0, 0); janela 640x480
6 rect(screen,10,10,100,100,makecol(0,0,255)); desenha retangulo azul de 10,10 à
100,100
7 rectfill(screen,200,200,540,100,makecol(0,255,0 desenha retangulo preenchido de verde
)); de 10,10 à 100,100
8 line(screen,10,400,500,250,makecol(255,0,0)); desenha linha vermelha de 10,400 à
500,250
9 circle(screen,600,600,50,makecol(155,100,0)); desenha circulo de centro 600,600 de
raio 50
10 putpixel(screen,450,450,makecol(200,200,50)); desenha 5 pontos na tela
11 putpixel(screen,460,450,makecol(200,200,50));
15 readkey(); pára o programa
16 } Fecha main()
17 END_OF_MAIN() necessario p/ portabilidade
10.1 Exercícios
Básicos
10.2.1.Desenhe na tela um retângulo de 50 x 100 pontos, utilizando putpixel(), a partir da
posição (100,100)..
10.2.2.Trace linhas diagonais (45º) ajustadas ao tamanho da tela a partir da diagonal principal
até o início da janela, espaçadas de 10 em 10 pontos. O tamanho da janela deverá ser 300 de
largura por 300 de altura.
10.2.3.Trace linhas diagonais (45º) ajustadas ao tamanho da tela a partir da diagonal
secundária até o final da janela, espaçadas de 10 em 10 pontos. O tamanho da janela deverá
ser de 500 de largura por 500 de altura.
10.2.4.Faça um programa que desenhe a bandeira do Brasil na tela
if
10.2.5.Faça um programa que desenhe um retângulo de 50 x 100 (50 de largura por 100 de
altura) em uma janela gráfica de 800x600. O usuário deverá decidir qual dos 4 cantos da
janela gráfica será desenhado este retângulo, digitando 1 (canto superior esquerdo), 2 (canto

superior direito), 3 (canto inferior direito) ou 4 (canto inferior esquerdo).

10.2.6.Faça um programa que desenhe uma linha de tamanho 100 no centro de uma janela
gráfica de 800x600. O usuário deverá decidir qual a direção desta linha, digitando 1
(horizontal), 2 (vertical).
While
10.2.7. Faça 20 circunferências circunscritas na tela. Use while.
10.2.8. Refaça o exercício 11.2.2, desenhando uma circunferência de cada cor.
10.2.9. Refaça o exercício 11.2.2, pintando o interior de cada área formada entre elas com cores
diferentes.
10.2.10. Faça 50 retângulos circunscritos na tela.
10.2.11. Refaça o exercício 11.2.5, desenhando um retângulo de cada cor.
10.2.12. Refaça o exercício 11.2.5, pintando o interior de cada área formada entre eles com cores
diferentes.
10.2.13. Faça um campo de futebol com faixas no gramado de cor verde escuro e claro.
10.2.14.Desenhe uma grade de 50x50, a partir da linha 0, coluna 0, com intervalo entre linhas e
colunas de 10 pontos, em uma janela gráfica.
10.2.15.Preencha uma área quadrada de 100x100 da janela gráfica, usando pontos (putpixel()),
a partir da posição 50,50. Os pontos devem estar espaçados de 3 pontos entre cada um deles.
10.2.16.Faça a representação de um ambiente (contornado de linha preta), através de uma grade
cinza clara, de 300x300 com espaçamento de 10x10 para cada vão. Pinte de preto um destes
vãos para representar a localização de um sensor.
Animação
10.2.17. Faça uma bola amarela ficar "pingando" na tela. Faça o desenho na própria tela
(screen).
10.2.18.Faça uma bola amarela ficar "pingando" na tela, usando a técnica double-buffer. A idéia
desta técnica é realizar todas as atualizações em uma variável de memória e, depois disso,
copiar (função blit()) a variável para a tela
10.2.19.Refaça o exercício 11.2.10 mudando a cor da bola sempre que a mesma tocar a borda.
Vetor
10.2.20. Permita que o usuário digite 10 valores referentes ao tamanho de 10 linhas a serem
desenhadas na tela. Carregue os valores em um vetor e desenhe as linhas com intervalo de 20
pixel entre elas.
10.2.21.Permita que o usuário digite valores referentes as cores RGB de 10 círculos, a serem
desenhados na tela. Estes valores deverão ser armazenados em 3 vetores, um para cada cor.
Os círculos não poderão se sobrepor.
10.2.22.Desenhe na tela um gráfico, que represente os valores dos PH´s da chuva de cada
município,. Receba o vetor de índices de Ph de 20 municípios. Os eixos (cuja origem deve
estar em 10,400) devem ser pretos e as linhas verticais coloridas (uma cor representando cada
município),. Escreva os títulos do gráfico, do eixo x e do eixo y.
Matriz
10.2.23.Receba uma matriz e seu tamanho (total de linhas e de colunas),, referentes a
localização de cada cidade dentro do estado. Após o recebimento, desenhe um círculo de raio

10, representando cada cidade na tela.

Obs.: O x e o y já estão na escala da tela do computador.

Apêndices A – Algoritmos e Fluxogramas
A vantagem de desenvolvermos algoritmos/fluxogramas, é

que não precisamos pensar em qual linguagem será implementado,
reservando nosso esforço totalmente na lógica da solução, e não nos
recursos computacionais que deveríamos usar.
O princípio da lógica de programação em computadores é o
mesmo que usamos em nosso cotidiano. No dia-a-dia decidimos a todo
momento o que vamos fazer no próximo segundo. Algumas tarefas
fazemos tantas vezes que nosso cérebro mecaniza o processo. Neste
processo estão todas as tarefas que temos que fazer em uma seqüência
lógica. Alguns exemplos são:
1. Lavar a louça até que não haja mais louça para lavar.
2. Dirigir o carro até chegar à escola.
3. Praticar um percurso de corrida até que o percurso
acabe.
Todas estas tarefas são constituídas por tarefas menores,
por exemplo:
Tarefa 1: Lavar louça

1. Juntar as louças na pia
2. Passar água em todas elas
3. Encher um vasilha de água com detergente
4. Lavar cada uma das louças até que acabe
5. Lavar a pia
Tarefa 2: Dirigir carro

1. Entrar no carro
2. Dar a partida
3. Tirar o carro da garagem
4. Dirigir até chegar à escola
5. Parar o carro
Tarefa 3: Corrida
1. Iniciar a corrida
2. Correr até acabar o percurso
3. Parar de correr
A cada uma destas 3 tarefas podemos chamar de

algoritmo, pois são uma seqüência lógica. Algoritmo então, nada mais
é que um conjunto de procedimentos colocados em uma seqüência
lógica de forma a resolver um problema proposto.
Em um algoritmo devemos ficar atentos aos verbos (ações),

pois eles são os “comandos” que deverão ser seguidos por nosso
cérebro para atingir o objetivo de resolver o problema. Na tarefa 1,
temos: juntar, passar, encher, lavar, lavar. Na tarefa 2, temos: entrar,
dar, tirar, dirigir, parar. Na tarefa 3, temos: iniciar, correr, parar.
Agora pense você: descreva algumas rotinas cotidianas e

destaque os verbos utilizados.
Todo algoritmo, geralmente, obedece 3 procedimentos

básicos: Entrada, processamento e saída.
Entrada Processamento Saída
Entrada: são as informações que o algoritmo precisará para

resolver o problema. Estas informações podem estar com o usuário, em
um arquivo ou vir de outro algoritmo.
Processamento: é o que é feito com as informações de
entrada para obter os resultados necessários.
Saída: é o resultado que se espera do algoritmo, ou seja, a
resolução do problema.
Por exemplo, se tivermos o problema de guardar livros em
uma prateleira, teríamos:
Entrada: livros
Processamento: verificar o assunto do livro, localizar o
assunto na prateleira
Saída: guardar o livro
Outro exemplo seria o cálculo da média de duas matérias de

um aluno.
Entrada: nota da matéria 1, nota da matéria 2
Processamento: calculo da média (nota 1 + nota 2) / 2
Saída: mostra a média
Um algoritmo escrito para ser executado em um

computador, pode ser chamado de português estruturado.
Chamamos de português estruturado porque é escrito de
forma natural, porém obedecendo uma estrutura minima de escrita.
Geralmente estes algoritmos são bem próximos daquilo que teremos
que escrever nos editores para realmente executarmos nossos
programas. Alguns comandos (verbos no imperativo) utilizados nesta
linguagem são listados abaixo:
Comandos descrição
Inicio Marca o início da lógica

Fim Marca o fim da lógica

Indica uma atribuição à memória
Leia Recebe uma informação do usuário
escreva Retorna uma informação ao usuário
Se-senão-fimdose Decide qual procedimento executar
dependendo de uma condição
No exemplo do cálculo da média das disciplinas teríamos o

seguinte algoritmo:
inicio
leia nota 1
leia nota 2
media ← (nota 1 + nota 2) / 2
escreva media
fim
Neste caso, estamos lendo do usuário a nota 1 e a nota 2,

calculando a média e guardando em um local na memória chamado
media e por último mostrando a média para o usuário.
Além dos algoritmos, podemos descrever os procedimentos

que resolvem um problema através de um fluxograma.
Fluxograma (ou diagrama de blocos) é uma representação
gráfica da seqüência de execução dos procedimentos. Cada tipo de
procedimento requer um símbolo diferente. Abaixo mostramos os
principais.
Símbolos Descrição
Início/Fim – determina o começo ou final de uma seqüência de
procedimentos.
Atribuição – altera conteúdo da memória.
Entrada/Saída – permite entrada e saída de informações.
decisão/repetição – decide entre dois ou mais caminhos, dependendo do

caso permite a repetição da execução de procedimentos.
Abre/fecha arquivo
Sub-rotina – permite o desvio da execução do programa para uma sub-

rotina

Direção – direciona o fluxo dos procedimentos

Conector – conecta uma parte do fluxograma a outra parte (usado quando
não é possível a representação contínua, normalmente com uma letra no
interior)
Conector de página – conecta uma parte do fluxograma à outra localizada
em outra página
O exemplo do cálculo da média teria o seguinte fluxograma:
Início
Leia Nota 1
Leia Nota 2
Media = (nota 1 + nota 2) / 2
Escreva media
Fim

Apêndices B – Resumo de comandos e funções

Nome Descrição Exemplo Observações
stdio.h
scanf() Recebe entrada scanf(“%i”,&valor); %i é o formato e valor é a variável que
do usuário guardará a informação do usuário
printf() Mostra printf(“Valor: %i”,valor); a variável valor substituirá o formato (%i)
informações ao quando a mensagem for impressa.
usuário
fopen() Abre arquivo arq=fopen(“c:\\arquivo.dat”,”a”); Abre o arquivo arquivo.dat, vincula ao
nome interno (arq) e permite inclusão no
final do arquivo (parâmetro “a”)
fclose() Fecha arquivo fclose(arq) Fecha o arquivo que foi vinculado ao nome
interno “arq”
fread() Lê um registro leu=fread(&reg,sizeof(reg),1,arq); A variável “leu” receberá 1 se um registro
do arquivo e conseguiu ser lido pela função e 0, caso
guarda na contrário. Os parâmetros são: endereço da
memória struct (registro), tamanho em bytes da
struct, qtd de structs a serem lidos e nome
interno do arquivo.
fwrite() Grava o fwrite(&reg,sizeof(reg),1,arq); Grava um registro no arquivo através da
conteúdo da struct “reg” da memória. Os parâmetros são:
struct da endereço da struct, tamanho em bytes da
memória para struct, qtd de structs a serem lidos e nome
o arquivo interno do arquivo.
stdlib.h
system() executa system(“pause>nul”); pause pára a execução do programa
comandos do
sistema
operacional
math.h
sqrt() Calcula e raiz=sqrt(x); A variável raiz receberá o valor da raiz
retorna a raiz quadrada do conteúdo da variável x.
quadrada de
um numero
cos() Calcula e c=cos(ang); A variável c receberá o coseno da variável
retorna o ang (valor do ângulo em radiano)
coseno de um
numero
sin() Calcula e s=sin(ang); A variável s receberá o seno da variável ang
retorna o seno (valor do ângulo em radiano)
de um numero
Conio.h (não é padrão ANSI)
gotoxy() Posiciona o gotoxy(10,20); A mensagem “Salario: ” será mostrada na
cursor na tela. printf(“Salario: ”); tela na coluna 10, linha 20.
clrscr() Limpa a tela clrscr(); A tela será limpa
textbackground() Muda cor de textbackground(BLUE); Onde for escrito na tela, o fundo será azul.
fundo Use clrscr() logo abaixo para deixar toda a
tela azul.
textcolor() Muda cor do textcolor(YELLOW) Muda para amarelo todo caractere que
caractere aparecer na tela.
Comandos
if/else Executa if (nota >= 5){ A condição “nota>=5” testa se nota maior
determinadas printf(“Aprovado”); que 5 e se for o programa imprimirá
instruções de } “Aprovado” na tela; caso contrário (nota
acordo com else{ <5) o programa imprimirá “Reprovado”
condições printf(“Reprovado”
}

Nome Descrição Exemplo Observações

while Repete a valor=1; A variável “valor” é inicializada com 1. O
execução de while (valor <= 5){ while verificada se valor é menor que 5 e
determinadas printf(“\nValor %i”,valor); enquanto não for menor, o programa
instruções valor=valor + 1; imprimirá o conteúdo de valor na tela,
enquanto a } somando 1 à variavel valor após cada
condição for impressão na tela.
verdadeira
for Repete a for (i=1;i<=5;i++){ A variável de controle “i” é incializada em
execução de printf(“\nValor %i”, i); 1. o for testa se i é menor ou igual a 5 e se
determinadas } for o programa mostra o valor de “i” na tela,
instruções retorna a 1ª linha, soma 1 na variavel “i” e
enquanto a testa novamente, se i for ainda menor ou
condição for igual a 5, entra novamente no for e mostra
verdadeira novamente o valor de i. Isto se repete até i
ser maior que 5.
Allegro.h (não é padrão ANSI)
allegro_init() Inicializa o allegro_init(); Primeira função a ser usada antes de
Allegro qualquer outra função gráfica
set_gfx_mode() Define janela set_gfx_mode(GFX_AUTODETECT_WINDOW Detecta a placa de video e define o modo
gráfica ED,640,480,0,0); (640,480). Os 2 ultimos parametros definem
janela virtual (não recomendavel,por isso
0,0)
circle() Desenha uma circle(screen,100,100,50,makecol(0,0,255)); Desenha um circulo, na tela, na posição
circunferência 100,100 de raio 50, de borda azul (0,0,255).
circlefill() com os mesmos parâmetros
desenha um círculo azul
rect() Desenha um rect(screen,100,100,200,200,makecol(0,255,0)); Desenha um retângulo, na tela, com canto
retângulo superior esquerdo em 100,100 e canto
inferior direito em 200,200, de borda verde.
rectfill() com os mesmos parâmetros
desenha um retângulo verde
line() Desenha uma line(screen,250,50,100,300,makecol(255,0,0)); Desenha uma linha vermelha na tela, com
linha ponto inicial em 250,50 e ponto final em
100,300,de borda verde.
putpixel() Desenha um putpixel(screen,10,10,makecol(255,0,0)) Desenha um ponto vermelho na tela, na
ponto posição 10,10.
floodfill() Preenche floodfill(screen,120,240,makecol(0,255,0)); Preenche uma região de cor verde a partir
região do ponto 120,240 até encontrar uma borda
(de qualquer cor)
set_color_depth() Define set_color_depth(32); Define que teremos 4 bytes de profundidade
profundidade de cor. Usado sempre que definirmos um
de cor BITMAP em nosso programa.
install_keyboard() Instala install_keyboard(); Reconhece cada tecla do teclado.
recursos de
teclado
install_mouse() Instala install_mouse(); Reconhece posição e cliques do mouse
recursos de
mouse
clear_to_color() Pinta toda área clear_to_color(screen,makecol(255,0,0)); Pinta o bitmap (neste caso, a tela) de
de um bitmap vermelho
(inclusive tela)
de uma
determinada
cor.
blit() Copia uma blit(img,screen,0,0,0,0,640,480); Copia o conteúdo de img para screen (tela)
área de a partir da posição 0,0 da origem (img) para
memória para a posição 0,0 do destino (screen). 640,480 é
outra o tamanho do bitmap de origem (img)
textout_ex() Escreve texto textout_ex(screen,font,"Teste",100,350,makecol(2 Escreve “Teste” no bitmap da tela na
na tela 55,255,255),-1); posição 100, 350 na cor branca. O -1 serve
para deixar transparente o fundo de cada
caractere.

Apêndices C – Acesso a Porta Paralela
A porta paralela é referenciada pelo computador através de

um endereço de memória. Na grande maioria dos pc´s este endereço é
0x378. No site www.rogercom.com (excelente) está disponibilizado
uma biblioteca (inpout32.dll) que permite efetivar este acesso sem
problemas, porém algumas instruções são necessárias.
1. Copie o arquivo inpout32.dll (baixado do site) e o
PortaP.h (listagem abaixo) para o diretório “Porta” (crie este
diretorio).
Arquivo PortaP.h – Exemplo do Rogercom modificado
/**************************************************
PortaP.h - Programa TEST.c do Roger.com modificado
-- test interface to inpout32.dll
( http://www.logix4u.net/inpout32.htm )
Copyright (C) 2003, Douglas Beattie Jr.
Modificado em 2006, Kesede R Julio
*******************************************************/
#include <stdio.h>
#include <conio.h>
#include <windows.h>
/* Definitions in the build of inpout32.dll are: */

/* short _stdcall Inp32(short PortAddress); */
/* void _stdcall Out32(short PortAddress, short data); */
/* prototype (function typedef) for DLL function Inp32: */
typedef short _stdcall (*inpfuncPtr)(short portaddr);

typedef void _stdcall (*oupfuncPtr)(short portaddr, short datum);
HINSTANCE hLib;
inpfuncPtr inp32;
oupfuncPtr oup32;
int InicializaPP(void)
{
/* Load the library */

hLib = LoadLibrary("inpout32.dll");
if (hLib == NULL) {
printf("LoadLibrary Failed.\n");
return -1;
}

/* get the address of the function */
inp32 = (inpfuncPtr) GetProcAddress(hLib, "Inp32");
if (inp32 == NULL) {
printf("GetProcAddress for Inp32 Failed.\n");
return -1;
}
oup32 = (oupfuncPtr) GetProcAddress(hLib, "Out32");
if (oup32 == NULL) {
printf("GetProcAddress for Oup32 Failed.\n");
return -1;
}
void FinalizaPP(){
FreeLibrary(hLib);
}
2. Faça um programa teste (Exemplo B1 - testeP.c) e grave-o no

diretório “Porta” (mesmo diretório da inpout32.dll e do
PortaP.h). Este exemplo, considera uma placa de 8 leds
conectada a porta paralela.
Digite o Exemplo B1:- Faça um programa que acenda dois leds quaisquer ao mesmo tempo e
faça tocar um beep.
1 #include "PortaP.h" Inclui as funções de acesso (InicializaPP()
e FinalizaPP()) à porta paralela
3 InicializaPP(); Chama a funcao da Porta.h que carrega a

biblioteca inpout32.dll, disponibilizando
suas funções de acesso (oup32() e inp32())
4 oup32(0x378,10); Envia o decimal 10 para paralela
5 Beep(100,1000); Emite um som na frequencia 100 por 1

segundo.
6 FinalizaPP(); Chama a funcao da Porta.h que libera da
memoria a biblioteca inpout32.dll
7 system("pause"); Pára o programa
8 } Fecha main()
Alguns Exercícios para acesso à Porta Paralela

1. Acenda o 1º. e 3º. Led.

2. Acenda o 7º. e 8º. Led
3. Acenda os 4 ultimos leds.
4. Acenda os 4 primeiros leds
5. Acenda o 1º., 3º.,5º, 7º. Led
6. Acenda o 2º., 4º.,6º, 8º. Led
7. Faça os leds acenderem alternadamente do 1º. ao ultimo.
8. Faça todos os leds piscarem. Repita 100 vezes.
9. Acenda os leds 1º. e 8º., 2º. e 7º., 3º. e 6º., 4º. e 5º. . Repita a seqüência 100 vezes
10. Permita que o usuário escolha a posição do led que deseja acender.
11. Permita ao usuário escolher quantas posições de led ele desejar acender.
1. Faça um programa que permita que todos os leds pisquem 100
vezes. A cada vez, os leds devem piscar mais rápido.
Faça um programa que permita que os leds pisquem (de 4 em 4 leds

alternadamente) 100 vezes. A cada 2 piscadas, a velocidade deverá ser
mais lenta.
Faça um programa que permita que os 8 leds pisquem sequencialmente

(1 de cada vez, alternadamente) 100 vezes. A cada 8 piscadas, a
velocidade deverá ser mais rápida.

Apêndices D – Exercícios Resolvidos
Seção 2.3
// Exercício 2.3.1 case 3:
printf("quarta");
#include <stdio.h> break;
#include <stdlib.h> case 4:
printf("quinta");
int main(){ break;
int dia; case 5:
printf("sexta");
scanf("%d",&dia); break;
case 6:
switch (dia){ printf("sabado");
case 0: break;
printf("domingo"); default:
break; printf("Digite um numero de 0 a 6");
case 1: }
printf("segunda"); printf("\n");
break; system("pause");
case 2: }
printf("terca");
break;
/*2.3.5 Um restaurante oferece um desconto scanf("%f",&valcont);

de 7% para todos os clientes que gastarem
mais que R$ 250,00 no fechamento da conta. if (valcont>250){
Faça um programa que pergunte ao usuário desc=valcont*0.07;
qual o valor da conta e mostre o valor real a valtotal=valcont-desc;
ser pago. }
---------------------------------------------------*/ else{
valtotal=valcont;
#include <stdio.h> }
#include <stdlib.h> printf("Desconto de R$ %.2f.\nValor a ser
pago sera: R$ %.2f",desc,valtotal);
system("pause>nul");
int main(){ }
float valcont,desc,valtotal;
// Exercício 2.3.7
// Verifica se eh triangulo
#include <stdio.h> if (lado1>=lado2 && lado1>=lado3){
#include <stdlib.h> maior=lado1;
menor1=lado2;
int main(){ menor2=lado3;
float lado1, lado2, lado3, maior, menor1, }
menor2; if (lado2>=lado1 && lado2>=lado3){
maior=lado2;
scanf("%f",&lado1); menor1=lado1;
scanf("%f",&lado2); menor2=lado3;
scanf("%f",&lado3); }

if (lado3>=lado1 && lado3>=lado2){ printf("O triangulo eh escaleno");

maior=lado3; }
menor1=lado1; else{
menor2=lado2; printf("O triangulo eh isosceles");
} }
// }
if (menor2+menor1>maior){ }
else{
// eh triangulo printf("Os lados nao formam triangulo");
if (maior==menor2 && menor2==menor1){ }
printf("O triangulo eh equilatero."); system("pause");
} }
else{
if (maior!=menor2 && maior!=menor1 &&
menor2!=menor1){
// Exercício 2.3.6 }else{

if (venda<3500){
#include <stdio.h> bonif=0.07*venda;
}else{
int main(){ bonif=0.1*venda;
float venda, bonif; }
}
printf("Digite o valor vendido: "); printf("A bonificacao eh: %.2f\n",bonif);
scanf("%f",&venda); system("pause");
}
if (venda < 1500){
bonif=0.05*venda;
// Exercício 2.3.12 if (delta<0){

printf("Nao existe raiz");
#include <math.h> else{
#include <stdlib.h> if (delta==0){
r1=(-b)/(2*a);
int main(){ printf("A raiz eh : %.3f",r1);
float a, b, c, delta, r1, r2; }
else{
system("cls"); r1=((-b)+sqrt(delta))/(2*a);
printf("Coeficiente A: "); r2=((-b)-sqrt(delta))/(2*a);
scanf("%f",&a); printf("Raiz 1 = %.3f e RAiz 2 = %.3f", r1,
printf("Coeficiente B: "); r2);
scanf("%f",&b); }
printf("Coeficiente C: "); }
scanf("%f",&c); system("pause");
}
//calculo das possiveis raizes
delta=(b*b)-(4*a*c);

Seção 3.3
/*3.3.4 - Faça um programa que permita que qtd=1;

o usuário digite a idade de 10 funcionários e somaid=0;
após a digitação, mostre a somatória das while (qtd<=10){
idades. A soma das idades deve ser feita scanf("%i",&idade);
dentro do looping e apenas a exibição fora somaid=somaid+idade;
dele. qtd=qtd+1;
*/ }
printf("A soma das idades eh: %i",
#include <stdio.h> somaid);
#include <stdlib.h> system("pause>nul");
}
int main(){
int idade, somaid, qtd;
Seção 7.6
/*---------------------------------------------------- scanf("%f",&n1);
7.6.1 Escreva uma função capaz de scanf("%f",&n2);
retornar a média aritmética de três scanf("%f",&n3);
parâmetros passados. med=media(n1,n2,n3);
----------------------------------------------------*/ printf("A media eh: %.1f",med);
system("pause>nul");
#include <stdlib.h>
float media(float nota1, float nota2, float
float media(float nota1, float nota2, float nota3){
nota3); float m;
int main(){ m=(nota1+nota2+nota3)/3;

float n1, n2,n3,med; return m;
}
/*-----------------------------------------------
7.6.3 Escreva uma função que receba a base scanf("%f",&altura);
e a altura de um triângulo e retorne a área scanf("%f",&base);
desse triângulo. Area = (base * altura) / 2 printf("A area eh: %f",area(altura,base));
-----------------------------------------------*/ system("pause>nul");
}
#include <stdio.h>
#include <stdlib.h> float area(float a, float b){
float ar;
float area(float a, float b);
ar=(b*a)/2;
int main(){ return ar;
float altura, base; }

/*------------------------------------------ scanf("%i",&valor);
7.6.6 Efetue, recursivamente, a soma dos 10 printf("%i",soma(valor));
primeiros números inteiros. Faça o diagrama system("pause>nul");
de execução. }
------------------------------------------*/
#include <stdio.h> int soma(int n){
#include <stdlib.h> if (n==1){
return 1;
int soma(int n); }
else{
int main(){ return n+soma(n-1);
int valor; }
}
/*------------------------------------------ system("pause>nul");
7.6.7 Mostre, recursivamente, os }
números de 1 a 10. Faça o diagrama de
execução. void mostra(int cont){
------------------------------------------*/ if (cont==1){
#include <stdio.h> printf("%i\n",cont);
#include <stdlib.h> }
else{
void mostra(int cont); mostra(cont-1);
printf("%i\n",cont);
int main(){ }
}
mostra(10);
Seção 9.3
// Exercício 9.3.1 for (i=0;i<tam;i++){
if (elem == *(vet+i) ){
int main(){ achou=1;
int tam, *vet, elem,i, achou=0; i=tam;
}
printf("Qual tamanho do vetor: "); }
scanf("%d",&tam);
if (achou){
vet=(int *) malloc(tam*sizeof(int)); printf("Achou!!!");
}
for (i=0;i<tam;i++){ else{
scanf("%d",vet+i); printf("Nao achou");
} }
free(vet);
printf("Qual o elemento que deseja encontrar? system("pause");
"); }
scanf("%d",&elem);

Bibliografia
Ziviani, Nivio. Projeto de Algoritmos com implementação em Pascal e C, Pioneira Thonson

Learning: São Paulo, 2002.
Schildt, Herbert. C Completo e Total. 3a. Ed. Makron Books.

Agradecimentos
Espero que este material tenha alcançado seu objetivo. A

partir daqui, você poderá estender o que aprendeu através da prática e
de outros livros que, com certeza, lhe auxiliarão. Que este
conhecimento tenha caído em terra boa, que dê bons frutos, que outras
pessoas possam ser beneficiadas e assim possamos construir uma
sociedade mais justa, capaz de trocar, de ajudar, de compreender. Não
despreze nenhum conhecimento, principalmente o seu, saiba que não
se pode saber tudo, nem conseguimos e nem precisamos saber tudo,
porém a busca poderá ajudá-lo na realização de seus sonhos e de sua
felicidade, proposta fundamental da vida. Deixe Deus te ajudar a
conquistar isso. Confie Nele. Que o Deus da PAZ te abrace e te dê
consolo nos momentos de angustia, medo e solidão.
Kesede Rodrigues Julio

kesedejulio@yahoo.com.br

Linguagem C-2009

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Linguagem C-2009

Uploaded by

Copyright:

Available Formats

Kesede R Julio

Linguagem de Programação C - versão 2009 2

9.1 Vetores de Ponteiros.................................................................................................57

Linguagem de Programação C - versão 2009 3

O estudo de programação requer uma boa dose de

1.2 Ferramenta de programação: Linguagem C

Para fazer nossos programas, usaremos a linguagem C. Para

Linguagem de Programação C - versão 2009 4

serem executados a partir do próprio ambiente.

Através da digitação dos exemplos deste capítulo, você

Linguagem de Programação C - versão 2009 5

Linguagem de Programação C - versão 2009 6

1.3 Estrutura de um Programa

A estrutura de um programa C é, basicamente, realizada em

<tipo de retorno> <nome da função> (<argumento>,...){

1.4 Inserção de Arquivos de Função

São arquivos texto contendo os cabeçalhos das funções

Linguagem de Programação C - versão 2009 7

scanf():- função que permite a digitação de dados pelo

Neste exemplo, o programa será interrompido para que o

Linguagem de Programação C - versão 2009 8

1.5 Tipos e Variáveis

Sempre que preciso manipular alguma informação, tenho

int: 2 bytes com sinal (4 bytes para computadores 32bits) –

float: 4 bytes com sinal – conjunto dos números reais – Ex.:

double: 8 bytes com sinal - conjunto dos números reais – Ex.:

Assim: float salario;

Reserva um espaço de memória chamado “salario” do tipo

1.6 Operadores Básicos

Existem 4 tipos de operadores: Aritmético, Lógico,

Operador Tipo Descrição

Linguagem de Programação C - versão 2009 9

% Aritmético Resto da divisão

1.7 Exercícios Propostos

1.7.1 Faça um programa que imprima “Ola” na tela.

Linguagem de Programação C - versão 2009 10

Moeda Valor (R$)

Dica: Use sqrt() (math.h) para calcular a raiz quadrada.

Horário de Saída : 14:28:32

Linguagem de Programação C - versão 2009 11

Definição: Usado para executar um ou mais comandos

if (<condição> &&/|| <condição> ...){

A palavra “if” é obrigatória. Tudo que estiver entre “<” e “>”

2 #include <conio.h> Permite o uso da função getch()

3 int main(){ Abre a função principal do programa

4 float nota; Define espaço de memória chamado nota

5 scanf(“%f”, &nota); Recebe a nota do usuário

6 if (nota>=6){ Verifica se nota é maior ou igual a 6

Linguagem de Programação C - versão 2009 12

7 printf(“Aprovado”); Caso seja, imprime mensagem na tela

9 else{ Verifica se nota é menor que 6 (caso contrário do if)

10 printf(“Reprovado”); Caso seja menor que 6. imprime mensagem

12 getch(); Pára a execução do programa

13 } Fecha função principal

No exemplo 2.1, o programa recebe do usuário um valor e

Definição: Usado para executar um ou mais comandos caso

switch (<variavel testada>){

Como última função para cada caso, utilizamos a função

Linguagem de Programação C - versão 2009 13

determinada variável para ser verificada sua igualdade com diversos

2 #include <conio.h> Permite o uso da função getch()

3 int main(){ Abre a função principal do programa

4 int codigo; Define espaço de memória chamado salario