Apostila Dev C Rev 02-06-2009

+++++++++++ ÍNDICE +++++++++++
Módulo I – Lógica de Programação
Capítulo 1 Histórico 3
Capítulo 2 Objetivos 3
Capítulo 3 Ambiente 4
Capítulo 4 Bibliotecas 5
Capítulo 5 Tipos de Dados 6
Capítulo 6 Documentação 7
Capítulo 7 A Função Principal - main() 8
Capítulo 8 Delimitadores de Bloco 8
Capítulo 9 Variáveis 9
Capítulo 10 Funções de Saída 10
Capítulo 11 Funções de Entrada 11
Capítulo 12 Estruturas de Decisões 16
12.1 - Seqüências Simples 16
12.2 - Seqüências Alternativas 17
12.2.1 - Seqüências Alternativas Simples - if 17
12.2.2 - Seqüências Alternativas Compostas - if...else 18
12.2.3 - Seqüências Alternativas com Múltiplas Condições 19
12.2.4 - Estrutura Caso - case 20
Capítulo 13 Laços de Repetição - Iterações 24
13.1 - Iteração Enquanto - while 24
13.2 - Iteração Repita – do while 29
13.3 - Iteração Para - for 33
Capítulo 14 Estruturas Homogêneas 36
14.1 - Matrizes com Uma Dimensão (Vetores) 37
14.2 - Matrizes com Duas dimensões 39
Capítulo 15 Estruturas Heterogêneas 45
15.1 – Registros - struct 45
Capítulo 16 Procedimentos e Funções 53
Módulo II – Estruturas de Dados
Capítulo 1 Cadeia de Caracteres 56

Capítulo 2 Listas Lineares 61
Capítulo 3 Filas 67
Capítulo 4 Pilhas 72
Capítulo 5 Deques 68
Capítulo 6 Recursividade 84
Capítulo 7 Árvores 87
Módulo III – Arquivos
Capítulo 1 Arquivo Texto 93

Capítulo 2 Arquivo Binário 96
Anexo I – Exercícios Resolvidos
Anexo II – Projetos Comentados
Capítulo 1 Criptografia Simétrica 130

Capítulo 2 Criptografia Assimétrica 137
Capítulo 3 Agenda 155
Capítulo 4 Locadora 183
Capítulo 5 Controle de Estoque 212
-2-
+++++++++++ MÓDULO I +++++++++++
LÓGICA DE PROGRAMAÇÃO
I HISTÓRICO
A Linguagem C foi desenvolvida no início dos anos 70, em 1972, por Dennis M. Ritchie. Sua
primeira implementação foi feita num PDP-11 com sistema UNIX, tendo sido, em seguida, utilizada para
rescrever o UNIX.
O desenvolvimento da linguagem C foi fortemente influenciado pela linguagem B, desenvolvida por

Ken Tompson que, por sua vez, teve suas origens em uma linguagem relativamente antiga, BCPL,
desenvolvida por Martin Richards.
Embora muitas características de "C" sejam comuns com BCPL, "C" não é um dialeto desta última
linguagem.
II OBJETIVOS
C é uma linguagem de propósito geral. Mesmo tendo sido criada com o objetivo de ser uma
linguagem de programação de sistemas operacionais e utilitários, pelas suas facilidades de acesso a nível
de máquina e eficiência do código gerado, "C" também é bastante útil para escrever um grande número de
aplicações numéricas, de processamento de texto e de programas para banco de dados.
Este livro aborda os conceitos básicos da Linguagem, tratando o programa em C++ em módulos,
desde uma aplicação simples como uma soma de dois números até uma aplicação complexa na realização
de um sistema de criptografia assimétrica.
O foco principal deste documento são alunos universitários, e para isso o livro aborda a ementa de
duas (ou três) disciplinas básicas do curso de Ciência da Computação: Algoritmos, Linguagem de
Programação e ainda Estrutura de Dados.
Em Estrutura de Dados são apresentadas as principais estruturas como: Cadeia de Caracteres,

Listas, Filas, Pilhas, Deques e ainda Árvores, com o intuito de preparar o aluno para uma outra disciplina da
grade de Ciência da Computação: grafos.
O livro fecha com quatro projetos práticos:
criptografia simétrica - criação e editão de arquivos texto com técnica criptográfica sem
senha privada,
criptografia assimétrica - incluindo senha privada além da senha pública já presente no

projeto anterior),
agenda - com as principais funções de uma agenda telefônica básica e
locadora - com variações para Cd, VHS e DVD permitindo inclusão, alteração, exclusão,
consulta, listagem, relatório, etc.
-3-
III O AMBIENTE Dev C++
O ambiente Dev C++ integra os recursos de um compilador com um editor de textos, através da
seleção de opções em um ambiente windows com menus e ferramentas específicas para a linguagem.
Figura 1 – Ambiente Dev C++
À medida que os recursos da linguagem forem utilizados, e os recursos da plataforma DEV C++
forem necessários, estes serão citados e explicados paulatinamente.
Boa parte das funções e comandos usados neste livro, com foco na plataforma DEV C++, também
são compatíveis com outros compiladores da linguagem C, como o Turbo C++ da Borland, que até pouco
tempo atrás ainda era o compilador mais usado nas universidades com o foco acadêmico e introdutório nas
linguagens de programação.
-4-
IV BIBLIOTECAS
A linguagem C é por natureza própria uma linguagem estruturada. A maior parte de seus recursos é
conseguida via utilização de funções. Assim sendo, a linguagem possui uma coleção de bibliotecas que
podem ser usadas a qualquer momento.
Uma biblioteca é o conjunto de rotinas prontas para serem usadas pelo programador. Abaixo, são
apresentadas algumas das bibliotecas existentes na Linguagem C e sua rápida descrição:
stdio.h
Esta biblioteca é a mais utilizada na programação em C, pois é a biblioteca padrão (std) de entrada
(i) e saída (o) de dados. É nela que estão todas as funções de entrada e saída de dados da linguagem,
como: scanf(), printf(), getchar(), puts(), gets() entre outras que serão apresentadas nos próximos capítulos.
conio.h
Esta biblioteca possui as rotinas de console de entrada e saída no Ms-DOS, e ainda as funções de
ambiente clrscr(), gotoxy(), getche() entre outras. No DEV C++ algumas destas funções estão alocadas em
uma variação da biblioteca conio, chamada conio.c
math.h
Esta biblioteca possui as rotinas do pacote matemático.
dos.h
Esta biblioteca possui as rotinas de tratamento do Ms-DOS e dos processadores da família Intel: x86.
Alguns compiladores tem dificuldade em trabalhar com recursos do DOS, impossibilitando o uso desta
biblioteca.
graphic.h
Esta biblioteca possui as rotinas do pacote gráfico
string.h
Esta biblioteca possui as rotinas de tratamento de memória e strings.
Etc...
Para poder fazer uso deste recurso é necessário o uso de uma diretiva (#include), que deve ser
colocada antes da declaração da função main(). Desta forma, sua sintaxe corresponde a:
#instrução <biblioteca>
Onde instrução é uma palavra reservada (include entre outras) e biblioteca é uma ou mais das
bibliotecas citadas acima.
Uma diretiva caracteriza-se na linguagem C, por ser uma instrução precedida do caractere tralha "#",
que deverá ser sempre escrito na primeira coluna. A instrução, após o símbolo tralha, é uma palavra
reserva do pré-processador.
O pré-processador é um programa que checa o programa-fonte escrito em linguagem C e efetua no

programa-fonte, modificações. O pré-processador recebe este nome pelo fato de ser o primeiro programa a
ser executado em um processo de compilação, fazendo com que o programa-fonte seja alterado, na forma
de texto, antes de ser propriamente compilado.
Uma biblioteca poderá ser escrita como: #include <stdio.h> ou #include “stdio.h” substituindo os
sinais de menor (<) e maior (>) por aspas (“) e vice-versa.
-5-
V TIPOS DE DADOS
Para se desenvolver um programa que seja executável dentro de um computador, é necessário ter
em mente que o trabalho de gerenciamento de dados ocorre em três níveis:
1. A entrada dos dados;

2. O processamento dos dados;
3. A saída de dados.
O objetivo principal de qualquer computador é a manipulação de dados, que são representados por
elementos em estado primário.
Ao agregar valores à esses dados, são criadas as informações, que ao serem estruturadas de
forma organizada e com algum significado, tem por objetivo gerar algum conhecimento.
Os computadores servem para armazenar informações e programas para sua manipulação.

Sendo assim, um programador consciente não pode ignorar a importância dos dados e
como eles devem ser estruturados.
Como exemplo padrão da estruturação de dados e informações pode ser citada a lista
telefônica , que por ser ordenada alfabeticamente, torna razoavelmente simples e rápido o
acesso a um determinado número de telefone de um assinante.
Os dados então são representados pelas informações a serem processadas por um computador. A
linguagem C fornece ao programador um conjunto de tipos de dados predefinidos, podendo ser dos tipos:
numéricos, caracteres e lógicos (“camuflados” por 0 e 1).
5.1. Tipos de dados inteiros
São caracterizados tipos inteiros os dados numéricos positivos ou negativos, excluindo-se destes
qualquer número fracionário. Em C, este tipo de dado pode ser referenciado por um dos seguintes
identificadores:
int de -32.768 a 32.767

long de -2.147.483.648 até 2.147.483.647
unsigned int de 0 até 65.535
5.2 Tipos de dados reais
São caracterizados tipos reais os dados numéricos positivos, negativos e números fracionários e
também os inteiros. Em C, este tipo de dado pode ser referenciado por um dos seguintes identificadores:
float de 3.4 E -38 até 3.4 E+38

double de 1.7 E -308 até 1.7 E+308
Este tipo de dado real permite trabalhar com uma representação de valores em ponto flutuante que
consiste em uma mantissa (parte fracionária).
5.3 Tipos de dados caracteres
São caracterizadas tipos caracteres as seqüências contendo letras, números e símbolos especiais.
Uma seqüência de caracteres deve ser representada na linguagem C entre aspas ( " " ). Este tipo de dado
é referenciado pelo identificador char, podendo armazenar de 0 até 255 caracteres.
5.4 Tipos de dados lógicos
Na linguagem C, não existe um tipo de dado lógico ou booleano propriamente dito, ou seja, não
existirão os valores lógicos Falso ou Verdadeiro para um determinado tipo de dado. Nesta linguagem,
qualquer valor igual a zero 0, é considerado um valor lógico falso, e qualquer valor diferente de zero (que
será representado pelo número 1 inteiro) será considerado um valor lógico verdadeiro.
-6-
VI DOCUMENTAÇÃO
Desenvolvendo Comentários
O uso de comentários é de extrema importância para o programador, pois tem a finalidade de

documentar o programa, deixando-o mais claro e fácil de ser compreendido, alterado ou corrigido.
Existem dois tipos de comentários:
comentário do prólogo e
comentários intercalares
6.1 Comentário do Prólogo
É colocado antes da lógica de programação e é constituído por quatro etapas:
1ª- Definição do programa

Ex: // Programa Soma entre 2 números
2ª- Nome do autor e datas de criação e última alteração do programa

Ex: // Fulano de Tal em: 04/04/1989; Ultima Alteração: 12/03/2008
3ª- Declarações das variáveis novas ou desconhecidas usadas no programa

Ex: // N1 e N2 = Números digitados pelo usuário; S = Soma encontrada
4ª- Funcionalidade do Programa

Ex: // O usuário digita 2 números e tem como resposta a soma entre eles.
6.2 Comentários Intercalares
Servem para comentar, de maneira breve, funções ou comandos novos ou desconhecidos para o
programador.
Obs. 1: A especificação de comentários em Linguagem C++ é identificada pelo uso de duas barras em
seqüência: //
Obs. 2: Quando em um comentário são utilizadas mais de uma linha, também é possível delimitá-lo com o
uso de /* no inicio da primeira linha e */ no final da última linha.
/* Programa Soma entre 2 números
Fulano de Tal em: 04/04/1989; Ultima Alteração: 03/03/2008
N1 e N2 = Números digitados pelo usuário; S = Soma encontrada
O usuário digita 2 números e tem como resposta a soma entre eles. */
-7-
VII A FUNÇÃO PRINCIPAL
Todo e qualquer programa em C é constituído de no mínimo uma função, tendo assim a
possibilidade de se construir programas modulares ou estruturados.
main( ) Primeira, e principal função do C.
A função main( ) é a principal instrução a ser considerada em um programa escrito na linguagem C,

ou seja, esta função deverá estar presente em algum lugar do programa, pois é ela que marca o ponto de
inicialização do processo de execução do programa. É apresentado a seguir, o modelo da forma geral de
escrita de um programa em C, com a definição e comentário de cada um dos elementos básicos do
programa.
[<definições de pré-processamento>]
[<declaração das variáveis globais>]
main()
{
/*
Este trecho é reservado para o corpo da função, com a declaração de suas variáveis locais, seus
comandos e funções de trabalho.
*/
}
Toda informação situada entre [ ] indica informações que poderão ou não estar presentes em um
programa. Já qualquer informação entre < > caracteriza-se por ser obrigatória. Os símbolos ( ) indicam
início e fim da rotina.
Todas as informações escritas entre os delimitadores /* e */ são comentários para documentação

do programa e não são compiladas quando da execução do programa pelo compilador.
Normalmente, um programa em C é iniciado com as definições de pré-processamento e com a

declaração das variáveis globais, lembrando que estas variáveis poderão ser usadas em qualquer parte do
programa, seguidas da declaração de todas as funções a serem utilizadas no programa.
As funções em C são formadas inicialmente pela declaração de seu tipo, informação esta opcional,
e de seu nome seguida da lista de parâmetros entre parênteses a ser utilizada pela mesma. A lista de
parâmetro poderá estar vazia, sendo que a finalidade de um parâmetro é servir como um ponto de
comunicação bidirecional entre as várias funções de um programa.
VII
VIII DELIMITADORES DE BLOCO
Delimitam toda a lógica de programação escrita pelo programador.

São representados (em C++) por { e } conforme observado na sintaxe abaixo:
/* ...Comentário do Prólogo... */
Bibliotecas;
main()
{
---------
---------
---------
}
-8-
IX VARIÁVEIS
Variável, no sentido de programação, é uma região previamente identificada e que tem por
finalidade armazenar as informações (dados) de um programa temporariamente. Uma variável armazena
apenas um valor por vez. Sendo considerado como valor o conteúdo de uma variável, desta forma, um
valor está relacionado ao tipo de dado de uma variável, podendo ser numérico, lógico ou caractere.
O nome de uma variável é utilizado para sua identificação e posterior uso dentro de um programa,
sendo assim é necessário se estabelecer algumas regras de utilização das mesmas:
Nomes de uma variável poderão ser atribuídos com um ou mais caracteres;

O primeiro caractere do nome de uma variável não poderá ser em hipótese alguma um número, sempre
deverá ser uma letra;
O nome de uma variável não poderá possuir espaços em branco;
Não poderá ser nome de uma variável uma palavra reservada a uma instrução ou identificador de uma
linguagem de programação;
Não poderão ser utilizados outros caracteres a não ser letras e números, com exceção do caractere
underscore "_", que poderá ser utilizado para simular a separação entre duas palavras, como:
MEDIA_ESCOLAR.
Na linguagem C, os 32 primeiros caracteres de um nome de variável são significativos, porém, se o

sistema operacional em uso é o MS-DOS, somente serão considerados os primeiros 8 caracteres. Este
fator limita um pouco o uso das variáveis.
Outro detalhe a ser considerado na linguagem C é o fato de haver diferença entre caracteres
maiúsculos e minúsculos. Sendo assim as variáveis: NOME, nome e Nome, são diferentes.
Todo dado a ser armazenado na memória de um computador através de uma variável utilizando-se a
linguagem C deve ser previamente declarado, ou seja, primeiro é necessário saber qual o seu tipo para
depois fazer o seu armazenamento. Estando armazenado o dado, este poderá ser utilizado e manipulado a
qualquer momento, durante a execução do programa.
Pelo fato de a linguagem C obrigar o programador a trabalhar de forma estruturada e ser baseada no
uso de funções, as variáveis podem assumir dois estados de comportamento (global e local).
Uma variável é considerada Global quando é declarada no inicio de um programa escrito em C,

precisamente antes da função main ( ), que será estuda a seguir, podendo este tipo de variável ser
utilizado por qualquer parte do programa.
Uma variável é considerada Local quando é declarada apenas dentro de uma função e é somente
válida dentro do limite de abrangência da referida função. Desta forma, as demais rotinas não poderão
fazer uso daquelas variáveis como Global, pois não visualizam a existência das mesmas.
Todo programa tem a obrigatoriedade de declarar (antes da lógica) todas as variáveis que serão
utilizadas, pois estas só poderão receber valores após tal declaração, que ocorre de acordo com a seguinte
sintaxe:
tipo_de_dado NOME_DA_VARIAVEL ;
Ex: int IDADE;

float N1 , N2 , S ;
-9-
9.1 Constantes
Tem-se como definição de constante tudo aquilo que é fixo ou estável, e existirão vários momentos
em que este conceito deverá estar em uso. Ao operar com variáveis correspondentes a valores constantes
ou fórmulas, deve-se utilizar o símbolo “=“ que significa uma atribuição. Por exemplo, o valor 4.12 da
fórmula a seguir é uma constante e está sendo atribuído à variável INSS:
INSS = SAL * 4.12.
9.2 Operadores Aritméticos
Tanto variáveis como constantes poderão ser utilizadas na elaboração de cálculos matemáticos
com a utilização de operadores aritméticos. Os operadores aritméticos são classificados em duas
categorias, sendo binários ou unários. São binários quando atuam em operações de: exponenciação,
multiplicação, divisão, adição e subtração. São unários quando atuam na inversão de um valor atribuindo a
este o sinal positivo ou negativo.
X FUNÇÕES DE SAÍDA
São responsáveis pela saída de dados, ou seja: apresentação destes valores em qualquer
programa, sendo obrigatório o uso dos parênteses para delimitar os dados apresentados.
A primeira função de saída apresentada é a printf( ) que possibilita efetuar a saída de informações
no vídeo, de acordo com a sintaxe:
printf ("expressão de controle", lista de argumentos);
A expressão de controle se caracteriza por conter códigos de formatação para o tipo de dado a ser
processado, precedidos pelo sinal de percentagem %.
Veja a seguir, a tabela com os códigos de formatação para a função printf( ).
%c Permite que seja efetuada a escrita de apenas um caractere
%d Permite que seja efetuada a escrita de números inteiros decimais
%e Permite que seja efetuada a escrita de números em notação científica
%f Permite que seja efetuada a escrita de números reais (ponto flutuante)
%g Permite que seja efetuada a escrita de %e ou %f no formato mais curto
%o Permite que seja efetuada a escrita de números octais
%s Permite que seja efetuada a escrita de uma série de caracteres
%u Permite que seja efetuada a escrita de um número decimal sem sinal
%x Permite que seja efetuada a escrita de um número hexadecimal
- 10 -
A função printf ( ) pode usar além da expressão de controle e da lista de argumentos um conjunto de
códigos especiais através do símbolo “\” com finalidade de efeito visual conforme apresentado abaixo:
printf (“Clube do Remo \n Campeão Brasileiro Série C 2005”);
O resultado desta operação na tela do computador seria:
Clube do Remo
Campeão Brasileiro Série C 2005
A utilização destes códigos especiais tem a finalidade de auxiliar o programador na utilização de

recursos não disponíveis no teclado. Estes códigos são apresentados a seguir:
\n Cria uma linha nova a partir do ponto que é indicado
\t Cria um espaço de tabulação do ponto que é indicado
\b Executa um retrocesso de espaço do ponto que é indicado
\” Apresenta o símbolo de aspas no ponto que é indicado
\\ Apresenta o símbolo de barra no ponto que é indicado
\f Adiciona um salto de página de formulário (impressora)
\0 Gera um nulo
XI FUNÇÕES DE ENTRADA
São responsáveis pela inserção de dados em um programa, ou seja, tudo que tiver de ser digitado
pelo usuário deverá usar uma função de entrada.
Também é obrigatório o uso dos parênteses para delimitar os dados digitados e obedece a seguinte
sintaxe:
A primeira função de saída apresentada é a função scanf( ) , que possibilita efetuar entrada de
dados via teclado.
A sintaxe desta função se caracteriza por ser uma expressão de controle seguida de uma lista de
argumentos separados por virgula, sendo que seus argumentos são endereços de variáveis.
scanf ("expressão de controle", lista de argumentos);
A expressão de controle se caracteriza por conter códigos de formatação para o tipo de dado a ser
processado, precedidos pelo sinal de percentagem %.
Veja a seguir, a tabela com os códigos de formatação para a função scanf( ).
%c Permite que seja efetuada a leitura de apenas um caractere

%d Permite que seja efetuada a leitura de números inteiros decimais
%e Permite que seja efetuada a leitura de números em notação científica
%f Permite que seja efetuada a leitura de números reais (ponto flutuante)
%l Permite que seja efetuada a leitura de um número inteiro longo
%o Permite que seja efetuada a leitura de números octais
%s Permite que seja efetuada a leitura de uma série de caracteres
%u Permite que seja efetuada a leitura de um número decimal sem sinal
%x Permite que seja efetuada a leitura de um número hexadecimal
- 11 -
A lista de argumentos se caracteriza por ser a indicação dos endereços das variáveis em uso,
através do operador de endereço &, que possibilita retomar o conteúdo da variável. Caso não seja usado o
operador de endereço &, será retornado o endereço de memória em que se encontra a variável.
O Primeiro Programa em C
Para colocar em prática o que foi explicado até este momento, considere o seguinte exemplo:
/* Programa Nome
Autor: Fulano de Tal Dt_Cri: 22/08/1986 Dt_Ult_Alt: 12/03/2008
Sem Variáveis
O usuário simplesmente é apresentado ao autor do programa */
#include <stdio.h>
#include <conio.h>
main ( ) // Primeira função do programa em C

{ // Corresponde ao "Inicio" do Algoritmo
printf ( "Programa desenvolvido por \n Fulano de Tal" );
// Corresponde ao "escreva" do algoritmo
getch ( ); // Espera ser pressionada qualquer tecla p/ continuar
} // Corresponde ao "fim" do algoritmo
Edite o programa acima, compile-o e verifique a funcionalidade de seu arquivo executável.
Considere agora o seguinte exemplo de algoritmo: "Deverá ser desenvolvido um programa que
efetue a leitura de dois valores numéricos. Faça a operação de adição entre os dois valores e apresente o
resultado obtido".
Com relação ao problema da leitura dos dois valores (que não conhecemos e também não
precisamos conhecer, pois utilizaremos duas variáveis para trabalhar estas incógnitas N1 e N2) e a sua
respectiva adição (conseqüência dos valores informados, a qual também é uma incógnita e dependendo
dos valores fornecidos, utilizaremos para esta a variável S).
Assim sendo, o programa em questão deverá obedecer a seguinte ordenação:
Algoritmo Literal:
1. Ler um valor para a variável N1;
2. Ler outro valor para a variável N2;
3. Efetuar a adição das variáveis N1 e N2, implicando o seu resultado na variável S;
4. Apresentar o valor da variável S após a operação de soma dos dois valores fornecidos.
Observe que temos neste exemplo, as três fases de trabalho de um programa: a fase de entrada
retratada nos passos 1 e 2, o processamento retratado no passo 3 e por fim a saída retratada no passo 4.
Completada a fase de interpretação do problema e da definição das variáveis a serem utilizadas,

através de um algoritmo, passa-se para a fase de diagramação.
Tendo estabelecido os passos anteriores, será efetuada a codificação do programa. Desta forma,
são utilizadas no exemplo, três variáveis: N1, N2 e S (que neste caso estão no estado de variáveis locais),
sendo que estas deverão ser declaradas segundo o seu tipo, no caso como inteiras.

- 12 -
main( )
{
int N1;
int N2;
int S;
Tendo relacionado as variáveis que serão utilizadas no programa, bem como os seus respectivos
tipos, passa-se para a fase de montagem do programa propriamente dito.
As variáveis poderiam ser também relacionadas em uma única linha:

int N1, N2, S;
Observe que o bloco de instruções entre “{“ e “}” está deslocado um pouco para a direita. Este estilo
de escrita deve ser obedecido, para facilitar a leitura de um bloco de programa, recebendo o nome de
identação.
Apesar de a informação escrita entre os delimitadores /* e */ não ser processada, é adequado

sempre identificar um programa com um nome que deve vir no comentário de prólogo.
scanf ("%d", &N1);

scanf ("%d", &N2);
S = N1 + N2;
printf ("%d", S);
}
Após a leitura dos valores para as variáveis N1 e N2 com a função scanf ( ), estes serão adicionados e
implicados na variável S, a qual será apresentada com o valor da adição processada através da função
printf ( ).
Note que as instruções utilizadas dentro da função main( ) são precedidas de ponto e virgula, indicando
desta forma o fim da instrução naquela linha.
A seguir, é apresentado o programa SOMA completo:

#include <stdio.h>
#include <conio.h>
main ( ) // Primeira função do programa em C
{ // Corresponde ao "Inicio" do Algoritmo

int N1,N2,S; // Declaração das variáveis como inteiras
printf ("\n Programa Soma \n\n ");
printf ("Informe 1º numero: "); // Corresponde ao "escreva" do Algoritmo

scanf ("%d", &N1); // Corresponde ao "leia" do Algoritmo
printf ("Informe 2º numero: ");

scanf ("%d", &N2);
S = N1 + N2;
printf ("\n A Soma é igual a %d", S);
getch ( ); // Espera ser press. qq tecla p/ prosseguir

}
- 13 -
Edite o programa SOMA, compile-o e verifique a funcionalidade de seu arquivo executável.
Como terceiro exemplo, desenvolva um programa que efetue o cálculo do salário liquido de um
profissional que trabalhe por hora.
Para fazer este programa você deverá possuir alguns dados, tais como: valor da hora de trabalho,
número de horas trabalhadas no mês e o percentual de desconto do INSS.
O programa em questão deverá apresentar o valor do salário bruto, o valor descontado e o valor do
salário liquido.
Algoritmo Literal
1. Estabelecer a leitura da variável HT (horas trabalhadas no mês);
2. Estabelecer a leitura da variável VH (valor hora trabalhada);
3. Estabelecer a leitura da variável PD (percentual de desconto);
4. Calcular o salário bruto (SB), sendo este a multiplicação das variáveis HT e VH;
5. Calcular o total de desconto (TD) com base no valor de PD dividido por 100;
6. Calcular o salário liquido (SL), subtraindo o desconto do salário bruto;
7. Apresentar os valores dos salários bruto e liquido: SB, TD e SL.
A seguir, é apresentado o programa completo:
/* Programa Calculo de Salário

HT horas trabalhadas no mês, VH valor da hora trabalhada , PD percentual de desconto ,
SB Salário Bruto, D Desconto e SL Salário liquido
O usuário digita HT, VH e PD e tem SB, TD e SL. */
include <stdio.h>
include <conio.h>
main( )
{
float HT, VH, PD, D, SB, SL;
printf ("Informe numero de horas trabalhadas no mês: ");

scanf ("%f", &HT);
printf ("Informe valor da hora trabalhada: ");

scanf ("%f", &VH);
printf ("Informe percentual de desconto: ");

scanf ("%f", &PD);
SB = HT * VH;
D = (PD/100) * SB;
SL = SB - D;
printf ("Salário Bruto............: %7.2f \ n ”, SB);

printf ("Desconto..................: %7.2f \ n ”, D);
printf ("Salário liquido..........: %7.2f \ n ”, SL);
getch( );
}
Note que no exemplo de cálculo de salários estão sendo colocados junto ao código da expressão de
controle dois valores separados por ponto: %7.2f. O valor numérico 7 indica que será estabelecido um
campo para a parte do valor inteiro com a capacidade de apresentar tabulados valores até 9999, pois o
valor 2 depois do ponto indica que serão utilizadas apenas duas casas decimais para valores com ponto
flutuante, utilizando três espaços dos sete espaços separados.
- 14 -
ExercícioS
ExercícioS
1) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para encontrar a média
escolar de uma disciplina que trabalha com a seguinte fórmula: duas provas valendo 10 pontos sendo que
a primeira tem peso 4 e a segunda tem peso 6. O usuário deverá digitar somente as 2 notas e deverá ser
apresentada à ele a média encontrada.
2) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para encontrar o delta de
2
uma equação do 2º grau. A fórmula geral de equações do 2º grau é a seguinte: Ax + Bx + C = 0 e a do
2
Delta é: B - 4AC . O usuário deverá digitar os coeficientes A, B e C respectivamente e lhe será
apresentado o valor do delta.
3) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para que um usuário,
informando a distância entre dois pontos e o tempo gasto no percurso, tenha como resposta a velocidade
obtida no trajeto. Lembre-se que V = S/T. Adotar as unidades: km para a distância e hora para o tempo.
4) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para efetuar o cálculo da
quantidade de litros de combustível gastas em uma viagem, utilizando-se um automóvel que faz 12 Km por
litro. Para obter o cálculo, o usuário deverá fornecer o tempo gasto na viagem e a velocidade média durante
a mesma. Desta forma, será possível obter a distância percorrida com a fórmula DISTANCIA = TEMPO *
VELOCIDADE. Tendo o valor da distância, basta calcular a quantidade de litros de combustível utilizada na
viagem com a fórmula: LITROS_USADOS = DISTANCIA / 12. O programa deverá apresentar os valores da
velocidade média, tempo gasto, a distância percorrida e a quantidade de litros utilizada na viagem.
5) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para ler uma temperatura
em graus Centígrados e apresentá-la convertida em graus Fahrenheit. A fórmula de conversão é: F = (9 * C
+ 160) / 5, onde F é a temperatura em Fahrenheit e C é a temperatura em Centígrados.
6) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para ler uma temperatura
em graus Fahrenheit e apresentá-la convertida em graus Centígrados. A fórmula de conversão é: C = (F -
32) * 5/9, onde F é a temperatura em Fahrenheit e C é a temperatura em Centígrados.
7) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para calcular e apresentar o
2
valor do volume de uma lata de óleo, utilizando a fórmula: VOLUME = 3.14159 * R * ALTURA.
- 15 -
XII ESTRUTURAS DE DECISÕES
12.1 - Seqüência Simples
É considerada linguagem em Seqüência Simples, todo programa que contém comandos escritos e
executados de forma linear, ou seja: de cima para baixo, sem desvios, de acordo com a seguinte sintaxe:
bibliotecas;
main()
{
Ação 1;
Ação 2;
Ação N;
}
Ex.:
/* Programa Soma entre 2 números reais

#include <stdio.h>
#include <conio.h>
main ( )
{
float N1,N2,S;
printf ("Informe 1º numero: "); scanf ("%f", &N1);
printf ("Informe 2º numero: "); scanf ("%f", &N2);
S = N1 + N2;
printf ("\n A Soma é igual a %f", S);
getch ( );
}
12.2 - Seqüências Alternativas
12.2.1 - Seqüências Alternativas Simples: if
São estruturas compostas por desvios em sua formação, ou seja: não são executadas
necessariamente de maneira linear, pois existem blocos de instruções que podem ser saltados (ignorados)
dentro do corpo do programa.
Neste tipo de estrutura uma condição é analisada e caso o valor lógico desta condição seja
verdadeiro, um determinado bloco de ações (B) é executado. Caso o valor lógico da condição seja falso,
este bloco de ações (B) é ignorado, podendo ocorrer então um desvio na seqüência de comandos.
A sintaxe das estruturas com alternativa simples é a seguinte:
bibliotecas;
main()
{
Ações A;
if (CONDIÇÃO)
{
Ações B;
}
Ações C;
}
- 16 -
Obs.1: Utiliza-se { e } para delimitar blocos internos de um desvio com mais de um comando em
sua formação.
Obs.2: O uso dos parênteses ( ) é obrigatório para delimitar as condições.
Obs.2: Ao utilizar estruturas alternativas, é aconselhável o uso da identação. Entende-se por

identação, como sendo a organização estética dos blocos de comandos ou ações existentes no programa.
Para exemplificar a estrutura, considere o seguinte problema: "Ler dois valores numéricos, e mostra-
los em ordem crescente”. Ou seja, poderá haver uma troca entre variáveis.
Algoritmo
1. Conhecer dois valores inteiros e incógnitos ( estabelecer variáveis A e B );

2. Verificar se o valor de A é maior que de B;
a. Se for verdadeiro, efetuar a troca (*) de valores entre as variáveis;
b. Se for falso, pedir para executar o que esta estabelecido no passo 3;
3. Apresentar os valores das duas variáveis
(*) Para efetuar a troca, foi necessário usar uma terceira variável, no caso, X (por exemplo), de forma
que X seja igual ao valor de A, liberando A para receber o valor de B deixando B livre para receber o valor
que está em X, que anteriormente constava o conteúdo de A.
Programa
/* Programa Ordenação entre 2 números inteiros

A e B = Números digitados pelo usuário; X = Variável auxiliar
O usuário digita 2 números e tem como resposta ambos ordenados. */
#include <stdio.h>
#include <conio.h>
main( )
{
int A, B, X;
printf ("Informe um valor para a variável A:”); scanf (“%d”, &A);
printf ("Informe um valor para a variável B:”); scanf (“%d”, &B);
if (A > B)
{
X = A;
A = B;
B = X;
}
printf("\n Os valores ordenados são: %d e %d", A, B);
getch( );
}
Note a utilização das chaves { e } após a utilização da instrução if. Isto se fez necessário, pois a
troca de valores é conseguida com a execução de três operações, sendo que estas três operações devem
acontecer quando a condição for Verdadeira. Sendo a condição Falsa, serão apresentados os valores como
entrados, uma vez que já estão em ordem.
Observe a linha:
printf ("\n Os valores ordenados são: %d e %d", A, B);
note que a colocação do código %d dentro da mensagem indica o local de posicionamento do valor
da variável.
- 17 -
Operadores Relacionais
No exemplo anterior, foi utilizado o sinal de > (maior que) para verificar o estado da variável quanto
ao seu valor, ou seja, a sua condição. Sendo assim, uma condição também poderá ser verificada como:
diferente, igual, menor que, maior ou igual a que e menor ou igual a que. Estas verificações são efetuadas
com a utilização dos chamados operadores relacionais, conforme tabela abaixo:
== Igual
!= Diferente
> Maior
< Menor
>= Maior ou Igual
<= Menor ou Igual
Obs.
Ao fazer uso do operador relacional "= =" que representa o valor de igualdade de uma comparação
entre dois elementos, deve-se tomar o cuidado para não confundi-lo com o sinal "=", que na linguagem C é
utilizado como símbolo de atribuição. Este erro é comum para quem utiliza outras linguagens de
programação como Pascal, Visual Basic, Delphi, Quick Basic, pois a segunda forma é usada tanto para
atribuição como para comparação.
12.2.2 - Seqüências Alternativas Compostas: if ... else
São estruturas compostas por desvios múltiplos em sua formação, onde um bloco de ações B é
executado em caso de condição verdadeira e um bloco de ações C é executado em caso de condição falsa.
A estrutura de formação para as seqüências alternativas compostas utiliza a seguinte sintaxe:
bibliotecas;
main()
{
Ações A;
if (CONDIÇÃO)
{
Ações B;
}
else
{
Ações C;
}
Ações D;
}
Para um exemplo da utilização desta estrutura considere o seguinte problema:
"Ler dois valores numéricos, efetuar a adição. Caso o valor somado seja maior ou igual a 10, este
deverá ser apresentado somando-se a ele mais 5. Caso o valor somado não seja maior ou igual a 10, este
deverá ser apresentado subtraindo-se 7".
Algoritmo Literal
1. Conhecer dois valores ( variáveis A e B );

2. Efetuar a soma dos valores A e B e implicar o valor da soma em X;
3. Verificar se X é maior ou igual 10, caso sim mostre X+5, senão mostre X-7.
- 18 -
Programa
/* Adiciona Números */
#include <stdio.h>
#include <conio.h>
main( )
{
int A, B, X;
printf ("Informe um valor para a variável A: "); scanf ("%d", &A);
printf ("Informe um valor para a variável B: "); scanf ("%d", &B);
X = A + B;
printf ("\n O resultado eqüivale a: ");
if (X >= 10)
printf ("%d", X+5);
else
printf ("%d", X-7);
getch( );
}
Observe que após a definição dos tipos de variáveis, é solicitada a leitura dos valores para as
variáveis A e B, depois estes valores são implicados na variável X, que possui o resultado da adição dos
dois valores. É apresentada então a mensagem O resultado eqüivale a:, que não posicionará o cursor na
próxima linha, desta forma qualquer que seja o resultado avaliado pela condição, será apresentado ao lado
direito da mensagem. Em seguida a esta linha é verificado no programa, a condição que permitirá escrever
o resultado da soma adicionado de 5, caso esta seja maior ou igual a 10. Não sendo, o programa
apresentará o resultado subtraindo 7.
Operadores ou Conectivos Lógicos
Existem ocasiões onde é necessário trabalhar com o relacionamento de duas ou mais condições ao
mesmo tempo na mesma instrução if, efetuando desta forma testes múltiplos. Para estes casos é
necessário trabalhar com a utilização dos operadores lógicos, também conhecidos como operadores
booleanos.
Já foi comentado anteriormente que a linguagem C não faz uso de valores lógicos, tais como:
Verdadeiro ou Falso, pelo fato de estes dois valores não existirem. Em uma expressão condicional ou no
uso de operadores lógicos, será considerado como valor Verdadeiro o resultado da expressão que for não-
zero (que será considerado para efeito de avaliação lógica o valor numérico um: 1). Sendo o resultado da
expressão zero, esta será considerada como valor Falso.
Os 3 operadores lógicos utilizados comumente na Linguagem C são: E, OU e NÃO. Em alguns

casos, o uso de operadores lógicos evita a utilização de muitas instruções if encadeadas.
Operador Lógico E: &&
O operador do tipo && é utilizado quando dois ou mais relacionamentos lógicos de uma
determinada condição necessitam ser verdadeiros. Abaixo é apresentada a tabela verdade para este tipo
de operador:
Condição 1 Condição 2 Resultado .
0 (Falsa) 0 (Falsa) 0 (Falso)
1 (Verdadeira) 0 (Falsa) 0 (Falso)
0 (Falsa) 1 (Verdadeira) 0 (Falso)
1 (Verdadeira) 1 (Verdadeira) 1 (Verdadeiro)
O operador && faz com que somente seja executada uma determinada operação se todas as
condições mencionadas forem simultaneamente verdadeiras, gerando assim um resultado lógico
verdadeiro.
- 19 -
Operador Lógico OU: ||
O operador do tipo || é utilizado quando pelo menos um dos relacionamentos lógicos (quando
houver mais de um relacionamento) de uma condição necessita ser verdadeiro. Abaixo é apresentada a
tabela verdade para este tipo de operador:
Condição 1 Condição 2 Resultado .

0 (Falsa) 0 (Falsa) 0 (Falso)
1 (Verdadeira) 0 (Falsa) 1 (Verdadeiro)
0 (Falsa) 1 (Verdadeira) 1 (Verdadeiro)
1 (Verdadeira) 1 (Verdadeira) 1 (Verdadeiro)
O operador | | faz com que seja executada uma determinada operação, se pelo menos uma das
condições mencionadas gerar um resultado lógico verdadeiro.
Operador Lógico NÃO: !
O operador do tipo ! é utilizado quando se necessita estabelecer que uma determinada condição
deve não ser verdadeira ou deve não ser falsa. O operador ! se caracteriza por inverter o estado lógico de
uma condição. Abaixo é apresentada a tabela verdade para este tipo de operador:
Condição Resultado .
1 (Verdadeira) 0 (Falso)
0 (Falso) 1 (Verdadeira)
O operador ! faz com que seja executada uma determinada operação, invertendo o resultado lógico
da condição.
12.2.3 - Seqüências Alternativas com Múltiplas Condições
Esta estrutura é composta por múltiplas condições, onde cada uma pode conter um valor lógico
diferente. Tais condições são analisadas individualmente e a elas são atribuídos valores lógicos individuais,
que passam a ser operados com as tabelas verdade, encontrando assim um único valor lógico
correspondente ao conjunto de condições citadas na operação.
A estrutura de seqüências alternativas com múltiplas condições deve respeitar a seguinte sintaxe:
bibliotecas;
main()
{
Ações A;
if (CONDIÇÃO1 conectivológico CONDIÇÃO2 conectivológico CONDIÇÃON)
{
Ações B;
}
else
{
Ações C;
}
Ações D;
}
Para demonstrar a utilização de operadores lógicos, considere o seguinte problema (clássico):
"Ler três valores para os lados de um triângulo, considerando lados como: A, B e C.

Verificar se os lados fornecidos formam realmente um triângulo.
Se for esta condição verdadeira, deverá ser indicado qual tipo de triângulo foi formado: isósceles,
escaleno ou equilátero".
- 20 -
Algoritmo Literal
Forma-se um triângulo quando A<B+C, quando B<A+C e quando C<A+B. Tendo certeza de que os
valores informados para os três lados formam um triângulo, serão então analisados os valores para se
estabelecer qual tipo de triângulo será formado: isósceles, escaleno ou equilátero.
Um triângulo é equilátero quando possui todos os lados iguais, sendo A==B e B==C;
é isósceles quando possui dois lados iguais, sendo A==B ou A==C ou B==C;
é escaleno quando possui todos os lados diferentes, sendo A!=B e B!=C e A!=C
1. Ler três valores para os lados de um triângulo: A, B e Q

2. Verificar se cada lado é menor que a soma dos outros dois lados
a. Se sim, saber se A= =B e se B= =C, sendo verdade o triângulo é equilátero
b. Se não, verificar A= =B ou se A= =C ou se B= =C, sendo verdade o triângulo é
isósceles, caso contrário o triângulo será escaleno;
3. Caso os lados fornecidos não caracterizem um triângulo, avisar a ocorrência.
Programa
/* Programa Tipo de Triângulo */

#include<stdio.h>
#include<conio.h>
main( )
{
float A, B, C;
printf("\t Programa Tipo de Triangulo \n\n");
printf("\n Informe o lado A: "); scanf("%f", &A);
printf("\n Informe o lado B: "); scanf("%f", &B);
printf("\n Informe o lado C: "); scanf("%f", &C);
printf("\n");
if (A<B+C && B<A+C && C<A+B)
{
if (A==B && B== C)
printf("Triangulo Equilatero \n");
else
{
if (A==B || A==C || C==B)
printf("Triangulo Isosceles \n");
else
printf("Triangulo Escaleno \n");
}
}
else
printf("Os valores fornecidos nao formam um triangulo \n”);
getch( );
}
O exemplo demonstra através da utilização dos operadores lógicos, a capacidade de um programa

definir se determinados valores fornecidos formam realmente um triângulo, e se a condição for verdadeira,
este programa indica o tipo de triângulo formado.
Se forem fornecidos respectivamente os valores 8, 2 e 3 para os lados A, B e C, será apresentada a

mensagem: "Os valores fornecidos não formam um triângulo", pois a primeira condição da instrução if
(A<B+C && B<A+C && C<A+B) resulta o valor lógico falso, uma vez que 8 é maior que a soma de 2 com 3.
Caso sejam fornecidos os valores 8, 8 e 2, a primeira instrução if será verdadeira, indicando que os
lados fornecidos formam um triângulo. Apesar de o lado A ser igual ao lado B, mas este não ser igual ao
lado C, o triângulo formado não é do tipo equilátero, desta forma a segunda instrução if tem seu resultado
lógico como falso, sobrando a verificação da condição para a terceira instrução if que indica o triângulo
como sendo do tipo isósceles, pois o lado A é igual ao lado B.
- 21 -
Extra: COMANDOS ESPECIAIS DE REFINAMENTO
A seguir são apresentados alguns comandos de controle

controle de ambiente de tela que a linguagem C
oferece ao seu programador.
Para usá-los deve-se

se acrescentar a biblioteca conio.h no início do programa.
No Dev C++, além da biblioteca conio.h ainda podem ser necessárias as bibliotecas conio.c e/ou
conio2.h,, caso estas estejam instaladas no pacote do compilador.
textcolor ();
Usado para adotar cores em textos fazê-los piscar.

Ex.: textcolor (RED);
// A cor do texto fica vermelha.
textbackground();
Usado para adotar cor de fundo nas fontes do C.

Ex.: textbackground (BLUE);
// A cor do fundo do texto fica azul.
getche();
Tem a finalidade de interromper momentaneamente

a execução de um programa em C.
clrscr();
Tem a função de limpar a tela, posicionando o cursor no canto superior

superior esquerdo da tela.
gotoxy(col,lin);
Tem a finalidade de direcionar uma instrução para uma determinada coluna e linha da tela.
Ex.: gotoxy (30,10); // Posiciona a próxima instrução na coluna 30 e na linha 10 da tela.
Obs. Para utilizar alguns destes comandos,

comandos principalmente no Turbo C++, deve-se
se acrescentar a letra c no
início da função que se deseja usar. Por exemplo:
textcolor (RED);
cprintf (“Esta mensagem aparecerá com a cor vermelha na tela”);
O compilador C também utiliza um vasto conjunto

conjunto de funções aritméticas que facilitam o acesso aos
cálculos matemáticos mais complexos. Para utilizar essas funções, deve-se
deve se declarar um outro arquivo
cabeçalho com a biblioteca math.h.
A seguir são apresentadas algumas destas funções:
cos (x) retorna o co-seno

co da variável x.
sin (x) retorna o seno da variável x.
exp (x) retorna o valor de e elevado a x.
log (x) calcula o logaritmo natural de x.
sqrt(x) calcula a raiz quadrada do valor x.
Etc...
- 22 -
12.2.4 - Estrutura Caso - case
Este tipo de estrutura, tem a finalidade de simplificar o uso de condições excessivas de acordo com
a utilização da instrução switch, que possui a sintaxe:
switch (VC)
{
case <opção1> : <Instrução1>; break;
case <opção2> : < Instrução2>; break;
case <opçãoN> : < InstruçãoN>; break;
default : <Instrução default>;
}
onde:
<VC> - representa a Variável de Controle da estrutura; ou seja: é a opção que digitada pelo
usuário busca comparativos com as opções estabelecidas pelo programador (opção1, opção2...).
<opção> - é o conteúdo da variável a ser verificado;
<instrução> - representa a execução de uma instrução ou rotina do programa.
A instrução default (equivalente ao casocontrario do algoritmo) é opcional na estrutura.
A instrução break tem a finalidade de desviar o processamento para fora do comando switch. Isto
é necessário, uma vez que após o processamento da função, ele retorna para a primeira instrução após
sua chamada, que neste caso é a instrução break.
Obs.: Quando são utilizados mais de um comando dentro do Bloco de Instruções, deve-se incluir os
delimitadores de bloco { e }.
Como exemplo, é apresentado abaixo um programa que simula a execução de um menu. Digite-o e teste-o.
#include<stdio.h>
#include<conio.h>
#include<conio.c>
main()
{
char op;
textbackground(WHITE); clrscr();
textcolor(WHITE);textbackground(BLUE);
gotoxy(27,2); printf(" ----------------------------------------- ");
gotoxy(27,3); printf(" Sistema MENU SIMULADO ");
gotoxy(27,4); printf(" ----------------------------------------- ");
gotoxy(27,5); printf(" 1 - Inserir ");
gotoxy(27,6); printf(" 2 - REMOver ");
gotoxy(27,7); printf(" 3 - Consultar ");
gotoxy(27,8); printf(" 4 - Sair ");
gotoxy(27,9); printf(" Opcao: ");
gotoxy(27,10); printf(" ----------------------------------------- ");
gotoxy(49,9); op = getche();
gotoxy(31,17); textcolor(YELLOW);
switch (op)
{
case '1' : printf(" Simulando Inclusao! "); break;
case '2' : {
printf(" Simulando REMOcao! "); break;
}
case '3' : printf(" Simulando Consulta! "); break;
case '4' : printf(" Obrigado por usar o Sistema << MENU SIMULADO >> "); break;
default : printf(" Opcao Invalida! Pressione qualquer tecla para continuar! ");
}
getch();
}
- 23 -
Exercícios
Exercícios
1) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para que um usuário,
informando a distância entre dois pontos e o tempo gasto no percurso, tenha como resposta a velocidade
obtida no trajeto. Lembre-se que V = S/T. Adotar as unidades: km para a distância e hora para o tempo. O
diferencial deste exercício, é que deverá ser retornando um aviso de multa caso a velocidade tenha
ultrapassado o limite de 110km/h e uma mensagem de boa conduta em caso contrário.
2) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para ler um número
inteiro positivo e saber se este número é par ou ímpar. O resultado deve ser apresentado ao usuário do
programa.
3) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para Efetuar a leitura de
três valores (variáveis A, B e C) e efetuar o cálculo da equação de segundo grau, apresentando as duas
raízes, se para os valores informados for possível efetuar o referido cálculo.
4) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para ler duas notas
escolares de um aluno e imprimir uma mensagem dizendo que o aluno foi aprovado se o valor da média
escolar (média simples) for maior ou igual a 7. Se o valor da média for menor que 7, solicitar que seja
informada uma nota de exame. Some então esta nota de exame com o valor da média anterior e encontre a
nova média. Se esta nova média for maior ou igual a 5, apresentar uma mensagem dizendo que o aluno foi
aprovado, caso contrário: reprovado. Apresentar junto com as mensagens o valor da média do aluno para
qualquer condição.
5) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para efetuar o controle de
entrada de um cinema a partir da informação do valor do ingresso e ainda a idade do cliente. Se a idade
for >= 65 ou a idade for < 12 o cliente paga apenas meia entrada, caso contrário paga inteira.
6) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para que a partir da leitura
de 3 valores, A, B e C, saber se estes valores formam ou não um triângulo. O resultado da pesquisa deve
ser informado ao usuário do programa e caso os valores formem um triângulo, deverá ser mostrado ao
usuário o tipo do triângulo formado.
7) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para que a partir da
informação da base e altura de um triângulo, seja encontrada e apresentada a área do mesmo,
( A = ( B * H ) / 2 ). Refine o seu algoritmo, dando respostas específicas caso a base ou a altura sejam
informadas como negativas ou zero.
- 24 -
XII
XIII Laços DE Repetições
(ITERAÇÕES – Loopings )
Existem sistemas que tem necessidade de repetir um determinado trecho do programa algumas
vezes. Isto pode ser conseguido de duas formas: a primeira, de forma “braçal”, com muito Crtl+C Ctrl+V, é
escrito o mesmo trecho tantas vezes quanto necessário, um tanto trabalhoso e “sem classe” e a segunda
forma, muito mais inteligente, utilizando o conceito de looping, que são conhecidos também por: laços,
iterações ou repetições.
Supondo um programa que deveria executar um determinado trecho de instruções por quatro
vezes. Com o conhecimento adquirido até este momento você só poderia optar pela primeira forma,
escrevendo o mesmo tantas vezes quanto for necessário, no caso quatro vezes.
Por exemplo, imagine um programa que peça a leitura de dois valores para as variáveis A e B
respectivamente. Efetue a adição de um com o outro, implicando o resultado na variável de resposta R e
em seguida apresente o valor do resultado obtido, repetindo esta seqüência por quatro vezes.
/* Programa soma de dois números 4 vezes sem looping

Autor: Fulano de tal Data: 04/04/1974
Var: A e B para os números somados e R para o resultado a soma.
Funcionalidade: o usuário informa 2 números e tem a soma entre eles por 4 vezes consecutivas
*/
#include <stdio.h>
#include <conio.h>
main ( )
{
int A, B, R;
printf (" \n\n Programa soma de 2 números por 4 vezes \n\n ");
printf (" Entre com um valor para A: "); scanf("%d", &A);

printf (" Entre com um valor para B: "); scanf("%d", &B);
R = A + B;
printf (" O resultado da soma é: %d \n\n\n ", R);

R = A + B;

R = A + B;

R = A + B;
getch();
}
A vantagem em se utilizar looping é que o programa passa a ter um tamanho menor, podendo sua
amplitude de processamento ser aumentada sem se alterar o tamanho do código de programação. Desta
forma, podem-se determinar repetições com números variados de vezes; como veremos a seguir.
- 25 -
13.1 Iteração Enquanto - Looping com condição no início: while
Esta estrutura caracteriza-se por efetuar um teste lógico no inicio de um looping, verificando se é
permitido executar o trecho de instruções subordinado a este.
A estrutura while tem o seu funcionamento controlado por condição. Desta forma, poderá executar
um determinado conjunto de instruções enquanto a condição verificada permanecer Verdadeira. No
momento em que esta condição se torna Falsa, o processamento da rotina é desviado para fora do looping.
Sendo a condição Falsa logo no inicio do looping, as instruções contidas no bloco de ações são ignoradas.
Caso seja necessário executar mais de uma instrução para uma condição verdadeira dentro de um looping,
estas deverão estar mencionadas dentro de um bloco definido com { e }. Desta forma, a instrução while
deverá ser escrita respeitando a seguinte sintaxe:
while (condição verdadeira)

{
<Bloco de Ações>;
}
1º - Exemplo
Como exemplo, considere o problema anterior, onde é necessário executar quatro vezes a
solicitação de dois números para o cálculo da adição. Neste caso, será necessário definir um contador para
controlar a execução do programa, e a cada vez que for executado o trecho desejado do programa, este
contador deverá ser incrementado de mais 1. Observe abaixo os detalhes para a solução deste problema:
Algoritmo Literal
1. Criar uma variável para servir como contador com valor inicial 1;
2. Enquanto o valor do contador for menor ou igual a 4, processar os passos 3, 4 e 5;
3. Ler os dois valores;
4. Efetuar o cálculo, implicando o resultado em R;
5. Apresentar o valor calculado contido na variável R;
6. Acrescentar o contador com mais 1 unidade;
7. Quando o contador for maior que 4, encerrar o processamento.
Programa
/* Programa soma de dois números 4 vezes com looping while

Var: A e B para os números somados; R para o resultado e CONTADOR para contar os 4 loopings
Funcionalidade: o usuário informa 2 números e tem a soma entre eles por 4 vezes consecutivas
*/
#include <stdio.h>
#include<conio.h>
main( )
{
int A, B, R, CONTADOR;
printf ("\n\n Programa soma de 2 números por 4 vezes \n\n ");
CONTADOR=1;
while (CONTADOR <= 4)
{
printf (" \n Entre com um valor para A: "); scanf("%d", &A);
printf (" \n Entre com um valor para B: "); scanf("%d", &B);
R = A + B;
printf (" \n O resultado da soma é: %d \n\n ", R);
CONTADOR = CONTADOR + 1;
}
getch( );
}
- 26 -
Além da utilização das variáveis A, B e R, foi necessário criar uma terceira variável, chamada no
caso de CONTADOR para controlar a contagem do número de vezes que o trecho de programa é
executado.
Assim que o programa é inicializado, a variável contador é atribuída com o valor 1 (CONTADOR =1).
Em seguida a instrução while (CONTADOR <= 4) efetua a checagem da condição estabelecida, verificando
que a condição é verdadeira, pois o valor da variável CONTADOR que neste momento é 1, é realmente
menor que 4 e enquanto for, deverá processar o looping. Desta forma, é iniciada a execução da rotina de
instruções contidas no looping delimitado com a instrução while.
Depois de efetuar a solicitação dos valores, ter processado a operação de adição e exibido o
resultado, o programa encontra a linha com a instrução CONTADOR = CONTADOR + 1, indicando o
acréscimo de 1 na variável contador. Observe que a variável CONTADOR possui neste momento o valor 1
e somado a mais 1 esta passa a ter o valor 2, ou seja, CONTADOR = 1 + 1, resultando em CONTADOR =2.
Estando a variável CONTADOR com o valor 2, o processamento do programa volta para a instrução
while (CONTADOR <= 5), que verifica a condição da variável. Sendo esta condição Verdadeira, será
executada novamente a mesma rotina de instruções. Quando o processamento do programa chegar na
instrução CONTADOR = CONTADOR + 1, fará com que a variável CONTADOR passe a possuir o valor 3.
Desta forma o programa processará novamente a rotina de instruções, passando o valor de CONTADOR
para 4, que será verificado, e sendo menor ou igual a 4, será executada mais uma vez a mesma rotina de
instruções. Em seguida o valor da variável CONTADOR passa a ser 5, que resultará para a instrução while
uma condição falsa e por conseguinte desviará o processamento para a primeira instrução encontrada após
o bloco definido entre { e }, no caso para o getch() e em seguida para o fim do programa.
O uso de contadores na linguagem C também pode ser escrito de outras formas. No programa
anterior, por ex., a linha CONTADOR = CONTADOR + 1 poderia ter sido escrita como: CONTADOR += 1.
Imagine agora uma outra situação, onde o usuário deseja executar a rotina do programa várias
vezes, mas não sabe quantas vezes ao certo deverá executar o trecho de programa. Neste caso, não seria
conveniente manter um contador para controlar o looping, seria melhor que o programa fizesse ao usuário
uma pergunta, solicitando se o mesmo deseja ou não continuar executando o programa. Veja o exemplo:
/* Programa soma de dois números indeterminadas vezes com looping while

Var: A e B para os números somados; R para o resultado e RESP para determinar o número de loopings
Funcionalidade: o usuário informa 2 números e tem a soma entre eles por n vezes consecutivas
*/
#include <stdio.h>
#include <conio.h>
main()
{
int A, B, R;
char RESP = 's';
printf ("\n\n Programa soma de 2 números por indeterminadas vezes \n ");
while (RESP == 's')

{
printf (" \n\n Entre com um valor para A: "); scanf("%d", &A);
printf (" \n Entre com um valor para B: "); scanf("%d", &B);
R = A + B;
printf (" \n O resultado da soma é: %d \n\n ", R);
printf (" \n Deseja continuar? - Tecle (s) ou (n): ”);

RESP = getche();
}
}
- 27 -
No exemplo, o contador foi substituído pela variável RESP, que enquanto tiver o seu valor igual a 's',
executará o bloco de instruções subordinado a while. Neste caso, o número de vezes que a rotina se
repetirá será controlado pelo usuário e dependerá da informação fornecida para a variável RESP. Observe
no programa anterior, o uso de apóstrofos na string da condição ao invés de aspas. Na linguagem C,
somente são colocadas strings entre aspas quando são usadas com a função printf(), no caso de uma
condição, deve-se fazer uso de apóstrofos.
Observe que para a entrada da resposta não foi utilizada a função scanf(), sendo usada a função
getche() que permite que seja feita a leitura de um caractere do teclado sem que se pressione a tecla
<ENTER>.
Outro detalhe a ser observado na sintaxe da linguagem C é o fato de permitir simplificações na forma
de escrita. No programa anterior, é iniciada a variável RESP como sendo do tipo string (char) e antes de
iniciar o looping esta variável é atribuída com o valor 's' para dar início ao processamento do looping.
Perceba que após a inicialização da variável com o seu tipo, está sendo atribuído simultaneamente o
valor da variável RESP = 's': char RESP = 's'.
Outro Exemplo
Considere como exemplo um programa que efetue o cálculo da fatorial de um número qualquer.
Supondo que este número seja 5, o programa deverá apresentar o resultado 5! (fatorial de 5) Desta forma,
temos que 5! = 5 . 4 . 3. 2 . 1 ou 5! = 1 .2 . 3 . 4. 5, equivalente a 120.
O programa deverá executar as multiplicações sucessivamente e acumulá-las a fim de possuir o

valor 120 após 5 passos. O número de passos deverá ser controlado por um contador. Veja a seguir:
Algoritmo
1. Inicializar as variáveis FATORIAL e CONTADOR com 1;
2. Solicitar o valor de um número para calcular a sua fatorial;
3. Multiplicar sucessivamente a variável FATORIAL pela variável CONTADOR;
4. Incrementar 1 á variável CONTADOR, efetuando o controle até o limite definido no passo 2;
5. Apresentar ao final o valor obtido.
Pelo fato de se ter que efetuar o cálculo de uma fatorial de um número qualquer (N!), isto implica que
o contador deverá variar de 1 a N, por este motivo deverá ser a variável CONTADOR inicializada com valor
1. Pelo fato de a variável FATORIAL possuir ao final o resultado do cálculo da fatorial pretendida (através
de uma multiplicação sucessiva), esta deverá ser inicializada com valor 1. Se esta for inicializada com zero,
não existirá resultado final, pois qualquer valor multiplicado
por zero resulta zero.
Observe dentro do looping a indicação de dois contadores o primeiro funcionando como um

acumulador, pois é este que terá no final o valor do resultado da fatorial, e o segundo sendo utilizado para
controlar a execução do looping e ser a base para o cálculo do acumulador.
Programa
/* Looping do tipo while para Fatorial */
#include <stdio.h>
#include <conio.h>
main()
{
int N, CONTADOR = 1 ;
long FATORIAL = 1;
printf("\n Programa Fatorial \n\n\t Fatorial de que numero:”); scanf(“%d” ,&N);
while (CONTADOR <= N)
{
FATORIAL *= CONTADOR;
CONTADOR += 1;
}
printf("\n fatorial de %d equivale à %d", N, FATORIAL);
getch( );
}
- 28 -
Exercícios
Exercícios
1) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para escrever na tela de um
computador 20 vezes a frase: “Eu serei aprovado”.
computador todos os números inteiros entre 33 e 50.
computador todos os números inteiros e pares entre 44 e 74.
computador indeterminadas vezes a frase: “Remo Campeão” enquanto o usuário do programa assim
desejar. Confirme a vontade do usuário com a variável RESP sendo ou não igual a ‘s’. Use o comando:
RESP = getche();
5) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para ler a matrícula (RA) de
um aluno e enquanto esta matrícula for diferente de 0 (zero), cadastrar 2 notas e encontrar a média entre
elas de acordo com a seguinte fórmula: M = (N1+N2)/2. Apresentar a média encontrada e ainda: se essa
média for maior ou igual a 5, comunicar que o aluno está aprovado, senão comunicar que este aluno está
reprovado.
6) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para controlar a entrada em
uma boate com capacidade para até 300 pessoas. É proibida a entrada de menores de 18 anos e o
programa é encerrado quando o usuário informa 0 (zero) para a idade de um cliente. Deve ser solicitada a
idade de cada cliente da boate e se esta idade for menor que 18 anos, deve ser apresentada uma
mensagem de “entrada proibida” para o cliente, porém, se a idade for maior ou igual a 18, o cliente entra na
boate e é apresentado para o usuário do programa o número de clientes que estão naquele momento
dentro da boate.
7) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para efetuar a contagem
regressiva de um lançamento de um foguete. O tempo da contagem é de 8 segundos. Utilize o comando
_sleep(1000) , que faz parte da biblioteca <stdlib.h> , para que cada laço demore um segundo para ser
executado. Informe ao usuário, segundo a segundo, o tempo restante para o lançamento do foguete,
Quando o foguete for lançado o usuário deve ser informado que o lançamento foi executado. Tente
representar o foguete “decolando” com o uso do comando gotoxy().
8) Inserir em todos os programas anteriores, a formatação de cores de texto – textcolor ( ) – e cores de

fundo – textbackground ( ) – e ainda refinar a estética com o uso do comando gotoxy(C,L).
- 29 -
13.2 - Looping com condição no fim: do...while
Esta estrutura caracteriza-se por efetuar um teste lógico no final de um looping, sendo parecida com
a estrutura while. Seu funcionamento é controlado também por decisão. Este tipo de looping irá efetuar a
execução de um conjunto de instruções pelo menos uma vez antes de verificar a validade da condição
estabelecida. Diferente da estrutura while que executa somente um conjunto de instruções se e enquanto a
condição é verdadeira.
Desta forma, a iteração do...while irá processar um conjunto de instruções no mínimo uma vez até
que a condição se torne Falsa. A sintaxe da instrução do...while é a seguinte:
do
{
<instrução1 >;
<instrução2 >;
<instrução3 >;
<instrução N >;
}
while <(condição)>;
1º - Exemplo
Para exemplificar a utilização deste tipo de estrutura de looping, será considerado o exemplo visto na
iteração while: "o programa deverá pedir a leitura de dois valores para as variáveis A e B, efetuar a adição
dos dois valores e implicar o resultado na variável de resposta R e em seguida apresentar o valor do
resultado obtido, repetindo esta seqüência por cinco vezes".
Algoritmo Literal
1. Criar uma variável para servir como contador com valor inicial 1;
2. Ler os valores;
4. Apresentar o valor calculado contido na variável R;
5. Acrescentar o contador com mais 1;
6. Repetir os passos 2, 3, 4 e 5 até que o contador seja menor ou igual a 5.
Programa
/* Looping do tipo Do...While */

#include <stdio.h>
#include <conio.h>
main()
{
int A, B, R, I =1;
printf ("\n Programa 5 Repetições \n");
do
{
printf ("\n\n\t Entre um valor para A: "); scanf ("%d", &A);
printf ("\t Entre um valor para B: "); scanf ("%d", &B);
R = A + B;
printf ("\n O resultado %d corresponde a: %d", I, R);
I=I+1;
}
while ( I <= 5 ) ;
getch();
}
Assim que o programa é executado, a variável contador I é inicializada com o valor 1 ( I=1). Em
seguida a iteração é executada até que a condição estabelecida pela instrução do...while ( I <= 5) seja
falsa; ou seja: enquanto a condição for verdadeira.
- 30 -
A seguir, é apresentado o exemplo em que não se utiliza o contador como forma de controle de
execução do número de vezes de uma determinada rotina em uma estrutura de repetição. Considere que
será o usuário que encerrará o processamento segundo a sua vontade.
Algoritmo Literal
1. Criar uma variável para ser utilizada como resposta;
2. Ler os valores;
4. Apresentar o valor calculado contido na variável R
5. Perguntar ao usuário se deseja continuar executando o programa;
6. Repetir os passos 2, 3, 4 e 5 até que a resposta do usuário seja diferente de ‘s’.
Programa
/* Looping do tipo Do...While Versão 2 */
#include <stdio.h>
#include <conio.h>
#include <conio.c>
main()
{
int A, B, R;
char RESP = 's';
do
{
clrscr();
printf ("\n\n Programa Soma \n\n\t Entre com um valor para A: "); scanf("%d", &A);
printf ("\n\t Entre com um valor para B: "); scanf("%d", &B);
R = A + B;
printf ("\n O resultado corresponde da soma é: %d", R);
printf ("\n\n\t\t Deseja continuar? - Tecle (s) ou (n):”);
RESP = getche();
}
while (RESP == 's');
}
2º-. Exemplo
Com do...while, é apresentado a seguir o programa para cálculo da fatorial de um número qualquer.
Programa
/* Looping do tipo Do...While para Fatorial */

#include <stdio.h>
#include <conio.h>
main()
{
int CONTADOR, N;
long FATORIAL = 1;
CONTADOR = 1;
printf ("\n Programa Fatorial \n");
printf ("\n Fatorial de que numero:”); scanf (“%d”,&N);
do
{
FATORIAL = FATORIAL * CONTADOR;
CONTADOR = CONTADOR + 1;
}
while (CONTADOR <= N);
printf ("\n Fatorial de %d equivale a %d", N, FATORIAL);
getch();
}
- 31 -
Exercícios
Exercícios
computador todos os números inteiros de 1 até 100 com o auxílio da iteração do...while.
2) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para encontrar a média
entre duas notas de acordo com a fórmula: M=(N1+N2)/2. O programa deverá ser efetuado de acordo com
a digitação de um RA que deverá ser diferente de zero. Diferencial: Cada nota digitada no programa deve
por obrigação estar compreendida entre zero e dez. Apresentar ao usuário, a média e a situação do aluno,
sendo aprovado caso a média seja maior ou igual a 5 e reprovado caso contrário.
3) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para calcular a soma dos
salários de “N” funcionários de uma empresa durante um ano, de janeiro a dezembro, enquanto o nome do
funcionário for diferente de “Sair”, apresentando no final, os valores totalizados no ano corrente (POR
FUNCIONÁRIO). Utilize as estruturas while e do..while no desenvolvimento de seu programa.
4) Uma loja atacadista deseja saber quanto arrecada em: 1- Vendas por
Balcão, 2- Vendas no Telefone, e ainda saber o total de vendas acumuladas
e por setor em 3- Totalização. Considerando-se que será lido o código (1 ou
2) e o valor da venda, Desenvolver um programa no Dev C++, completo e
voltado ao usuário final, para a resolução do problema de acordo com o
menu ao lado. Atenção: não permita que sejam digitados valores não
positivos para as vendas. Force o usuário a informar corretamente.
5) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para calcular o total gasto
com Combustível em um automóvel “flex”, informando os litros consumidos em cada abastecimento do
veículo, de acordo com o menu ao lado. A cada abastecimento o usuário
escolherá o combustível (por códigos: 1- Álcool ou 2- Gasolina) e digitará o
volume, em litros, do abastecimento (obrigar o usuário a informar o volume
sempre maior que zero e menor que o limite do tanque, que é de 40 litros). Os
gastos então são computados de acordo com os seguintes valores por litro:
Álcool: R$ 1,09 e Gasolina: R$ 2,39. A qualquer momento, o usuário poderá
solicitar a apresentação dos valores gastos (em R$) com o auxílio da opção (3-Gastos) no menu, onde são
apresentados os gastos individuais por combustível e ainda o valor total gasto em abastecimentos (álcool +
gasolina) até o momento da solicitação. O programa é encerrado quando o usuário escolher no menu a
opção 4-Sair. Utilize as iterações (e estruturas em geral) mais adequadas para cada situação.
6) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para calcular (com o auxílio
de um menu) o total gasto com DDD por operadora (1-Telefônica, 2-Embratel), saindo do sistema somente
quando a opção (4-Sair) for selecionada. A cada ligação interurbana o usuário escolherá a operadora (por
códigos: 1 ou 2) e lançará o tempo gasto, em minutos, da conversa telefônica (não permitir a digitação de
tempo menor que zero), que serão computados de acordo com os seguintes valores por minuto: Telefônica:
R$ 0,15 e Embratel: R$ 0,21. A qualquer momento, o usuário poderá solicitar a apresentação dos valores
gastos com o auxílio da opção (3-Gastos) no menu, onde são apresentados os gastos individuais por
operadora e ainda o valor total gasto em interurbanos até o momento da solicitação. Utilize as iterações (e
estruturas em geral) mais adequadas para cada situação.
- 32 -
13.3 - Looping finito: For
Você já aprendeu duas formas de elaborar loopings. Com as técnicas apresentadas é possível
elaborar rotinas que efetuam a execução de um looping, um determinado número de vezes, através da
utilização de um contador (variáveis que executam um determinado número de vezes) ou mesmo por uma
variável que aguarde a resposta do usuário. Independentemente da forma de tratamento, esta variável é
denominada variável de controle.
Existe uma outra forma que visa facilitar o uso de contadores finitos, sem fazer uso das estruturas
anteriores. Desta forma, os looping com while e do...while passam a ser utilizados em situações onde não
se conhece de antemão, o número de vezes que uma determinada seqüência de instruções deverá ser
executada. Os loopings que possuem um número finito de execuções poderão ser processados através do
looping do tipo: for.
Este tipo de looping tem seu funcionamento controlado por uma variável de controle do tipo contador,
podendo ser crescente ou decrescente, tendo como sintaxe:
for (<início>; <fim>; <incremento>)

<instruções>;
Caso venha a existir mais de uma instrução para ser executada dentro do looping, estas deverão
estar inseridas em um bloco { e }:
for (<início>; <fim>; <incremento>)

{
<instruções l>;
<instruções 2>;
<instruções N>;
}
onde:
<inicio> é uma instrução de atribuição com o valor inicial do laço
<fim> é uma instrução de condição com o valor final do laço
<incremento> expressão com o incremento do laço
Exemplo 1
O exemplo a seguir, escreverá na tela os valores 1, 2, 3, 4, 5, 6, 7, 8, 9 e 10. Observe a indicação na

função for() dos três argumentos necessários para o seu funcionamento. O primeiro argumento inicializa a
variável contador com 1, o segundo argumento verifica se a variável atingiu o valor limite e o terceiro
argumento se encarrega de executar o incremento de 1 em 1 na variável em uso.
/* Looping crescente de 1 em 1 */
#include <stdio.h>
main( )
{
int I ;
for (I = 1; I <= 10; I++)
printf ("\n Número = %d", I ) ;
}
- 33 -
Exemplo 2
O exemplo a seguir, escreverá na tela os valores 10, 9, 8, 7, 6, 5, 4, 3, 2 e 1. O primeiro argumento

inicializa a variável contador com 10, o segundo argumento verifica se a variável atingiu o valor limite e o
terceiro argumento se encarrega de executar o decremento de 1 em 1 na variável em uso.
/* Looping decrescente de 1 em 1 *
#include <stdio.h>
main( )
{
int I;
for (I =10; I >= 1; I--)
printf ("\n Número = %d", I ) ;
}
Exemplo 3
O exemplo a seguir, escreverá na tela os valores 1, 3, 5, 7 e 9. O primeiro argumento inicializa a

variável contador com 1, o segundo argumento verifica se a variável atingiu o valor limite e o terceiro
argumento se encarrega de executar o incremento de 2 em 2 na variável em uso.
/* Looping crescente de 2 em 2 */
#include <stdio.h>
main( )
{
int I;
for (I = 1; I<=9; I+=2)
printf ("\n Número = %d", I );
}
Exemplo 4 (Completo e pronto para ser digitado – com getch() e conio.h)
Será considerado agora como exemplo, um programa que deverá pedir a leitura de dois valores
para as variáveis A e B, efetuar a adição dos dois valores e implicar o resultado na variável de resposta R e
em seguida apresentar o valor do resultado obtido, repetindo esta seqüência por cinco vezes.
/* Looping do tipo For */
#include <stdio.h>
#Include <conio.h>
main( )
{
int A, B, R, I ;
printf ("\n\t Programa 5 Somas \n\n ") ;
for(I = 1; I <= 5; I++)
{
printf ("\n Entre com um valor para A: ") ; scanf("%d", &A) ;
printf ("\n Entre com um valor para B: ") ; scanf("%d", &B) ;
R=A+B;
printf ("\n\t O resultado corresponde a: %d", R) ;
}
getch() ;
}
- 34 -
Exercícios
Exercícios
computador todos os números inteiros de 1 até 100 com o auxílio da iteração for.
2) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para apresentar todos os
números inteiros pares de 2 até 2000 (incluindo ambos), com o auxílio da iteração for.
3) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, que mostre todos os
números múltiplos de 3; entre 1 e 300 inclusive.
4) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para efetuar a contagem
regressiva de um lançamento de um foguete com o auxílio da iteração for. O tempo da contagem é de 8
segundos. Utilize o comando _sleep(1000) , que faz parte da biblioteca <stdlib.h> , para que cada laço
demore um segundo para ser executado. Informe ao usuário, segundo a segundo, o tempo restante para o
lançamento do foguete. Quando o foguete for lançado o usuário deve ser informado que o lançamento foi
executado. Tente representar o foguete “decolando” com o uso do comando gotoxy().
5) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, que leia um número N
(obrigatoriamente positivo), mostre todos os números inteiros entre 1 e N (inclusive) e a média aritmética
dos números mostrados.
6) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para calcular o gasto total
na compra de um automóvel em dólar, em 24 prestações fixas + “variação cambial”.
Adote o dólar paralelo valendo R$ 2,00 e leve em consideração que durante os 24 meses de
prestação, o dólar aumentará 1 centavo ao mês (esta é a “variação cambial”).
O programa deverá informar ao usuário:
a) quanto ele gastará em cada mês em
Reais (R$) na prestação do carro e
b) quanto ele gastará no final das 24
prestações também em Real.
Atenção: O usuário deverá informar, apenas
uma vez, o valor fixo em dólar contido no carnê
de 24 prestações.
7) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para calcular o total gasto
com Pedágio durante um ano inteiro (12 meses, de janeiro (1) a dezembro (12) – utilize iteração for neste
momento). O usuário deverá digitar somente quanto gastou em cada mês (não permita que sejam aceitos
valores negativos – utilize iteração do...while neste momento).
Deverá ser apresentado mensalmente
o total parcial acumulado gasto até o mês corrente.
No final do ano, após o último dos 12 valores ser
digitado, deverá ser apresentado o total gasto no
ano inteiro e ainda uma mensagem indicando:
gasto nulo (se o total for igual a 0),
moderado (se o total for menor que R$300,00), ou
excessivo (se o total for maior ou igual que R$300,00).
- 35 -
XIV
XIV Estruturas Homogêneas
Tem a característica de permitir o agrupamento de várias informações do mesmo tipo de dado em uma única
variável, em formato de Matriz, criando um Novo Tipo de Dado Construído com base em um Tipo de Dado
Primitivo (int, float, char...) ou com base em outro Tipo de Dado previamente Construído (como uma Matriz de
Matriz por exemplo).
14.1 - MATRIZES COM UMA DIMENSÃO (VETORES)
Este tipo de estrutura caracteriza uma matriz unidimensional. Sua utilização mais comum está
vinculada á criação de tabelas. Caracteriza-se por ser definida uma única variável dimensionada com um
determinado tamanho. A dimensão de uma matriz é constituída por constantes inteiras e positivas. Os
nomes dados às matrizes seguem as mesmas regras de nomes utilizados em variáveis simples.
Exemplo:
Calcular e apresentar a média geral de uma turma de 8 alunos. Desta forma, será necessário somar
todas as médias e dividi-las por 8. Da média de cada aluno, é efetuado o cálculo da média da turma.
De maneira equivocada, SEM usar matrizes, para representar a média do primeiro aluno é utilizada
a variável MD1, para o segundo MD2 e assim por diante. Levando em consideração que já se tem as
médias de cada aluno (Ex.: MD1=4.5, MD2=6.5, MD3=8.0, MD4=3.5, MD5=6.0, MD6=7.0, MD7=6.5,
MD8=6.0) basta então somá-las e dividi-las pela quantidade de alunos, resultando na média da turma.
/* Cálculo de Média Escolar */

#include <stdio.h>
#include <conio.h>
main()
{
float MD1, MD2, MD3,MD4, MD5, MD6, MD7, MD8;
float SOMA, MEDIA;
SOMA = 0;
printf ("Programa 8 Médias”);
printf ("Informe Média 1:”); scanf ("%f”,&MD1);

SOMA = MD1 + MD2 + MD3 + MD4 + MD5 + MD6 + MD7 + MD8;

MEDIA = SOMA / 8;
printf ("A Média é: %.2f", MEDIA);

getch();
}
Note que para receber a média foram utilizadas 8 variáveis. Com a técnica de matrizes poderá ser
utilizada apenas uma variável com a capacidade de armazenar os 8 valores resultando em um programa
muito mais eficiente e inteligente.
- 36 -
14.1.1 Operações com Matrizes Unidimensionais (Vetor)
Uma matriz de uma dimensão ou vetor é representada por seu nome, tamanho (dimensão) entre
colchetes e seu tipo, tendo assim, a seguinte sintaxe:
tipo MATRIZ [dimensão];

onde:
<tipo> O tipo de dado a ser guardado na matriz;

<matriz> O nome atribuído à matriz;
<dimensão> O tamanho da matriz ,em número de elementos
Uma variável somente pode conter um valor por vez. No caso das matrizes, estas poderão
armazenar mais de um valor por vez, pois são dimensionadas exatamente para este fim. Lembrando que a
manipulação dos elementos de uma matriz ocorrerá de forma individualizada, pois não é possível efetuar a
manipulação de todos os elementos do conjunto ao mesmo tempo.
No caso do exemplo do cálculo da média dos 8 alunos, é possível ter então uma única variável
contendo todos os valores das 8 notas. Isto é representado, por exemplo, da seguinte forma: MD[1] = 4.5,
MD[2] = 6.5, MD[3] = 8.0, MD[4] = 3.5, MD[5] = 6.0, MD[6] = 7.0, MD[7] = 6.5, MD[8] = 6.0.
Observe que o nome é um só, o que muda é a informação indicada dentro dos colchetes. A esta
informação dá-se o nome de índice, sendo este o endereço onde o elemento está armazenado, ou seja, a
média do aluno. Para uma tabela de 8 elementos, os índices são numerados de 0 até 7, ou de 1 até 8, etc...
Tanto a entrada quanto a saída de dados operada com uma matriz, é processada passo a passo,
um elemento por vez. Estes processos devem ser executados com o auxilio de uma iteração.
1º - Exemplo
Considerando a proposta anterior, segue o programa que executa a leitura da média de cada aluno,
o cálculo da média da sala e em seguida a apresentação da média geral UTILIZANDO Vetor.
/* Cálculo de Média para 8 alunos COM Vetor */

#include <stdio.h>
#include <conio.h>
main( )
{
float MD[8];
float MEDIA, SOMA = 0;
int I;
printf("\n Cálculo de Média Escolar \n \ n");
for (I = 1; I <= 8; I++)
{
printf("Informe a nota %d: ", I); scanf("%f", &MD[I]);
SOMA = SOMA + MD[I];
}
MEDIA = SOMA / 8;
printf("\n A média da turma é: %.2f \n", MEDIA);
getch( );
}
O programa em questão faz referência à área de declaração de variáveis, a matriz MD[8], onde é
definido o número de elementos, no caso 8 elementos, iniciando-se, neste caso específico, com índice 1
sendo percorrido de um em um (I++) até o índice 8.
- 37 -
2º- Exemplo
Desenvolver um programa que efetue a leitura de 8 elementos de uma matriz A tipo vetor. Construir
uma matriz B de mesmo tipo, observando a seguinte lei de formação: Se o valor do índice for par, o valor
deverá ser multiplicado por 5; sendo ímpar, deverá ser somado com 5. Ao final, mostrar os conteúdos das
duas matrizes. Este exemplo demonstra como fazer o tratamento da condição do índice.
Algoritmo Literal
1. Iniciar o contador de índice, variável I como 1 em um contador até 8;
2. Ler os 8 valores, um a um;
3. Verificar se o índice é par, se sim, multiplica por 5; se não, soma 5. Criar a matriz B;
4. Apresentar os conteúdos das duas matrizes.
Programa
/* Checa índice: Par ou Ímpar */

#include <stdio.h>
#include <conio.h>
main()
{
int A[8], B[8];
int I;
printf("\t Programa dois vetores Par ou Ímpar \n \n");
/* Entrada de dados */
for (I = 1; I<= 8; I++)
{
printf("Informe um valor para o elemento A[%d]: ", I);
scanf("%d", &A[I]);
}
/* Checando se índice é Par / Ímpar */
for (I=1; I<=8; I++)
{
if ( I % 2 == 0 ) /* % tem o mesmo sentido do mod em Algoritmos */
B[I] = A[I] * 5;
else
B[I] = A[I] + 5;
}
/* Saída na tela das matrizes */
for (I=1; I<=8; I++)
printf (“\n A[%d] = %d \t B[%d] = %d”, I, A[I], I, B[I] );
getch();
}
Exercícios
Exercícios
1) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para Ler duas matrizes
unidimensionais (vetores) A e B com 20 elementos cada. Construir um vetor C, onde cada elemento de C é
a soma dos elementos correspondentes aos índices dos vetores A com B.
2) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para Ler 15 elementos de
uma matriz A unidimensional (vetor). Construir um vetor B de mesmo tipo, observando a seguinte lei de
formação: Todo elemento do vetor B deverá ser o quadrado do elemento de A correspondente.
3) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para cadastrar 2 notas de
provas (float) (obrigatoriamente entre 0 e 10) em um vetor e apresentar a média encontrada. Em seguida,
apresentar em ordem crescente as 2 notas cadastradas no vetor, indicando em qual prova o aluno foi
melhor.
- 38 -
14.2 - MATRIZES COM MAIS DE UMA DIMENSÃO
Com o conhecimento adquirido até agora, você teria condições suficientes para elaborar um
programa que efetuasse a leitura das notas de “n” alunos, o cálculo da média de cada aluno e no final
apresentar a média do grupo, utilizando-se apenas de matrizes unidimensionais. Porém, há de se
considerar que o trabalho seria grande, uma vez que se necessitaria manter um controle de cada índice em
cada matriz para cada aluno.
Para facilitar o trabalho com este tipo de estrutura, são utilizadas matrizes com mais dimensões. A
mais comum é a matriz de duas dimensões por se relacionar diretamente com a utilização de tabelas.
Matrizes com mais de duas dimensões são utilizadas com menos freqüência, mas poderão ocorrer
momentos em que se necessite trabalhar com um número maior de dimensões, porém estas serão fáceis
de ser utilizadas se você dominar bem a utilização de uma matriz com duas dimensões.
Em matrizes de mais de uma dimensão, os seus elementos serão também manipulados de forma
individualizada, sendo a referência feita sempre através de dois índices: o primeiro para indicar a linha e o
segundo para indicar a coluna. Desta forma, TABELA[2][3] indica que está sendo feita uma referência ao
elemento armazenado na linha 2 coluna 3.
Pode-se considerar que uma matriz com mais de uma dimensão é também um vetor, sendo válido
para este tipo de matriz tudo o que já foi utilizado anteriormente para as matrizes de uma dimensão.
Na realidade, a linguagem C não trabalha com o conceito de matrizes que tenham mais de uma
dimensão, mas permite a simulação perfeita deste efeito. isto ocorre pelo fato desta linguagem trabalhar
com o conceito de matrizes de matrizes, ou seja, uma matriz considerada de duas dimensões é na verdade
uma matriz onde cada um de seus elementos é por sua vez uma outra matriz.
14.2.1 Operações com Matrizes de duas Dimensões
Uma matriz de duas dimensões estará sempre fazendo menção a linhas e colunas e será
representada por seu nome e seu tamanho (dimensão) entre colchetes. Desta forma, seria uma matriz de
duas dimensões TABELA[8][5], onde seu nome é TABELA, possuindo um tamanho de 8 linhas e 5 colunas,
ou seja, é uma matriz de 8 por 5 (8 x 5). Isto significa que poderão ser armazenados em TABELA até 40
elementos. A tabela a seguir apresenta a matriz TABELA com a indicação dos endereços (posições) que
poderão ser utilizados para armazenamento de seus elementos.
Matriz: TABELA
11 12 13 14 15
21 22 23 24 25
31 32 33 34 35
41 42 43 44 45
51 52 53 54 55
61 62 63 64 65
71 72 73 74 75
81 82 83 84 85
Uma matriz de duas dimensões é atribuída de forma semelhante à atribuição de uma matriz de uma
dimensão, sendo representada pelo seu nome, tamanho (dimensão de linhas e colunas) entre colchetes e
seu tipo, tendo assim, a seguinte sintaxe:
tipo MATRIZ [dimensão linha] [dimensão coluna];

onde:
<tipo> O tipo de dado homogêneo a ser guardado na matriz

<matriz> O nome atribuído a matriz.
<dimensão linha> O tamanho da matriz, em número de linhas;
<dimensão coluna> O tamanho da matriz, em número de colunas;
- 39 -
Para exemplificar a utilização de matrizes deste tipo, considere o programa de entrada e saída das
notas escolares. A leitura e escrita de uma matriz de duas dimensões, assim como as matrizes de uma
dimensão, são processadas passo a passo.
Considerando a manipulação de 2 notas de 5 alunos, a tabela em questão armazenará 10

elementos. Um detalhe a ser considerado é a utilização de duas variáveis para controlar os dois índices de
posicionamento de dados na tabela, uma para cada dimensão.
/* 2 notas de 5 Alunos */
#include <stdio.h>
#include <conio.h>
main()
{
float MD[5] [2], NUMERO;
int I, J;
printf("\n Leitura e Apresentação de 2 notas de 5 Alunos \n");
/* Entrada das notas */
for (I= 1; I<= 5; I++)
{
printf("\n Informe as notas do Aluno %d: \n\n”,I);
for (J= 1; J<= 2; J++)

{
printf("\t Nota %d: ", J);
scanf("%f", &NUMERO);
MD[I] [J] = NUMERO;
}
}
/* saída das notas */
printf("\n\n Apresentação das notas dos 5 Alunos \n");
for (I= 1; I<= 5; I++)
{
printf("\n Notas do aluno %d: ", I);
for (J= 1; J<= 2; J++)
printf(" Nota %d: %.2f \t ", J, MD[I][J]);
}
getch();
}
Note que em um exemplo anterior foi utilizada a variável I para controlar as posições dos elementos
dentro da matriz, ou seja, a posição em nível de linha. Neste exemplo, a variável I continua tendo o mesmo
efeito e a segunda variável, a J, está controlando a posição da coluna.
Analisando o programa, temos a inicialização das variáveis I e J como 1 através dos laços for, ou
seja, a leitura será efetuada na primeira linha da primeira coluna. Em seguida é iniciado o looping da
variável I para controlar a posição em relação às linhas e depois é iniciado o looping da variável J para
controlar a posição em relação ás colunas.
Veja que ao serem iniciados os valores para o preenchimento da matriz, estes são colocados na
posição MD[1,1] (primeira linha e primeira coluna), lembrando que o primeiro valor dentro dos colchetes
representa a linha e o segundo representa a coluna. Assim sendo, será então digitado para o primeiro aluno
a sua primeira nota.
Depois é incrementado mais 1 em relação a coluna, sendo colocada para a entrada a posição
MD[1,2] (primeira linha e segunda coluna) da matriz. Desta forma, será digitado para o primeiro aluno a sua
segunda nota. Em seguida o contador da variável i será incrementado com mais 1, tornando-se 2. Será
então inicializado novamente o contador J em 1, permitindo assim, que seja digitado um novo dado na
posição MD[2,1] e assim sucessivamente até o preenchimento total da matriz.
- 40 -
Exercícios
Exercícios
1) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para Ler duas matrizes
bidimensionais A e B, cada uma com 5 linhas e 3 colunas de elementos inteiros. Construir uma matriz S de
mesma dimensão, onde S é formada pela soma dos elementos da matriz A com os elementos da matriz B.
Apresentar os valores da matriz S com a diagramação correta de uma matriz bidimensional usando a
função gotoxy( ).
2) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para preencher uma matriz
de 3 linhas e 4 colunas com “P” para as colunas pares e “I” para as colunas ímpares. Apresentar esta
matriz formada ao usuário com a diagramação correta de uma matriz bidimensional usando a função
gotoxy( ). O usuário, neste caso, apenas executa o programa e visualiza a formação correta da matriz.
3) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para Ler uma matriz A
quadrada de 25 elementos inteiros na íntegra e em seguida apresentar os valores da matriz formada com a
diagramação correta de uma matriz bidimensional usando a função gotoxy( ). Apresentar também a soma
dos elementos da diagonal principal da matriz digitada.
4) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para Ler uma matriz A de
uma dimensão com 5 elementos inteiros. Construir uma matriz B de duas dimensões com 3 colunas e 5
linhas, onde a primeira coluna da matriz B é formada pelos elementos da matriz A somados com 5 (+5), a
segunda coluna é formada pelos elementos da matriz A subtraídos de 1 (-1) e a terceira e última coluna
deverá ser formada pelo quadrado (↑2) dos elementos correspondentes da matriz A. Apresentar a matriz
formada ao usuário do programa. Apresentar os valores da matriz B com a diagramação correta de uma
matriz bidimensional usando a função gotoxy( ) seguindo o modelo abaixo.
- 41 -
EXTRA
Trabalhando com STRINGS
É um dos mais importantes tipos de dados utilizados em uma linguagem de programação, pois é
usado para a operação e armazenamento de textos. E na linguagem C, este tipo de dado recebe um
tratamento diferente de outras linguagens, pois caracteriza-se por ser um vetor (matriz unidimensional) do
tipo char o qual é terminado com o caractere null “\0".
Já é sabido que uma matriz é o conjunto de dados de mesmo tipo, armazenado em uma mesma
variável e controlado por um índice. Em C, o tipo string é um conjunto de elementos do tipo char. Desta
forma, é possível acessar qualquer um dos elementos da referida matriz.
Em alguns programas anteriores, você já trabalhou com string, por exemplo no programa anterior:
printf("\n Leitura e Apresentação de 2 notas de 5 Alunos \n");
a mensagem: Leitura e Apresentação de 2 notas de 5 Alunos, é uma string considerada constante
pelo fato de estar escrita entre aspas. O caractere null “\0" também está presente no final da string, apesar
de não ser visível, sendo este de suma importância, pois é a única forma que as funções possuem de
identificar o final de uma string.
Será estudado neste momento, como trabalhar com strings variáveis, as quais serão fornecidas via
teclado, como: um nome, um endereço, um número de telefone, etc. Estas strings inicialmente serão
entradas para processamento através da função scanf() com a utilização do formato %s.
A seguir, é dado um exemplo com um programa que pede o nome e o sobrenome, faz uma
saudação e apresenta o nome completo.
/* Pede dados pessoais */

#include <stdio.h>
#include <conio.h>
main()
{
char NOME[10], SB_NOME[15];
printf("Digite o seu nome ...........: "); scanf ("%s", NOME);
printf("Digite o seu sobrenome ..: "); scanf ("%s", SB_NOME);
printf("Nome completo: %s %s", NOME, SB_NOME);
getch();
}
O exemplo anterior está fazendo uso de duas matrizes do tipo string: uma sendo NOME com a
capacidade de armazenar até 10 caracteres e a outra sendo SB_NOME com a capacidade de até 15
caracteres.
As instruções scanf("%s", NOME); e scanf("%s", SB_NOME); fazem a leitura de cada caractere

digitado e os armazenam seqüencialmente a partir do endereço de NOME e SB_NOME. O processo é
encerrado quando um caractere branco encontrado na string. Neste momento, o caractere'"\0" é colocado
automaticamente nesta posição. Desta forma, é necessário tomar cuidado com o tamanho da matriz do tipo
string. Se a matriz possui declarado um valor de tamanho como 10, você só poderá usar 9, deixando pelo
menos uma posição livre para o caractere “\0”.
Outro detalhe a ser observado é a ausência do operador &, precedendo o segundo argumento das
instruções de entrada com a função scanf(). Quando se utilizam matrizes, este operador não pode ser
usado, pois o nome de uma matriz é o seu endereço inicial. Desta forma, a expressão scanf("%s", NOME);
é equivalente a scanf("%s", &NOME[0]);.
- 42 -
Operações Básicas com string
Por exemplo, se for digitado para NOME a string Dennys e em seguida para SB_NOME for digitado
a string Noronha, será apresentada a mensagem: Nome Completo: Dennys Noronha. Porém, se para
NOME for digitado Dennys Peixoto , o programa não irá solicitar o sobrenome, pois na string Dennys
Peixoto existe um espaço em branco entre Dennys e Peixoto. Desta forma, a string Dennys fica
armazenada em NOME e a string Peixoto fica armazenada em SB_NOME.
Este efeito indesejável ocorre pelo fato da função scanf() ser bastante limitada para a leitura de
string. Para resolver este problema podemos usar uma outra função de entrada de dados: gets (), pois o
propósito desta função é efetuar leitura de dados do tipo string fornecidos via teclado. A função gets()
aceita caracteres em branco no meio da string, colocando o caractere de controle "\0" apenas quando for
pressionada a tecla <ENTER>. Observe o exemplo a seguir:
/* Pede dados pessoais com função gets() */

#include <stdio.h>
#include<conio.h>
main()
{
printf("Digite o seu nome ..............: "); gets (NOME);
printf("Digite o seu sobrenome ......: "); gets (SB_NOME);
printf("Nome Completo: %s %s", NOME, SB_NOME);
getch();
}
Além do uso da função gets(), foi tomado o cuidado de aumentar o tamanho das matrizes, para
assim evitar qualquer corte na string.
Assim como a função scanf() foi substituída pela função gets(), a função printf() pode ser
substituída pela função puts() que tem com principal característica o fato de permitir a impressão de uma
única string por vez, além de pular sozinha uma linha após a impressão de uma string.
Deve-se considerar que a função puts() não será usada para todas as aplicações, pois esta
somente aceita um argumento, a variável que será impressa, podendo causar alguns efeitos visuais
distorcidos e incômodos. Veja a seguir o exemplo:
/* Pede dados pessoais com gets() e imprime com puts() */

#include <stdio.h>
#include <conio.h>
main()
{
puts("Digite o seu nome .................: "); gets(NOME);
puts("Digite o seu sobrenome .......: "); gets(SB_NOME);
printf("Nome Completo: %s %s", NOME, SB_NOME);
getch();
}
Observe, ao executar o exemplo, que ao ser encontrada a instrução puts("Digite o seu nome ...: ");,
o cursor é posicionado na linha seguinte, onde será fornecido o respectivo dado. Note também que a
apresentação do nome completo está sendo feita com a função printf().
- 43 -
Cadeia de Caracteres
Uma cadeia de caracteres é uma string e existe um tratamento específico para trabalhar com esse tipo de
dado na Linguagem C; começando pela inserção de uma nova biblioteca possibilitando o uso de suas
principais funções:
#include <string.h>
Na sintaxe de criação deste tipo de dado em C++, já é indicado além do nome da variável, o tipo e
o tamanho máximo da cadeia:
char Cadeia[tam] ;
A seguir são apresentadas algumas funções para trabalhar com tratamento de Strings na Linguagem C++ :
scanf Lê um texto até o primeiro espaço em branco scanf ( “%s” , S1 ) ;

gets Lê um texto até que seja pressionado enter gets ( S1 ) ;
printf Escreve uma seqüência de caracteres printf ( “%s” , S1 ) ;
puts Escreve uma seqüência de caracteres puts ( S1 ) ;
strcpy copia uma string em outra strcpy ( SDest , SOrig ) ;
strncpy copia os N primeiros caracteres de SO em SD strncpy ( SDest , SOrig , 4 ) ;
strcat Concatena uma string S2 em S1 strcat (S1 , S2 ) ;
strcmp Compara duas strings strcmp ( S1 , S2 ) ;
strlwr Transforma uma string toda em letras minúsculas strlwr ( S1 ) ;
strupr Transforma uma string toda em letras maiúsculas strupr ( S1 ) ;
strchr Retorna a ocorrência de um caracter qualquer na string strchr ( S1 , ‘c’ ) ;
strncat Concatena os N primeiros caracteres de S2 em S1 strncat ( S1 , S2 , 4 ) ;
strstr Procura a ocorrência da substring S2 em S1 strstr ( S1 , S2 ) ;
strncmp Compara os N primeiros caracteres de S1 e S2 strncmp ( S1 , S2 , 7 ) ;
strlen Retorna o tamanho de uma string strlen ( S1 ) ;
Exercícios
Exercícios
1) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para calcular o
comprimento de uma cadeia de caracteres qualquer, dada esta cadeia pelo usuário do programa em forma
de uma frase com até 40 caracteres.
#include <stdio.h>
#include <conio.h>
#include <string.h>
main()
{
char frase[40];
int comp;
printf( "\t Programa Comprimento de uma Cadeia de Caracteres \n\n" );
printf( "Digite uma frase qualquer: " );

gets(frase);
comp = strlen(frase);
printf( "\n\nEsta frase possui %d caracteres", comp );

getch( );
}
2) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para solicitar uma senha
(char) de um usuário e em seguida verificar se a confirmação da senha é igual a senha digitada
anteriormente. Quando a confirmação for igual a primeira senha digitada, diga que a senha está OK, caso
contrário faça com que o usuário informe a senha e a confirmação da senha novamente. Utilize a estrutura
do...while. O número máximo de tentativas deve ser igual a 3.
- 44 -
XV Estruturas Heterogêneas
Para utilizar diferentes tipos de dados em uma mesma variável, torna-se necessário, como
mecanismo para construção de novos tipos de dados, o uso da estrutura Registro (struct), pois só assim é
possível operar com agregados heterogêneos.
15.1 - REGISTROS (struct)
A estrutura heterogênea da linguagem C é chamada de registro em outras linguagens, enquanto

os membros da estrutura são chamados de campos. Na verdade, o conceito é o mesmo, o que muda é a
nomenclatura, pois uma estrutura é o conjunto de uma ou mais variáveis, geralmente de tipos diferentes,
colocadas sob um mesmo nome.
Para tanto, considere que seja informado para um funcionário: seu código, seu nome e seu salário,
conforme diagrama apresentado abaixo. São três variáveis com tipos de dados distintos. Somente um
registro, que agrega dados heterogêneos, é capaz de suportar tais dados associados à mesma variável.
Para criar uma estrutura registro struct na Linguagem C, deve ser utilizada uma entre as três
sintaxes abaixo. A primeira e a segunda em qualquer situação e a última, apresentando a variável que irá
operar o registro imediatamente após a criação da struct e retirando assim o ; que fecha o bloco.
struct <nome> struct <nome> struct <nome>

{ { {
<tipos e variáveis>; <tipos e variáveis>; <tipos e variáveis>;
}; }; }
struct <nome> <variável>; <nome> <variável>; <variável>;
Onde nome é o nome da estrutura (registro) e tipos e variáveis é a relação de variáveis que serão
usadas como campos, bem como o seu tipo, podendo ser: float, int, char e qualquer outro tipo construído.
Tomando como exemplo o diagrama do Funcionário apresentado acima, a struct FUNCIONARIO

poderia ser criada das seguintes formas:
struct FUNCIONARIO struct FUNCIONARIO struct FUNCIONARIO

{ { {
int CODIGO; int CODIGO; int CODIGO;
char NOME[40]; char NOME[40]; char NOME[40];
float SALARIO; float SALARIO; float SALARIO;
}; }; }
struct FUNCIONARIO F; FUNCIONARIO F; F;
A estrutura que está sendo denominada FUNCIONARIO, é representada por um conjunto de dados
heterogêneos (um membro tipo int, um char e um float). Desta forma, é possível guardar em uma mesma
estrutura, e consequentemente em uma mesma variável, diferentes campos com diferentes tipos de dados.
Qualquer menção feita a um membro de uma estrutura, seja uma leitura, uma escrita ou mesmo
uma atribuição a uma variável, deverá ser feita com o nome da estrutura seguido do nome da variável
separado por um caractere "." (ponto) que recebe o nome de operador de associação, como pode ser
observado no programa de Leitura e Escrita de um Funcionário apresentado a seguir:
- 45 -
#include <stdio.h>
#include <conio.h>
main()
{
struct FUNCIONARIO
{
int CODIGO;
char NOME[40];
float SALARIO;
}
F;
printf("Cadastro de Funcionario \n\n");

printf("Informe Codigo...: "); scanf("%d", &F.CODIGO);
printf("Informe Nome.....: "); scanf("%s", F.NOME);
printf("Informe Salario..: "); scanf("%f", &F.SALARIO);
printf("\n Codigo .......: %d \n" , F.CODIGO);

printf(" Nome .........: %s \n" , F.NOME);
printf(" Salario.......: %.2f\n", F.SALARIO);
getch();
}
No exemplo apresentado temos apenas um registro FUNCIONARIO. É possível criarmos vários

destes registros aplicando os conceitos de matrizes, visto no Capítulo 14.
Desta forma podemos criar um vetor de registros, conforme apresentado no exemplo a seguir.
#include <stdio.h>
#include <conio.h>
main()
{
struct FUNCIONARIO
{
int CODIGO;
char NOME[40];
float SALARIO;
}
F[3];
int i;
printf("Cadastro de Funcionarios \n\n");

for (i=0;i<=2;i++)
{
printf("\n Cadastrando Funcionario %d \n\n",i+1);
printf("Informe Codigo...: "); scanf("%d", &F[i+1].CODIGO);
printf("Informe Nome.....: "); scanf("%s", F[i+1].NOME);
printf("Informe Salario..: "); scanf("%f", &F[i+1].SALARIO);
}
printf("\n Listagem de Funcionarios: \n");
for (i=0;i<=2;i++)
{
printf("Codigo .......: %d \n" , F[i+1].CODIGO);
printf("Nome .........: %s \n" , F[i+1].NOME);
printf("Salario.......: %.2f\n", F[i+1].SALARIO);
}
getch();
}
- 46 -
Note que para criar um vetor de 3 registros de Funcionários foi necessário apenas incluir o tamanho
da variável F em [3] rodando o laço for nas posições F[0], F[1] e F[2] fazendo então com que a variável i
tivesse a necessidade de ser incrementada em uma unidade para sua melhor apresentação ao usuário.
Caso você não queira trabalhar com uma unidade a mais para a variável de controle e trocar o i+1
por simplesmente i , torna-se necessário adicionar uma unidade no tamanho do vetor. No caso específico,
a variável F iria de [3] para [4], rodando o laço for nas posições F[1], F[2] e F[3], deixando a posição F[0]
livre.
Este artifício, de incrementar em uma unidade o tamanho do vetor, será usado nos próximos
exemplos.
Agora vamos pensar na possibilidade de cada funcionário poder ter 12 salários e não mais apenas
um. Assim seria necessário criarmos um vetor para a variável SALARIO com 12+1 elementos:
SALARIO[13].
Desta forma podemos criar um vetor de 3 registros, indicado por F[3+1] representado por F[4] e
com um vetor entre seus campos, com a variável SALARIO[13] conforme apresentado no exemplo a seguir:
#include <stdio.h>
#include <conio.h>
main()
{
struct FUNCIONARIO
{
int CODIGO;
char NOME[40];
float SALARIO[13];
}
F[4];
int i,j;
printf("Cadastro de Funcionarios \n\n");
for (i=1;i<=3;i++)
{
printf("\n Cadastrando Funcionario %d \n\n",i);
printf("\t Informe Codigo...: "); scanf("%d", &F[i].CODIGO);
printf("\t Informe Nome.....: "); scanf("%s", F[i].NOME);
for (j=1; j<=12; j++)
{
printf("\t Informe Salario [%d]: ",j);
scanf("%f", &F[i].SALARIO[j]);
fflush(stdin);
}
}
printf("\n Listagem de Funcionarios: \n");
for (i=1;i<=12;i++)
{
printf("\n\t Codigo .......: %d \n" , F[i].CODIGO);
printf("\t Nome .........: %s \n" , F[i].NOME);
for (j=1; j<=3; j++)
printf("\t Salario [%d]...: %.2f\n",j, F[i].SALARIO[j]);
}
getch();
}
- 47 -
No programa anterior, foi implementada a função fflush(stdin);, logo após a leitura dos valores dos
salários. Isto é necessário, pois o buffer de teclado pode ficar carregado com o valor anterior, causando
resultados imprevisíveis. A função fflush() tem por finalidade descarregar o buffer pendente.
O argumento stdin (standard input) se refere á entrada padrão, que no caso é o teclado.
Para que a função fflush() aceite corretamente o argumento stdin, é necessária a utilização da
biblioteca padrão stdio.h (standard input/output) através da diretiva #include (conforme apresentado no
Capítulo 4).
Exercício exemplo:
Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para controlar o estoque
pessoal de 50 DVDs de um usuário. Cada DVD terá um nome e um preço que deverão ser cadastrados. Ao
final do cadastro, deverá ser apresentado quanto o usuário gastou com os 50 DVDs e ainda todos os DVDs
cadastrados (registro completo – nome e preço) com valor maior que R$ 20,00.
/* Definição: Algoritmo Controle de 50 DVDs

* Autor: Dennys Noronha Data de Criação: 02/06/2009
* Var: i controla os laços e as posições dos elementos
* Funcionalidade: O usuário cadastra 50 DVDs com Nome e Preço e vê os maiores que R$20,00
*/
#include <stdio.h>
#include <conio.h>
main()
{
struct DVD
{
char NOME[40];
float PRECO;
}
D[51];
int i;
float TOTAL = 0 ;
printf("Cadastro de DVDs \n\n");
for (i=1;i<=50;i++)
{
printf("\n Cadastrando DVD %d \n\n",i);
printf("\t Informe Titulo.: "); scanf("%s", D[i].NOME);
printf("\t Informe Preco..: "); scanf("%f", &D[i].PRECO);
TOTAL = TOTAL + D[i].PRECO ;
}
printf("\n\n Total gasto com DVDs: R$ %.2f \n\n", TOTAL);

printf("\n\n Listagem de DVDs maiores que R$20,00: \n\n");
for (i=1;i<=50;i++)
{
if (D[i].PRECO > 20 )
{
printf("\n\t Titulo %d ...: %s \n" ,i, D[i].NOME);
printf("\t Preco.......: R$ %.2f \n", D[i].PRECO);
}
}
getch();
}
- 48 -
Exercícios
Exercícios
1) Em uma maratona X qualquer, é possível a inscrição de 7 atletas. Cada um com código int e Nome
char. Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para atribuir inicialmente
espaços vazios para as 7 possíveis inscrições de atletas. Possibilitar então o cadastro de todos os atletas
inscritos na maratona, um a um, através de um menu com 1- Inclusão (Inscrição do Atleta) e 2- Listagem
dos Inscritos, até que a opção do usuário seja igual a 3- Sair. No momento do cadastro, o atleta irá escolher
seu número de inscrição que corresponderá aos índices do vetor de registros (obrigatoriamente de 1 até 7)
e não poderá estar ocupado.
2) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para trabalhar com um
Controle de CD’s... Serão até 7 registros de CD’s... Cada registro possuindo em sua formação:
um Código (int),um Nome (char) e ainda um Preço (float).
O usuário deverá ter, através de um menu, as seguintes opções:

1-Inclusão (incluir, na íntegra, um registro CD de cada vez);
2-Consulta Geral (apresentar todos os CD’s cadastrados);
3-Sair (apresentar uma mensagem de “até breve”).
Observações:
1- Inicializar todos os registros como vazios; (usar iteração for);
2- Adotar o código dos CD’s como sendo a própria posição (índice) do vetor (1 até 7);
3- O Sistema deverá ser executado até que a opção desejada seja igual a 3-Sair (usar uma iteração
do...while para isso) e não deve aceitar valores diferentes de 1, 2 ou 3 (usar default);
4- Os índices (códigos) são limitados de 1 até 7. Não deixe que sejam informados índices fora deste
intervalo e não permita a inclusão de um registro em uma posição (índice) ocupada.
- 49 -
3) Desenvolver um programa no Dev C++, completo e voltado ao usuário final, para trabalhar com um
Controle de Livraria... Serão até 7 registros de Livros... Cada registro possuirá um Código (int), um
Título (char) e ainda o Preço de cada Livro (float). O usuário deverá ter, através de um menu, as seguintes
opções: 1-Incluir (deverá ser incluído, na íntegra, um registro de cada vez); 2-Consultar (serão
apresentados todos os Livros cadastrados – somente os cadastrados); 3-Alterar (deverão ser alterados na
íntegra, os dados cadastrais de cada Livro - registro - de acordo com o código informado); 4-REMOver
(deverão ser excluídos, na íntegra, os dados cadastrais de cada Livro - registro - de acordo com o código
informado); 5-Sair (deverá ser apresentada uma mensagem de “até breve”).
Observações:
1. Inicializar todos os registros como vazios; (usar iteração for);
2. Adotar o código do Livro como sendo a própria posição do
vetor (1 até 7);
3. O Sistema deverá ser executado até que a opção desejada
seja igual a 5-Sair e não deve aceitar valores diferentes de
1, 2, 3, 4 ou 5;
4. Os índices (códigos) são limitados de 1 até 7. Não deixe que sejam informados índices fora deste
intervalo;
5. Não é permitida a inclusão de um registro em uma posição (índice) ocupada. Isso deve ser
comunicado ao usuário e a inclusão não deve ser efetuada.
6. Deve ser apresentada uma Confirmação de operação para o usuário na alteração e na exclusão dos
registros; (ex.: Deseja realmente alterar / excluir os dados do Livro ALGORITMOS S/N)
7. Deve ser apresentada também uma mensagem de “operação realizada com ou sem sucesso” após
cada, inclusão, consulta, alteração, ou exclusão de registro.
8. Não devem ser apresentados registros vazios na Consulta Geral. Apresente apenas os registros já
cadastrados.
- 50 -
Resolução do Exercício 2: (Sem bordas, janelas e refinamento estético)
/* Definição: Algoritmo Controle de 7 CDs

* Var: i e j: controlam os laços e as posições dos elementos op: opção do menu
* Funcionalidade: O usuário pode Incluir e Listar ate 7 CDs com Código, Nome e Preço
*/
#include <stdio.h>
#include <conio.h>
#include <conio.c>
main()
{
int i,j;
char op, NomeTemp[9];
struct CDS
{
int CODIGO;
char NOME[9];
float PRECO;
}
CD[8];
for (i=1; i<=7; i++) //Zerando Todos os Registros

{
CD[i].CODIGO='\0';
CD[i].NOME[0]='\0';
CD[i].PRECO='\0';
}
do
{
textcolor(BLACK);
textbackground(BLACK);
clrscr();
textcolor (WHITE);
gotoxy(27,3); printf(" CONTROLE DE CDS ");
textcolor(BLACK); textbackground(YELLOW);
gotoxy(27,5); printf(" ");
gotoxy(27,6); printf(" 1: Incluir CD ");
gotoxy(27,7); printf(" 2: Consulta Geral ");
gotoxy(27,8); printf(" 3: Sair ");
gotoxy(27,9); printf(" Opção: ");
textbackground(BLACK);textcolor(YELLOW); printf("[ ]");
gotoxy(51,9); textcolor(WHITE); op=getche();
switch(op)
{
case '1':
{
gotoxy(26,13); printf(" INCLUSAO DE CDS ");
textbackground(YELLOW);textcolor(BLACK);
gotoxy(21,15); printf("Informe o Codigo do CD [1a7]:");
textcolor(YELLOW);textbackground(BLACK);printf("[ ]");
gotoxy(51,15); textcolor(WHITE); scanf("%d",&i);
if ((CD[i].NOME[0] == '\0')&&(i<8))
{
CD[i].CODIGO = i;
textbackground(YELLOW);
- 51 -
textcolor(BLACK); gotoxy(21,17); printf("Informe o Titulo do CD......:");
textcolor(YELLOW); textbackground(BLACK); printf("[ ]");
textcolor(BLACK); gotoxy(21,19); printf("Informe o Preco do CD......:");
gotoxy(51,19); textcolor(WHITE); printf("R$ .00");
fflush(stdin); // Limpa o buffer de entrada de dados
gotoxy(51,17); gets(NomeTemp);
//Lê o conteúdo da variável NomeTemp incluindo espaços em branco
strcpy (CD[i].NOME,NomeTemp);
// Copia o conteudo da string NomeTemp para CD[i].NOME
gotoxy(54,19); scanf("%f",&CD[i].PRECO);
gotoxy(21,22); printf(" Dados Inseridos com Sucesso! ");
textbackground(BLACK); textcolor(YELLOW);
gotoxy(21,25); printf("Pressione qualquer tecla para continuar!"); getch();
}
else
{
gotoxy(21,22);
if ((CD[i].NOME[0] != '\0')&&(i<8))
printf(" Codigo Ocupado ");
else
printf(" Codigo Invalido ");
textcolor(YELLOW);
}
} break;
case '2':
{
gotoxy(26,13); printf(" LISTAGEM GERAL DE CDS ");
textbackground(YELLOW); textcolor(BLACK);
gotoxy(3,18); printf(" NOME:");
gotoxy(3,21); printf("PRECO:");
for (i=1;i<=7;i++)
{
if (CD[i].NOME[0] != '\0')
{
gotoxy(3+i*10,16); printf(" %d ",CD[i].CODIGO);
gotoxy(i*10,18); printf("%9s",CD[i].NOME);
gotoxy(i*10,21); printf("R$ %6.2f",CD[i].PRECO);
}
}
gotoxy(21,25); textbackground(BLACK); textcolor(YELLOW);
printf("Pressione qualquer tecla para continuar!"); getch();
} break;
default:
{
textcolor(YELLOW);
if (op!='3')
{
gotoxy(12,25); printf("Opcao Invalida! Pressione qualquer tecla para continuar!"); getch();
}
else
{
gotoxy(36,25); printf("Ate Logo..."); _sleep(1000);
}
}
}
}
while(op!='3');
}
- 52 -
XVI Procedimentos
Procedimentos e Funções
Levando em consideração que já sabemos que a Linguagem C é bastante funcional, veremos

agora como criar funções nos programas, fazendo com que eles fiquem mais compactos resultando no
melhor entendimento do programador.
A criação destas funções, em modo geral, pode ser expressa de acordo com a seguinte sintaxe:
[<tipo>] <nome> ([parâmetros])

[<tipos de parâmetros>];
{
[<variáveis (locais)>];
[<instruções>];
}
onde:
<tipo> tipo de dado que a função dará retorno;

<nome> o nome atribuído ao procedimento;
<parâmetros> informação opcional com as variáveis de controle da função;
<tipos de parâmetros> quando existente, necessita declarar tipo;
<variáveis> lista de variáveis locais (opcionais);
<instruções> processamento do corpo da função.
16.1 Aplicação da Função Rotina
Vamos usar como base a idéia do exercício da Inclusão e Consulta dos 7 CDs, com resolução
apresentada no último Capítulo.
Cada opção do menu (incluir e consultar) vira uma rotina que é chamada na função principal.
Outro ponto importante a ser notado é a possibilidade de desmembramento das Variáveis em

Locais e Globais. Sendo globais aquelas variáveis que servem para qualquer rotina (e/ou inclusive para o
programa principal), e como variáveis locais as que são usadas especificamente por apenas uma rotina ou
apenas pelo programa principal.
As Variáveis Globais são então declaradas antes das funções no programa, enquanto que as
variáveis locais aparecem dentro das funções que elas fazem parte especificamente.
No programa em questão, que inclui e consulta até 7 CDs, temos o desmembramento das variáveis
da seguinte forma:
A variável CD que trata do vetor de registros com Código, Nome e Preço deve ser tratada
como global, pois é usada em mais de uma rotina do programa.
As variáveis i e j, também são tratadas como globais, pois servem de variável de controle de
laços em mais de uma rotina.
A variável op, vira local do programa principal, pois só é usada na operação da estrutura caso.
O mesmo ocorre com a variável NomeTemp que passa a ser local da rotina incluir(), visto que
a mesma só é utilizada dentro desta rotina.
A seguir é apresentado o exercício da Inclusão e Consulta dos 7 CDs utilizando funções.
Utilize a mesma idéia nos exercícios 1 e 3 do Capítulo de Registros e em qualquer outra situação
que opere com menus.
- 53 -
/* Definição: Algoritmo Controle de 7 CDs
* Var: i e j: controlam os laços e as posições dos elementos op: opção do menu
* Funcionalidade: O usuário pode Incluir e Listar ate 7 CDs com Código, Nome e Preço
*/
#include <stdio.h>
#include <conio.h>
#include <conio.c>
struct CDS
{
int CODIGO;
char NOME[9];
float PRECO;
}
CD[8];
int i,j;
int incluir()
{
char NomeTemp[9];
gotoxy(26,13); printf(" INCLUSAO DE CDS ");
textbackground(YELLOW);textcolor(BLACK);
gotoxy(21,15); printf("Informe o Codigo do CD [1a7]:");
textcolor(YELLOW);textbackground(BLACK);printf("[ ]");
gotoxy(51,15); textcolor(WHITE); scanf("%d",&i);
if ((CD[i].NOME[0] == '\0')&&(i<8))
{
CD[i].CODIGO = i;
textcolor(BLACK); gotoxy(21,17); printf("Informe o Titulo do CD......:");
textbackground(YELLOW); textcolor(BLACK); gotoxy(21,19); printf("Informe o Preco do CD......:");
gotoxy(51,19); textcolor(WHITE); printf("R$ .00");
fflush(stdin); // Limpa o buffer de entrada de dados
gotoxy(51,17); gets(NomeTemp);
//Lê o conteúdo da variável NomeTemp incluindo espaços em branco
strcpy (CD[i].NOME,NomeTemp);
// Copia o conteudo da string NomeTemp para CD[i].NOME
gotoxy(54,19); scanf("%f",&CD[i].PRECO);
gotoxy(21,22); printf(" Dados Inseridos com Sucesso! ");
textbackground(BLACK); textcolor(YELLOW);
}
else
{
gotoxy(21,22);
if ((CD[i].NOME[0] != '\0')&&(i<8))
printf(" Codigo Ocupado ");
else
printf(" Codigo Invalido ");
textcolor(YELLOW);
}
}
- 54 -
int consultar()
{
gotoxy(26,13); printf(" LISTAGEM GERAL DE CDS ");
textbackground(YELLOW); textcolor (BLACK);
gotoxy(3,18); printf(" NOME:");
gotoxy(3,21); printf("PRECO:");
for (i=1;i<=7;i++)
{
if (CD[i].NOME[0] != '\0')
{
gotoxy(3+i*10,16); printf(" %d ",CD[i].CODIGO);
gotoxy(i*10,18); printf("%9s",CD[i].NOME);
gotoxy(i*10,21); printf("R$ %6.2f",CD[i].PRECO);
}
}
gotoxy(21,25); textbackground(BLACK); textcolor(YELLOW);
printf("Pressione qualquer tecla para continuar!");
getch();
}
main()
{
char op;
for (i=1; i<=7; i++) //Zerando Todos os Registros
{
CD[i].CODIGO='\0';
CD[i].NOME[0]='\0';
CD[i].PRECO='\0';
}
do
{
textcolor(BLACK); textbackground(BLACK); clrscr();
textcolor (WHITE); gotoxy(27,3); printf(" CONTROLE DE CDS ");
textcolor(BLACK); textbackground(YELLOW);
gotoxy(27,6); printf(" 1: Incluir CD ");
gotoxy(27,7); printf(" 2: Consulta Geral ");
gotoxy(27,8); printf(" 3: Sair ");
gotoxy(27,9); printf(" Opcao:");
textbackground(BLACK); textcolor(YELLOW); printf("[ ]"); gotoxy(52,9); textcolor(WHITE); op=getche();
switch(op)
{
case '1': incluir(); break;
case '2': consultar(); break;
default:
{
textcolor(YELLOW);
if (op!='3')
{
gotoxy(12,25);
printf("Opcao Invalida! Pressione qualquer tecla para continuar!"); getch();
}
else
{
gotoxy(36,25); printf("Ate Logo..."); _sleep(1000);
}
}
}
}
while(op!='3');
}
- 55 -

Apostila Dev C Rev 02-06-2009

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila Dev C Rev 02-06-2009

Enviado por

Direitos autorais:

Formatos disponíveis

+++++++++++ ÍNDICE +++++++++++

Módulo I – Lógica de Programação

Módulo II – Estruturas de Dados

Capítulo 1 Cadeia de Caracteres 56

Módulo III – Arquivos

Capítulo 1 Arquivo Texto 93

Anexo I – Exercícios Resolvidos

Anexo II – Projetos Comentados

Capítulo 1 Criptografia Simétrica 130

O desenvolvimento da linguagem C foi fortemente influenciado pela linguagem B, desenvolvida por

Em Estrutura de Dados são apresentadas as principais estruturas como: Cadeia de Caracteres,

O livro fecha com quatro projetos práticos:

criptografia assimétrica - incluindo senha privada além da senha pública já presente no

agenda - com as principais funções de uma agenda telefônica básica e

Figura 1 – Ambiente Dev C++

O pré-processador é um programa que checa o programa-fonte escrito em linguagem C e efetua no

1. A entrada dos dados;

Os computadores servem para armazenar informações e programas para sua manipulação.

5.1. Tipos de dados inteiros

int de -32.768 a 32.767

5.2 Tipos de dados reais

float de 3.4 E -38 até 3.4 E+38

5.3 Tipos de dados caracteres

5.4 Tipos de dados lógicos

O uso de comentários é de extrema importância para o programador, pois tem a finalidade de

Existem dois tipos de comentários:

6.1 Comentário do Prólogo

É colocado antes da lógica de programação e é constituído por quatro etapas:

1ª- Definição do programa

2ª- Nome do autor e datas de criação e última alteração do programa

3ª- Declarações das variáveis novas ou desconhecidas usadas no programa

4ª- Funcionalidade do Programa

6.2 Comentários Intercalares

/* Programa Soma entre 2 números

Fulano de Tal em: 04/04/1989; Ultima Alteração: 03/03/2008

N1 e N2 = Números digitados pelo usuário; S = Soma encontrada

O usuário digita 2 números e tem como resposta a soma entre eles. */

main( ) Primeira, e principal função do C.

A função main( ) é a principal instrução a ser considerada em um programa escrito na linguagem C,

Todas as informações escritas entre os delimitadores /* e */ são comentários para documentação

Normalmente, um programa em C é iniciado com as definições de pré-processamento e com a

Delimitam toda a lógica de programação escrita pelo programador.

Nomes de uma variável poderão ser atribuídos com um ou mais caracteres;

Na linguagem C, os 32 primeiros caracteres de um nome de variável são significativos, porém, se o

Uma variável é considerada Global quando é declarada no inicio de um programa escrito em C,

Ex: int IDADE;

INSS = SAL * 4.12.

9.2 Operadores Aritméticos

printf ("expressão de controle", lista de argumentos);

Veja a seguir, a tabela com os códigos de formatação para a função printf( ).

%c Permite que seja efetuada a escrita de apenas um caractere

%d Permite que seja efetuada a escrita de números inteiros decimais

%e Permite que seja efetuada a escrita de números em notação científica

%f Permite que seja efetuada a escrita de números reais (ponto flutuante)

%g Permite que seja efetuada a escrita de %e ou %f no formato mais curto

%o Permite que seja efetuada a escrita de números octais

%s Permite que seja efetuada a escrita de uma série de caracteres

%u Permite que seja efetuada a escrita de um número decimal sem sinal

%x Permite que seja efetuada a escrita de um número hexadecimal

printf (“Clube do Remo \n Campeão Brasileiro Série C 2005”);

O resultado desta operação na tela do computador seria:

A utilização destes códigos especiais tem a finalidade de auxiliar o programador na utilização de

\n Cria uma linha nova a partir do ponto que é indicado

\t Cria um espaço de tabulação do ponto que é indicado