Linguagem C PDF

Kesede R Julio
kesedejulio@gmail.com
Apostila de
Linguagem
Campinas – São Paulo - Brasil

Í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.......................................................................................................8
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........................................................................................................................15
2.3 Exercícios..................................................................................................................16
3 - Comandos de Repetição..............................................................................................19
3.1 Comando while.........................................................................................................19
3.2 Comando do-while....................................................................................................21
3.3 Teste de mesa............................................................................................................22
3.4 Exercícios..................................................................................................................26
4 - Vetor..............................................................................................................................29
4.1 Comando For.............................................................................................................30
4.2 Exercícios..................................................................................................................31
5 - String............................................................................................................................36
5.1 Exercícios..................................................................................................................39
6 - Matriz...........................................................................................................................42
6.1 Exercícios..................................................................................................................43
7 - Estruturas Heterogêneas.............................................................................................46
7.1 Exercícios.................................................................................................................48
8 - Funções.........................................................................................................................49
8.1 Passagem de Parâmetros por Valor e Retorno de Valor............................................50
8.2 Passagem de Parâmetros por Referência................................................................52
8.3 Exercícios................................................................................................................53
9 - TAD – Tipo Abstrato de Dados...................................................................................55
Exercícios.......................................................................................................................56
10 - Arquivo.......................................................................................................................57
10.1 Armazenamento em disco.......................................................................................57
10.2 Exercícios................................................................................................................69
11 - Allegro........................................................................................................................71
11.1 Exercícios ..............................................................................................................72
Linguagem de Programação C 2
Apêndices A – Algoritmos e Fluxogramas......................................................................75
Apêndices B – Resumo de comandos e funções..............................................................82
Apêndices C – Acesso a Portas de Comunicação...........................................................83
Bibliografia........................................................................................................................88
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, releia 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
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, abra o Dev que você acabou de instalar, selecione
“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 corrigi-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.
Segue abaixo 3 exemplos para serem digitados, compilados
e executados. Nossos exemplos sempre seguirão este padrão: um
enunciado dizendo o que deve ser feito, uma coluna com o número da
linha (ou do bloco) do código, outra coluna para o código que deve ser
digitado e outra com a descrição do que ele faz. Exercite digitando os
exemplos abaixo.
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 incluídos para
arquivos .c.
2 #include <conio.h> Permite o uso da função conio(). Não
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.
scanf().Não precisam ser incluídos para
arquivos .c.
2 #include <conio.h> Permite o uso da função conio(). Não
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.
Aritméticos
Símbolo Descrição
+ Soma
- Subtração
* Multiplicação
/ Divisão
% Resto da divisão
++ Incremento
-- Decremento
Lógicos
== Igualdade
!= Diferente
< Menor
<= Menor ou igual
> Maior
>= Maior ou igual
Condicionais
&& E
|| Ou
Bit-a-bit
& E
| 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 “ToadaGoo”, 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. Os símbolos “<” e “>”
não devem ser digitados.
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).
O if pode ser usado com duas ou mais condições amarradas
com um “e lógico” (&&) ou com um “ou lógico” (||). Nestas condições
cuidado com o uso do eles, pois ele representará a inversão do
operador condicional e do operador lógico.
Abaixo apresentamos alguns exemplos.
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.
Digite o Exemplo 2.2:- 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, “Exame” se sua nota
estiver entre 4 e 5,9 ou “Reprovado”, se sua nota for menor que 4.
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
8 } Fecha o if
9 else{ Verifica se nota é menor que 6 (caso contrário do if)

if (nota>=4){ Verifica se a nota é maior que 4
printf(“Exame”); Caso seja, imprime mensagem
} Fecha o if
else{ Verifica se nota é menor que 4 (caso contrário do if)
10 printf(“Reprovado”); Caso seja menor que 4, imprime mensagem
11 } Fecha else
} Fecha else

No exemplo 2.2, 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, testa se a nota é maior que 4, caso
seja mostra “Exame” na tela, caso contrário, mostra “Reprovado”.
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(“%i”,&codigo); Recebe o valor do código do usuário
7 switch (codigo){ Abre o comando switch para verificação do

código
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.
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.6Uma 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.8 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.9 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.10 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.11 Receba 3 números inteiros e distintos, a partir do usuário, e

mostre-os em ordem crescente.
2.3.12 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.

scanf()
4 int i=1; (declaração e inicialização da variável i)
Define espaço de memória chamado i e
atribui 1 p/ este espaço
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(“%i\n”, i); Imprime o conteúdo da variável i
8 i=i+1; (contador) Soma 1 em i e atribui o
resultado no próprio 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. Ao comando “i=i+1”
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.
scanf()
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(“%i”, &idade); Recebe a idade do usuário e guarda
seu valor na variável “idade”
9 somaid=somaid+idade; (acumulador) 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; (contador) 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
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.
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.
scanf()
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

tela. linha 5 – Simulamos um valor digitado pelo
Teste de mesa usuário.
Memória tela Teste de mesa
Idade somaid qtd Memória tela

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

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

25 20 2 20 0 1
23 45 3 25 20 2
30 68 4 23 45 3
30 68 4
Linha 6 – soma idade a somaid e guarda em 28 98 5
somaid
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
30 68 4 25 20 2
98 23 45 3
30 68 4
28 98 5
126
Linha 7 – soma 1 em qtd
Teste de mesa
Memória tela
Idade somaid qtd
20 0 1
Linha 7 – soma 1 em qtd
25 20 2
Teste de mesa 23 45 3
Memória tela 30 68 4
28 98 5
Idade somaid qtd 126 6
20 0 1
25 20 2 Linha 8 – fecha o looping e volta para linha
23 45 3 4
30 68 4
98 5 linha 4 – Verifica se qtd é menor ou igual a 5.
O retorno é falso. Isto não gera alteração na
Linha 8 – fecha o looping e volta para linha tabela, apenas define que executaremos a
4 linha 9.

5. O retorno é verdadeiro. Isto não gera linha 9 – Imprime a somatória na tela.
alteração na tabela, apenas define que Teste de mesa
Memória tela
linha 5 – Simulamos um valor digitado pelo Idade somaid qtd
usuário.
20 0 1 A soma das idades eh
25 20 2 126
23 45 3
30 68 4
28 98 5
126 6
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.4.1Imprima os 10 primeiros números inteiros na tela.
3.4.2Imprima o quadrado dos 10 primeiros números inteiros.
3.4.3Faça um programa que permita que o usuário digite a idade

de 10 funcionários.
3.4.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.4.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.4.6 Implementar um programa que imprima a tabuada de um

número digitado pelo usuário.
3.4.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. Ex.:
Se N=3 o programa calculará 1+3+5=9, que é o quadrado de 3.
3.4.8Em 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 Desconto
compra (R$) (%)
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.4.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.4.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.4.11Calcule a seguinte expressão: x
i 1
i
Onde: x é digitado pelo usuário.
3.4.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.4.13 Calcule a expressão, sem utilizar a função pow() da math.h:

XY
Onde: X e Y são digitados pelo usuário
3.4.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.4.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.4.16Uma 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 Elementos do vetor
0 1 2 3 4 Índices do vetor
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. Estas notas devem ser carregadas em um vetor.
1 /*-------------------------------------------------------- O “/*” e o “*/”, abre e fecha um
Descrição: Calcula media das notas de 30 alunos bloco de comentários. Estes
de uma classe
comentários ajudam muito em
Data : Agosto/2009
Autor : Kesede R Julio seus estudos. Faça isso em
---------------------------------------------------------*/ todos os seus programas.
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 int 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 %i a. 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]; (acumulador) 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 um programa que carregue um vetor de inteiros,
permitindo que o usuário defina a quantidade de elementos a
serem carregados. O usuário também deve digitar o valor de um
elemento o qual deseja saber quantos destes elementos existem
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

4.2.5
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.
1 #include <stdio.h> Permite inclusão de funções de i/o
2 #include <string.h> Permite inclusão de funções para manipulação de
string
3 #include <conio.h> Permite inclusão da função getch()
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.
2 #include <string.h> Permite inclusão de funções para
manipulação de string
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 é
buffer 1\n");
porque negou as 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 é
buffer 3\n");
porque negou as 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.
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.
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], i_maior, j_maior, i, j, maior, tot=0; Declara variáveis.
4 for(i=0; i<10; i++){ Carrega a matriz a partir
for(j=0; j<10;j++){
scanf(“%i”, &ac[i][j]); do usuário
}
}
5 maior=ac[0][0]; Incializa a variavel auxiliar
for(i=0; i<10; i++){
for(j=0; j<10;j++){ “maior” com o primeiro
if(ac[i][j] > maior){ elemento da matriz. Em
i_maior=i;
j_maior=j; seguida, percorre a matriz
maior=ac[i][j]; verificando se existe algum
}
} elemento maior que o
} primeiro, guardado na
printf(“A rua %i esquina com %i teve %i acidentes,
sendo a esquina com maior nr de acidentes do centro.”, variavel “maior”. Caso
i_maior,j_maior, maior);
exista, atualiza “maior” e
getch();
guarda os índices (esquina)
deste elemento. Ao final,
imprime e 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.
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 de ordem 4, da seguinte

forma:
se i <> j, m[i, j] = 0 e
se i = j, m[i, j] = 1
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.8 Faç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.9 Faç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.

10x10, a partir do usuário. Mostre na tela a somatória de todos os
valores, exceto os valores das linhas pares.

10x10, a partir do usuário. Carregue um vetor com os valores da
diagonal secundária da matriz.
6.1.12 Em 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.13 Em 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.14 Considere 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: .
d  ( x 2  x1)2  ( y 2  y1)2
O valor de n será dado pelo usuário.
6.1.15 Considere 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
#include <stdlib.h>
#include <conio.h> cabeçalho
#include <ctype.h>
#include <math.h>
3 typedef struct DadosGeo{ Declara uma struct como
char nome[50];
int x, y; tipo contendo 3
}; informações: nome, x, y
int i=0, xRef, yRef, qtdcid; Declara variáveis, inclusive
DadosGeo cidades[1000];
char nomeRef[50], resp; o vetor “cidades” do tipo
float dist; DadosGeo
4 do{ Carrega o vetor, a partir do
system("cls");
printf("Nome: "); usuário
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
gets(nomeRef);
printf("\nPosicao X: "); dados da cidade que será
scanf("%i",&xRef); referência para o cálculo
printf("\nPosicao Y: ");
scanf("%i",&yRef); das distâncias
7 printf("\n\nListagem das distancias\n"); Percorre todo o vetor,

for (i=0;i<qtdcid;i++){
dist=sqrt(pow(xRef-cidades[i].x,2)+pow(yRef- calculando a distância para
cidades[i].y,2)); cada cidade. Mostra o
printf("%-10s - %.1f Km\n", cidades[i].nome, dist);
} nome da cidade e a
getch(); distância.
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 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 função que receba dois valores inteiros do usuário, some-os e
mostre o resultado para o usuário.
1 void soma2(){ Abre a função soma2
2 int val1, val2, soma; Declara variáveis val1 e val2 como

inteiros
3 scanf(“%i”,&val1); Usuário digita valores para “val1” e
4 scanf(“%i”,&val2); “val2”
5 soma=val1+val2; Soma “val1” e “val2” e guarda na

variável “soma”
6 printf(“%i”,soma); Imprime “soma”
7 } Fecha a função soma2
No exemplo 8.1, a função “soma2()” faz apenas o que se

pede dela, ou seja, recebe dois valores inteiros do usuário, soma-os e
mostra o resultado na tela. Claro que não conseguimos executar esta
função, pois todo programa em C exige uma função “main()” para
iniciar sua execução e chamar a função “soma2()” para ser executada.
Acrescente o código no mesmo arquivo e logo abaixo da função
soma2(). Salve e execute o programa.
Digite o Exemplo 8.1 (continuação): Faça a função main() para chamar a executar de soma2()
1 int main(){ Abre a função principal
5 soma2(); Chama a função soma2() para ser

executada
8.1Passagem de Parâmetros por Valor e Retorno de Valor

Quando precisamos generalizar o uso de uma função,
enviamos valores para a elas. Estes valores são enviados através de
parâmetros. Ao chamarmos a função, enviamos estes valores e
declaramos, no cabeçalho da função, variáveis para receber estes
valores. Vamos supor que queremos que a função soma2() some dois
valores provenientes de qualquer lugar (do usuário, de arquivo, de
calculos etc).
Digite o Exemplo 8.2: Faça um programa que recebe dois valores a partir do usuário, some-os
e mostre o resultado na tela. Os valores devem ser recebidos como parâmetro em uma função
que some-os e mostre o resultado.
1 #include <stdio.h> Permite o uso da função printf()
3 void soma2(int v1, int v2){ Abre a função soma2() e recebe os valores de
val1 e val2 em v1 e v2, respectivamente. A
quantidade de valores enviados deve ser a
quantidade de variáveis aqui declaradas. A
atribuição é realização da esquerda para direita.
4 int soma; Declara variável local “soma”
5 soma=v1+v2; Soma v1 e v2 e guarda resultado em soma
6 printf(“%i”,soma); Imprime a variável soma na tela
7 getch(); Pára o programa
8 } Fecha função soma2()
10 int val1, val2; Declara variáveis val1 2 val2 como inteiros
11 scanf(“%i”,&val1); Recebe val1 do usuário
13 soma2(val1,val2); Chama a função soma2() para execução,
enviando os valores das variáveis val1 e val2.
14 } Fecha a função soma2()
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).
Para generalizar ainda mais a função, além de receber

parâmetros, podemos retornar o valor calculado, através da palavra
reservada “return”. O valor do retorno é enviado para a função
chamadora, e assim, ao invés da função soma2() mostrar o resultado
na tela, ela retornaria o resultado para a função main() (função
chamadora) para que a main() resolvesse o que fazer com o resultado,
no caso, imprimir na tela.
Digite o Exemplo 8.3: Faça um programa que recebe dois valores a partir do usuário, some-os
e mostre o resultado na tela. A soma deve ser feita em uma função, que receberá os valores
como parâmetro e retornará o resultado.
1 #include <stdio.h> Permite o uso da função printf()
3 void soma2(int v1, int v2){ Abre a função soma2() e recebe os valores de
val1 e val2 em v1 e v2, respectivamente. A
quantidade de valores enviados deve ser a
quantidade de variáveis aqui declaradas. A
atribuição é realização da esquerda para direita.
4 int soma; Declara variável local “soma”
5 soma = v1+v2; Soma v1 e v2 e guarda resultado em soma
6 return Retorna o valor de “soma” para a função
chamadora
8 } Fecha função soma2()
10 int val1, val2, s; Declara variáveis val1 2 val2 como inteiros
13 s = soma2(val1,val2); Chama a função soma2() para execução,
enviando os valores das variáveis val1 e val2.
Após a execução de soma2(), atribui o valor de
retorno na variável “s”.
printf(“%i”,s); Imprime a variável “s”
getch(); Pára o programa
14 } Fecha a função soma2()
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 que 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);
perimetro, alterados na 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 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.3 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.4 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);
8.3.5 Faça um programa que calcule o Desvio Padrão de uma
sequência de valores inteiros. Para isto cria as seguintes funções:
1. int RecebeValores(int *v);
Esta função receberá os valores do usuário, carregará em um
vetor (v) e retornará quantos valores foram digitados. O
carregamento deve parar quando o usuário digitar o valor 0 (zero).
2. float CalcMedia(int *v, int T);
Esta função calcula e retorna a média aritmética do vetor (v) de
tamanho T.
3. float DesvioPadrao(int *v, float m, int T);
Esta função calcula e retorna o Desvio Padrão dos valores do vetor
“v” de tamanho “T” utilizando a média dos valores “m”.
9 - TAD – Tipo Abstrato de Dados
Um TAD é caracterizado pelo agrupamento de dados e

funções que manipulam estes dados. Assim, para construirmos um Tipo
Abstrato de Dados em C, devemos criar um arquivo separado. Podemos
fazer isso agrupando dados e funções em um arquivo .h, por exemplo.
Vamos fazer um exemplo para entender isso.
Exemplo 9.1: Crie um arquivo contendo uma estrutura e duas funções para manipula-la, uma
para carregar o vetor e outra para mostrá-lo na tela. Grave este arquivo como Cor.h
1 #include <stdio.h> Inclue arquivos de protótipos.
#include <conio.h>
2 typedef struct Cor{ Definição do tipo estrutura Cor,

int r,g,b; a ser manipulada pelas
}Cor; funções da TAD.
3 void Carregar(Cor *c){ Função que carregará os
scanf(“%i”,&c.r); dados na estrutura
scanf(“%i”,&c.g);
scanf(“%i”,&c.b);
}
4 void Mostrar(Cor c){ Função que mostrará os dados
printf(“\nCor R = %i”,c.r); da estrutura na tela.
printf(“\nCor G = %i”,c.g);
printf(“\nCor B = %i”,c.b);
}
Agora vamos criar uma aplicação que irá manipular a TAD

do exemplo 9.1. Este código conterá a função main() e terá extensão
.c. Os dois arquivos (.h e .c) devem estar no mesmo diretório.
Exemplo 9.2: Crie um arquivo Cor.c contendo que permita a entrada de cores (R, G e B) em
uma estrutura e logo em seguida mostre estas cores na tela. Use a TAD Cor.h
1 #include “Cor.h” Inclusão da TAD Cor.h que
deve estar no mesmo diretório
deste arquivo
2 void main(){ Abre função principal
3 Cor c; Define variável do tipo
estrutura para uso na
aplicação. Isto é possível
devido a inclusão da TAD
através do include.
4 Carregar(&c); Chama a função Carregar()
enviando como parâmetro por
referência a variável c. Isto
possibilitará a alteração das
variáveis internas da estrutura.
5 Mostrar(c); Chama a função Mostrar()
enviando como parâmetro por
valor a variável c, pois apenas
uma cópia da estrutura
chegará na função, uma vez
que a mesma não será
modificada por ela.
6 getch(); Pára o programa
7 } Finaliza a função principal.
9.1 Exercícios
9.1.1 Faça uma TAD Aluno.h com sua estrutura contendo ra, nome, nota 1, nota 2,
media, e funções para:
1. Set() para cada variável (exceto media) a partir do usuário.

2. Get() para cada variável.
3. Set() para um aluno.
4. Set() para media das notas.
5. Mostrar um aluno na tela.
- Faça uma aplicação Aluno.c que receba dados de 5 alunos em um vetor de

estrutura e mostre estes alunos na tela. Use a TAD Aluno.h.
- Acrescente uma função à TAD Aluno.h que faça a busca de um ra, recebido por
parâmetro, em um vetor de alunos. Retorne 1 caso encontre, e 0, caso contrário.
9.1.2 Faça uma TAD Carro.h com sua estrutura contendo placa, modelo, fabricante,
cor, data de venda. A data de venda tambem deve ser uma estrutura, uma vez que é
uma variável composta. Faça funções para:
1. Set() para cada variável a partir do usuário.

2. Get() para cada variável.
3. Set() para um carro.
4. Mostrar um carro na tela.
- Faça uma aplicação Carro.c que receba dados de 3 carros em um vetor de

estrutura e mostre estes carros na tela. Use a TAD Carro.h.
10 - Arquivo
10.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.
No modo 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). Caso não acrescente esta letra, o default é binário.
Os exemplos abaixo mostram como podemos
gravar/consultar dados em disco.
Digite o Exemplo 10.1: Faça um programa que receba do usuário o número do RA e o nome de
5 alunos e grave estas informações em um arquivo no disco.
1 #include <stdio.h> Inclue função de i/o de arquivo
2 #define MAX 5 Define a macro MAX como 5
3 struct Aluno{ Declara o modelo Aluno para ser
int ra;
char nome[30]; usado para gravar os dados de
}; cada aluno
4 int main(){ Início da função principal
5 FILE *ArqAlu; Declara variável ponteiro de
arquivo
6 struct Aluno RegAlu; Declara variável de estrutura
8 ArqAlu=fopen("Alunos.dat","a"); Abre o arquivo para gravação de
registros. Vincula o arquivo
interno (ArqAlu) com o arquivo
externo (Alunos.dat). O arquivo
será criado no diretório corrente,
caso já nao exista.
9 for (i=0;i<MAX;i++){ Início do looping (5x)
10 printf("Digite o RA do %i.o aluno: ",i+1); Recebe variáveis (RA e nome) do
scanf("%i",&RegAlu.ra);
printf("Digite o nome do %i.o aluno: ",i+1); usuário e guarda nas variáveis
scanf(" %s",RegAlu.nome); de registro. Note o espaço em
branco antes do “%”, isto é
importante para toda entrada de
caracteres.
11 fwrite(&RegAlu,sizeof(RegAlu),1,ArqAlu); Grava o registro no arquivo
12 } Fim do looping
13 fclose(ArqAlu); Fecha o arquivo
14 } Fim da função principal
Digite o Exemplo 10.2: Faça um programa que mostre os dados gravados no exemplo 9.1.
1 #include <stdio.h> Inclue função de i/o de arquivo
2 struct Aluno{ Declara o modelo Aluno para ser
int ra;
char nome[30]; usado para gravar os dados de
}; cada aluno
3 int main(){ Início da função principal
4 FILE *ArqAlu; Declara variável ponteiro de
arquivo
5 struct Aluno RegAlu; Declara variável de estrutura
7 ArqAlu=fopen("Alunos.dat","r"); Abre o arquivo para leitura de
registros. Vincula o arquivo interno
(ArqAlu) com o arquivo externo
(Alunos.dat). Caso o arquivo não
estiver criado no diretório corrente,
devolverá “NULL” para ArqAlu.
8 printf("RA Nome\n"); Imprime um cabeçalho para os
dados
9 while (fread(&RegAlu,sizeof(RegAlu),1,ArqAlu)){ Lê um registro do arquivo e aloca
na estrutura de memória. O fread()
retorna 1 (while torna-se
verdadeiro) se conseguiu ler um
registro e zero (while torna-se
falso), caso contrário.
10 printf("%i ", RegAlu.ra); Mostra dados alocados na
printf("%s\n", RegAlu.nome);
estrutura da memória pelo fread()
11 } Finaliza o looping
12 fclose(ArqAlu); Fecha o arquivo
13 } Fim da função principal
Digite o Exemplo 10.3: 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
int consulta_geral(); criadas pelo programador
int consulta_cod();
int alteracao();
int exclusao();
char menu();
3 struct Reg_brinq{ Define uma estrutura chamada Reg-brinq,
char cod_prod[5]; contendo 4 variáveis de dados e mais
char descricao[30]; uma variável flag (“exc”) para marcar ou
float preco; não o registro para exclusão.
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
case '1':
ou 6 e chama a respectiva função. Caso
inclusao();
seja opcao 6, o programa se encerra. O
break;
break fará com que o programa saia do
case '2':
switch.
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
printf(“MENU PRINCIPAL\n\n"); de arquivo para o usuário, permitindo que
printf("1 – Inclusao\n"); ele escolha qual opção deseja. Retorna a
printf("2 - Consulta Geral\n"); opcao escolhida.
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","a"); abre o arquivo para escrita, criando-o
caso nao exista (“a”). 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
17 printf("INCLUSAO\n\n"); as variáveis da estrutura deverão ser
18 printf("Codigo: "); antecedidas pela variavel brinq.Caso
19 gets(brinq.cod_prod); aconteça um erro de execução na
20 printf("Descricao: "); entrada do codigo ou da descrição,
21 gets(brinq.descricao); acrescente a função fflush(stdin) antes de
22 printf("Preco: "); cada gets(). Esta função limpa o buffer do
23 scanf(“%f”,&brinq.preco);
teclado.
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.
<s/n>? ");
Recebe a resposta, converte para
29 resp=toupper(getchar());
maiúscula (toupper()) e guarda na
30 }while (resp=='S');
variavel resp. Testa se “resp” é igual a 'S'
e, caso seja retorna para o “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
38 printf("Erro de abertura!"); aberto. Caso nao consiga (diretorio
39 getchar(); errado, problema na midia etc), mostra
40 return 0; um erro e volta ao menu principal.
41 }
42 system(“cls”); Mostra um cabeçalho para o relatório do
printf("CONSULTA GERAL\n\n"); brinquedos
printf(" Codigo Descricao
Preco Qtd Vendida\n");
43 while Lê um registro do arquivo e atribui para a
(fread(&brinq,sizeof(brinq),1,Arq_brinq)){
estrutura da 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
%d”, brinq.cod_prod , brinq.descricao,
brinq.preco, brinq.qtd_vend); carregados para a estrutura a partir do
arquivo.
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
57 printf("Erro de abertura. Talvez o tenha ocorrido 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
63 printf("CONSULTA POR usuário deseja encontrar.
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
Arq_brinq)){
69 if (!strcmp(xcod_prod, Verifica se o campo cogido do registro
brinq.cod_prod ) ){
que acabou de ser lido é 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
printf(“%s\n”, brinq.descricao); campos do registro
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
printf("\nEste brinquedo nao esta seja encontrado
cadastrado!!");
}
77 printf("\nDesejar continuar a consulta Pergunta se deseja continuar e retorna
<s/n>? ");
para o “do” (linha 61) caso deseje.
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 tenha ocorrido retorna ao menu principal
getchar();
return 0;
}
88 do{ Abre do-while
printf("ALTERACAO POR usuário deseja encontrar 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
Arq_brinq)){
94 if (!strcmp(xcod_prod, Verifica se o campo cogido do registro
brinq.cod_prod )){
95 printf("Descricao: "); Caso sejam iguais, mostra o restante dos
96 printf(“%s\n”, brinq.descricao); campos do registro
97 printf("Preco: ");
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
102 pritnf("Descricao: "); eventual alteração do usuário
103 gets(brinq.descricao);
104 printf("Preco: ");
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
sizeof(brinq),SEEK_SET);
registro que foi lido, pois o mesmo foi
deslocado na leitura.
109 fwrite(&brinq,sizeof(brinq),1,Arq_b Grava sobre o registro que foi lido,
rinq);
alterando-o
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
printf("\nO brinquedo nao esta encontrado o codigo do brinquedo no
cadastrado!!";
arquivo
}
115 pritnf("\nDesejar continuar a alteracao Pergunta se deseja continuar e retorna
<s/n>? ";
para o “do” (linha 88) caso deseje.
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 tenha ocorrido retorna ao menu principal
getchar();
return 0;
}
126 do{ Abre looping do-while
printf("EXCLUSAO POR usuário deseja encontrar.
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
Arq_brinq)){
131 if (!strcmp( xcod_prod, Verifica se o campo cogido do registro
brinq.cod_prod) && (brinq.exc=='n')){
132 printf(“%s\n”, brinq.descricao); Caso sejam iguais, mostra o restante dos
printf("Preco: "); campos do registro
printf(“%.2f\n”, brinq.preco);
printf("Qtd Vendida: ");
printf(“%d\n”, brinq.qtd_vend);
133 printf("Confirma exclusao Pergunta para o usuário se deseja
<s/n>? \n";
realmente excluir
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
sizeof(brinq),SEEK_SET);
registro que foi lido, pois o mesmo foi
deslocado na leitura.
138 fwrite(&brinq,sizeof(brinq),1,Arq Grava sobre o registro que foi lido,
_brinq);
alterando-o
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
printf("\nO brinquedo nao esta código procurado
cadastrado!!";
}
145 printf("\nDesejar continuar a exclusao Pergunta ao usuário se deseja continuar,
<s/n>? ";
recebe resposta e retorna ao “do” caso a
resp=toupper(getchar());
resposta seja afirmativa
}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
xArq_brinq=fopen("brinq1.dat","wb"); auxiliar p/ gravacao
148 while (fread(&brinq,sizeof(brinq), 1, Lê um registro do arquivo principal e
Arq_brinq)){
atribui para a 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 10.3, 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.
10.2Exercícios
10.2.1 Faça um programa que receba o id e o nome de 5 figuras

geométricas. Guarde estas informações em um arquivo.
10.2.2Sabendo que uma cor é composta por 3 componentes (R, G
e B), faça uma função que receba os componentes de cor para 5
figuras geométricas e guarde estas informações em um arquivo.
10.2.3 Faça um programa que mostra na tela as informações
gravadas em disco no exercício 10.2.1.
10.2.5 faça uma função que crie um arquivo a partir dos dados
dos arquivos gravados no exerc. 10.2.1 e 10.2.2.
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:
10.2.7Uma 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.
10.2.8Uma 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.).
10.2.9Uma 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.
10.2.10Todos os clientes do estado de São Paulo em ordem
alfabética por razão social.
10.2.11Uma Consulta Geral de todos os produtos.
10.2.12Uma rotina que mostre a quantidade de produtos em
estoque.
10.2.13Uma rotina que mostre o valor total do estoque.
10.2.14Uma rotina que mostre o valor médio do estoque.
10.2.15Faç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.
10.2.16Faça uma função que leia um arquivo já gravado (na
questão 10.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.
11 - 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.
Caso você esteja usando CodeBlock no Ubuntu aí vai um

tutorial para instalação e configuração do Allegro. Este tutorial foi
retirado do link abaixo:
http://www.rafaeltoledo.net/out-of-series-3-configurando-a-
biblioteca-allegro-no-codeblocks-ubuntu/
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 11.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 200,200 à 540,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
11.1 Exercícios
Dica: Verifique a lista de funções do Allegro no Apendice desta

apostila.
Básicos
11.1.1 Desenhe na tela um retângulo de 50 x 100 pontos,
utilizando line(), a partir da posição (100,100)..
11.1.2 Desenhe 1 circulo de raio 50, circunscrito em um
quadrado, no centro de cada quadrante de uma janela gráfica
de 800x600.
11.1.3 Faça um desenho humanóide, contendo cabeça, tronco,
pernas e braços. Use linhas, círculos e elipses.
11.1.4 Faça um programa que desenhe a bandeira do Brasil na
tela. Use line() para desenhar o losango e floodfill() para pintar
as figuras.
if
11.1.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).
11.1.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
11.1.7 Faça 20 circunferências circunscritas na tela. Use while.
11.1.8 Refaça o exercício 11.1.2, desenhando uma circunferência
de cada cor.
11.1.9 Refaça o exercício 11.1.2, pintando o interior de cada área
formada entre elas com cores diferentes.
11.1.10 Faça 50 retângulos circunscritos na tela.
11.1.11 Refaça o exercício 11.1.5, desenhando um retângulo de
cada cor.
11.1.12 Refaça o exercício 11.1.5, pintando o interior de cada
área formada entre eles com cores diferentes.
11.1.13 Faça um campo de futebol com faixas no gramado de cor
verde escuro e claro.
11.1.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.
11.1.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.
11.1.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
11.1.17 Faça uma bola amarela ficar "pingando" na tela. Faça o
desenho na própria tela (screen).
11.1.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
11.1.19 Refaça o exercício 11.1.10 mudando a cor da bola sempre
que a mesma tocar a borda.
Vetor
11.1.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.
11.1.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.
11.1.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
11.1.23 Faça um programa que receba uma matriz (5x2), a partir
do usuário, onde cada linha faz referencia a cada cidade do
estado e cada coluna faz referencia a localização “x” e “y”.
Após o carregamento da matriz, desenhe um círculo de raio 5,
representando cada cidade na tela.
Obs.: O x e o y já estão na escala da tela do computador.
Arquivo
11.1.24 Leia a localização x e y, e o nome da cidade, referentes a
cada cidade do estado de São Paulo, a partir de um arquivo e
plote as cidades na tela com os respectivos nomes de
identificação.
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 nota1
. . leia nota2
. . media ← (nota1 + nota2) / 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
Poderíamos também realizar um teste, através do comando

de decisão se-senão, de forma que seja impresso “Aprovado”, caso a
média seja maior ou igual a 5,0 e “Reprovado” se média menor que 5,0.
Abaixo temos as soluções em algoritmo e fluxograma.
inicio
. . leia nota1
. . leia nota2
. . media ← (nota1 + nota2) / 2
. . se media >= 5
. . . . escreva “Aprovado”
. . senão
. . . . escreva “Reprovado”
. . fim do se
. . escreva media
fim
início
leia nota1
leia nota2
media = (nota1+nota2)/2
não sim
media >=5
Escreva Escreva
“Reprovado” “Aprovado”
Escreva
media
fim
Um outro recurso importante da lógica é o comando de
repetição chamado “enquanto”. Este recurso permita repetir a execução
de procedimentos, ou seja, quando temos que fazer a mesma coisa
muitas vezes, podemos usar este recurso. NO caso apresentado acima,
caso queiramos permitir que o programa seja executado para 30
alunos, ao invés de apenas um, podemos usar o comando “enquanto” e
repetir a execução de todo o procedimento (digitação das notas, calculo
e exibição da mensagem) 30 vezes. Mostramos abaixo como o
algoritmo e fluxograma seriam reescritos.
inicio
. . cont = 1
. . enquanto cont <= 30
. . . . leia nota1
. . . . leia nota2
. . . . media ← (nota1 + nota2) / 2
. . . . se media >= 5
. . . . . . escreva “Aprovado”
. . . . senão
. . . . . . escreva “Reprovado”
. . . . fim do se
. . . . escreva media
. . . . cont = cont + 1
. . fim do enquanto
fim
início
cont = 1
não
cont <=30
sim
leia nota1
leia nota2
media = (nota1+nota2)/2
não
media >=5 sim
Escreva Escreva
“Reprovado” “Aprovado”
Escreva
media
cont = cont + 1
fim
Apêndices B – Resumo de comandos e funções
Nome Descrição Exemplo Observações
stdio.h
scanf() Recebe entrada do scanf(“%i”,&valor); %i é o formato e valor é a variável que
usuário guardará a informação do usuário
printf() Mostra informações ao printf(“Valor: %i”,valor); a variável valor substituirá o formato (%i)
usuário quando a mensagem for impressa.
fopen() Abre arquivo arq=fopen(“c:\\arquivo.dat”,”a”); Abre, se já existir, o arquivo arquivo.dat. Se
não existir, cria. Vincula ao nome interno
(arq) e permite inclusão no final do arquivo
(parâmetro “a”). O parâmetro “w” abre para
criação e gravação e o parâmetro “r” abre
para leitura.
fclose() Fecha arquivo fclose(arq) Fecha o arquivo que foi vinculado ao nome
interno “arq”
fread() Lê um registro do leu=fread(&reg,sizeof(reg),1,arq); A variável “leu” receberá 1 se um registro
arquivo e guarda na conseguiu ser lido pela função e 0, caso
memória contrário. Os parâmetros são: endereço da
struct (registro), tamanho em bytes da struct,
qtd de structs a serem lidos e nome interno
do arquivo.
fwrite() Grava o conteúdo da fwrite(&reg,sizeof(reg),1,arq); Grava um registro no arquivo através da
struct da memória para struct “reg” da memória. Os parâmetros são:
o arquivo endereço da struct, tamanho em bytes da
struct, qtd de structs a serem lidos e nome
interno do arquivo.
conio.h
getch() Pausa o programa e l=getch(); Recebe um caractere do usuário e guarda na
recebe um caractere do variavel “l”. Usado sem a variável apenas
usuário. pausa o programa aguardando digitação de
qualquer tecla.
math.h
sqrt() Calcula e retorna a raiz=sqrt(x); A variável raiz receberá o valor da raiz
raiz quadrada de um quadrada do conteúdo da variável x.
numero
cos() Calcula e retorna o c=cos(ang); A variável c receberá o coseno da variável
coseno de um numero ang (valor do ângulo em radiano)
sin() Calcula e retorna o s=sin(ang); A variável s receberá o seno da variável ang
seno de um numero (valor do ângulo em radiano)
Comandos
if/else Executa determinadas if (nota >= 5){ A condição “nota>=5” testa se nota maior
instruções de acordo printf(“Aprovado”); que 5 e se for o programa imprimirá
com condições } “Aprovado” na tela; caso contrário (nota <5)
else{ o programa imprimirá “Reprovado”
printf(“Reprovado”
}
while Repete a execução de valor=1; A variável “valor” é inicializada com 1. O
determinadas while (valor <= 5){ while verificada se valor é menor que 5 e
instruções enquanto a printf(“\nValor %i”,valor); enquanto não for menor, o programa
condição for valor=valor + 1; imprimirá o conteúdo de valor na tela,
verdadeira } somando 1 à variavel valor após cada
impressão na tela.
for Repete a execução de for (i=1;i<=5;i++){ A variável de controle “i” é incializada em
determinadas printf(“\nValor %i”, i); 1. o for testa se i é menor ou igual a 5 e se
instruções enquanto a } for o programa mostra o valor de “i” na tela,
condição for retorna a 1ª linha, soma 1 na variavel “i” e
verdadeira testa novamente, se i for ainda menor ou
igual a 5, entra novamente no for e mostra
novamente o valor de i. Isto se repete até i
Nome Descrição Exemplo Observações
ser maior que 5.
Allegro.h (não é padrão ANSI)

allegro_init() Inicializa o Allegro allegro_init(); Primeira função a ser usada antes de
qualquer outra função gráfica
set_gfx_mode() Define janela gráfica set_gfx_mode(GFX_AUTODETECT_WI Detecta a placa de video e define o modo
NDOWED,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 retângulo. rect(screen,100,100,200,200,makecol(0,25 Desenha um retângulo, na tela, com canto
5,0)); 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 linha line(screen,250,50,100,300,makecol(255,0 Desenha uma linha vermelha na tela, com
,0)); ponto inicial em 250,50 e ponto final em
100,300,de borda verde.
putpixel() Desenha um ponto putpixel(screen,10,10,makecol(255,0,0)) Desenha um ponto vermelho na tela, na
posição 10,10.
floodfill() Preenche região floodfill(screen,120,240,makecol(0,255,0)) Preenche uma região de cor verde a partir
; do ponto 120,240 até encontrar uma borda
(de qualquer cor)
set_color_depth() Define profundidade set_color_depth(32); Define que teremos 4 bytes de profundidade
de cor de cor. Usado sempre que definirmos um
BITMAP em nosso programa.
install_keyboard() Instala recursos de install_keyboard(); Reconhece cada tecla do teclado. Exemplo:
teclado key[KEY_ESC]
install_mouse() Instala recursos de install_mouse(); Reconhece posição e cliques do mouse
mouse
clear_to_color() Pinta toda área de um clear_to_color(screen,makecol(255,0,0)); Pinta o bitmap (neste caso, a tela) de
bitmap (inclusive tela) vermelho
de uma determinada
cor.
blit() Copia uma área de blit(img,screen,0,0,0,0,640,480); Copia o conteúdo de img para screen (tela) a
memória para outra partir da posição 0,0 da origem (img) para a
posição 0,0 do destino (screen). 640,480 é o
tamanho do bitmap de origem (img)
textout_ex() Escreve texto na tela textout_ex(screen,font,"Teste",100,350,ma Escreve “Teste” no bitmap da tela na
kecol(255,255,255),-1); posição 100, 350 na cor branca. O -1 serve
para deixar transparente o fundo de cada
caractere.
PortaP.h (não é padrão ANSI)

InicializaPP() Carrega a biblioteca na InicializaPP();
memória
FinalizaPP() Descarrega a FinalizaPP()
biblioteca da memória
inp32() Recebe um sinal da s=inp32(0x379) Recebe um sinal da porta e atribui o valor
porta paralela para a variável inteira “s”
oup32() Envia um sinal para a oup32(0x378,255) Envia o sinal 255 para a porta paralela.
porta paralela Neste caso, setando todos os bits.
Apêndices C – Acesso a Portas de Comunicação
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()
O sinal enviado a porta paralela deve ser considerado na

sequência binária, ou seja, considerando os 8 leds da placa, vinculamos
cada led à um bit. Assim, se quisermos acender os dois primeiros leds e
o quinto led, enviamos o número 19 (em decimal) para a porta.
0 0 0 1 0 0 1 1
bit 7 bit 6 bit 5 bit 4 bit 3 bit 2 bit 1 Bit 0
27
26
25
24
23
22
21 20 valor do bit
Para sabermos qual valor enviar para a porta, basta converter

o valor binário para decimal. No exemplo acima: 24 + 21 + 20 = 19.
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.
12. Faça um programa que permita que todos os leds pisquem 100 vezes. A cada vez,
os leds devem piscar mais rápido.
13. 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.
14. 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.
Porta Serial
A porta serial é referenciada pelo computador através de uma

identificação (com1, com2, com3 etc). Quando você conecta um
dispositivo à porta, sua identificação pode ser verificada no gerenciador
de dispositivo do Windows.
O site http://playground.arduino.cc//Interfacing/CPPWindows
apresenta um codigo com funções para acesso a porta serial. Este
código permite a inicializacao, leitura, escrita e finalizacao da porta
serial atraves de um programa escrito na linguagem C (.c) no Windows.
Para utilizá-lo siga as instruções abaixo:
Crie um Projeto no Dev-cpp
1. Selecione File/New/Project. Escolha um nome para o seu
projeto, escolha “Console Application” e clique OK.
2. Clique no “+” ao lado do nome do seu projeto. Clique-
direito no “main.cpp” e remova este arquivo. Não salve as mudanças.
3. Clique-direito no nome do projeto e some seu .c ao projeto.
4. Inclua também o arquivo Pserial.o
5. Clique-direito no nome do projeto. Escolha “Project
Options”. Na aba “Files” selecione o arquivo Pserial.o e tique em
“Including in linking”. Dê OK.
6. Não esqueça de incluir o “Pserial.h” em seu .c. Deixe estes
dois arquivo na mesma pasta.
7. Pronto! Basta executar seu projeto.
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
Agradeço todos os que me ajudaram de forma direta ou

indireta a escrever este material. Espero que 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 e 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.
“E ainda que distribuísse todos os meus bens para sustento

dos pobres, e ainda que entregasse o meu corpo para ser
queimado, e não tivesse amor, nada disso me
aproveitaria.” I Coríntios 13:3
Kesede Rodrigues Julio

Linguagem C PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Linguagem C PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Kesede R Julio

Campinas – São Paulo - Brasil

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

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

1.3 Estrutura de um Programa

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

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

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

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

Neste exemplo, o programa será interrompido para que o

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,

1.7 Exercícios Propostos

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

Moeda Valor (R$)

1.7.10 Faça um programa que calcule e mostre o salário líquido

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

1.7.13 Uma empresa de engenharia vai lotear uma fazenda e

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

Dica: Receba as entradas em variáveis inteiras separadas.

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

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

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

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

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

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

10 printf(“Reprovado”); Caso seja menor que 4, imprime mensagem

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

13 } Fecha função principal

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

switch (<variavel testada>){

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

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

5 printf(“Digite o codigo: ”); Mostra mensagem na tela

6 scanf(“%i”,&codigo); Recebe o valor do código do usuário

7 switch (codigo){ Abre o comando switch para verificação do

9 printf(“CD”); Caso seja, mostra mensagem

10 break; Sai o switch

11 case 2: Verifica se o código é igual a 2