Paulo DestroKesede R Julio
kesedejulio@gmail.com
Apostila de
Linguagem
C
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
Linguagem de Programação C
3
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
Linguagem de Programação C
4
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
precisam ser incluídos para arquivos .c
3
int main(){
char nome[30];
Abre a função principal do programa
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
substituindo
mensagem
o
formato
na
tela
(%s)
pelo
conteúdo da variável nome
Linguagem de Programação C
5
6
7
getch();
Pára a execução do programa
Fecha a função principal
}
Digite o Exemplo 1.3:- Um empregado da empresa Alfa tem dois vencimentos: salário e
gratificação. Faça um programa que receba os vencimentos do empregado, e mostre o salário
que ele irá receber.
1
#include <stdio.h>
Permite o uso das funções printf() e
scanf().Não precisam ser incluídos para
arquivos .c.
2
#include <conio.h>
Permite o uso da função conio().
Não
precisam ser incluídos para arquivos .c
3
int main(){
4
float salario;
Abre a função principal do programa
Deine
espaço
de
memória
chamado
salario
5
float grat;
Deine espaço de memória chamado grat
6
float soma;
Deine
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
13
getch();
14 }
Pára a execução do programa
Fecha a função principal
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().
Linguagem de Programação C
6
<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
Linguagem de Programação C
7
o usuário será: “Resultado da soma: 10.” (sem aspas).
scanf():- função que permite a digitação de dados pelo
usuário.
Sintaxe simplificada:
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) –
Linguagem de Programação C
8
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
Linguagem de Programação C
9
&
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, deinindo 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 deinidas 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 inal 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$)
Linguagem de Programação C
10
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 12 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
izesse um programa (faça primeiro o algoritmo e o luxograma)
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
Linguagem de Programação C
11
resultado para horas, minutos e segundos.
Linguagem de Programação C
12
2 - Comandos de Decisão
2.1Comando if/else
Definição: Usado para executar um ou mais comandos
dependentes de condições.
Sintaxe simplificada:
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()
3
int main(){
Abre a função principal do programa
4
float nota;
Linguagem de Programação C
Deine espaço de memória chamado nota
13
5
scanf(“%f”, ¬a);
Recebe a nota do usuário
6
if (nota>=6){
Veriica se nota é maior ou igual a 6
printf(“Aprovado”);
7
Caso seja, imprime mensagem na tela
8
}
Fecha o if
9
else{
Veriica se nota é menor que 6 (caso contrário do if)
printf(“Reprovado”);
10
Caso seja menor que 6. imprime mensagem
11
}
Fecha else
12
getch();
Pára a execução do programa
Fecha função principal
13 }
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.
1
#include <stdio.h>
Permite o uso das funções printf() e scanf()
2
#include <conio.h>
Permite o uso da função getch()
3
int main(){
Abre a função principal do programa
4
float nota;
Deine espaço de memória chamado nota
5
scanf(“%f”, ¬a);
Recebe a nota do usuário
6
if (nota>=6){
Veriica se nota é maior ou igual a 6
printf(“Aprovado”);
7
Caso seja, imprime mensagem
8
}
Fecha o if
9
else{
Veriica se nota é menor que 6 (caso contrário do if)
if (nota>=4){
printf(“Exame”);
Caso seja, imprime mensagem
}
Fecha o if
else{
Veriica se nota é menor que 4 (caso contrário do if)
printf(“Reprovado”); Caso seja menor que 4, imprime mensagem
10
}
11
12
Veriica se a nota é maior que 4
Fecha else
}
Fecha else
getch();
Pára a execução do programa
Fecha função principal
13 }
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
Linguagem de Programação C
14
“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.
Sintaxe simplificada:
switch (<variavel testada>){
case <valor>:
<comandos e funções>
break;
case <valor>:
<comandos e funções>
break;
default:
<comandos e funções>
}
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.
1
#include <stdio.h>
Permite o uso das funções printf() e scanf()
2
#include <conio.h>
Permite o uso da função getch()
3
int main(){
Abre a função principal do programa
4
int codigo;
Deine 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 veriicação do
código
Linguagem de Programação C
15
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.
case 1:
8
Veriica se o código é igual a 1
9
printf(“CD”);
Caso seja, mostra mensagem
10
break;
Sai o switch
case 2:
11
Veriica se o código é igual a 2
12
printf(“Livro”);
Caso seja, mostra mensagem
13
break;
Sai o switch
case 3:
14
Veriica se o código é igual a 3
15
printf(“Revista”);
Caso seja, mostra mensagem
16
break;
Sai o switch
case 4:
17
Veriica se o código é igual a 4
18
printf(“Jornal”);
Caso seja, mostra mensagem
19
break;
Sai o switch
default:
20
printf(“Opção Inválida”);
21
Veriica se é diferente de todos os cases
Caso seja, mostra mensagem
22
}
Fecha switch()
23
getch();
Pára execução do programa
24
}
Fecha função principal
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 veriicaçã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
Linguagem de Programação C
16
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 luxograma 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 boniicar 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
boniicaçõ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
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
Linguagem de Programação C
se
precisamos
17
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,
veriique 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. Veriique 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 luxograma antes do programa.
2.3.10 Dados 3 valores quaisquer, veriique 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 coeicientes 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 luxograma antes do programa.
Linguagem de Programação C
18
3 - Comandos de Repetição
3.1Comando while
Sintaxe simplificada:
while (<condição>){
<comandos e funções>
}
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.
1
#include <stdio.h>
Permite o uso das funções printf() e
scanf()
2
#include <conio.h>
Permite o uso da função getch()
3
int main(){
Abre a função principal do programa
4
int i=1;
(declaração e inicialização da variável i)
Deine 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){
Veriica 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
11 }
Fecha a função principal
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
Linguagem de Programação C
19
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.
1
#include <stdio.h>
Permite o uso das funções printf() e
scanf()
2
#include <conio.h>
Permite o uso da função getch()
3
int main(){
Abre a função principal do programa
4
int idade, cont=1, somaid=0;
Deine 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;
Deine espaço de memória loat para
guardar a media
6
printf(“Digite as idades\n”);
Imprime mensagem na tela
7
while (cont<=10){
Veriica 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
contador.
o
resultado
Na
próxima
no
próprio
iteração
o
contador já estará atualizado.
11 }
Linguagem de Programação C
Fecha o while
20
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
15 }
Fecha a função principal
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.
1
#include <stdio.h>
Permite o uso das funções printf() e
scanf()
2
#include <conio.h>
Permite o uso da função getch()
3
int main(){
Abre a função principal do programa
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 loat
6
do{
Abre o do-while
7
printf(“Nome:”);
Imprime mensagem (rotulo do que
será digitado)
8
fflush(stdin);
Limpa bufer 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)
Linguagem de Programação C
21
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 bufer do teclado
18
resp=toupper(getchar());
Recebe
a
resposta
do
usuário
e
converte sua resposta para maúscula
19
}while (resp=='S');
Veriica se a resposta é igual a S, caso
seja, volta no “do” para executar os
comandos novamente
20
}
Fecha a função principal
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
Linguagem de Programação C
22
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. 6>
<val. 8>
<mensagem 2>
<val. 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.
Teste de mesa
Memória
tela
linha 5 – Simulamos um valor digitado pelo
usuário.
Teste de mesa
Memória
Idade somaid qtd
tela
Idade somaid qtd
Linha 2 e 3 – atribui 1 e 0 para as respectivas
variáveis.
Teste de mesa
Memória
20
0
1
tela
Idade somaid qtd
0
1
linha 4 – Verifica se qtd é menor ou igual a
5. O retorno é verdadeiro. Isto não gera
alteração na tabela, apenas define que
executaremos a linha 5.
Linguagem de Programação C
Linha 6 – soma idade a somaid e guarda em
somaid
Teste de mesa
Memória
tela
23
Idade somaid qtd
20
0
20
Linha 8 – fecha o looping e volta para linha
4
1
Linha 7 – soma 1 em qtd
Teste de mesa
Memória
tela
Idade somaid qtd
20
0
20
linha 4 – Verifica se qtd é menor ou igual a
5. O retorno é verdadeiro. Isto não gera
alteração na tabela, apenas define que
executaremos a linha 5.
linha 5 – Simulamos um valor digitado pelo
usuário.
1
2
Teste de mesa
Linha 8 – fecha o looping e volta para linha
4
linha 4 – Verifica se qtd é menor ou igual a
5. O retorno é verdadeiro. Isto não gera
alteração na tabela, apenas define que
executaremos a linha 5.
Memória
tela
Idade somaid qtd
20
25
23
0
20
45
1
2
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
0
20
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
Memória
Teste de mesa
Memória
tela
20
25
0
20
45
1
2
Linha 7 – soma 1 em qtd
Teste de mesa
Memória
tela
Idade somaid qtd
20
25
0
20
45
Idade somaid qtd
20
25
23
Idade somaid qtd
1
2
3
Linguagem de Programação C
tela
0
20
45
68
1
2
3
4
Linha 8 – fecha o looping e volta para linha
4
linha 4 – Verifica se qtd é menor ou igual a
5. O retorno é verdadeiro. Isto não gera
alteração na tabela, apenas define que
executaremos a linha 5.
linha 5 – Simulamos um valor digitado pelo
usuário.
24
Teste de mesa
Memória
Teste de mesa
tela
Memória
Idade somaid qtd
20
25
23
30
0
20
45
68
tela
Idade somaid qtd
1
2
3
4
20
25
23
30
28
0
20
45
68
98
1
2
3
4
5
Linha 6 – soma idade a somaid e guarda em
somaid
Linha 6 – soma idade a somaid e guarda em
Teste de mesa
somaid
Memória
tela
Teste de mesa
Idade somaid qtd
Memória
tela
0
1
20
Idade somaid qtd
25
20
2
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
Linha 7 – soma 1 em qtd
Teste de mesa
Memória
tela
Idade somaid qtd
20
25
23
30
0
20
45
68
98
1
2
3
4
5
20
25
23
30
28
0
20
45
68
98
126
1
2
3
4
5
6
Linha 8 – fecha o looping e volta para linha
4
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.
linha 4 – Verifica se qtd é menor ou igual a
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
executaremos a linha 5.
Memória
tela
linha 5 – Simulamos um valor digitado pelo
usuário.
Linguagem de Programação C
Idade somaid qtd
25
20
25
23
30
28
0
20
45
68
98
126
1 A soma das idades eh
2 126
3
4
5
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
Linguagem de Programação C
5
26
De 501,00 a 1000,00
Acima de 1000,00
10
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 inalizar 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
veriicar 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
i =1
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.
Linguagem de Programação C
27
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.
Linguagem de Programação C
28
4 - Vetor
Até agora utilizamos estruturas únicas na memória, ou seja,
um único espaço foi alocado de cada vez. Porém, existem situações nas
quais queremos agrupar seqüencialmente na memória os nossos dados,
de forma a resgatá-los de maneira mais fácil. Podemos fazer a seguinte
analogia: geralmente, alocamos uma única casa e damos um nome
para ela. Quando queremos alocar um vetor, alocamos uma rua inteira e
damos um único nome para ela. Como a rua tem várias casas (neste
caso do mesmo tamanho), o compilador, automaticamente, atribui um
numero para cada casa, começando do zero. Chamamos este número
de índice. Assim:
int vet[5];
Aloca 5 espaços contíguos na memória, chamado vet, com
seu índice variando de 0 à 4. A figura 4.1 mostra alguns elementos
alocados através desta definição.
10 15 7 4 34
0
1
2
3
4
Elementos do vetor
Í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,
a[1], para acessar o índice 1,
a[2], para acessar o índice 2,
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
Linguagem de Programação C
29
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
2
/*-------------------------------------------------------Descrição: Calcula media das notas de 30 alunos
de uma classe
Data
: Agosto/2009
Autor
: Kesede R Julio
---------------------------------------------------------*/
O “/*” e o “*/”, abre e fecha um
#include <stdio.h>
Permite inclusão de funções de
bloco
de
comentários.
Estes
comentários ajudam muito em
seus
estudos.
Faça isso em
todos os seus programas.
i/o
3
#include <conio.h>
Permite
inclusão
da
função
getch()
4
5
int main(){
float notas[30], media, soma=0;
Linguagem de Programação C
Abre função principal
Declara o vetor notas com 30
30
posições do tipo loat, 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, veriica se i é menor que
30, na primeira vez. Nas outras
vezes, soma 1 em i e torna a
veriicar se i é menor que 30
8
printf("Entre com a %i a. nota", i+1);
Mostra uma mensagem na tela
9
scanf(“%f”,¬as[i]);
Recebe
usuário
valor
e
digitado
guarda
na
pelo
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”
14
getch();
Pára a execução do programa
15
}
Fecha a função principal
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.
Linguagem de Programação C
31
4.2.4Faça um programa que carregue um
vetor de inteiros,
permitindo que o usuário deina 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 inlação dos 12 meses
de 2008 (cada índice fará referência a um mês do ano).
a)Mostrar a inlação e o mês (numericamente) de menor índice
b)Mostrar a inlaçã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 ii 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).
Linguagem de Programação C
32
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, aim de veriicar 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 ixado 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 inais) e a velocidade de cada veículo
multado. Quando o sensor (usuário) captar (digitar) 0(zero) no
tempo, signiica 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 suiciente 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 suicientes.
Linguagem de Programação C
33
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
veriicaçã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 inal 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
Linguagem de Programação C
34
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 veriicar 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 inal do dia. A movimentação termina com valor 0.
Linguagem de Programação C
35
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
Linguagem de Programação C
36
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()
4
int main(){
Abre função principal
5
char string[10];
Declara variavel “string” de 10 posições
6
char str1[10] = "abcdefghi";
Declara variável “str1” de 10 posições e inicializa
com “abcdefghi”
7
strcpy(string, str1);
Copia conteúdo de “str1” para “string”
8
printf(“%s”, string);
Imprime o conteúdo de “string”
9
getch();
Pára a execução do programa
10
Fecha função principal
}
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.
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()
4
int main(){
Abre função principal
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
Veriica se “ptr” é maior que 0 (buf2
if (ptr > 0){
maior que buf1)
9
10
11
12
printf("buffer 2 eh maior que Caso seja, mostra mensagem
buffer 1\n");
Fecha if
}
Abre else
else{
if (ptr == 0){
Veriica se “ptr” é igual a 0 (buf2 igual
buf1)
printf("buffer 2 eh igual ao Caso seja, mostra mensagem
13
buffer 1\n");
14
}
Linguagem de Programação C
Fecha if
37
15
Abre else
else{
printf("buffer 2 eh menor que o Mostra mensagem, pois se entrou aqui é
16
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
Veriica se “ptr” é maior que 0 (buf2
if (ptr > 0){
maior que buf3)
21
printf("buffer 2 eh maior que Caso seja, mostra mensagem
buffer 3\n");
22
Fecha if
}
23
Abre else
else{
24
if (ptr == 0){
Veriica se “ptr” é igual a 0 (buf2 igual
buf3)
printf("buffer 2 eh igual ao Caso seja, mostra mensagem
25
buffer 3\n");
26
}
Fecha if
27
else{
Abre else
printf("buffer 2 eh menor que o Mostra mensagem, pois se entrou aqui é
28
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
32 }
Fecha função principal
Digite o Exemplo 5.3- Faça um programa que mostre a quantidade de caracteres de uma string.
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()
4
#include <stdio.h>
Permite inclusão de funções de i/o
5
#include <string.h>
Permite inclusão de funções para
manipulação de string
6
int main(){
Linguagem de Programação C
Abre função principal
38
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
9
getch();
Pára a execução do programa
Fecha função principal
10 }
Digite o Exemplo 5.4:- Faça um programa que concatene duas strings e mostre o resultado da
concatenação 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()
4
#include <string.h>
Permite
inclusão
de
funções
para
manipulação de strings
5
#include <stdio.h>
Permite inclusão de funções de i/o
6
int main(){
Abre função principal
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
14
}
Fecha função principal
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.
Linguagem de Programação C
39
5.1.3 Um programa de criptograia codiica as vogais a, e, i, o, u
como 1, 2 ,3, 4, 5, respectivamente. Faça um programa que
receba uma frase codiicada do usuário e mostre-a decodiicada.
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 inalizador.
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
Linguagem de Programação C
40
e devolva este nome na forma bibliográica.
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.
Linguagem de Programação C
41
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.
Linguagem de Programação C
42
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
2
int main(){
Abre função principal
3
int ac[10][10], i_maior, j_maior, i, j, maior, tot=0;
Declara variáveis.
4
for(i=0; i<10; i++){
for(j=0; j<10;j++){
scanf(“%i”, &ac[i][j]);
}
}
Carrega a matriz a partir
5
maior=ac[0][0];
for(i=0; i<10; i++){
for(j=0; j<10;j++){
if(ac[i][j] > maior){
i_maior=i;
j_maior=j;
maior=ac[i][j];
}
}
}
printf(“A rua %i esquina com %i teve %i acidentes,
sendo a esquina com maior nr de acidentes do centro.”,
i_maior,j_maior, maior);
getch();
do usuário
Incializa a variavel auxiliar
“maior”
com
o
primeiro
elemento da matriz. Em
seguida, percorre a matriz
veriicando se existe algum
elemento
maior
primeiro,
guardado
variavel
que
“maior”.
o
na
Caso
exista, atualiza “maior” e
guarda os índices (esquina)
deste elemento. Ao inal,
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
Linguagem de Programação C
43
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 Veriique 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.
6.1.10 Faça um programa que carregue uma matriz de inteiros
10x10, a partir do usuário. Mostre na tela a somatória de todos os
valores, exceto os valores das linhas pares.
6.1.11 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.
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
Linguagem de Programação C
44
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.
Linguagem de Programação C
45
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.:
Linguagem de Programação C
46
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.
por referência.
4.
Podem ser passadas como parâmetro, por valor ou
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
2
3
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <ctype.h>
#include <math.h>
Include
arquivos
int main(){
Abre função principal
de
cabeçalho
typedef struct DadosGeo{
char nome[50];
int x, y;
};
Declara uma struct como
int i=0, xRef, yRef, qtdcid;
DadosGeo cidades[1000];
char nomeRef[50], resp;
float dist;
Declara variáveis, inclusive
Linguagem de Programação C
tipo
contendo
3
informações: nome, x, y
o vetor “cidades” do tipo
DadosGeo
47
4
5
do{
system("cls");
printf("Nome: ");
fflush(stdin);
gets(cidades[i].nome);
printf("\nPosicao X: ");
scanf("%i",&cidades[i].x);
printf("\nPosicao Y: ");
scanf("%i",&cidades[i].y);
i++;
printf("Existem mais cidades? <S/N> ");
fflush(stdin);
resp=toupper(getch());
}while (resp=='S');
Carrega o vetor, a partir do
qtdcid=i;
Guarda a quantidade de
usuário
cidades
digitadas
usuário,
para
pelo
usar
no
usuário
os
controle do FOR.
printf("\nEntre com o nome da cidade referencia: ");
gets(nomeRef);
printf("\nPosicao X: ");
scanf("%i",&xRef);
printf("\nPosicao Y: ");
scanf("%i",&yRef);
Recebe
printf("\n\nListagem das distancias\n");
for (i=0;i<qtdcid;i++){
dist=sqrt(pow(xRef-cidades[i].x,2)+pow(yRefcidades[i].y,2));
printf("%-10s - %.1f Km\n", cidades[i].nome, dist);
}
getch();
Percorre
}
Fecha main()
6
7
8
do
dados da cidade que será
referência para o cálculo
das distâncias
todo
o
vetor,
calculando a distância para
cada
nome
cidade.
da
Mostra
cidade
e
o
a
distância.
7.1 Exercícios
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.
7.1.1
Linguagem de Programação C
48
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
2
void soma2(){
int val1, val2, soma;
Abre a função soma2
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”
Linguagem de Programação C
49
6
7
printf(“%i”,soma);
Imprime “soma”
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(){
5
soma2();
Abre a função principal
Chama a função soma2() para ser
executada
7
Fecha a função principal
}
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()
2
#include <conio.h>
Permite o uso da função getch()
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
Linguagem de Programação C
50
8
}
Fecha função soma2()
9
int main(){
Abre função principal
10
int val1, val2;
Declara variáveis val1 2 val2 como inteiros
11
scanf(“%i”,&val1);
Recebe val1 do usuário
12
scanf(“%i”,&val2);
Recebe val2 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()
2
#include <conio.h>
Permite o uso da função getch()
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()
9
int main(){
Abre função principal
10
int val1, val2, s;
Declara variáveis val1 2 val2 como inteiros
11
scanf(“%i”,&val1);
Recebe val1 do usuário
12
scanf(“%i”,&val2);
Recebe val2 do usuário
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
Linguagem de Programação C
51
retorno na variável “s”.
14
printf(“%i”,s);
Imprime a variável “s”
getch();
Pára o programa
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.
1
#include <stdio.h>
Permite inclusão de funções de i/o
2
#include <conio.h>
Permite inclusão da função getch()
3
void area_per(float l, float *a, float *p);
Declara o protótipo da função
4
int main(){
Abre função principal
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()
9
getch();
Pára a execução do programa
10
}
Fecha função principal
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
Linguagem de Programação C
52
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 coeicientes de uma
equação de 2º grau e devolva as raízes da equação, caso existam.
Linguagem de Programação C
53
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(loat
ax, loat bx, loat cx, loat *raiz1, loat *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. loat CalcMedia(int *v, int T);
Esta função calcula e retorna a média aritmética do vetor (v) de
tamanho T.
3. loat DesvioPadrao(int *v, loat 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”.
Linguagem de Programação C
54
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>
#include <conio.h>
Inclue arquivos de protótipos.
2
typedef struct Cor{
int r,g,b;
}Cor;
Definição do tipo estrutura Cor,
a
ser manipulada
pelas
funções da TAD.
3
void Carregar(Cor *c){
scanf(“%i”,&c.r);
scanf(“%i”,&c.g);
scanf(“%i”,&c.b);
}
Função que carregará
dados na estrutura
4
void Mostrar(Cor c){
printf(“\nCor R = %i”,c.r);
printf(“\nCor G = %i”,c.g);
printf(“\nCor B = %i”,c.b);
}
Função que mostrará os dados
da estrutura na tela.
os
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
Linguagem de Programação C
a
função
Mostrar()
55
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
7
getch();
}
Pára o programa
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.
2.
3.
4.
5.
Set() para cada variável (exceto media) a partir do usuário.
Get() para cada variável.
Set() para um aluno.
Set() para media das notas.
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.
Linguagem de Programação C
56
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
Linguagem de Programação C
57
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
bytes>,<origem do deslocamento>)
em
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.
Linguagem de Programação C
58
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
Deine a macro MAX como 5
3
struct Aluno{
int ra;
char nome[30];
};
Declara o modelo Aluno para ser
int main(){
Início da função principal
4
5
FILE *ArqAlu;
usado para gravar os dados de
cada aluno
Declara
variável
ponteiro
de
arquivo
6
struct Aluno RegAlu;
Declara variável de estrutura
7
int i;
Declara variável i
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++){
10
printf("Digite o RA do %i.o aluno: ",i+1);
scanf("%i",&RegAlu.ra);
printf("Digite o nome do %i.o aluno: ",i+1);
scanf(" %s",RegAlu.nome);
Início do looping (5x)
Recebe variáveis (RA e nome) do
usuário e guarda nas variáveis
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
Fim da função principal
14 }
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{
int ra;
char nome[30];
};
Declara o modelo Aluno para ser
int main(){
Início da função principal
3
4
FILE *ArqAlu;
usado para gravar os dados de
cada aluno
Declara
variável
ponteiro
de
arquivo
5
struct Aluno RegAlu;
Linguagem de Programação C
Declara variável de estrutura
59
6
int i;
Declara variável i
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
Imprime um cabeçalho para os
Nome\n");
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);
printf("%s\n", RegAlu.nome);
Mostra
dados
alocados
na
estrutura da memória pelo fread()
11
}
Finaliza o looping
12
fclose(ArqAlu);
Fecha o arquivo
Fim da função principal
13 }
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é-deinidos
#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{
Deine uma estrutura chamada Reg-brinq,
char cod_prod[5];
contendo 4 variáveis de dados e mais
char descricao[30];
uma variável lag (“exc”) para marcar ou
float preco;
não o registro para exclusão.
int qtd_vend;
Linguagem de Programação C
60
char exc;
};
4
int main(){
5
char opcao='0';
Abre main()
Inicializa opcao com zero para forçar a
primeira entrada no looping.
while (opcao!='6'){
Veriica 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){
case '1':
inclusao();
break;
case '2':
consulta_geral();
Veriica se a variável “opcao” é 1,2,3,4,5
ou 6 e chama a respectiva função. Caso
seja opcao 6, o programa se encerra. O
break fará com que o programa saia do
switch.
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();
Linguagem de Programação C
61
9
}
Fecha menu()
10
void inclusao(){
Abre inclusao()
11
FILE *Arq_brinq;
Deine uma variável ponteiro para FILE
(estrutura pr-e-deinida para controlar o
arquivo)
12
Reg_brinq brinq;
Deine 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
19
gets(brinq.cod_prod);
aconteça
20
printf("Descricao: ");
entrada
21
gets(brinq.descricao);
acrescente a função lush(stdin) antes de
22
printf("Preco: ");
cada gets(). Esta função limpa o bufer do
23
scanf(“%f”,&brinq.preco);
teclado.
24
pritnf(“Qtd_Vendida: ");
25
scanf(“%d”.&brinq.qtd_vend);
26
brinq.exc='n';
pela
um
do
variavel
brinq.Caso
erro
de
execução
codigo
ou
da
na
descrição,
inicializacao do campo exclusao
fwrite(&brinq,sizeof(brinq),1,Arq_brinq grava 1 registro no arquivo e move o
27
);
ponteiro do arquivo, preparando para
próxima gravação.
28
29
30
printf("Desejar continuar a inclusao Pergunta ao usuário se deseja continuar.
<s/n>? ");
Recebe a resposta, converte para
resp=toupper(getchar());
maiúscula (toupper()) e guarda na
}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;
Linguagem de Programação C
Declara variável ponteiro para FILE
62
35
36
Declara variável brinq do tipo estrutura
Reg_brinq brinq;
Arq_brinq=fopen("brinq.dat","rb");
37
if (Arq_brinq==NULL){
Abre o arquivo para leitura (“rb”)
Veriica
se
o
Caso
arquivo
conseguiu
ser
38
printf("Erro de abertura!");
aberto.
39
getchar();
errado, problema na midia etc), mostra
40
return 0;
um erro e volta ao menu principal.
nao
consiga
(diretorio
41
}
42
system(“cls”);
Mostra um cabeçalho para o relatório do
printf("CONSULTA GERAL\n\n");
brinquedos
printf(" Codigo
Preco Qtd Vendida\n");
43
Descricao
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,
carregados para a estrutura a partir do
brinq.preco, brinq.qtd_vend);
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 lag “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){
Veriica 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{
Linguagem de Programação C
Abre looping do-while
63
62
63
Recebe o codigo do brinquedo que o
system(“cls”);
printf("CONSULTA
CODIGO\n\n");
POR usuário deseja encontrar.
64
printf("Digite o Codigo: ");
65
gets(xcod_prod);
66
achou=0;
Inicializa lag 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)){
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
if (!strcmp(xcod_prod, Veriica se o campo cogido do registro
69
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 lag 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
78
printf("\nDesejar continuar a consulta Pergunta se deseja continuar e retorna
<s/n>? ");
para o “do” (linha 61) caso deseje.
resp=toupper(getchar());
79
}while (resp=='S');
80
fclose(Arq_brinq);
Linguagem de Programação C
Fecha o arquivo
64
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+");
87
if (Arq_brinq==NULL){
//abre o arquivo para leitura e gravação
Veriica se ocorreu erro de abertura. Caso
printf("Erro de abertura. Talvez o tenha ocorrido retorna ao menu principal
arquivo nao exista!");
getchar();
return 0;
}
88
89
Abre do-while
do{
Recebe o codigo do brinquedo que o
system(“cls”);
printf("ALTERACAO POR usuário deseja encontrar para alteração
CODIGO\n\n");
printf("Digite o Codigo: ");
gets(xcod_prod);
90
achou=0;
Incializa lag com zero
fseek(Arq_brinq,0,SEEK_SET);
Coloca o ponteiro do arquivo apontando
91
92
para o primeiro registro.
93
while
(fread(&brinq,sizeof(brinq),
Arq_brinq)){
1, Lê um registro do arquivo e atribui para a
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
if (!strcmp(xcod_prod, Veriica se o campo cogido do registro
94
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.
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);
Linguagem de Programação C
65
99
printf("Qtd Vendida: ");
100
printf(“%d\n”, brinq.qtd_vend);
101
printf("Campos para alterar:\n");
Disponibiliza
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
todos
os
campos
para
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.
fwrite(&brinq,sizeof(brinq),1,Arq_b Grava sobre o registro que foi lido,
109
rinq);
alterando-o
110
achou=1;
Seta lag 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
116
pritnf("\nDesejar continuar a alteracao Pergunta se deseja continuar e retorna
<s/n>? ";
para o “do” (linha 88) caso deseje.
resp=toupper(getchar());
117
}while (resp=='S');
118
fclose(Arq_brinq);
119
Fecha arquivo
Fecha alteração
}
120 int exclusao(){
Abre exclusão
121
Declara
FILE *Arq_brinq, *xArq_brinq;
variavel
arquivo
(principal
e
variavel
registro
(principal
e
auxiliar)
122
Reg_brinq brinq, xbrinq;
Declara
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
125
if (Arq_brinq==NULL){
Veriica se ocorreu erro de abertura. Caso
printf("Erro de abertura. Talvez o tenha ocorrido retorna ao menu principal
arquivo nao exista!");
getchar();
Linguagem de Programação C
66
return 0;
}
126
127
Abre looping do-while
do{
Recebe o codigo do brinquedo que o
system(“cls”);
printf("EXCLUSAO
POR usuário deseja encontrar.
CODIGO\n \n");
printf("Digite o Codigo: ");
gets(xcod_prod);
128
achou=0;
Inicializa lag 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)){
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
131
if (!strcmp( xcod_prod, Veriica se o campo cogido do registro
brinq.cod_prod) && (brinq.exc=='n')){
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.
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);
printf("Confirma exclusao Pergunta
133
<s/n>? \n";
para
o
usuário
se
realmente excluir
134
resp=toupper(getchar());
Recebe a resposta do usuário
135
if (resp=='S'){
Veriica se a resposta é airmativa
136
137
brinq.exc='s';
deseja
Marca o registro p/ exclusao
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.
fwrite(&brinq,sizeof(brinq),1,Arq Grava sobre o registro que foi lido,
138
_brinq);
alterando-o
139
}
Fecha if
140
achou=1;
Muda lag
141
break;
Sai do while
Linguagem de Programação C
67
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 airmativa
}while (resp=='S');
146
147
fclose(Arq_brinq);
Arq_brinq=fopen("brinq.dat","rb");
xArq_brinq=fopen("brinq1.dat","wb");
148
Fecha arquivo principal
Abre o arquivo principal p/ leitura e o
auxiliar p/ gravacao
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'){
Veriica se o lag 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
Linguagem de Programação C
68
(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 iguras
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
iguras 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.4 Faça um programa que mostra na tela as informações
gravadas em disco no exercício 10.2.2.
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.
10.2.6 Faça um programa que mostra na tela as informações
gravadas em disco no exercício 10.2.5.
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.
Linguagem de Programação C
69
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 (deinido 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.
Linguagem de Programação C
70
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-abiblioteca-allegro-no-codeblocks-ubuntu/
Linguagem de Programação C
71
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
2
int main(){
Abre main()
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));
12
putpixel(screen,470,450,makecol(200,200,50));
13
putpixel(screen,480,450,makecol(200,200,50));
14
putpixel(screen,490,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: Veriique 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áica
Linguagem de Programação C
72
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 loodill() para pintar
as iguras.
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áica de
800x600. O usuário deverá decidir qual dos 4 cantos da janela
gráica 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áica 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áica.
11.1.15 Preencha uma área quadrada de 100x100 da janela
gráica, 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 icar "pingando" na tela. Faça o
Linguagem de Programação C
73
desenho na própria tela (screen).
11.1.18 Faça uma bola amarela icar "pingando" na tela, usando a
técnica double-bufer. 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áico, 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áico, 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
identiicação.
Linguagem de Programação C
74
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,
Linguagem de Programação C
75
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
básicos: Entrada, processamento e saída.
Entrada
Processamento
3
procedimentos
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
Linguagem de Programação C
76
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 subrotina
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)
Linguagem de Programação C
77
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
Linguagem de Programação C
78
início
leia nota1
leia nota2
media = (nota1+nota2)/2
não
media >=5
Escreva
“Reprovado”
sim
Escreva
“Aprovado”
Escreva
media
fim
Linguagem de Programação C
79
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
Linguagem de Programação C
80
início
cont = 1
não
cont <=30
sim
leia nota1
leia nota2
media = (nota1+nota2)/2
não
media >=5 sim
Escreva
“Aprovado”
Escreva
“Reprovado”
Escreva
media
cont = cont + 1
fim
Linguagem de Programação C
81
Apêndices B – Resumo de comandos e funções
Nome
Descrição
Exemplo
Observações
stdio.h
scanf()
Recebe entrada do
usuário
scanf(“%i”,&valor);
%i é o formato e valor é a variável que
guardará a informação do usuário
printf()
Mostra informações ao printf(“Valor: %i”,valor);
usuário
a variável valor substituirá o formato (%i)
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
arquivo e guarda na
memória
leu=fread(®,sizeof(reg),1,arq);
A variável “leu” receberá 1 se um registro
conseguiu ser lido pela função e 0, caso
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(®,sizeof(reg),1,arq);
struct da memória para
o arquivo
Grava um registro no arquivo através da
struct “reg” da memória. Os parâmetros são:
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.
Recebe um caractere do usuário e guarda na
variavel “l”. Usado sem a variável apenas
pausa o programa aguardando digitação de
qualquer tecla.
math.h
sqrt()
Calcula e retorna a
raiz quadrada de um
numero
raiz=sqrt(x);
A variável raiz receberá o valor da raiz
quadrada do conteúdo da variável x.
cos()
Calcula e retorna o
coseno de um numero
c=cos(ang);
A variável c receberá o coseno da variável
ang (valor do ângulo em radiano)
sin()
Calcula e retorna o
seno de um numero
s=sin(ang);
A variável s receberá o seno da variável ang
(valor do ângulo em radiano)
Comandos
if/else
Executa determinadas
instruções de acordo
com condições
if (nota >= 5){
printf(“Aprovado”);
}
else{
printf(“Reprovado”
}
A condição “nota>=5” testa se nota maior
que 5 e se for o programa imprimirá
“Aprovado” na tela; caso contrário (nota <5)
o programa imprimirá “Reprovado”
while
Repete a execução de
determinadas
instruções enquanto a
condição for
verdadeira
valor=1;
while (valor <= 5){
printf(“\nValor %i”,valor);
valor=valor + 1;
}
A variável “valor” é inicializada com 1. O
while verificada se valor é menor que 5 e
enquanto não for menor, o programa
imprimirá o conteúdo de valor na tela,
somando 1 à variavel valor após cada
impressão na tela.
for
Repete a execução de
determinadas
instruções enquanto a
condição for
verdadeira
for (i=1;i<=5;i++){
printf(“\nValor %i”, i);
}
A variável de controle “i” é incializada em
1. o for testa se i é menor ou igual a 5 e se
for o programa mostra o valor de “i” na tela,
retorna a 1ª linha, soma 1 na variavel “i” e
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
Linguagem de Programação C
82
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
NDOWED,640,480,0,0);
Detecta a placa de video e define o modo
(640,480). Os 2 ultimos parametros definem
janela virtual (não recomendavel,por isso
0,0)
circle()
Desenha uma
circunferência.
circle(screen,100,100,50,makecol(0,0,255) Desenha um circulo, na tela, na posição
);
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))
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
de cor
set_color_depth(32);
Define que teremos 4 bytes de profundidade
de cor. Usado sempre que definirmos um
BITMAP em nosso programa.
install_keyboard() Instala recursos de
teclado
install_keyboard();
Reconhece cada tecla do teclado. Exemplo:
key[KEY_ESC]
install_mouse()
Instala recursos de
mouse
install_mouse();
Reconhece posição e cliques do mouse
clear_to_color()
Pinta toda área de um clear_to_color(screen,makecol(255,0,0));
bitmap (inclusive tela)
de uma determinada
cor.
Pinta o bitmap (neste caso, a tela) de
vermelho
blit()
Copia uma área de
memória para outra
blit(img,screen,0,0,0,0,640,480);
Copia o conteúdo de img para screen (tela) a
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.
InicializaPP()
Carrega a biblioteca na InicializaPP();
memória
FinalizaPP()
Descarrega a
biblioteca da memória
FinalizaPP()
inp32()
Recebe um sinal da
porta paralela
s=inp32(0x379)
Recebe um sinal da porta e atribui o valor
para a variável inteira “s”
oup32()
Envia um sinal para a
porta paralela
oup32(0x378,255)
Envia o sinal 255 para a porta paralela.
Neste caso, setando todos os bits.
Desenha um ponto vermelho na tela, na
posição 10,10.
PortaP.h (não é padrão ANSI)
Linguagem de Programação C
83
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;
}
Linguagem de Programação C
84
/* 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
2
3
int main(){
InicializaPP();
Abre main()
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");
Linguagem de Programação C
Pára o programa
85
Fecha main()
}
8
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
bit 7
bit 6
bit 5
bit 4
bit 3
bit 2
7
2
2
6
5
2
2
4
3
2
2
2
1
1
bit 1 Bit 0
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.
Linguagem de Programação C
86
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. Cliquedireito 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.
Linguagem de Programação C
87
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.
Linguagem de Programação C
88
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 de Programação C
89
Related papers
Pengaruh Pelatihan dan Pengembangan Serta Prestasi Kerja Terhadap Pengembangan Karir Pegawai Pada Dinas Koperasi Usaha Mikro Kecil Menengah Banjarmasin
Jurnal Riset Inspirasi Manajemen dan Kewirausahaan, 2017
Low Chronic Self-Esteem and Low Situational Self-Esteem: a literature review
Revista Brasileira de Enfermagem, 2020
International journalism in social media age: perspective of professionals
Aline KIBERINKA, 2020
Analysis of cash holding for measuring the efficiency of cash management: A study on IT sector
Management Science Letters, 2015
Determinants of GBP Recruitment to Toxoplasma gondii Vacuoles and the Parasitic Factors That Control It
PLOS One, 2011
The use of modified molecular model in learning molecular geometry among matriculation students
Jurnal Penyelidikan Pendidikan, 2016
Percutaneous Adjustable Closed Otoplasty for Prominent Ear Deformity
Journal of Craniofacial Surgery, 2013
Ropivacainevs bupivacaine in major surgery in infants
Canadian Journal of Anesthesia, 1999
Accelerated Restoration of Ocular Surface Health in Dry Eye Disease by Self-Retained Cryopreserved Amniotic Membrane
The ocular surface, 2015
Tribulus terrestris fruit’s potential for synthesizing gold nanoparticles with remarkable biological prospects
Journal of Biological Research - Bollettino della Società Italiana di Biologia Sperimentale, 2025
Hospitals of the Future: Designing Interactive Robotic Systems for Resilient Emergency Departments
Proceedings of the ACM on human-computer interaction, 2022
Second international spectroradiometer intercomparison: results and impact on PV device calibration
Progress in Photovoltaics: Research and Applications, 2014
Electrochemical engineering approach of high performance solid-state flexible supercapacitor device based on chemically synthesized VS2 nanoregime structure
Journal of Energy Chemistry, 2018
Detection of PVC in ECG signals using fractional linear prediction
Biomedical Signal Processing and Control, 2016