Fundamentos de Programação
ESCOLA
Fundamentos
de Programação
1
Escola Alcides Maya - Primeiro Módulo
2
Fundamentos de Programação
Sumário
Fundamentos de Programação1
1 Introdução........................................................................................................................................ 4
2 Introdução à Linguagem C............................................................................................................. 4
3 Técnicas Básicas de Programação.................................................................................................. 8
4 Estruturas de Controle – A Tomada de Decisões........................................................................ 30
5 Estruturas de Controle – Laços de Repetição............................................................................. 43
6 Estruturas de Dados Homogêneas I............................................................................................. 52
7 Estruturas de Dados Homogêneas II........................................................................................... 59
8. Programação Estruturada .......................................................................................................... 64
3
Escola Alcides Maya - Primeiro Módulo
1 Introdução
A disciplina de Fundamentos de Programação está ligada a de Lógica de Programação e vamos aplicar as
estruturas lógicas utilizando a linguagem C.
C é uma linguagem de programação de finalidade geral. Foi criada por Dennis M. Ritchie e Ken Thompson,
na Bell Laboratories em 1972, e estava associada ao sistema operacional UNIX. A linguagem, entretanto não
está ligada a um sistema operacional, hoje usamos C em DOS, Windows e Linux.
C foi baseada na linguagem B de Thompson que era uma evolução da antiga Linguagem BCPL. B foi nomeada
com a primeira letra de BCPL e C com a segunda.
C é uma linguagem de “baixo nível”, que o deixa especificar todos os detalhes em lógica de algoritmos para
obter a máxima eficácia do computador. Mas C também é uma linguagem de alto nível que pode esconder
detalhes da arquitetura dos computadores, resultando no aumento da eficiência na programação.
C foi escrita para que o programador possa planejar programas estruturados e modulares. O resultado é
um programa mais legível e documentado. Hoje já podemos programar de forma moderna utilizando a OOP
(Programação Orientada para Objetos) e também a Programação voltada para Eventos.
O padrão ANSI C
O comitê ANSI desenvolveu padrões para a linguagem C. Diversas destas modificações tiveram a intenção
de aumentar a flexibilidade da linguagem, enquanto outras tentaram padronizar características previamente
deixadas a cargo do implementador do compilador.
Anteriormente, o único padrão era o livro: Linguagem de Programação C, de Brian Kernighan e Dennis Ritchie.
Este livro não era específico em alguns detalhes da linguagem, o que levou a divergências entre os compiladores.
O padrão ANSI tentou remover essas ambigüidades. Embora algumas das modificações propostas pudessem
causar problemas para alguns programas escritos anteriormente, elas não afetam muito o código existente. O
padrão ANSI C proporciona uma oportunidade melhor para escrever um código C portátil. Entretanto, o padrão
não corrige todas as áreas de confusão e, por causa da eficiência da interface da linguagem C, com o hardware
da máquina, muitos programas sempre exigirão algumas revisões quando você os mover para um ambiente
diferente.
2 Introdução à Linguagem C
Vamos agora ver alguns detalhes iniciais da linguagem.
Primeiro programa em C
Iniciaremos nosso estudo com um programa simples, que apenas escreve na tela de seu computador a frase:
“Meu primeiro programa”. Veja, abaixo, como é o programa:
main( )
{
printf (“Meu primeiro programa” );
}
Agora algumas considerações sobre o programa acima:
• Um programa em C consiste de uma ou mais funções que especificam o que deve ser feito. No exemplo
acima main( ) é uma função. Qualquer programa em C começa com a função main( ) que marca o ponto inicial
da execução do programa.
• Todas as instruções devem estar dentro das chaves que iniciam e terminam a função, elas têm a mesma
função que o begin e end em Pascal.
4
Fundamentos de Programação
• A linha: printf (“Meu primeiro programa”); é uma chamada a função printf, com o argumento “Meu primeiro
programa”, que é uma seqüência de caracteres entre aspas “. . . “, chamada de: cadeia de caracteres, ou também
string. A printf é uma função de biblioteca que escreve o argumento na tela do seu computador. Os parênteses
devem estar presentes mesmo quando não há argumentos.
• As instruções C são sempre encerradas por um ponto-e-vírgula (;).
Limpando a tela
Seria interessante você colocar uma função para limpar a tela, antes de escrever a mensagem: “Meu primeiro
programa”. Para fazer isto podemos utilizar a função clrscr( ) que serve para este propósito. Veja as alterações
feitas no programa abaixo:
main( )
{
clrscr( );
printf (“Meu primeiro programa” );
}
A Função printf( )
A função printf( ) é uma das funções de E/S (entrada e saída) que podem ser usadas em C. Ela não faz parte
da definição de C, mas todos os sistemas têm uma versão de printf( ) implementada.
Os parênteses indicam que estamos em uma função. Entre os parênteses estão as informações que são
passadas pelo programa main( ) para a função printf( ), isto é “Meu primeiro programa”. Esta informação é
chamada de argumento.
Quando o programa encontra esta linha, passa o controle para a função printf( ) que imprime na tela do seu
computador “Meu primeiro programa” e, quando encerra a execução, o controle é transferido novamente para a
função main. Vamos ver o próximo exemplo:
main( )
{
clrscr( );
printf(“Escola Técnica Alcides Maya\n”);
printf(“Estamos na etapa número: 2”);
}
A função printf( ) pode ter um ou vários argumentos. Na primeira printf temos o seguinte argumento: “Escola
Técnica Alcides Maya\n” onde encontramos a string: Escola Técnica Alcides Maya, e também os caracteres
“\n”.
Este caractere \n é a notação C para o caractere de nova-linha, que provoca o avanço do cursor para o início
da próxima linha. Se você omitir o \n, você verá como resultado as duas string´s escritas em apenas uma linha
na tela.
Além do caractere \n temos outros caracteres que estão na tabela abaixo:
Código
Significado
\n
Nova linha
\t
Tabulação
\b
Retrocesso
\”
Aspas
\\
Barra
5
Escola Alcides Maya - Primeiro Módulo
Formato inteiro decimal
Veja as alterações que fizemos no programa anterior:
main( )
{
clrscr( );
printf(“Escola Técnica Alcides Maya\n”);
printf(“Estamos na etapa número: %d” , 2);
}
Agora, colocamos dois argumentos na segunda printf: “Estamos na etapa número: %d” , 2
Estes dois argumentos são separados por uma virgula.
A expressão de controle pode conter caracteres que serão exibidos na tela e códigos de formatação que
indicam o formato em que os argumentos devem ser impressos.
No exemplo o código de formatação %d solicita a printf( ) imprimir o segundo argumento no formato de um
número inteiro decimal.
Escrevendo uma string na tela
Além do código de formatação decimal (%d), existe outros. No exemplo a seguir veremos o uso do código %s
para escrever na tela uma string.
main( )
{
clrscr( );
printf(“O %s é um dos melhores transportes urbanos”, “Metrô”);
}
Vamos agora escrever um programa com mais de uma instrução:
main( )
{
clrscr( );
printf(“O %s venceu de %d gols de diferença contra o time adversário”, “Inter” , 4);
}
Neste exemplo passamos dois argumentos para a função printf o %s do nome do time: “Inter” e o %d da
quantidade de gols: 4.
Vejamos o próximo exemplo:
main( )
{
clrscr( );
printf(“A letra %c ”, ´x´);
printf(“pronuncia-se %s.”, “xis” );
}
Note que o ´x´ é delimitado por aspas simples enquanto que “xis” é delimitado por aspas duplas. Isto indica
ao compilador como diferenciar um caractere de uma string.
6
Fundamentos de Programação
A tabela, a seguir, mostra os códigos para impressão formatada de printf( );
Código
Significado
%c
Caracteres simples
%d
Decimal
%f
Ponto flutuante
%s
String de caracteres
%u
Decimal sem sinal
%x
Hexadecimal
Exercícios de Fixação
Vamos agora realizar alguns exercícios de fixação para sedimentar em nossa mente os conhecimentos
adquiridos:
1. No programa abaixo há alguns problemas, faça as correções necessárias.
main( )
(
clrscr( )
printf(Temos %d aulas no semestre, 33 );
)
2. Qual será o resultado do programa abaixo:
main( )
(
clrscr( )
printf(“As notas escolares são: %d %d %d\n” , 4, 7, 9);
)
3. Neste outro programa o que será apresentado na tela do computador:
main( )
(
clrscr( )
printf(“%s \n %s \n %s” , “Escola”, “Técnica”,”Alcides Maya” );
)
4. Faça um programa que contenha uma única instrução e escreva na tela:
Esta é a primeira linha.
Esta já é a segunda linha.
7
Escola Alcides Maya - Primeiro Módulo
5. Escreva um programa que escreva na tela:
UM
DOIS
TRES
QUATRO
6. Qual será a impressão obtida na tela por cada uma destas instruções? Assuma que fazem parte de um
programa completo.
a) printf (“Boa Tarde ! Maria.”);
printf (“Você já lanchou ? \n”);
b) printf(“Escola Técnica\nAlcides Maya\n”);
8. Faça um programa que escreva na tela o teu nome, o nome da tua mãe e o nome da tua avó, todos em
linhas diferentes na tela. (Use o \n).
9. Faça um programa que escreva na tela uma mensagem do tipo: “Eu tenho 23 anos”, sendo que a idade
deverá ser um argumento do tipo inteiro decimal. (Use o %d).
10. Faça um programa que numere as linhas da tela (cada linha com um número).
3 Técnicas Básicas de Programação
A partir deste momento vamos ter um contato direto com a parte pratica da Lógica de Programação.
Variáveis
O computador possui uma área de armazenamento temporária conhecida como memória. A memória do
computador pode ser entendida como uma seqüência finita de caixas, que num dado momento, guardam algum
tipo de informação, como um número, uma letra, uma palavra, uma frase, etc, não importa, basta saber que lá
sempre existe alguma informação.
O computador, para poder trabalhar com algumas destas informações, precisa saber onde, na memória, o
dado está localizado.
Fisicamente, cada caixa, ou cada posição de memória, possui um endereço, ou seja, um número, que indica
onde cada informação está localizada, este número é representado através da notação hexadecimal, tendo o
tamanho de quatro, ou mais bytes. Abaixo segue alguns exemplos:
Endereço Físico
Informação
3000:B712
“João”
2000:12EC
45
3000:0004
‘J’
Como pode ser observado, o endereçamento das posições de memória através de números hexadecimais é
perfeitamente compreendido pela máquina, mas para nós humanos torna-se uma tarefa complicada.
Pensando nisto, as linguagens de computador facilitaram o manuseio, por parte dos programadores, das
posições de memória da máquina, permitindo, que, ao invés de trabalhar diretamente com o número hexadecimal,
fosse possível dar nomes diferentes a cada posição de memória.
Tais nomes seriam de livre escolha do programador.
Com este recurso, os programadores ficaram livres dos endereços físicos (números hexadecimais) e passaram
a trabalhar com endereços lógicos (nomes dados pelos próprios programadores).
8
Fundamentos de Programação
Desta forma, o exemplo acima, poderia ser alterado para ter o seguinte aspecto:
Endereço Físico
Informação
Cliente
“João”
Idade
45
Inicial
‘J’
Como tínhamos dito, os endereços lógicos são como caixas, que num dado instante guardam algum tipo de
informação. Mas é importante saber que o conteúdo desta caixa não é algo fixo, permanente, na verdade, uma
caixa pode conter diversas informações, ou seja, como no exemplo acima, a caixa (endereço lógico) rotulada de
“Cliente” num dado momento contém a informação “João”, mas em um outro momento, poderá conter uma outra
informação, por exemplo “Pedro”.
Com isto queremos dizer que o conteúdo destas caixas (endereço lógico) podem variar, isto é, podem sofrer
alterações em seu conteúdo.
Tendo este conceito em mente, a partir de agora iremos chamar as caixas ou endereços lógicos, de
Variáveis.
Desta forma podemos dizer que uma variável é uma posição de memória representada por um Nome simbólico
(atribuído pelo programador), a qual contém, num dado instante uma informação.
Variáveis na linguagem C
Uma variável em C é um espaço de memória reservado para armazenar um certo tipo de dado com um nome
para referenciar o seu conteúdo.
Em um programa a variável poderá conter um valor em um determinado momento e um outro valor em outro
momento. Veja o programa a seguir:
main( )
{
int num;
num = 2;
printf(“Este é o número: %d \n” , num);
num = 5 + 10;
printf(“Este é o número: %d \n” , num);
}
Agora algumas considerações sobre o programa acima:
• Na linha int num; é a declaração da variável, que tem nome: num e tipo: int, ou seja, irá armazenar valores
numéricos inteiros.
• Na linha num = 2; estamos atribuindo a variável o valor 2 (dois), portanto o endereço de memória
identificado como num contém neste instante o número 2 (dois).
• Na linha printf(“Este é o número: %d \n” , num); estamos apresentado o conteúdo desta variável.
• Na linha num = 5 + 10; estamos efetuando um cálculo e atribuindo a variável o resultado deste cálculo,
portanto a variável num contém neste instante o número 15 (quinze).
• Na linha printf(“Este é o número: %d \n” , num); estamos apresentando o conteúdo desta variável.
9
Escola Alcides Maya - Primeiro Módulo
Nomes das variáveis
Para nomearmos variáveis, geralmente, seguimos algumas regras, que, conforme o livro Linguagem de
Programação C, de Brian Kernighan e Dennis Ritchie, elas seriam as seguintes:
• Os nomes das variáveis são construídos com letras e dígitos.
• O primeiro caractere deve ser uma letra.
• O caractere de sublinha “_” vale como uma letra; ele é útil para aumentar a clareza de nomes muito longos
de variáveis. Exemplo: data_de_nascimento.
• Letras em maiúsculo e minúsculo são diferentes; uma prática tradicional em C é de usar letras minúsculas
para vaiáveis. CASA, Casa, casa, representam variáveis diferentes.
• Somente os primeiros oito caracteres de um nome interno são significativos, embora mais caracteres
possam ser usados.
• Naturalmente é melhor escolher nomes de variáveis que tenham algum significado, que estejam
relacionados com a finalidade da variável, e que sejam diferenciados tipograficamente.
Declarações das variáveis
Na declaração de uma variável instruímos ao programa reservar uma quantidade de memória apropriada
para armazenar o tipo especificado e indicar que o seu conteúdo será referenciado pelo nome dado.
Se você tiver mais de uma variável do mesmo tipo, poderá declará-las de uma única vez, separando seus
nomes por virgulas.
int idade, casa, livro;
O local indicado para declarar as variáveis é logo após a chave inicial da função main, veja o exemplo
abaixo:
main( )
{
int num, nota1, nota2, nota3, nota4, media;
.
.
.
.
.
}
Antes de prosseguir, temos uma observação importante: “Em C todas as variáveis devem ser declaradas
antes de serem utilizadas”.
Tipos de variáveis
O tipo de uma variável informa a quantidade de memória, em bytes, que está irá ocupar.
Tipo
Bit
Bytes
Escala
char
8
1
-128 a 127
int
16
2
-32768 a 32767
float
32
4
3.4 E -38 a 3.4 E +38
double
64
8
1.7 E -308 a 1.7 E +308
O tipo char é capaz de conter um caractere. O tipo int poderá conter números inteiros (ex.: 35, 0, -56) e o tipo
float e double poderá conter números reais (35, 0, -56, 1.2, -45.897).
10
Fundamentos de Programação
C provê os modificadores de tipo como o short que é um inteiro curto que varia de –32.763 até 32.762 e
também o long que é um inteiro longo e que varia de –2.147.483.648 até 2.147.483.647.
main( )
{
int idade;
char inicial;
float tempo;
idade = 25;
inicial = ´C´;
tempo = 17.25;
printf(“A inicial do meu nome é: %c \n” , inicial);
printf(“Minha idade é: %d anos\n” , idade);
printf(“Meu tempo na prova foi de %f minutos \n” , tempo);
}
Agora algumas considerações sobre o programa anterior:
• Na linha int idade; é a variável, do tipo inteiro, que irá conter a idade.
• Na linha char inicial; é a variável, do tipo caractere, que irá conter a letra inicial de um nome.
• Na linha float tempo; é a variável, do tipo ponto flutuante, que irá conter o tempo em minutos.
• Na linha idade = 25; é a inicialização da variável idade.
• Na linha inicial = ’C’; é a inicialização da variável inicial.
• Na linha tempo = 17.25; é a inicialização da variável tempo.
• Na linha printf(“A inicial do meu nome é: %c \n” , inicial); é a apresentação do conteúdo da variável
inicial.
• Na linha printf(“Minha idade é: %d anos\n” , idade); é a apresentação do conteúdo da variável idade.
• Na linha printf(“Meu tempo na prova foi de %f minutos \n” , tempo); é a apresentação do conteúdo da
variável tempo.
Operadores
Veremos agora o conteúdo relacionado a operadores aritméticos e operadores de atribuição.
C é uma linguagem rica em operadores. Alguns são mais usados que outros, como é o caso dos operadores
aritméticos que executam operações aritméticas.
Operadores aritméticos
Para efetuar cálculos matemáticos temos os seguintes operadores aritméticos:
Operador
Ação
Exemplo
Resultado
-
Subtração
5–1
4
+
Adição
5+1
6
*
Multiplicação
5*2
10
/
Divisão
10 / 2
5
%
Resto da divisão
11%2
1
11
Escola Alcides Maya - Primeiro Módulo
Operador de atribuição
Em C, o sinal de igual não tem a interpretação dada em matemática. Representa a atribuição da expressão
à direita ao nome da variável à esquerda. Por exemplo:
num = 2000;
atribui o valor 2000 a variável num. A ação é executada da direita para a esquerda deste operador.
C aceita várias atribuições numa mesma instrução:
laranjas = bergamotas = cenouras = abacates = 80;
A seguir temos um programa que usa vários operadores aritméticos e converte temperatura Fahrenheit em
seu correspondente Celsius.
main( )
{
float ftemp, ctemp;
ftemp = 120;
ctemp = ( ftemp – 32.0 ) * ( 5.0 / 9.0 );
printf(“Temperatura em graus Celsius é: %f” , ctemp);
}
Agora algumas considerações sobre o programa acima:
• Na linha float ftemp, ctemp; é a declaração de duas variáveis, do tipo float, que irá conter a temperatura
em graus Fahrenheit e Celsius.
• Na linha ftemp = 120; estamos utilizando o operador de atribuição que armazena a temperatura de 120
graus Fahrenheit na variável ftemp.
• Na linha ctemp = ( ftemp – 32.0 ) * ( 5.0 / 9.0 ); estamos efetuando o cálculo de conversão da temperatura
em Fahrenheit para Celsius e atribuindo o resultado do cálculo para a variável ctemp. Note que colocamos
parênteses em ftemp – 32.0. Se você lembra um pouco de álgebra, a razão estará clara. Nós queremos que 32
seja subtraído de ftemp antes de multiplicarmos por 5 e dividirmos por 9. A multiplicação e a divisão são feitas
antes da soma ou subtração.
• Na linha printf(“Temperatura em graus Celsius é: %f” , ctemp); estamos apresentando o resultado do
cálculo.
12
Fundamentos de Programação
Comentários
Comentários podem ser colocados em qualquer lugar de seu programa. Comentários são recomendados
para documentar a lógica utilizada no programa. Tudo que começa com dois caracteres, chamados símbolos de
comentários, barra-asterisco (/*) e terminam por asterisco-barra (*/), são comentários e o conteúdo entre eles
não será verificado pelo compilador.
No programa abaixo mostraremos vários comentários:
/* Exercício 015
* Este programa calcula
* a idade de uma pessoa
* em dias
*/
main( )
{
float anos, dias;
/* declaração de variáveis */
anos = 12;
/* inicializa a variável anos */
dias = anos * 365;
/*calcula idade em dias*/
printf(“A idade em dias é: %f \n” , dias); /* apresentar o resultado */
}
Exercícios de Fixação
1. Faça um programa que armazene a quilometragem inicial de um carro. Depois de uma viagem, armazenar
a quilometragem final do carro. Calcular e apresentar a distância percorrida pelo carro.
2. Faça um programa que armazene as notas de um aluno (serão 4 notas, portanto, teremos 4 variáveis).
Calcule a média do aluno e armazene em uma variável, depois apresente a média do aluno (use variáveis do tipo
inteiro).
3. Faça um programa que armazene as notas de um aluno (serão 4 notas, portanto, teremos 4 variáveis).
Calcule a média do aluno e armazene em uma variável, depois apresente a média do aluno (use variáveis do tipo
ponto flutuante).
4. Faça um programa que calcule e apresente o valor do volume de uma lata de óleo, utilizando a fórmula:
volume = 3.14159 * raio² * altura. Obs.: Atribua valores a variável raio e altura.
5. Faça um programa que calcule e apresente o volume de uma caixa retangular, por meio da fórmula:
volume = comprimento * largura * altura. Obs.: Atribua valores a variável comprimento, largura e altura.
6. Faça um programa que leia dois valores inteiros para as variáveis A e B, e efetuar a troca dos valores de
forma que a variável A passe a possuir o valor da variável B e a variável B passe a possuir o valor da variável A.
Apresentar na tela os novos valores das variáveis A e B.
7. Faça um programa que leia quatro números inteiros e apresentar o resultado da adição destes números.
(A + B + C + D)
8. Faça um programa que leia quatro números inteiros e apresentar o resultado da multiplicação destes
números. (A * B * C * D)
13
Escola Alcides Maya - Primeiro Módulo
9. Indique com um X quais dos dados abaixo são do tipo inteiro.
( ) 1000
( ) “0”
( ) “-900”
( ) -456
( ) 34
( ) ‘C’
( )0
( ) –1.56
( ) 34.76
10. Indique com um X quais dos dados abaixo são do tipo float.
( ) -678
( ) “0.87”
( ) 99.8
( ) “cinco”
( ) 34
( ) ‘C’
( ) 45.8976
( ) –1.56
( ) 34.76
Funções de Entrada e Saída
O computador não é uma máquina isolada, pois ele precisa se comunicar com o mundo exterior, com
vídeo, impressora, teclado, discos, fitas, etc. Para realizar esta comunicação existem comandos que permitem
que informações sejam exibidas, por exemplo, no vídeo, como também existem comandos que permitem que
informações sejam colocadas na memória do computador através do teclado do PC.
Os comandos que iremos ver são os comandos para LER e ESCREVER, respectivamente, comando de
entrada e de saída.
Entrada, Processamento e Saída
Para criar um programa que seja executável dentro de um computador, deve-se ter em mente três coisas: a
entrada de dados, o seu processamento e a saída deles.
Sendo assim, todo programa estará trabalhando com estes três conceitos. Se os dados forem entrados de
forma errada, serão conseqüentemente processados de forma errada e resultarão em respostas erradas.
Desta forma, dizer a alguém que foi erro do computador é ser um tanto “medíocre”. E isto é o que mais
ouvimos quando nosso saldo está errado e vamos ao banco fazer uma reclamação ou quando recebemos uma
cobrança indevida. Se houve algum erro, é porque foi causado por falha humana. Realmente é impossível um
computador errar por vontade própria, pois vontade é uma coisa que os computadores não têm.
O processo de execução de um programa ocorre segundo o exposto, após a entrada de dados com a
instrução leia e a sua saída com a instrução escreva. O processamento será uma conseqüência da manipulação
das variáveis de ação.
Uma entrada e uma saída poderá ocorrer dentro de um computador de diversas formas. Por exemplo, uma
entrada poderá ser feita via teclado. Uma saída poderá ser feita em vídeo.
As funções de biblioteca da linguagem C, mais comuns para a entrada e saída de dados são a printf() e a
scanf().
14
Fundamentos de Programação
A função printf( )
A função printf( ) é uma das funções de saída de dados da linguagem C, que você já utilizou na Aula 1.
A função scanf( )
A função scanf( ) é o complemento de printf( ) e nos permite fazer a entrada de dados do teclado.
Sua sintaxe é uma expressão de controle seguida por uma lista de argumentos separados por virgulas. Os
argumentos de scanf( ) devem ser endereços de variáveis, cuja sintaxe será apresentada a seguir:
scanf( “expressão de controle”, lista de argumentos);
A expressão de controle contem códigos de formatação, sempre precedida por um sinal de %
(percentagem).
A lista de argumentos deve consistir nos endereços das variáveis, onde serão armazenados os valores lidos.
C oferece um operador para tipos básicos chamados operador de endereço e referenciado pelo símbolo & que
retorna o endereço do operando, voltaremos a este assunto quando será abordado a aula de pointers.
Para exemplificar o que estamos apresentando, veremos no programa a apresentação do conteúdo
armazenado em uma variável e o endereço da variável.
main( )
{
int num;
num = 2;
printf(“Conteúdo da variável.......: %d \n” , num);
printf(“Endereço Decimal............: %u \n” , &num);
printf(“Endereço HexaDecimal....: %u \n” , &num);
}
Agora algumas considerações sobre o programa acima:
• Na declaração int num; estamos declarando a variável inteira num.
• Na linha seguinte num = 2; estamos inicializando a variável com o número inteiro 2.
• Na linha printf(“Conteúdo da variável.......: %d \n” , num); a função printf vai apresentar o conteúdo da
variável através do código de formatação “%d” e na linha seguinte, através do código “%u” o endereço da variável
num. Repare que o nome da variável vem precedido do caractere “&”, indicando que é o endereço da variável.
Um endereço de memória é visto como um número inteiro sem sinal, por isso usamos o “%u”.
Mas o que este programa tem a ver com a entrada de dados?
Nada, apenas estamos apresentando a você o endereço da variável, já que para ler um valor para uma
variável, utilizando a função scanf, temos que informar o endereço da variável.
No programa abaixo, ao invés de inicializar o valor da variável, como em num = 2; vamos ler um número
qualquer e depois apresentá-lo.
main( )
{
int num;
printf(“Digite um número: “);
scanf(“%d” , &num);
15
Escola Alcides Maya - Primeiro Módulo
printf(“O número digitado foi: %d “ , num);
}
Agora algumas considerações sobre o programa acima:
• Na declaração int num; estamos declarando a variável inteira num.
• Na linha printf(“Digite um número: “); informamos ao usuário que ele deverá digitar um número.
• Na linha seguinte scanf(“%d” , &num); estamos esperando que o usuário digite um número inteiro e
pressione a tecla ENTER. Nunca esqueça que ao usar a função scanf você deve informar o endereço da variável
para onde vamos ler alguma coisa, caso contrário você terá surpresas desagradáveis no teu programa.
• Na última linha printf(“O número digitado foi: %d “ , num); a função printf vai apresentar o conteúdo da
variável num.
Veja na tabela a seguir os códigos básicos de formatação da função scanf( )
Código
Função
%c
Leia um único caractere
%d
Leia um inteiro decimal
%f
Leia um número em ponto flutuante
Agora vamos fazer um exemplo ligeiramente mais difícil. O próximo programa pede ao usuário o comprimento
em “jardas”, e então escreve na tela o valor convertido em “pés” e “polegadas”.
main( )
{
int jardas, pes, polegadas;
printf(“Digite o comprimento a ser convertido: “);
scanf(“%d” , &jardas);
/* entrada de dados */
polegadas = 36 * jardas;
pes = 3 * jardas;
/* processamento */
printf(“ %d jardas = %d pés \n” , jardas, pés );
/* saída de dados */
printf(“ %d jardas = %d polegadas \n” , jardas, polegadas );
}
Agora algumas considerações sobre o programa acima:
• Na declaração int jardas, pes, polegadas; estamos declarando as variáveis inteiras jardas, pés,
polegadas.
• Na linha printf(“Digite o comprimento a ser convertido: “); solicitamos ao usuário que ele deverá digitar um
comprimento.
• Na linha seguinte scanf(“%d” , &jardas); estamos esperando que o usuário digite um número inteiro e
pressione a tecla ENTER. Este número será armazenado na variável: jardas.
• Nas duas linhas seguintes: polegadas = 36 * jardas; e na linha pes = 3 * jardas; estamos calculando a
conversão de jardas em polegadas e a conversão de jardas em pés.
• E, finalmente nas duas últimas chamadas a função printf, estamos apresentando o resultado das
conversões realizadas.
16
Fundamentos de Programação
Observação importante: veja como ficaram visíveis, neste programa, as três partes básicas do processamento
de dados: entrada, processamento e saída, destacadas no programa através dos comentários.
Se em cada programa, nos concentrássemos nestas partes básicas, já teríamos metade da solução do
programa resolvida. Veja o exemplo a seguir:
Exemplo – Faça um programa que leia um número inteiro qualquer, que representa o comprimento em jardas.
Sabendo-se que esta medida de comprimento poderá ser transformada em polegadas multiplicando-se pelo
número 36, e que poderá ser transformada em pés multiplicando-se pelo número 3, calcular e apresentar este
valor convertido em pés e polegadas.
Conforme o enunciado do programa devemos procurar identificar os elementos básicos do processamento
de dados, ou seja, a entrada, o processamento e a saída de dados, fazendo algumas perguntas. Veja abaixo:
Entrada de dados
Pergunta: O que devemos ler?
Resposta: Um número inteiro que represente o comprimento em jardas.
Pergunta: Temos que ler mais alguma coisa?
Resposta: Não
Processamento de dados
Pergunta: O que devemos fazer com esta informação lida?
Resposta: Calcular a conversão de jardas para polegadas e pés.
Pergunta: Como fazemos isto?
Resposta: Matematicamente 1 jarda corresponde a 3 pés e 1 jarda corresponde a 36 polegadas.
Devemos multiplicar o valor lido por 3 e obteremos a quantidade de pés.
Também, multiplicar o valor lido por 36 e obteremos a quantidade de polegadas.
Pergunta: Tem mais algum calculo para fazer?
Resposta: Não
Saída de dados
Pergunta: Depois de calcular a conversão o que devemos fazer?
Resposta: Apresentar os valores convertidos.
Pergunta: Tem mais alguma coisa para apresentar?
Resposta: Não
Podemos então encerrar o programa.
Estas são algumas considerações importantes, mas gostaria de ressaltar o seguinte:
“Se todos os programadores fizessem o algoritmo do programa, antes de começar a codificar o programa,
muitas dores de cabeça e tempo perdidos seriam eliminados, pois encontrar um erro de sintaxe da linguagem é
fácil, mas encontrar um erro de lógica no programa é 10 vezes mais difícil”.
Se você é um programador experiente, antes de codificar o programa, você faz o algoritmo, e ao fazelo você estará identificando, automaticamente os elementos do processamento de dados, que é a entrada o
processamento e a saída.
17
Escola Alcides Maya - Primeiro Módulo
Exercícios de Fixação
Desenvolva os exercícios abaixo:
1. Faça um programa que leia e armazene em variáveis dois números inteiros quaisquer. Calcular e apresentar
a soma entre eles.
2. Faça um programa que leia e armazene em variáveis dois números em ponto flutuantes. Calcular e
apresentar a diferença entre eles.
3. Faça um programa que leia e armazene dois números quaisquer. Calcular e apresentar o produto entre
eles.
4. Faça um programa que leia e armazene em variáveis dois números inteiros quaisquer. Calcular e apresentar
o resto da divisão de um pelo outro.
5. Faça um programa que leia um número do tipo ponto flutuante e outro número inteiro. Calcular e apresentar
a divisão do número do tipo ponto flutuante pelo número inteiro.
6. Faça um programa que leia e armazene em variáveis quatro notas escolares (entre 0 e 10) de um aluno.
Calcular e apresentar a média final do aluno.
7. Faça um programa que leia e armazene em variáveis uma letra e um número. No final apresentar a letra
e o número lido.
8. Faça um programa que leia e armazene a idade de uma pessoa em anos. Calcular e apresentar a
quantidade de dias, a quantidade de horas, a quantidade de minutos e de segundos desde o nascimento.
9. Faça um programa que leia a receita e a despesa de uma empresa. Calcular e apresentar o seu lucro.
10. Faça um programa que leia o número de identificação de um funcionário, o seu número de horas
trabalhadas no mês, o valor que recebe por hora. Calcular o salário total deste funcionário, sabendo-se que ele
é pago para trabalhar por hora. No final apresentar o salário total deste funcionário.
Exemplos de Aula
Na disciplina de lógica apresentamos alguns exemplos de aula que agora reproduzimos escritos em linguagem
C para que você possa fazer uma comparação entre eles.
Primeiro exemplo
Desenvolver um programa que efetue o cálculo da área de uma circunferência, apresentando a área
calculada.
Algoritmo
Para efetuar o cálculo da área de uma circunferência é necessário conhecer a fórmula que executa este
cálculo sendo esta: A = pR², em que A é a variável que conterá o resultado do cálculo da área, p é o valor de pi
(3.14159), sendo uma constante na fórmula) e R o valor do raio. Sendo assim, basta estabelecer:
1 – Ler um valor para o raio, no caso a variável R;
2 – Estabelecer que PI possui o valor 3,14159;
3 – Efetuar o cálculo da área, elevando ao quadrado o valor de R e multiplicando por PI;
4 – Apresentar o valor da variável A.
A fórmula para o cálculo da área passará a ser escrita como: A  3.14159 * R h 2 ou se você preferir poderá
escrever da seguinte forma: A  3.14159 * R * R.
18
Fundamentos de Programação
Codificação em Linguagem C
main( )
{
float A,R;
clrscr( );
printf ( “Digite o raio da circunferência: “ );
scanf ( “%f”, &R );
A = 3.14159 * R * R;
printf ( “A área da circunferência e: %f”, A );
getch( );
}
Segundo exemplo
Construir um programa que efetue o cálculo do salário líquido de um professor. Para fazer este programa, você
deverá possuir alguns dados, tais como: valor da hora aula, número de horas trabalhadas no mês e percentual de
desconto do INSS. Em primeiro lugar, deve-se estabelecer qual será o seu salário bruto para efetuar o desconto
e ter o valor do salário líquido.
Algoritmo
1 – Estabelecer a leitura da variável HT (Horas trabalhadas no mês);
2 – Estabelecer a leitura da variável VH (valor hora aula);
3 – Estabelecer a leitura da variável PD (Percentual de desconto de INSS);
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 líquido (SL), deduzindo o desconto do salário bruto;
7 – Apresentar os valores dos salários bruto e líquido: SB e SL.
Codificação em Linguagem C
main( )
{
int HT;
float VH, PD, TD, SB, SL;
clrscr( );
printf(“Digite a quantidade de horas trabalhadas no mes: “);
scanf(“%d”, &HT);
printf(“Digite o valor da hora aula: “);
scanf(“%f”, &VH);
printf(“Digite o percentual de desconto do INSS: “);
scanf(“%f”, &PD);
SB = HT * VH;
TD = (PD/100) * SB;
19
Escola Alcides Maya - Primeiro Módulo
SL = SB - TD;
printf(“O valor do salario bruto e.....: %12.2f\n”, SB);
printf(“O valor do salario liquido e...: %12.2f\n”, SL);
getch( );
}
Exercícios de Aula
Abaixo são apresentados exercícios, sugiro que você os faça sem ver a solução pronta do mesmo, utilize a
solução para verificar se você fez corretamente.
Primeiro exercício
Desenvolver um programa que leia dois valores numéricos e apresente o resultado da soma dos quadrados
dos valores lidos.
Algoritmo
1 – Ler um valor para a variável A e outro para a variável B;
2 – Efetuar o cálculo do quadrado dos valores lidos, atribuindo os resultados as variáveis QA e QB;
3 – Somar o quadrado dos valores lidos atribuindo o resultado a variável R;
4 – Apresentar o valor da variável R.
Codificação em Linguagem C
main( )
{
int A, B, QA, QB, R;
clrscr( );
printf(“Digite um numero..................: “);
scanf(“%d”, &A);
printf(“Digite outro numero..............: “);
scanf(“%d”, &B);
QA = A * A;
QB = B * B;
R = QA + QB;
printf(“A soma dos quadrados e.....: %d”, R);
getch( );
}
Segundo exercício
Desenvolver um programa que apresente o resultado do cálculo da área de um trapézio.
Algoritmo
O cálculo da área do trapézio é: área = ( bMaior + bMenor * altura ) / 2, então:
20
Fundamentos de Programação
1 – Ler um valor para a base maior atribuindo a variável bMaior;
2 – Ler um valor para a base menor atribuindo a variável bMenor;
3 – Ler um valor para a altura atribuindo a variável altura;
4 – Efetuar o cálculo da área atribuindo a variável area;
5 – Apresentar o valor da variável area.
Codificação em Linguagem C
main( )
{
float area, bMaior, bMenor, altura;
clrscr( );
printf(“Digite o valor da base Maior...: “);
scanf(“%f”, &bMaior);
printf(“Digite o valor da base Menor...: “);
scanf(“%f”, &bMenor);
printf(“Digite o valor da altura.......: “);
scanf(“%f”, &altura);
area = ((bMaior + bMenor) * altura) / 2;
printf(“A area do trapezio e...........: %5.2f”, area);
getch( );
}
Detalhes adicionais da Linguagem C
Veremos agora alguns detalhes interessantes da Linguagem C.
Operadores
Já tínhamos visto os operadores aritméticos e de atribuição. Vamos agora complementar o assunto vendo os
operadores de incremento e decremento, os operadores aritméticos de atribuição e os operadores relacionais.
Operadores de incremento (+ +) e decremento (--)
O operador de incremento (+ +) incrementa de um seu operando, ou seja, ele obtém o valor do operando e
acrescenta um a este valor, é o somar mais um.
Em um primeiro instante isto parece uma coisa difícil de se entender, mas analise o programa abaixo e verás
que é muito fácil.
main( )
{
int num;
num = 2;
printf(“Valor inicial = %d \n” , num);
num = num + 1;
printf(“Novo valor = %d \n” , num);
}
21
Escola Alcides Maya - Primeiro Módulo
Agora algumas considerações sobre o programa acima:
• Na declaração int num; estamos declarando a variável inteira num. Na linha seguinte num = 2; estamos
inicializando a variável com o número inteiro 2.
• Na próxima linha printf(“Valor inicial = %d \n” , num); está sendo apresentado o valor inicial da variável
num.
• Na linha num = num + 1; estamos somando um ao valor inicial da variável num, e é isto que chamamos
de incrementar (somar um), e então na última linha apresentamos o valor final de num que deverá ser: “três”
Agora veja o mesmo programa, mas utilizando o operador de incremento.
main( )
{
int num;
num = 2;
printf(“Valor inicial = %d \n” , num);
num++;
printf(“Novo valor = %d \n” , num);
}
Agora algumas considerações sobre o programa acima:
• A única diferença deste programa para o anterior é a linha num++; onde estamos somando um ao valor
inicial da variável num.
Mas, haveria uma outra forma de escrever o mesmo programa, veja as alterações a seguir:
main( )
{
int num;
num = 2;
printf(“Valor inicial = %d \n” , num++ );
printf(“Novo valor = %d \n” , num);
}
Encontrou as diferenças?
• Neste programa apagamos a linha num++; porque colocamos o incremento na linha anterior printf(“Valor
inicial = %d \n” , num++ ); onde você deve notar que ao final da printf estamos usando o incremento do num++.
Você deve estar se perguntando: “Mas não seria apresentado o valor 3 já na primeira printf?” E a resposta é:
“Não, estamos usando a regra de precedência, neste programa primeiro ele apresenta o valor de num para
depois incrementa-lo”.
Este operador trabalha de dois modos. O primeiro modo é chamado pré-fixado e o operador aparece antes do
nome da variável. O segundo modo é o pós-fixado em que o operador aparece seguindo o nome da variável.
Em ambos os casos, a variável é incrementada. Porém quando ++num é usado numa instrução, num e
incrementada antes de seu valor ser usado, e quando num++ estiver numa instrução, num é incrementada
depois de seu valor ser usado. Veja o exemplo a seguir.
22
Fundamentos de Programação
main( )
{
int n,x;
n = 5;
x = n++;
printf(“Valor de x = %d \n” , x);
printf(“Valor de n = %d \n” , n);
}
6.
Veja o que aconteceu neste programa:
• Na linha n = 5; atribuímos o valor 5 a variável n
• Na linha seguinte x = n++; o valor de n é atribuído a x e depois n é incrementada de 1, tornando seu valor
• Na primeira printf a saída será: Valor de x = 5 e na outra vai ser: Valor de n = 6 comprovando que quando
o operador é pós-fixado ele incrementa o valor da variável depois de seu valor ser usado.
Vejamos o mesmo exemplo utilizando agora o operador de incremento sendo utilizado pré-fixado.
main( )
{
int n,x;
n = 5;
x = ++n;
printf(“Valor de x = %d \n” , x);
printf(“Valor de n = %d \n” , n);
}
Veja o que aconteceu neste programa:
• Na linha n = 5; atribuímos o valor 5 a variável n
• Na linha seguinte x = ++n; o valor de n é incrementada de 1 tornando seu valor 6, e atribuído a x.
• Na primeira printf a saída será: Valor de x = 6 e na outra vai ser: Valor de n = 6 comprovando que quando
o operador é pré-fixado ele incrementado de um e depois o seu valor ser usado.
Operadores aritméticos de atribuição +=, -=, *=, /=, %=
Nestes operadores é usado um nome de variável a sua esquerda e uma expressão a sua direita. A operação
consiste em atribuir um novo valor a variável que dependerá do operador e da expressão à direita.
Se n é uma variável, exp uma expressão e op um operador aritmético, então:
n op= exp;
Equivale a
n = (n) op (exp);
23
Escola Alcides Maya - Primeiro Módulo
Exemplos:
i + = 2;
x *= y+1;
t /= 2.5;
p %= 5;
d -= 3;
equivale a
equivale a
equivale a
equivale a
equivale a
i = i + 2;
x = x * (y+1);
t = t / 2.5;
p = p % 5;
d = d - 3;
Uma expressão com estes operadores são mais compactos e normalmente produzem um código de máquina
mais eficiente.
Exercícios de Fixação
1. Analise o programa abaixo e informe os valores apresentados na tela:
main( )
{
int a=1, b=2, c=3, d;
d = a;
printf(“%d \n” , d);
/* valor de d: _________ */
d = b++;
printf(“%d \n” , d); /* valor de d: _________ */
d = ++c;
printf(“%d \n” , d); /* valor de d: _________ */
a += b;
printf(“%d \n” , a); /* valor de a: _________ */
c *= b;
printf(“%d \n” , c); }
/* valor de c: _________ */
2. Assuma que todas as variáveis são do tipo int. Encontre o valor de cada uma delas e escreva um programa
que as imprima para verificar os resultados:
a) x = ( 2 + 1 ) * 6;
b) y = ( 5 + 1 ) / 2 * 3;
c) i = j = ( 2 + 3 ) / 4;
d) a = 3 + 2 * ( b = 7 / 2 );
e) c = 5 + 10 % 4 / 2;
3. Reescreva as seguintes instruções usando os operadores de incremento e decremento:
num = num + 1;
num = num – 1;
24
Fundamentos de Programação
4. Reescreva as seguintes instruções usando os operadores aritméticos de atribuição:
num1 = num1 + num2;
num2 = num2 – num1;
5. Analise o programa abaixo e informe os valores apresentados na tela:
main( )
{
int num=0;
printf(“%d \n” , num);
/* valor de num: _________ */
printf(“%d \n” , num++);
printf(“%d \n” , num);
}
/* valor de num: _________ */
/* valor de num: _________ */
6. Analise o programa abaixo e informe os valores apresentados na tela:
main( )
{
int num=0;
printf(“%d \n” , num);
/* valor de num: _________ */
printf(“%d \n” , ++num);
printf(“%d \n” , num);
}
/* valor de num: _________ */
/* valor de num: _________ */
7. Analise o programa abaixo e informe os valores apresentados na tela:
main( )
{
int num=0;
printf(“%d \n” , num);
/* valor de num: _________ */
printf(“%d \n” , - -num);
printf(“%d \n” , num);
}
/* valor de num: _________ */
/* valor de num: _________ */
25
Escola Alcides Maya - Primeiro Módulo
8. Analise o programa abaixo e informe os valores apresentados na tela:
main( )
{
int num=0;
printf(“%d \n” , num);
/* valor de num: _________ */
printf(“%d \n” , num- -);
printf(“%d \n” , num);
}
/* valor de num: _________ */
/* valor de num: _________ */
9. Analise o programa abaixo e informe os valores apresentados na tela:
main( )
{
int num=0;
num += 10;
printf(“%d \n” , num);
/* valor de num: _________ */
num += 10;
printf(“%d \n” , num);
}
/* valor de num: _________ */
Strings – Um tipo especial de caracteres
Em nosso primeiro programa colocamos na tela do computador, através da função printf uma seqüência de
caracteres entre aspas “Meu primeiro programa”, lembra ?
Havia escrito que podemos chamá-la de “cadeia de caracteres” ou de “String”. Usaremos, a partir deste
momento, apenas “String”.
String é uma das mais importantes formas de dados em C e é usada para armazenar e manipular textos como
palavras, nomes e sentenças.
String é um vetor unidimensional do tipo char terminada pelo caractere null.
Composta de uma série de caracteres, a definição de string como sendo um vetor do tipo char é bastante
razoável.
Cada caractere de uma string pode ser acessado como um elemento do vetor o que proporciona uma grande
flexibilidade aos programas que processam textos.
Na string a seguir: “Alcides Maya” cada caractere ocupa um byte de memória e o último caractere é sempre
‘\0´(null). Veja uma representação de como é uma string no computador:
A
l
c
I
d
e
s
M
a
y
a
\0
No exemplo acima temos uma série de elementos do vetor de caracteres, sendo que o primeiro elemento,
onde está a letra “A” é o elemento 0 (zero) do vetor. O segundo elemento, onde está a letra “l” é o elemento 1 (um)
do vetor. O terceiro elemento, onde está a letra “c” é o elemento 2 (dois) do vetor e assim sucessivamente.
A
l
c
I
d
e
s
0
1
2
3
4
5
6
26
7
M
a
y
a
\0
8
9
10
11
12
Fundamentos de Programação
Variáveis que armazenam uma string
Uma das maneiras de receber uma string do teclado é através da função scanf( ) pelo formato %s.
main( ) {
char nome[16];
printf(“Digite seu nome: “);
scanf(“%s” , &nome[0]);
printf(“Olá, %s, tudo bem?” , nome);
}
Agora algumas considerações sobre o programa acima:
• Na declaração: char nome[16]; declaramos a variável nome do tipo char que tem um tamanho de 16
caracteres, reservando o último elemento da string para o caracter \0 (null).
• Na linha printf(“Digite seu nome: “); você encontra uma string entre as aspas
• Na próxima linha scanf(“%s” , &nome[0]); temos a função scanf() que vai ler uma string e armazenar na
variável nome. Você deve ter notado que usamos o operador & precedendo o segundo argumento de scanf() e
também que estamos fazendo referência ao primeiro elemento do vetor [0]. Visto que o nome de um vetor é o
seu endereço inicial poderíamos usar a scanf() da seguinte forma: scanf(“%s” , nome); que o resultado seria o
mesmo.
• Na última linha printf(“Olá, %s, tudo bem?” , nome); estamos apresentando o conteúdo do vetor.
Lendo strings com a Função scanf()
Ler uma string consiste em dois passos: reservar espaço de memória para armazená-la e usar alguma função
que permita a sua entrada.
O primeiro passo é declarar a string especificando o seu tamanho, sempre com um espaço a mais para o
caracter \0 (null).
char nome[16];
Uma vez reservado o espaço necessário você pode usar a função scanf() para receber a string. A função
scanf() é bastante limitada para a leitura de strings.
Por exemplo, considere a seguinte execução do Exercício 26.
Digite seu nome: Alcides Maya
Olá, Alcides, tudo bem?
O programa subitamente eliminou o último nome.
Lembre-se de que scanf() usa qualquer espaço em branco para terminar a entrada. O resultado é que não
existe uma forma de digitar um texto de múltiplas palavras numa única variável usando scanf().
A função scanf() é usada, principalmente para ler uma mistura de tipos de dados numa mesma instrução.
Por exemplo, se em cada linha de entrada quisermos ler o nome de um material do estoque, o seu número do
estoque e o seu preço, scanf() se adaptam perfeitamente.
Lendo strings com a Função gets()
A função gets() é bastante conveniente para a leitura de strings.
O seu propósito é ler uma string da sua entrada padrão, que por “default” é o teclado.
Visto que uma string não tem um tamanho predeterminado, gets( ) Iê caracteres até encontrar o de nova linha
(´\n’) que é gerado pressionando-se a tecla [Enter]. Todos os caracteres anteriores ao ‘\n’ são armazenados na
string e é então incluído o caractere ´\0´.
Caracteres brancos como espaços e tabulações são perfeitamente aceitáveis como parte da string. Eis um
27
Escola Alcides Maya - Primeiro Módulo
exemplo simples:
main( )
{
char nome[16];
printf(“Digite seu nome: “);
gets(nome);
printf(“Olá, %s, tudo bem?” , nome);
)
Agora algumas considerações sobre o programa acima:
• No programa anterior usamos scanf(“%s” , &nome[0]); mas agora, utilizamos gets(nome); que poderá ler
mais de uma palavra separada por espaço em branco. A função gets( ) é exatamente o que procurávamos: agora
o programa lembrará todo o nome.
Agora ao digitarmos duas ou mais palavras, será armazenado o nome completo.
Se forem digitadas as palavras “Alcides Maya”, teremos o resultado apresentado como no exemplo abaixo:
Digite seu nome: Alcides Maya
Olá, Alcides Maya, tudo bem?
OBSERVAÇÃO: Se você digitar um nome maior que o espaço reservado para o string, (15 caracteres no
programa acima) o programa segue armazenando os dados na memória do computador, sem fazer qualquer
consistência em relação ao tamanho do string, podendo armazenar em cima da área de programa, que está na
memória do computador.
Experimente rodar o programa acima digitando as seguintes palavras: “Escola Técnica Alcides Maya”, e veja
o que poderá acontecer.
Inicializando strings
O compilador oferece uma forma de inicialização de strings consideravelmente mais simples:
char nome[ ] = “Ana”;
Enquanto os caracteres simples são colocados entre aspas simples, a string é colocada entre aspas duplas.
O uso da segunda forma causa a inclusão automática do caractere ‘\0´, ou seja teremos a seguinte string na
memória.
A na
0 12
\0
3
main( )
{
char nome[ ] = “Alcides Maya”;
printf(“Olá, %s, tudo bem?” , nome);
}
28
Fundamentos de Programação
Agora algumas considerações sobre o programa acima:
• Na linha char nome[ ] = “Alcides Maya”; estamos declarando a variável nome que é do tipo vetor de
caracteres e já está sendo inicializada com o valor “Alcides Maya”, ele terá um tamanho de 13 caracteres, já
contando o lugar reservado para o \0 (null).
Exercícios de Fixação
1. Faça um programa que leia o nome de 2 pessoas e armazene os nomes lidos (use a função scanf para ler
os nomes). Depois escreva na tela os nomes lidos.
2. Faça um programa que leia o nome de 2 pessoas e armazene os nomes lidos (use a função gets para ler
os nomes). Depois escreva na tela os nomes lidos.
3. Faça um programa que leia três frases. As frases deverão ser armazenadas e depois ser apresentadas na
tela.
4. Faça um programa que declare uma string de 80 caracteres de espaço em branco. Depois escrever 25
printf´s que imprimam esta string na tela. O que acontece?
5. Faça um programa que leia o teu nome, o nome da tua mãe e escreva na tela o teu nome e o nome da tua
mãe, cada um em uma linha da tela.
6. Quais das declarações de string está correta?
( ) string nome[80];
( ) char nome(80);
( ) char nome[80];
( ) char nome = 80;
( ) Nenhuma alternativa acima
7. Qual das funções é mais apropriada para ler uma string composta por várias palavras?
(
(
(
(
(
)
)
)
)
)
scanf
printf
puts
gets
Nenhuma alternativa acima
8. Assuma a seguinte inicialização:
char nome[] = “Escola Alcides Maya”;
Como você se refere à string “Maya” (as últimas 4 letras da string)?
9. Qual é o erro da instrução abaixo?
nome = “Alcides Maya”;
29
Escola Alcides Maya - Primeiro Módulo
10.
( )
( )
( )
( )
( )
Qual é o último caractere de uma string?
\n
\t
\s
\0
Nenhuma alternativa acima
4 Estruturas de Controle – A Tomada de Decisões
Foi visto anteriormente como trabalhar com entrada, processamento e saída utilizando funções, variáveis e
operadores. Apesar de já se conseguir solucionar problemas e transforma-los em programas, os recursos até
aqui estudados são limitados, pois haverá momentos em que um determinado valor dentro de um programa
necessitará ser tratado para se efetuar um processamento mais adequado.
Imagine a seguinte situação: um programa que apresente a média escolar de um aluno. Até aqui, muito
simples, mas além de calcular a média, o programa deve apresentar se ele está aprovado ou reprovado segundo
a análise de sua média.
Observe que aqui será necessário verificar a média do aluno para então tomar uma decisão no sentido de
apresentar a sua real situação: aprovado ou reprovado.
Tomar esta decisão implica em comparar a média com um valor numérico, e para realizar esta comparação
utilizamos operadores relacionais que veremos a seguir.
Operadores relacionais
Os operadores relacionais são usados para fazer comparações. São eles:
Operador
Ação
Exemplo
Resultado
>
maior do que
5 > 2
V
>=
maior ou igual
5 >= 7
F
<
menor do que
5 < 7
V
<=
menor ou igual
5 <= 7
V
==
igual a
5 == 7
F
!=
diferente
5 != 7
V
Operadores relacionais são o vocabulário que o programa usa para fazer perguntas.
Em C não existe um tipo de variável chamada “booleana”, isto é, que assuma um valor verdadeiro ou falso. O
valor zero (0) é considerado falso e qualquer valor diferente de zero (0) é considerado verdadeiro.
Vamos fazer um exemplo que possa identificar estes operadores.
main( )
{
int valor1, valor2;
printf(“Informe um valor1: “);
scanf(“%d” , &valor1);
printf(“Informe um valor2: “);
scanf(“%d” , &valor2);
printf(“valor1 > valor2 é %d \n” , (valor1 > valor2) );
printf(“valor1 < valor2 é %d \n” , (valor1 < valor2) );
printf(“valor1 >= valor2 é %d \n” , (valor1 >= valor2) );
30
Fundamentos de Programação
printf(“valor1 <= valor2 é %d \n” , (valor1 <= valor2) );
printf(“valor1 == valor2 é %d \n” , (valor1 == valor2) );
printf(“valor1 != valor2 é %d \n” , (valor1 != valor2) );
}
Desvio Condicional Simples
O comando if, que significa “se”, é utilizado para fazer um “Desvio Condicional Simples”.
Sua forma geral é:
if (expressão)
comando;
Onde a expressão é avaliada; se for verdadeira (isto é, se a expressão tiver um valor diferente de zero), o
comando é executado.
Desde que um if simplesmente testa o valor numérico de uma expressão, certas abreviações na codificação
são possíveis. A mais óbvia é escrever:
if (expressão)
Ao invés de
if (expressão ! = 0)
Algumas vezes isso é natural e claro; outras vezes, é totalmente obscuro.
Iniciaremos nosso estudo do “if” com um programa simples, que lê um número do teclado e escreve na tela
de seu computador se o número digitado é positivo.
main( )
{
int num;
printf (“Digite um número: “ );
scanf (“%d” , &num);
if (num > 0)
printf (“O número digitado é positivo”);
}
Agora algumas considerações sobre o programa acima:
• Declaramos uma variável numérica do tipo inteiro e pedimos para o usuário digitar um número.
• Na linha if (num > 0) estamos testando o número digitado para saber se o mesmo é maior do que zero. Se
o resultado desta expressão for verdadeira a linha printf (“O número digitado é positivo”); será executada.
• Repare que o comando abaixo do if foi colocado alguns espaços mais para dentro da linha, este processo
de codificação é chamado de “edentação”. Isto facilita a leitura de um programa em qualquer linguagem. Para
o compilador não é necessário a edentar, mas para os programadores, quando estão depurando erros de
programação, é extremamente útil.
31
Escola Alcides Maya - Primeiro Módulo
Exemplo de Aula
Primeiro exemplo
Desenvolver um programa que leia dois valores numéricos. Efetuar a adição e apresentar o seu resultado
caso o valor somado seja maior que 10.
Algoritmo
1 – Ler um valor para a variável A e outro valor para a variável B;
2 – Efetuar a soma dos valores incógnitos A e B, atribuindo o valor da soma na variável X;
3 – Apresentar o valor da soma contido na variável X, caso o valor de X seja maior que 10.
Codificação em Linguagem C
main( )
{
int A,B,X;
clrscr( );
printf ( “Digite um número: “ );
scanf ( “%d”, &A );
printf ( “Digite outro número: “ );
scanf ( “%d”, &B );
X = A + B;
if ( X > 10 )
printf ( “A Soma dos números ée: %d “, X );
getch( );
}
Desvio Condicional Composto
O comando if-else, onde o if significa “se” e o else significa “senão” é utilizado para fazer um “Desvio
Condicional Composto”.
Sua forma geral é:
if (expressão)
comando_1;
else
comando_2;
Onde a expressão é avaliada; se for verdadeira (isto é, se a expressão tiver um valor diferente de zero), o
comando_1 é executado. Se for falsa (isto é, se a expressão tiver um valor igual a zero) e se houver uma parte
else, o comando_2 é executado.
Continuaremos o estudo do “if-else” com um programa simples, que lê um número do teclado e escreve na
tela de seu computador se o número digitado é positivo ou se é negativo.
32
Fundamentos de Programação
main( )
{
int num;
printf (“Digite um número: “ );
scanf (“%d” , &num);
if (num > 0)
printf (“O número digitado é positivo”);
else
printf (“O número digitado é negativo”);
}
Agora algumas considerações sobre o programa acima:
• Declaramos uma variável numérica do tipo inteiro e pedimos para o usuário digitar um número.
• Na linha if (num > 0) estamos testando o número digitado para saber se o mesmo é maior do que zero. Se
o resultado desta expressão for verdadeira a linha printf (“O número digitado é positivo”); será executada.
• Na linha else (senão for um número maior do que zero) estamos indicando para o programa executar a
linha printf (“O número digitado é negativo”);
Exemplo de Aula
Primeiro exemplo
Desenvolver um programa que ler dois valores numéricos e efetuar a adição. Caso o valor somado seja maior
ou igual a 10, deverá ser apresentado somando a ele mais 5; caso o valor somado não seja maior ou igual a 10,
este deverá ser apresentado subtraindo 7.
Algoritmo
1 – Ler um valor para a variável A e outro valor para a variável B;
2 – Efetuar a soma dos valores incógnitos A e B, atribuindo o valor da soma na variável X;
3 – Verificar se X é maior ou igual a 10; caso seja verdadeiro, calcule R  x + 5. Senão calcule R  X – 7.
Codificação em Linguagem C
main( )
{
int A,B,X,R;
clrscr( );
printf ( “Digite um numero: “ );
scanf ( “%d”, &A );
printf ( “Digite outro numero: “ );
scanf ( “%d”, &B );
X = A + B;
if ( X >= 10 )
R = X + 5;
33
Escola Alcides Maya - Primeiro Módulo
else
R = X - 7;
printf ( “O resultado do calculo e: %d “, R );
getch( );
}
Múltiplos comandos dentro de um if
Quando desejamos agrupar comandos, criando um bloco de comandos, utilizamos o abre chaves “{“ e fecha
chaves “}” para encapsular estes comandos.
No if é a mesma coisa, caso vários comandos sejam necessários no corpo do comando if, eles devem estar
entre chaves.
Sua forma geral é:
if (expressão)
{
comando_11;
comando_12;
comando_13;
}
else
{
comando_21;
comando_22;
}
Onde a expressão é avaliada; se for verdadeira os comando_11, comando_12 e o comando_13 são
executados. Se for falsa o comando_21 e o comando_22 são executados.
O programa abaixo dá um exemplo de como encapsulamos comandos.
main( )
{
int num;
printf (“Digite um número: “ );
scanf (“%d” , &num);
if (num > 0)
{
printf (“O número “);
printf (“digitado é “);
printf (“positivo”);
}
34
Fundamentos de Programação
else
{
printf (“O número digitado é “);
printf (“negativo”);
}
}
Exercícios de Fixação
Vamos fazer alguns exercícios
1. FUP que leia dois números quaisquer, e escreva o maior deles.
2. FUP que leia dois números quaisquer, e escreva o menor deles.
3. FAÇA UM PROGRAMA que leia dois números quaisquer, e escreva o resultado do cálculo do maior
dividido pelo menor.
4. FAÇA UM PROGRAMA que leia a receita e a despesa de uma empresa e apresente se ela está com
LUCRO ou com PREJUÍZO.
5. FAÇA UM PROGRAMA que leia 4 notas escolares de um aluno. Calcule e apresente a média. Sabendo-se
que a média de aprovação da escola é 7, apresente a informação se o aluno foi APROVADO ou REPROVADO.
6. FAÇA UM PROGRAMA que leia dois números e apresente o sinal do produto entre eles. Considere que
somente números diferentes de zero serão digitados.
7. FAÇA UM PROGRAMA que leia um número e escreva “maior do que 100”, se o número digitado for maior
que 100 e escreva “menor do que 100”, se o número for menor do que 100.
8. FAÇA UM PROGRAMA que leia um código:1 – sinal vermelho, 2 – sinal verde. Baseado no código digitado
diga para o pedestre que está esperando no sinal:“SIGA” ou “ESPERE”
9. FAÇA UM PROGRAMA que leia a quantidade de vitórias e a quantidade de derrotas de um time de futebol.
Escrever BOM se o número de vitórias for maior que o número de derrotas, caso contrário escrever RUIM.
Desvio Condicional Encadeado
Existem casos em que é necessário estabelecer verificação de condições sucessivas, em que uma determinada
ação poderá ser executada se um conjunto anterior de instruções ou condições for satisfeito. Sendo a ação
executada, ela poderá ainda estabelecer novas condições. Isto significa utilizar uma condição dentro de outra
condição. Este tipo de estrutura poderá possuir diversos níveis de condição, sendo chamadas de aninhamentos
ou encadeamentos.
Exemplos de Aula
Primeiro exemplo
Desenvolver a lógica para um programa que efetue o cálculo do reajuste de salário de um funcionário.
Considere que o funcionário deverá receber um reajuste de 15% caso seu salário seja menor que 500. Se o
salário for maior ou igual a 500, mas menor ou igual a 1000, seu reajuste será de 10%; caso seja ainda maior
que 1000, o reajuste deverá ser de 5%”.
Algoritmo
Perceba que o problema em questão estabelece três condições para calcular o reajuste do salário do
funcionário, sendo:
• Salário <= 500, reajuste de 15%
• Salário > 500, mas <= 1000, reajuste será de 10%
• Salário > 1000, reajuste será de 5%
Estas condições deverão ser encadeadas, pois todas as possibilidades de reajuste deverão ser cercadas.
Sendo assim, observe o algoritmo abaixo:
35
Escola Alcides Maya - Primeiro Módulo
1 – Definir uma variável para o salário reajustado: novo_salario;
2 – Ler um valor para a variável salário;
3 – Verificar se o valor de salario <= 500, se sim reajustar em 15%;
4 – Verificar se o valor de salario <= 1000, se sim reajustar em 10%;
5 – Verificar se o valor de salario > 1000, se sim reajustar em 5%;
6 – Apresentar o valor reajustado, atribuindo a novo_salário.
Codificação em Linguagem C
main( )
{
float novo_salario,salario;
printf ( “Digite o valor do salario: “ );
scanf ( “%f”, &salario );
if ( salario <= 500 )
novo_salario = salario * 1.15;
else
if ( salario <= 1000 )
novo_salario = salario * 1.10;
else
novo_salario = salario * 1.05;
printf ( “O novo salario e: %12.2f “, novo_salario );
}
Exercícios de Fixação
Vamos fazer alguns exercícios
1 - FAÇA UM PROGRAMA que leia o valor do salário hora, a quantidade de horas trabalhadas e a quantidade
de filho menores de 14 anos de um funcionário. Calcular o valor do salário bruto. Para calcular o valor do salário
família levar em consideração o seguinte:
• Se o salário bruto for até R$ 500,00 o salário família será de R$ 10,50 por cada filho;
• Se o salário bruto for acima de R$ 500,00 até R$ 1.000,00 o salário família será de R$ 6,50 por cada
filho;
• Se o salário bruto for acima de R$ 1.000,00 o salário família será de R$ 1,50 por cada filho.
No final apresentar o valor do salário bruto e o valor do salário família a ser recebido.
2 - FAÇA UM PROGRAMA que leia o salário bruto de uma pessoa e calcule o desconto do INSS levando em
consideração o seguinte:
• Para salários até R$ 500,00 a alíquota de INSS será de 8%
• Para sal.acima de R$ 500,00 até R$ 1.000,00 a alíquota de INSS será de 10%
• Para sal.acima de R$ 1.000,00 a alíquota de INSS será de 12%.
No final deverá ser apresentado:
• Salário bruto
• Taxa de INSS
• Valor de INSS
• Salário líquido
36
Fundamentos de Programação
3 - FAÇA UM PROGRAMA que leia o código de uma mercadoria e que escreva o nome do produto conforme
tabela abaixo:
1 – Sabão
2 – Vassoura
3 – Detergente
4 - FAÇA UM PROGRAMA que leia dois números e o código de uma operação matemática (+, -, *, /) e que
apresente o resultado da operação. Por exemplo: se forem digitados os números [2] e [5] e a operação [-], será
apresentado o resultado [-3].
Operadores Lógicos
Os operadores lógicos, como o próprio nome diz, avaliam uma expressão lógica e retornam valores também
lógicos, ou seja, verdadeiro ou falso.
Em várias ocasiões na tomada de decisões temos que usar os operadores lógicos.
Os operadores lógicos mais comuns são: .e., .ou., .não., representados em português estruturado, mas que
em linguagem C são respectivamente &&, ||, !.
A tabela seguinte apresenta todos os operadores lógicos da linguagem C:
Operador Representação Descrição
&&.e.
Efetua a operação lógica E. Se ambas as expressões forem verdadeiras, então o resultado será
verdadeiro.
|| .ou.
Efetua a operação OU. Se uma das expressões (ou ambas) for verdadeira, então o resultado
será verdadeiro.
! .não.
Efetua a operação lógica NÃO. Inverte o estado lógico de uma expressão; se ela for verdadeira,
tona-a falsa e vice-versa.
Para entender melhor como funcionam os operadores lógicos, vamos analisar cada um deles.
O Operador Lógico &&
O operador lógico && (.E.) pode ser visto como um conector lógico. Imagine que você possua dois fios ligados
a uma lâmpada e a uma bateria. A lâmpada somente acenderá se você tiver ligado ambos os fios aos pólos da
bateria. Acompanhe esse exemplo no seguinte diagrama:
Fio vermelho ligado
Frio preto ligado
Lâmpada acende
Falso
Falso
Falso
Verdadeiro
Falso
Falso
Falso
Verdadeiro
Falso
Verdadeiro
Verdadeiro
Verdadeiro
Exemplos de Aula
Primeiro exemplo
Desenvolver um programa que leia um número. Informar se o número digitado está na faixa de 20 a 90.
Algoritmo
1 – Ler um valor para a variável num;
2 – Se o valor digitado estiver na faixa de 20 a 90 apresentar uma mensagem informando.
37
Escola Alcides Maya - Primeiro Módulo
Codificação em Linguagem C
main( )
{
int num;
clrscr( );
printf ( “Digite um número: “ );
scanf ( “%d”, &num );
if (num >= 20 && num <= 90)
printf ( “O número está na faixa de 20 a 90” );
else
printf ( “O número está fora da faixa de 20 a 90” );
getch( );
}
O operador lógico .e. é escrito em C através do operador && , observe também a posição dos parênteses.
Segundo exemplo
Desenvolver a lógica para um programa que leia um ângulo (entre 0º e 360º) e que escreva o quadrante ao
qual pertence. Ignorar os eixos.
Algoritmo
1 – Ler um valor para a variável angulo;
2 – Verificar se o ângulo digitado é > 0 e < 90, se for verdade: “ângulo está no primeiro quadrante”
3 – Verificar se o ângulo digitado é > 90 e < 180, se for verdade: “ângulo está no segundo quadrante”
4 – Verificar se o ângulo digitado é > 180 e < 270, se for verdade: “ângulo está no terceiro quadrante”
5 – Verificar se o ângulo digitado é > 270 e < 360, se for verdade: “ângulo está no quarto quadrante”
Codificação em Linguagem C
main( )
{
int angulo;
clrscr( );
printf ( “Digite um angulo: “ );
scanf ( “%d”, &angulo );
if (angulo > 0 && angulo < 90)
printf ( “Angulo no primeiro quadrante” );
else
if (angulo > 90 && angulo < 180)
printf ( “Angulo no segundo quadrante” );
else
if (angulo > 180 && angulo < 270)
printf ( “Angulo no terceiro quadrante” );
else
38
Fundamentos de Programação
if (angulo > 270 && angulo < 360)
printf ( “Angulo no quarto quadrante” );
getch( );
}
Operador Lógico: .ou.
O operador do tipo .ou. é 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 de decisão
para este tipo de operador:
Condição 1
Condição 2
Resultado
Falsa
Falsa
Falso
Verdadeira
Falsa
Verdadeiro
Falsa
Verdadeira
Verdadeiro
Verdadeira
Verdadeira
Verdadeiro
Considere agora, como exemplo, que você deseja escrever uma carta. Se você tiver uma máquina de escrever
ou (OR) um microcomputador, pode tranqüilamente satisfazer seu desejo. Acompanhe o diagrama em seguida:
Tem máquina
Tem computador
Pode escrever
Falso
Falso
Falso
Verdadeiro
Falso
Verdadeiro
Falso
Verdadeiro
Verdadeiro
Verdadeiro
Verdadeiro
Verdadeiro
Exemplos de Aula
Primeiro exemplo
Desenvolver um programa que leia o código relativo ao sexo (masculino=1 ou feminino=2). Se for digitado um
código correto informar que o código é válido, caso contrário informar que o código é inválido.
Algoritmo
1 – Ler um código numérico para a variável codigo;
2 – Se o código digitado for igual a 1 ou igual a 2 apresentar uma mensagem informando que o código é válido
caso contrário informar que o código é inválido.
39
Escola Alcides Maya - Primeiro Módulo
Codificação em Linguagem C
main( )
{
int codigo;
clrscr( );
printf( “Digite 1 - para sexo masculino\n” );
printf( “Digite 2 - para sexo feminino: “ );
scanf( “%d”, &codigo );
if ( codigo == 1 || codigo == 2 )
printf ( “O código do sexo e válido” );
else
printf ( “O código do sexo e inválido” );
getch( );
}
O operador lógico .ou. é escrito em C através do operador | | (barra,barra).
Operador Lógico: .não.
O operador do tipo .não. é utilizado quando houver necessidade de estabelecer a inversão do resultado
lógico de uma determinada condição. Se a condição for verdadeira, será considerada falsa. Se a condição for
falsa, será considerada verdadeira. Abaixo, é apresentada a tabela de decisão para este tipo de operador:
Condição
Resultado
Falsa
Verdadeiro
Falsa
Verdadeiro
Considere agora, como exemplo, que se você possui um carro e o pneu está furado, você não (NOT) pode
viajar. É o que mostra a tabela abaixo:
Pneu está furado
Pode viajar
Falso
Verdadeiro
Verdadeiro
Falso
Exemplos de Aula
Primeiro exemplo
Desenvolver a lógica para um programa que somente efetue o cálculo de C  (A + B) * X, se o valor da
variável X não for maior que 5. Qualquer valor de 5 para baixo efetuará o cálculo C  (A + B) * X.
Se forem informados os valores 5, 1 e 2, respectivamente, para as variáveis A, B e X, resultará para a
variável C o valor 12, pois o valor 2 da variável X é controlado pela instrução se .não. (X > 5) então, como
sendo verdadeiro, uma vez que não é maior que 5. Sendo assim, os valores 5 e 1 são somados resultando 6 e
multiplicados por 2 resultando 12.
Mas se forem informados os valores 5, 1 e 6, respectivamente, para as variáveis A, B e X, resultará para a
variável C o valor 24, pois o valor 6 da variável X é controlado pela instrução se. não. (X > 5) então, como sendo
falso. Sendo assim, os valores 5 e 1 são subtraídos resultando 4 e multiplicados por 6 resultando 24.
40
Fundamentos de Programação
Algoritmo
1 – Ler um valor numérico para a variável A ,B, X;
2 – Se .não. (X > 5) então calcular: C  (A + B) * X caso contrário calcular: C  (A – B) * X
3 - Apresentar o valor do resultado do cálculo.
Codificação em Linguagem C
main( )
{
int A, B, C, X;
clrscr( );
printf( “\nDigite um numero qualquer.....: “);
scanf ( “%d”,&A );
printf( “\nDigite outro numero qualquer..: “);
scanf ( “%d”,&B );
printf( “\nDigite mais um numero qualquer: “);
scanf ( “%d”,&X );
if ( !(X > 5) )
C = (A + B) * X;
else
C = (A - B) * X;
printf ( “O resultado do calculo e: %d”, C );
getch( );
}
O operador lógico .não. é escrito em C através do operador ! (exclamação).
Exercícios de Aula
Primeiro exercício
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, e se for esta condição verdadeira, deverá ser indicado qual tipo de
triângulo foi formado: isósceles, escaleno ou eqüilátero.
Algoritmo
Para estabelecer este algoritmo, é necessário em primeiro lugar saber o que realmente é um triângulo. Se
você não souber o que é um triângulo, conseqüentemente não conseguirá resolver o problema.
Triângulo é uma forma geométrica (polígono) composta por três lados, sendo que cada lado é menor que
a soma dos outros dois lados. Perceba que isto é uma regra (uma condição) e deverá ser considerada. É 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 estabelecer qual tipo de triângulo será formado: isósceles, escaleno ou eqüilátero.
Um triângulo é isósceles quando possui dois lados iguais e um diferente, sendo A=B ou A=C ou B=C; é
escaleno quando possui todos os lados diferentes, sendo A<>B e B<>C e é eqüilátero quando possui todos os
lados iguais, sendo A=B e B=C.
1 – Ler três valores para os lados de um triângulo: A, B e C;
2 – Verificar se cada lado é menor que a soma dos outros dois lados. Se sim, saber se A=B e B=C, sendo
verdade o triângulo é eqüilátero.
41
Escola Alcides Maya - Primeiro Módulo
Se não, verificar se A=B ou A=C ou B=C, sendo verdade o triângulo é isósceles; caso contrário, o triângulo
é escaleno.
3 – Caso os lados fornecidos não caracterizem um triângulo, avisar a ocorrência.
Codificação em Linguagem C
main( )
{
float A, B, C;
clrscr( );
printf( “Digite um lado do triangulo.....: “ );
scanf (“%f”,&A );
printf( “Digite outro lado do triangulo..: “ );
scanf (“%f”,&B );
printf( “Digite o outro lado do triangulo: “ );
scanf (“%f”,&C );
if ( A < B + C && B < A + C && C < A + B)
if ( A == B && B == C )
printf (“Triangulo eqüilátero”);
else
if ( A == B || A == C || C == B )
printf (“Triangulo Isósceles”);
else
printf (“Triangulo Escaleno”);
else
printf( “As medidas não formam um triangulo” );
getch( );
}
Exercícios de Fixação
1 - FAÇA UM PROGRAMA que leia as coordenadas de um ponto no plano (x,y) e escreva o quadrante ao
qual pertence o ponto no plano. No primeiro quadrante x e y são positivos. No segundo quadrante y é positivo.
No terceiro quadrante nem x nem y é positivo. No quarto quadrante x é positivo.
2 - FAÇA UM PROGRAMA que leia o QI de uma pessoa e escreva uma mensagem baseada na tabela abaixo.
Observe que os colchetes identificam um intervalo fechado e os parênteses identificam um intervalo aberto.
[ 000, 030 ) - Ameba
[ 030, 050 ) - Débil Mental
[ 050, 070 ) - Regular
[ 070, 100 ) - Normal
[ 100, 150 ] - Gênio
Outros - QI inválido
42
Fundamentos de Programação
3 - FAÇA UM PROGRAMA que leia três notas de uma pessoa. Calcular a média e apresentar um conceito
conforme a tabela abaixo:
[ 10, 09 ]-
( 09, 07 ]-
( 07, 04 ]-
( 04, 00 ]-
A
B
C
D
4 - A empresa XYZ & Cia Ltda decidiu conceder um aumento de salários a seus funcionários de acordo com
a tabela abaixo:
SALÁRIO ATUAL
ÍNDICE DE AUMENTO
De 0 até 400
15%
Acima de 400 até 700
12%
Acima de 700 até 1000
10%
Acima de 1000 até 1800
7%
Acima de 1800 até 2500
4%
Acima de 2500
0%
FAÇA UM PROGRAMA que leia o número do funcionário, o seu salário atual. Calcular e apresentar o valor
do salário já corrigido.
5 Estruturas de Controle – Laços de Repetição
Como já foi visto na disciplina de Lógica de Programação, existem ocasiões em que é necessário efetuar
a repetição de um trecho de programa um determinado número de vezes. Neste caso, poderá ser criado um
looping que efetue o processamento de um determinado trecho, tantas vezes quantas forem necessárias. Os
loopings também são chamados de laços de repetição.
Vamos agora implementar estas estruturas em linguagem C.
Por exemplo, imagine um programa que peça a leitura de um valor para a variável num, multiplique esse valor
por 3, colocando a resposta na variável result e apresente o valor obtido, repetindo esta seqüência por cinco
vezes, conforme mostrado abaixo:
Codificação em Linguagem C
main( )
{
int num, result;
printf(“\nDigite um número: “);
scanf(“%d” , &num);
result = num * 3;
printf(“\nO número multiplicado por 3 é: %d” , result);
printf(“\nDigite um número: “);
scanf(“%d” , &num);
result = num * 3;
printf(“\nO número multiplicado por 3 é: %d” , result);
43
Escola Alcides Maya - Primeiro Módulo
printf(“\nDigite um número: “);
scanf(“%d” , &num);
result = num * 3;
printf(“\nO número multiplicado por 3 é: %d” , result);
printf(“\nDigite um número: “);
scanf(“%d” , &num);
result = num * 3;
printf(“\nO número multiplicado por 3 é: %d” , result);
printf(“\nDigite um número: “);
scanf(“%d” , &num);
result = num * 3;
printf(“\nO valor digitado multiplicado por 3 é: %d” , result);
}
Para estes casos existem comandos apropriados para efetuar a repetição de determinados trechos de
programas o número de vezes que for necessário. A principal vantagem deste recurso é que o programa passa
ater um tamanho menor, podendo sua amplitude de processamento ser aumentada sem alterar o tamanho do
código de programação. Desta forma, pode-se determinar repetições com números variados de vezes.
Repetição do tipo: Teste Lógico no início do looping
Caracteriza-se por uma estrutura que efetua um teste lógico no início de um looping, verificando se é permitido
executar o trecho de instruções subordinado a esse looping. A estrutura em questão é denominada de enquanto,
sendo conseguida com a utilização do conjunto de instruções enquanto...faça...fim_enquanto.
A estrutura enquanto...faça...fim_enquanto tem o seu funcionamento controlado por decisão. Sendo assim,
poderá executar um determinado conjunto de instruções enquanto a condição verificada for Verdadeira. No
momento em que esta condição se torna Falsa, o processamento da rotina é desviado para fora do looping. Se
a condição for Falsa logo de início, as instruções contidas no looping são ignoradas.
No início desta aula fizemos um programa que fazia a leitura de um valor para a variável num, multiplicava
esse valor por 3, colocando a resposta na variável result e apresentava o valor obtido, repetindo esta seqüência
por cinco vezes, porque não conhecíamos a estrutura enquanto...faça...fim_enquanto, agora vamos fazer o
mesmo exemplo utilizando a estrutura para o controle do laço de repetição.
Exercícios de Aula
Primeiro exemplo
Desenvolver um programa que faça a leitura de um valor para a variável num, multiplique esse valor por 3,
colocando a resposta na variável result e apresentar o valor obtido, repetindo esta seqüência por cinco vezes.
Algoritmo
1 – Criar uma variável para servir de contador com valor inicial 1;
2 – Enquanto o valor do contador for menor ou igual a 5, processar os passos 3, 4, 5 e 6
3 – Ler um valor para a variável num;
4 – Efetuar a multiplicação do valor de num por 3, atribuindo o resultado em result;
5 – Apresentar o valor calculado contido na variável result;
6 – Acrescentar +1 a variável do tipo contador, definida no passo 1;
7 – Quando contador for maior que 5, encerrar o processamento do looping.
44
Fundamentos de Programação
Codificação em Linguagem C
main( )
{
int num, result, cont;
clrscr( );
cont = 1;
while ( cont <= 5 )
{
printf ( “\nDigite um número: “ );
scanf ( “%d” , &num );
result = num * 3;
printf ( “\nO número multiplicado por 3 é: %d” , result );
cont = cont + 1;
}
getch( );
}
Segundo exemplo
Para ilustrar de forma um pouco diferente, imagine que o primeiro exemplo deverá ser executado enquanto
o usuário queira. Desta forma, em vez de possuir dentro da rotina um contador de vezes, pode-se possuir uma
instrução pedindo que o usuário informe se deseja continuar ou não.
Algoritmo
1 – Criar uma variável para ser utilizada como resposta;
2 – Enquanto a reposta for sim, executar os passos 3, 4 e 5.
3 – Ler um valor para a variável num;
4 – Efetuar a multiplicação do valor de num por 3, atribuindo o resultado em result;
5 – Apresentar o valor calculado contido na variável result;
6 – Quando a resposta for diferente de sim, encerrar o processamento do looping.
45
Escola Alcides Maya - Primeiro Módulo
Codificação em Linguagem C
main( )
{
int num,result;
char resp;
clrscr( );
resp = ‘S’;
while( resp == ‘S’ )
{
printf ( “\nDigite um numero: “ );
scanf ( “%d”, &num );
result = num * 3;
printf ( “O numero multiplicado por 3 e: %d \n”, result );
printf ( “Deseja continuar? “ );
resp = getch( );
}
}
Exercícios de Fixação
Utilizando a estrutura while os exercícios abaixo:
1. FAÇA UM PROGRAMA que escreva na tela os números de 0 até 20.
2. FAÇA UM PROGRAMA que escreva na tela os números pares de 0 até 20.
3. FAÇA UM PROGRAMA que escreva na tela os números de 20 até 0
4. FAÇA UM PROGRAMA que leia 10 valores inteiros e escreva no final a soma dos valores lidos.
5. FAÇA UM PROGRAMA que leia 10 valores inteiros e escreva no final a média dos valores lidos.
6. FAÇA UM PROGRAMA que leia 20 valores e escreva no final a soma dos valores positivos e a média dos
negativos.
7. FAÇA UM PROGRAMA que leia números até que o usuário não queira mais digitar os números. No final
escrever a soma dos valores positivos e a soma dos valores negativos.
Repetição do tipo: Teste Lógico no fim do looping
A estrutura em questão é denominada de repita, sendo conseguida com a utilização do conjunto de instruções
repita...até_que.
A estrutura repita...até_que tem o seu funcionamento controlado por decisão. Porém, 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 enquanto que executa somente um conjunto de instruções, enquanto a condição é verdadeira.
Desta forma repita tem seu funcionamento em sentido contrário a enquanto, pois sempre irá processar um
conjunto de instruções no mínimo uma vez até que a condição se torne verdadeira. Para a estrutura repita um
conjunto de instruções é executado enquanto a condição se mantém Falsa até que ela seja Verdadeira.
Exemplos de Aula
Primeiro exemplo
Desenvolver um programa que faça a leitura de um valor para a variável num, multiplique esse valor por 3,
colocando a resposta na variável result e apresentar o valor obtido, repetindo esta seqüência por cinco vezes.
É o mesmo exemplo utilizado na estrutura enquanto para que você possa fazer uma comparação entre as
estruturas.
46
Fundamentos de Programação
Algoritmo
1 – Criar uma variável para servir de contador com valor inicial 1;
2 – Ler um valor para a variável num;
3 – Efetuar a multiplicação do valor de num por 3, atribuindo o resultado em result;
4 – Apresentar o valor calculado contido na variável result;
5 – Acrescentar +1 a variável do tipo contador, definida no passo 1;
6 – Repita os passos 2, 3, 4 e 5 até que o contador seja maior que 5.
Codificação em Linguagem C
main( )
{
int num,result;
int cont;
clrscr( );
cont = 1;
do
{
printf ( “\nDigite um numero: “ );
scanf ( “%d”, &num );
result = num * 3;
printf ( “O numero multiplicado por 3 e: %d \n”, result );
cont = cont + 1;
}
while ( cont <= 5 );
}
Na linguagem C temos uma pequena mudança, pois, o laço de repetição com o teste no final tem a seguinte
tradução: faça...enquanto ou seja no laço de repetição acima ele será executado enquanto a condição cont <= 5
for verdadeira, quando ela tornar-se falsa então ele encerra o laço de repetição.
Segundo exemplo
A seguir, é apresentado o exemplo em que não se utiliza o contador como forma de controle de execução de
vezes de uma rotina em uma estrutura de repetição. Considere que será o usuário que encerrará o processamento
segundo a sua vontade.
Algoritmo
1 – Criar uma variável para ser utilizada como resposta;
2 – Ler um valor para a variável num;
3 – Efetuar a multiplicação do valor de num por 3, atribuindo o resultado em result;
4 – Apresentar o valor calculado contido na variável result;
5 – Repetir os passos 2, 3, 4 e 5 até que a resposta do usuário seja não.
47
Escola Alcides Maya - Primeiro Módulo
Codificação em Linguagem C
main( )
{
int num,result;
char resp;
clrscr( );
do
{
printf ( “\nDigite um numero: “ );
scanf ( “%d”, &num );
result = num * 3;
printf ( “O numero multiplicado por 3 e: %d \n”, result );
printf ( “Deseja continuar? “ );
resp = getch( );
}
while( resp == ‘S’ );
}
Exercícios de Fixação
Vamos fazer alguns exercícios
1. FAÇA UM PROGRAMA que leia números até que o usuário não queira
escrever a soma dos valores lidos.
2. FAÇA UM PROGRAMA que leia números até que o usuário não queira
escrever a média dos valores lidos.
3. FAÇA UM PROGRAMA que leia números até que o usuário não queira
escrever a soma dos valores positivos e a soma dos valores negativos.
4. FAÇA UM PROGRAMA que leia números até que o usuário não queira
escrever a soma dos valores positivos e a média dos valores negativos.
mais digitar os números. No final
mais digitar os números. No final
mais digitar os números. No final
mais digitar os números. No final
Repetição do tipo: Variável de Controle
Anteriormente, foram vistas duas formas de elaborar looping. Uma usando o conceito enquanto e a outra
usando o conceito repita. Foi visto também como elaborar rotinas que efetuaram a execução de um looping um
determinado número de vezes com a utilização de um contador (por meio de uma variável de controle).
Porém, existe uma possibilidade de facilitar o uso de contadores finitos sem fazer uso das duas estruturas
anteriores, deixando-as para utilização de loopings em que 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 processador por meio de estrutura de laços contados do tipo para, sendo conseguida
com a utilização do conjunto de instruções para...de...até...passo...faça...fim_para.
A estrutura para...de...até...passo...faça...fim_para tem o seu funcionamento controlado por uma variável
denominada contador. Sendo assim, poderá executar um determinado conjunto de instruções um determinado
número de vezes.
Exemplos de Aula
Primeiro exemplo
Desenvolver um programa que faça a leitura de um valor para a variável num, multiplique esse valor por 3,
colocando a resposta na variável result e apresentar o valor obtido, repetindo esta seqüência por cinco vezes.
É o mesmo exemplo utilizado na estrutura enquanto para que você possa fazer uma comparação entre as
estruturas.
48
Fundamentos de Programação
Algoritmo
1 – Definir um contador, variando de 1 a 5;
2 – Ler um valor para a variável num;
3 – Efetuar a multiplicação do valor de num por 3, atribuindo o resultado em result;
4 – Apresentar o valor calculado contido na variável result;
5 – Repitir os passos 2, 3, 4 e 5 até que o contador seja encerrado.
Codificação em Linguagem C
main( )
{
int num,result;
int cont;
clrscr( );
for( cont=1; cont <= 5; cont++ )
{
printf ( “\nDigite um numero: “ );
scanf ( “%d”, &num );
result = num * 3;
printf ( “O numero multiplicado por 3 e: %d \n”, result );
}
}
Segundo exemplo
Desenvolver um programa que escreva na tela os números de 1 até 10.
Repare que estamos desejando escrever os números na seguinte seqüência: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.
Algoritmo
1 – Definir um contador, variando de 1 a 10;
2 – Apresentar o valor contido na variável contador;
5 – Repitir o passo 2 até que o contador seja encerrado.
Codificação em Linguagem C
main( )
{
int cont;
clrscr( );
for( cont=1; cont <= 10; cont++ )
printf ( “%d \n”, cont );
getch( );
}
49
Escola Alcides Maya - Primeiro Módulo
Terceiro exemplo
Desenvolver um programa que escreva na tela os números de 10 até 1.
Repare que estamos desejando escrever os números na seguinte seqüência: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1.
Algoritmo
1 – Definir um contador, variando de 10 a 1;
2 – Apresentar o valor contido na variável contador;
5 – Repitir o passo 2 até que o contador seja encerrado.
Codificação em Linguagem C
main( )
{
int cont;
clrscr( );
for( cont=10; cont <= 1; cont-- )
printf ( “%d \n”, cont );
getch( );
}
Exercícios de Fixação
1 - FAÇA UM PROGRAMA que escreva a soma dos números de 1 até 100, ou seja, quanto é
1+2+3+...+98+99+100.
2 - FAÇA UM PROGRAMA que leia 10 valores e escreva no final a soma dos valores lidos.
3 - FAÇA UM PROGRAMA que leia 10 valores e escreva no final a soma dos valores positivos e a média dos
negativos.
4 - FAÇA UM PROGRAMA que leia valores e escreva no final a soma dos valores positivos e a média dos
negativos. Neste programa o usuário é quem vai determinar o fim da leitura dos números, ou seja, você deverá
perguntar ao usuário se ele deseja continuar digitando valores.
5 - FAÇA UM PROGRAMA que leia 4 notas escolares de 15 alunos. Para cada um dos alunos calcular e
apresentar a média.
6 - FAÇA UM PROGRAMA que leia 4 notas escolares de “n” alunos. Para cada um dos alunos calcular e
apresentar a média. Sabendo-se que a média da escola é 7, informar também se o aluno foi “Aprovado” ou
“Reprovado”. Neste programa o usuário é quem vai determinar o fim da leitura das notas, ou seja, você deverá
perguntar ao usuário se ele deseja continuar digitando notas.
7 - FAÇA UM PROGRAMA que leia dois números inteiros quaisquer. No final escrever os números entre
eles. Por exemplo, se forem digitados 6 e 2, deverá escrever 6, 5, 4, 3 , 2. Mas se forem digitados 2 e 6, deverá
escrever 2, 3, 4, 5, 6.
8 - FAÇA UM PROGRAMA que leia 20 vezes o código de um produto. Os produtos podem ser:
1 – Panela
2 – Chaleira
3 – Prato
Outro – Código inválido
Ao final escrever o total digitado de cada código, inclusive a quantidade de códigos inválidos digitados.
9 - FAÇA UM PROGRAMA que leia 4 notas escolares dos alunos de uma escola. Para cada um dos alunos
calcular e apresentar a média e informar o conceito do aluno baseado na informação abaixo:
[0 – 4) - Conceito D
[4 – 7)
- Conceito C
[7 – 9)
- Conceito B
[9 – 10]
- Conceito A
Os colchetes marcam o intervalo fechado e os parênteses marcam um intervalo aberto.
50
Fundamentos de Programação
Neste programa o usuário é quem vai determinar o fim da leitura das notas, ou seja, você deverá perguntar
ao usuário se ele deseja continuar digitando notas.
10 - FAÇA UM PROGRAMA que leia códigos e execute tarefas, conforme tabela abaixo:
0 – Encerra o programa
1 – Inclui uma unidade no estoque
2 – Exclui uma unidade no estoque
3 – Mostra o total disponível no estoque
4 – Mostra o total de entradas no estoque
5 – Mostra o total de saídas no estoque
Outro código escrever: “Código Inválido”
11 - FAÇA UM PROGRAMA para controlar o acesso de pessoas a um restaurante. O restaurante possui uma
capacidade de 40 vagas, que não poderá ser ultrapassada. O controle se dará através de códigos, conforme a
tabela:
0 – FIM
1 – ENTRA UMA PESSOA (escrever: “Entrou”)
2 – SAI UMA PESSOA (escrever: “Saiu”)
3 – MOSTRAR QUANTOS LUGARES ESTÃO DISPONÍVEIS
4 – MOSTRAR O TOTAL DE PESSOAS QUE ENTRARAM
5 – MOSTRAR O TOTAL DE PESSOAS QUE SAÍRAM
Outro código escrever: “Código Inválido”
12 - FAÇA UM PROGRAMA que calcule o desconto do imposto de renda. O programa deverá perguntar
quando a pessoa deseja encerrar o programa (“Deseja fazer outro cálculo? (S/N)”). O programa deve pedir
o valor do salário, calcular e apresentar o valor do desconto baseado na seguinte informação:
Salário até R$ 900,00 é isento (Não paga imposto de renda)
Salário acima de R$ 900,00 até R$ 1.800,00 para 15% de imposto de renda
Salário acima de R$ 1.800,00 para 27% de imposto de renda
13 - FAÇA UM PROGRAMA que leia o peso das pessoas que querem entrar em um elevador. A capacidade
máxima do elevador é de 15 pessoas ou 800 Kg, o que ocorrer primeiro. O programa deve ler o peso da pessoa
que deseja entrar, se a sua entrada não fizer com que seja ultrapassado qualquer um dos limites, deverá escrever:
“PODE ENTRAR”, caso contrário, ou seja, ultrapassando os limites, deverá escrever: “NÃO PODE ENTRAR:
ELEVADOR LOTADO” e encerrar o programa, mostrando o número de pessoas transportadas e o peso total
transportado.
14 - FAÇA UM PROGRAMA que leia dois números e a operação desejada ( + , - , * , / ) e que escreva na
tela o resultado da operação. O programa depois de apresentar o resultado deverá perguntar quando a pessoa
deseja encerrar o programa (“Deseja fazer outro cálculo? (S/N)”). Se a reposta for S deverá pedir outros
números e a operação desejada, se a resposta for N deverá encerrar o programa.
15 - Em uma fábrica de chocolates, foi designado ao programador, fazer um programa que calcule o desconto
de INSS dos funcionários. Este programa deve ler o nome do funcionário e o valor do salário bruto. Calcular o
desconto do INSS levando em consideração o seguinte:
f) Para salários até R$ 500,00 a alíquota de INSS será de 8%
g) Para salários acima de R$ 500,00 até R$ 1.000,00 a alíquota de INSS será de 10%
h) Para salários acima de R$ 1.000,00 a alíquota de INSS será de 12%
Para cada funcionário deverá ser apresentado na tela:
a) Nome do Funcionário
b) Salário Bruto
c) Taxa de INSS
d) Valor de INSS
e) Salário Líquido
Após estas apresentações o programa deverá fazer uma pergunta: “Deseja fazer mais algum cálculo? (S/N)”,
se a resposta for afirmativa o programa deverá continuar com os dados do próximo funcionário, caso contrário
51
Escola Alcides Maya - Primeiro Módulo
deverá ser terminado.
16 - FAÇA UM PROGRAMA que possibilite calcular a área total de uma residência (sala, cozinha, banheiro,
quartos, área de serviço, quintal, garagem, etc). O programa deve solicitar a entrada do nome, a largura e
o comprimento de um determinado cômodo. Em seguida, deve apresentar a área do cômodo lido e também
uma mensagem solicitando do usuário a confirmação de continuar calculando novos cômodos. Caso o usuário
responda que “NÃO”, o programa deve apresentar o valor total acumulado da área residencial.
6 Estruturas de Dados Homogêneas I
Durante os pontos estudados em Desvios condicionais e Estruturas de repetição, percebeu-se que o poder de
programação tornou-se maior, antes limitado somente ao que foi estudado em técnicas básicas de programação.
Porém, tendo o domínio das técnicas anteriores, ainda correr-se-á o risco de não conseguir resolver alguns tipos
de problemas, pois foram trabalhadas até aqui apenas variáveis simples que somente armazenam um valor por
vez.
Vamos agora apresentar uma técnica de programação que permitirá trabalhar como o agrupamento de várias
informações dentro de uma mesma variável, sendo sempre do mesmo tipo de dado, e por esta razão é chamado
de estrutura de dados homogênea.
A utilização deste tipo de estrutura de dados recebe diversos nomes, como: variáveis indexadas, variáveis
compostas, variáveis subscritas, arranjos, vetores, matrizes, tabelas em memória ou arrays (do inglês). São
vários os nomes encontrados, a que nós iremos tratar por matrizes.
Matrizes de uma dimensão ou vetores
Este tipo de estrutura é conhecida como matrizes unidimensionais ou também de vetor. Caracteriza-se por
ser definida uma única variável dimensionada com um determinado tamanho. A dimensão de uma matriz é
constituída por uma constante inteira positiva. Os nomes dados às matrizes seguem as mesmas regras de
nomes utilizados para identificar as variáveis simples.
Para ter uma idéia de como utilizar matrizes em uma determinada situação considere o seguinte problema:
“Em uma Escola Técnica de Informática, há um professor que faz 6 avaliações durante o semestre. Gostaríamos
de fazer um programa que leia as 6 notas de um aluno. No final calcular e apresentar a média do aluno”.
Desta forma será necessário somar as 6 notas de cada aluno e calcular a sua média. A tabela a seguir
apresenta um aluno, suas notas bimestrais e a coluna da média do aluno que deverá ser calculada.
Aluno
Nota 1
Nota 2
Nota 3
Nota 4
Nota 5
Nota 6
Média
1
4.0
6.0
5.0
3.0
7.5
4.0
?
Agora basta escrever um programa para efetuar o cálculo da média de cada aluno.
Vamos começar pelo cálculo da média de cada aluno, iremos representar as notas de cada aluno pelas
variáveis: nota1, nota2, nota3, nota4, nota5, nota6, e para o cálculo da média a variável media, todas do tipo
real.
Algoritmo
1 – Ler as notas do aluno para as variáveis nota1, nota2, nota3, nota4, nota5, nota6;
2 – Efetuar a soma das notas e a divisão delas por 6, atribuindo o seu resultado para a variável media;
3 – Apresentar o valor da variável media após a operação de soma e divisão dos valores fornecidos.
Com o conhecimento adquirido até este momento, seria então elaborado um programa que efetuaria a leitura
de cada nota, a soma delas e a divisão do valor da soma por 6, obtendo-se desta forma a média do aluno.
52
Fundamentos de Programação
Codificação em Linguagem C
main( )
{
float nota1;
float nota2;
float nota3;
float nota4;
float nota5;
float nota6;
float soma;
float media;
printf( “Digite a nota 1: “ );
scanf( “%f” , &nota1 );
printf( “Digite a nota 2: “ );
scanf( “%f” , &nota2 );
printf( “Digite a nota 3: “ );
scanf( “%f” , &nota3 );
printf( “Digite a nota 4: “ );
scanf( “%f” , &nota4 );
printf( “Digite a nota 5: “ );
scanf( “%f” , &nota5 );
printf( “Digite a nota 6: “ );
scanf( “%f” , &nota6 );
soma = nota1 + nota2 + nota3 + nota4 + nota5 + nota6;
media = soma / 6;
printf ( “A média do aluno foi: %f \n” , media );
}
Perceba que para receber as notas foram utilizadas 6 variáveis. Com a técnica de matrizes poderia ter sido
utilizada apenas uma variável com a capacidade de armazenar 6 valores.
Operações básicas com Matrizes de uma dimensão
Uma matriz de uma dimensão ou vetor será representada por seu nome e seu tamanho (dimensão) entre
colchetes. Desta forma seria uma matriz nota[6], sendo seu nome nota, possuindo um tamanho de 6.
Isto significa que poderão ser armazenados em nota até 6 elementos. Perceba que na utilização de variáveis
simples existe uma regra: uma variável somente pode conter um valor por vez. No caso das matrizes, poderão
armazenar mais de um valor por vez, pois são dimensionadas exatamente para este fim. Desta forma poderse-á manipular uma quantidade maior de informação com pouco trabalho de processamento. Deve-se apenas
considerar que com relação à manipulação dos elementos de uma matriz, eles ocorrerão 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 do aluno, ter-se-ia então uma única variável indexada (a matriz)
contendo todos os valores das 8 notas. Isto seria representado da seguinte forma:
53
Escola Alcides Maya - Primeiro Módulo
nota[0] = 4.0
nota[1] = 6.0
nota[2] = 5.0
nota[3] = 3.0
nota[4] = 7.5
nota[5] = 4.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 em que o elemento está armazenado. É
necessário que fique bem claro que o elemento é o conteúdo da matriz, neste caso os valores das notas. No caso
de nota[0] = 4.0, o número 0 é o índice; o endereço onde cujo elemento é 4.0 está armazenado.
Atribuição de uma Matriz
Anteriormente, foram utilizadas várias instruções para poder definir e montar um programa. No caso da
utilização de matrizes, será definida a instrução conjunto que indicará em português estruturado a utilização
de uma matriz, tendo como sintaxe: conjunto[<dimensão>] de <tipo de dado>, sendo que <dimensão> será a
indicação dos valores inicial e final do tamanho do vetor e <tipo de dado> se o vetor em questão utilizar valores
reais, inteiros, lógicos ou caracteres.
Leitura de dados de uma Matriz
A leitura de uma matriz é processada passo a passo, um elemento por vez. A instrução de leitura é leia seguida
da variável mais o índice. A seguir, são apresentados o fluxograma e a codificação em português estruturado da
leitura das notas dos alunos, cálculo da média e a sua apresentação.
Codificação em Linguagem C
main( )
{
float nota[6];
float soma;
float media;
int indice;
clrscr( );
soma = 0;
for( indice = 0; indice < 6; indice++ )
{
printf ( “Digite a nota %d do aluno: “, indice+1 );
scanf ( “%f”, &nota[indice] );
soma = soma + nota[indice];
}
media = soma / 6;
printf ( “A media do aluno e: %4.1f”, media );
getch( );
}
Observe que na linguagem C o índice começa com o valor zero, pois o endereço do primeiro elemento da
matriz em C é zero, o endereço do segundo elemento da matriz em C é um e assim sucessivamente.
54
Fundamentos de Programação
A tabela a seguir, mostra como ficarão os valores armazenados na matriz em linguagem C:
Matriz: nota
Índice
Elemento
0
4.0
1
6.0
2
5.0
3
3.0
4
7.5
5
4.0
Escrita dos dados de uma Matriz
O processo de escrita de uma matriz é bastante parecido com o processo de leitura de seus elementos. Para
esta ocorrência deverá ser utilizada a instrução escreva seguida da indicação da variável e seu índice.
Supondo que após a leitura das 6 notas, houvesse a necessidade de apresenta-las antes da apresentação
do valor da média. Abaixo são apresentados o fluxograma e a codificação em português estruturado da escrita
das 6 notas antes de ser apresentado o cálculo da média.
Codificação em Linguagem C
main( )
{
float nota[6];
float soma;
float media;
int indice;
clrscr( );
soma = 0;
for( indice = 0; indice < 6; indice++ )
{
printf ( “Digite a nota %d do aluno: “, indice+1 );
scanf ( “%f”, &nota[indice] );
soma = soma + nota[indice];
}
media = soma / 6;
for( indice = 0; indice < 6; indice++ )
printf ( “A nota %d do aluno e: %4.1f \n”, indice+1, nota[índice] );
printf ( “A media do aluno e: %4.1f”, media );
getch( );
}
Exemplos de Aula
Para demonstrar a utilização de uma matriz em um exemplo um pouco maior, considere como problemas os
exemplos apresentados em seguida:
55
Escola Alcides Maya - Primeiro Módulo
Primeiro exemplo
Desenvolver um programa que efetue a leitura de dez 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 o conteúdo da matriz A e B
Algoritmo
Este exemplo de resolução estará mostrando como fazer o tratamento da condição do índice.
1 – Iniciar o contador de índice, variável índice como 1 em um contador até 10;
2 – Ler os 10 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 o conteúdo das duas matrizes.
Deverá ser verificado se o valor do índice em um determinado momento é par (ele será par quando dividido
por 2 obtiver resto igual a zero). Sendo a condição verdadeira, será atribuído na matriz B[índice] a multiplicação
do elemento da matriz A[índice] por 5. Caso o valor do índice seja ímpar, será atribuído na matriz B[índice] a
soma do elemento da matriz A[índice] por 5.
Codificação em Linguagem C
main( )
{
int matrizA[10];
int matrizB[10];
int indice;
int resp;
clrscr( );
for( indice = 0; indice < 10; indice++ )
{
printf ( “Digite um valor numerico inteiro: “ );
scanf ( “%d”, &matrizA[indice] );
}
for( indice = 0; indice < 10; indice++ )
{
resp = indice %;
if ( resp == 0 )
matrizB[indice] = matrizA[indice] * 5;
else
matrizB[indice] = matrizA[indice] + 5;
}
for( indice = 0; indice < 10; indice++ )
printf ( “\nConteudo da Matriz A indice %d = %d”, indice, matrizA[indice] );
for( indice = 0; indice < 10; indice++ )
printf ( “\nConteudo da Matriz B indice %d = %d”, indice, matrizB[indice] );
getch( );
}
56
Fundamentos de Programação
Segundo exemplo
Desenvolver um programa que efetue a leitura de dez elementos de uma matriz A do tipo vetor. No final,
apresente o total da soma de todos os elementos que sejam ímpares.
Algoritmo
Perceba que em relação ao primeiro exemplo, este apresenta uma diferença: o primeiro pedia para verificar
se o índice era par ou ímpar. Neste exemplo, está sendo solicitado que analise a condição do elemento e não
do índice. Já foi alertado anteriormente para se tomar cuidado para não confundir elemento com índice. Vamos
a solução:
1 – Iniciar o contador de índice, variável índice como 1 em um contador até 10;
2 – Ler os 10 valores, um a um;
3 – Verificar se o elemento é ímpar; se sim efetuar a soma dos elementos;
4 – Apresentar o total somado de todos os elementos ímpares da matriz.
Observe que quando se faz menção ao índice indica-se a variável que controla o contador de índice, e no
caso do exemplo anterior, a variável índice. Quando se faz menção ao elemento, indica-se matrizA[índice] pois
desta forma está se pegando o valor armazenado e não a sua posição de endereço.
Codificação em Linguagem C
main( )
{
int matrizA[10];
int indice;
int resp;
int soma;
clrscr( );
soma = 0;
for( indice = 0; indice < 10; indice++ )
{
printf ( “Digite um valor numerico inteiro: “ );
scanf ( “%d”, &matrizA[indice] );
}
for( indice = 0; indice < 10; indice++ )
{
resp = matrizA[indice] % 2;
if ( resp == 1 )
soma = soma + matrizA[indice];
}
printf ( “\nA soma dos elementos ímpares é: %d” , soma );
getch( );
}
57
Escola Alcides Maya - Primeiro Módulo
Exercícios de Fixação
1 – Desenvolva os algoritmos, seus respectivos fluxogramas e proceda a codificação em português estruturado
os seguintes programas:
2. Faça um programa para ler 10 elementos de uma matriz tipo vetor e apresenta-los
3. Faça um programa para ler 8 elementos em uma matriz A tipo vetor. Construir uma matriz B de mesma
dimensão com os elementos da matriz A multiplicados por 3. O elemento B[1] deverá ser atribuído pelo elemento
A[1] * 3, o elemento B[2] atribuído pelo elemento A[2] * 3 e assim por diante, até 8. Apresentar a matriz B.
4. Faça um programa para ler duas matrizes A e B com 20 elementos. Construir uma matriz C, onde cada
elemento de C é a soma do elemento correspondente de A com B. Apresentar a matriz C.
5. Faça um programa que leia 15 elementos de uma matriz A do tipo vetor. Construir uma matriz B de mesmo
tipo, observando a seguinte lei de formação: “Todo elemento de B deverá ser o quadrado do elemento de A
correspondente”. Apresentar as matrizes A e B.
6. Faça um programa para ler uma matriz A do tipo vetor com 15 elementos. Construir uma matriz B de
mesmo tipo, sendo que cada elemento da matriz B seja o fatorial do elemento correspondente da matriz A .
Apresentar as matrizes A e B.
7. Faça um programa para ler duas matrizes A e B com 15 elementos cada. Construir uma matriz C, sendo
esta a junção das duas outras matrizes. Desta forma C deverá ter o dobro de elementos, ou seja 30. Apresentar
a matriz C.
8. Faça um programa para ler duas matrizes do tipo vetor, sendo A com 20 elementos e B com 30 elementos.
Construir uma matriz C, sendo esta a junção das duas outras matrizes. Desta forma C deverá ter a capacidade
de armazenar 50 elementos. Apresentar a matriz C.
9. Faça um programa para ler 20 elementos de uma matriz A tipo vetor e construir uma matriz B de mesma
dimensão com os mesmos elementos da matriz A, sendo que deverão estar invertidos. Ou seja, o primeiro
elemento de A passa a ser o último de B, o segundo elemento de A passa a ser o penúltimo de B e assim por
diante. Apresentar as matrizes A e B.
10. Faça um programa para ler três matrizes (A, B e C) de uma dimensão com 5 elementos cada. Construir
uma matriz D, sendo esta a junção das três outras matrizes. Desta forma D deverá ter o triplo de elementos, ou
seja 15. Apresentar os elementos da matriz D.
11.Faça um programa para ler uma matriz A do tipo vetor com 20 elementos. Construir uma matriz B do
mesmo tipo da matriz A, sendo que cada elemento de B seja o somatório do elemento correspondente da matriz
A . Se o valor do elemento de A[1] for 5, B[1] deverá ser 10, se o valor do elemento de A[2] for 7, B[2] deverá ser
14 e assim por diante.
12. Faça um programa para ler uma matriz A do tipo vetor com 10 elementos. Construir uma matriz B do
mesmo tipo da matriz A, sendo que cada elemento de B deverá ser o valor negativo do elemento correspondente
da matriz A . Desta forma, se o valor do elemento de A[1] for 8, B[1] deverá ser -8, se o valor do elemento de A[2]
for 3, B[2] deverá ser -3 e assim por diante.
13. Faça um programa para ler uma matriz A tipo vetor com 10 elementos. Construir uma matriz B de mesmo
tipo, sendo que cada elemento de B deverá ser a metade de cada elemento de A . Apresentar os elementos das
matrizes A e B.
14. Faça um programa que efetue o cálculo de uma tabuada de um número qualquer e armazene os resultados
em uma matriz A de uma dimensão para 10 elementos. Apresentar os valores armazenados na matriz.
15. Ler 20 elementos (valores reais) para temperaturas em graus Celsius em uma matriz A de uma dimensão
do tipo vetor. O programa deverá apresentar a menor, a maior e a média das temperaturas lidas.
16. Ler 25 elementos (valores reais) para temperaturas em graus Celsius em uma matriz A de uma dimensão
do tipo vetor. Construir uma matriz B de mesmo tipo e dimensão, em que cada elemento da matriz B deverá
ser a conversão da temperatura em graus Fahrenheit do elemento correspondente da matriz A . Apresentar os
elementos das matrizes A e B.
17. Ler 12 elementos inteiros para uma matriz A de uma dimensão do tipo vetor. Construir uma matriz B de
mesmo tipo e dimensão, observando a seguinte lei de formação: “Todo elemento da matriz A que for ímpar deverá
ser multiplicado por 2 e armazenado na matriz B; caso contrário, o elemento da matriz A deverá ser armazenado
na matriz B sem nenhum cálculo”. Apresentar os elementos das matrizes A e B.
18. Ler 15 elementos reais para uma matriz A de uma dimensão do tipo vetor. Construir uma matriz B de
mesmo tipo e dimensão, observando a seguinte lei de formação: “Todo elemento da matriz A que possuir índice
par deverá ter seu elemento dividido por 2; caso contrário, o elemento da matriz A deverá ser multiplicado por
1.5”. Apresentar os elementos das matrizes A e B.
58
Fundamentos de Programação
19. Faça um programa que leia uma matriz numérica de 10 elementos. No final apresentar quantos números
são positivos e quantos são negativos
20. Faça um programa que leia uma matriz numérica de 10 elementos. No final encontrar nesta matriz o
maior valor lido, apresentando a sua posição na matriz e o seu valor.
21. Faça um programa que leia uma matriz numérica de 10 elementos. No final encontrar nesta matriz o
menor valor lido, apresentando a sua posição na matriz e o seu valor.
22. Faça um programa que leia uma matriz numérica de 10 elementos. No final encontrar nesta matriz o
maior valor lido e o menor valor lido
23. Faça um programa que leia uma matriz numérica chamada notas de 10 elementos. Ler valores para o
vetor e, após ter lido, determinar a media dos valores contidos no vetor
24. Em uma Escola Técnica de Informática, há um professor que faz 6 provas. Faça um programa que leia
as notas destas provas para um vetor notas. No final calcular e apresentar a média do aluno e o resultado obtido
conforme a tabela a seguir:
[00,05)
- Reprovado
[05,07)
- Recuperação
[07,09)
- Satisfatório
[09,10]
- Ótimo
7 Estruturas de Dados Homogêneas II
No capítulo anterior trabalhamos com o agrupamento de várias informações dentro de uma mesma variável,
de mesmo tipo de dado, chamada de estrutura de dados homogênea, ou seja, matrizes, do tipo vetor. Agora
iremos trabalhar com uma estrutura um pouco mais complexa, também chamada de matrizes, mas de mais de
uma dimensão.
Matrizes com mais de uma dimensão
Anteriormente, houve contato com o uso de uma única variável indexada com apenas uma dimensão (uma
coluna e várias linhas), quando foi utilizado o exemplo para efetuar o cálculo da média do aluno. A partir deste
ponto, serão apresentadas tabelas com mais colunas, sendo assim, teremos variáveis no sentido horizontal e
vertical.
Com o conhecimento adquirido até este ponto, você tem condições suficientes para elaborar um programa
que leia as notas dos alunos, calcule a média de cada aluno e no final apresente a média de toda a turma,
utilizando-se de matrizes bidimensionais.
Porém, cuidado, é necessário manter um controle de cada índice em cada matriz para um mesmo aluno.
Para facilitar o trabalho com estruturas deste porte é que serã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 em
momentos em que se necessite trabalhar com um número maior de dimensões, porém estas são fáceis de
utilizar, se estivermos dominando bem a utilização de uma matriz com duas dimensões.
É importante considerar que na manipulação de uma matriz unidimensional é utilizada uma única instrução
de looping. No caso de matrizes com mais dimensões, deverão ser utilizadas o número de loopings relativo ao
tamanho de sua dimensão. Desta forma, uma matriz de duas dimensões deverá ser controlada com dois loopings
de três dimensões deverá ser controlada por três loopings e assim por diante.
Em matrizes de mais de uma dimensão os seus elementos são também manipulados de forma individualizada,
sendo a referência feita sempre por meio de dois índices; o primeiro para indicar a linha e o segundo para indicar
a coluna.
Para você ter uma idéia de como utilizar matrizes de duas dimensões vamos utilizar o mesmo exemplo
que usamos no capítulo anterior, mas agora com um número maior de alunos: “Em uma Escola Técnica de
Informática, há um professor que faz 4 avaliações durante o semestre. Gostaríamos de fazer um programa que
leia as 4 notas de cada aluno da turma (turma com 8 alunos), calcule e apresente a média de cada aluno.”.
59
Escola Alcides Maya - Primeiro Módulo
Veja como ficaria nossa tabela com as notas e as médias de cada aluno:
Aluno
Nota 1
Nota 2
Nota 3
Nota 4
1
4.0
6.0
5.0
3.0
2
6.0
7.0
5.0
8.0
3
9.0
8.0
9.0
6.0
4
3.0
5.0
4.0
2.0
5
4.0
6.0
6.0
8.0
6
7.0
7.0
7.0
7.0
7
8.0
7.0
6.0
5.0
8
6.0
7.0
2.0
9.0
Operações básicas com matrizes de duas dimensões
Uma matriz de duas dimensões está sempre fazendo referência a linhas e a colunas e é representada por
seu nome e seu tamanho (dimensão) entre colchetes.
Desta forma é uma matriz de duas dimensões nota[8][4] , onde seu nome é nota, possuindo um tamanho de
8 linhas e 4 colunas, ou seja, é uma matriz de 8 por 4 (8 x 4). Isto significa que podem ser armazenados em nota
até 32 elementos.
Para armazenar as 4 notas do primeiro aluno deveríamos fazer algo como visto abaixo:
nota[0] [0] = 4.0
nota[0] [1] = 6.0
nota[0] [2] = 5.0
nota[0] [3] = 3.0
Observe que o nome é um só. O que muda é a informação indicada dentro dos colchetes. No primeiro
colchete está a informação da linha e no segundo colchete está a informação da coluna.
Para armazenar as 4 notas do segundo aluno deveríamos fazer o seguinte:
nota[1] [0] = 6.0
nota[1] [1] = 7.0
nota[1] [2] = 5.0
nota[1] [3] = 8.0
Para armazenar as 4 notas do terceiro aluno deveríamos fazer o seguinte:
nota[2] [0] = 9.0
nota[2] [1] = 8.0
nota[2] [2] = 9.0
nota[2] [3] = 6.0
E assim sucessivamente até que se armazene as notas de todos os oito alunos.
Atribuição de uma Matriz
Uma matriz de duas dimensões é atribuída pela instrução conjunto já utilizada para definir o uso de uma
matriz de uma dimensão, sendo bastante parecidas em sua referência.
A sintaxe é: variável : conjunto[<dimensão1>:<dimensão2>] de <tipo de dado>, sendo que <dimensão1> e
<dimensão2> são a indicação do tamanho da tabela e <tipo de dado> o tipo da matriz, que poderá ser formada
por valores reais, inteiros, lógicos ou caracteres.
60
Fundamentos de Programação
Leitura de dados de uma Matriz
A leitura de uma matriz de duas dimensões, assim como das matrizes de uma dimensão é processado passo
a passo, um elemento por vez. A instrução de leitura é leia seguida da variável mais os seus índices. A seguir,
são apresentados o fluxograma e a codificação em português estruturado da leitura das notas dos alunos, cálculo
da média e a sua apresentação.
Observe que está sendo considerada a leitura de 4 notas de 8 alunos. Assim sendo, a tabela em questão
armazena 32 elementos. Um detalhe a ser considerado é a utilização de duas variáveis para controlar os dois
índices de posicionamento de dados na tabela. Anteriormente, utilizamos a variável índice 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 índice
passa a ser tratada como lin, controlando a posição da linha, e a segunda variável será tratada como col,
controlando a posição da coluna. Muitos programadores utilizam i no lugar de lin e utilizam j no lugar de col.
Analisando o fluxograma, temos a inicialização das variáveis lin e col como 1, ou seja, a leitura será efetuada
na primeira linha da primeira coluna. Em seguida é iniciado em primeiro lugar o looping da variável lin para
controlar a posição em relação às linhas e depois é iniciado o looping da variável col para controlar a posição em
relação às colunas.
Veja que, ao serem iniciados os valores para o preenchimento da tabela, eles são colocados na posição
nota[1,1], lembrando que o primeiro valor dentro dos colchetes representa a linha e o segundo representa a
coluna.
Será digitado então, para o primeiro aluno a primeira nota. Depois é incrementado mais 1 em relação à
coluna, sendo colocada para a entrada a posição nota[1,2], linha 1 coluna 2. Desta forma, será digitado para o
primeiro aluno a segunda nota.
Quando o contador de coluna atingir o valor 4, ele será encerrado e será efetuado o cálculo e a apresentação
da média. Em seguida o contador da variável lin será incrementado com mais 1, tornando-se 2. Será então
inicializado novamente o contador col em 1, permitindo que seja digitado um novo dado na posição nota[2,1].
O mecanismo de preenchimento estender-se-á até que o contador de linhas atinja o seu último valor, no
caso 8. Esse looping é o principal, tendo a função de controlar o posicionamento na tabela por aluno. O segundo
looping, mais interno, controla o posicionamento das notas.
Codificação em Linguagem C
main( )
{
float nota[8][4];
float soma, media, valor;
int lin, col;
clrscr( );
for( lin = 0; lin < 8; lin++ )
{
soma = 0;
for( col = 0; col < 4; col++ )
{
printf ( “Digite a nota %d do aluno %d : “, col+1, lin+1 );
scanf ( “%f”, &valor );
nota[lin][col] = valor;
soma = soma + nota[lin][col];
}
61
Escola Alcides Maya - Primeiro Módulo
media = soma / 4;
printf ( “A media do aluno e: %4.1f \n”, media );
}
getch( );
}
Exemplos de Aula
Para demonstrar a utilização de uma matriz de duas dimensões, considere os exemplos apresentado sem
seguida:
Primeiro exemplo
Desenvolver um programa que efetue a leitura das receitas e despesas dos primeiros 6 meses de uma
empresa. Calcular e armazenar o resultado mensal da empresa.
Algoritmo
1 – Ler as receitas de cada mês
2 – Ler as despesas de cada mês
3 – Calcular o resultado de cada mês subtraindo a receita da despesa
4 – Apresentar as receitas, as despesas e o resultados de cada mês
Pela característica do programa a ser desenvolvido, seria ideal utilizarmos uma matriz 3 x 6, para armazenar
estes dados. Nas colunas teremos os meses, nas linhas teremos respectivamente receitas, despesas e resultados,
veja o desenho a seguir:
Janeiro
Fevereiro
Março
Receitas
Despesas
Resultados
Codificação em Linguagem C
main( )
{
float caixa[3][6];
float valor;
int lin, col;
clrscr( );
lin = 0;
for( col = 0; col < 6; col++ )
{
printf ( “Digite a receita do mes %d: “, col+1 );
scanf ( “%f”, &valor );
caixa[lin][col] = valor;
}
lin = 1;
for( col = 0; col < 6; col++ )
62
Abril
Maio
Junho
Fundamentos de Programação
{
printf ( “Digite a despesa do mes %d: “, col+1 );
scanf ( “%f”, &valor );
caixa[lin][col] = valor;
}
for( col = 0; col < 6; col++ )
caixa[2][col] = caixa[0][col] - caixa[1][col];
for( col = 0; col < 6; col++ )
{
printf ( “A receita
do mes %d e: %.2f \n”, col+1, caixa[0][col] );
printf ( “A despesa do mes %d e: %.2f \n”, col+1, caixa[1][col] );
printf ( “O resultado do mes %d e: %.2f \n”, col+1, caixa[2][col] );
}
getch( );
}
Exercícios de Fixação
1 – Desenvolva os algoritmos, seus respectivos fluxogramas e proceda a codificação em português estruturado
os seguintes programas:
1. Faça um programa para ler duas matrizes A e B, cada uma de duas dimensões com 5 linhas e 3 colunas.
Construir uma matriz C de mesma dimensão, que é formada pela soma dos elementos da matriz A com os
elementos da matriz B. Apresentar a matriz C.
2. Faça um programa para ler duas matrizes A e B, cada uma com 7 elementos. Construir uma matriz C, de
duas dimensões, em que a primeira coluna deverá ser formada pelos elementos da matriz A e a segunda coluna
deverá ser formada pelos elementos da matriz B. Apresentar a matriz C.
3. Faça um programa para ler 20 elementos para uma matriz qualquer, considerando que ela tenha o tamanho
de 4 linhas por 5 colunas, em seguida apresentar a matriz.
4. Faça um programa para ler uma matriz A de uma dimensão com 10 elementos. Construir uma matriz
C de duas dimensões com três colunas, em que a primeira coluna da matriz C é formada pelos elementos da
matriz A somados com mais 5, a segunda coluna é formada pelo valor do cálculo da fatorial de cada elemento
correspondente da matriz A e a terceira e última coluna deverá ser formada pelos quadrados dos elementos
correspondentes da matriz A . Apresentar a matriz C.
5. Faça um programa para ler duas matrizes A e B, cada uma com uma dimensão pra 12 elementos. Construir
uma matriz C de duas dimensões, sendo que a primeira coluna da matriz C deverá ser formada pelos elementos
da matriz A multiplicados por 2 e a segunda coluna deverá ser formada pelos elementos da matriz B subtraídos
de 5. Apresentar a matriz C.
6. Faça um programa para ler uma matriz A de duas dimensões com 5 linhas e 4 colunas. Construir uma matriz
B de mesma dimensão, onde cada elemento da matriz B deverá ser o fatorial de cada elemento correspondente
da matriz A . Apresentar ao final as matrizes A e B.
7. Faça um programa para ler uma matriz A de duas dimensões com 4 linhas e 5 colunas, armazenando
nessa matriz os valores das temperaturas em graus Celsius. Construir uma matriz B de mesma dimensão,
sendo que cada elemento da matriz B deverá ser o valor da temperatura em graus Fahrenheit de cada elemento
correspondente da matriz A . Apresentar ao final as matrizes A e B.
8. Faça um programa para ler uma matriz A de duas dimensões com 5 linhas e 5 colunas. Construir uma
matriz B de mesma dimensão, sendo que cada elemento da matriz B deverá ser o dobro de cada elemento
correspondente da matriz A, com exceção para os valores situados na diagonal principal (posições B[1,1], B[2,2],
B[3,3], B[4,4] e B[5.5] ) os quais deverão ser o triplo de cada elemento correspondente da matriz A . Apresentar
63
Escola Alcides Maya - Primeiro Módulo
ao final a matriz B.
9. Faça um programa para ler uma matriz A de duas dimensões com 7 linhas e 7 colunas. Construir uma
matriz B de mesma dimensão, sendo que cada elemento da matriz B deverá ser o somatório de cada elemento
correspondente da matriz A, com exceção para os valores situados na diagonal principal (posições B[1,1], B[3,3],
B[5.5] e B[7,7] ) os quais deverão ser o fatorial de cada elemento correspondente da matriz A . Apresentar ao final
a matriz B.
10. Faça um programa para ler uma matriz A de duas dimensões com 6 linhas e 5 colunas. Construir uma
matriz B de mesma dimensão, que deverá ser formada do seguinte modo: para cada elemento par da matriz A
deverá ser somado 5 e para cada elemento ímpar da matriz A deverá ser subtraído 4. Apresentar ao final a matriz
A e B.
11.Faça um programa para ler uma matriz A de duas dimensões com 4 linhas e 4 colunas. Apresentar o
somatório dos elementos situados na diagonal principal (posições A[1,1], A[2,2], A[3,3], A[4.4] ) da referida
matriz.
12. Faça um programa que leia uma matriz A de duas dimensões com 15 linhas e 15 colunas. Apresentar o
somatório dos elementos pares situados na diagonal principal da referida matriz.
13. Faça um programa que leia uma matriz A de duas dimensões com 7 linhas e 7 colunas. Ao final apresentar
o total de elementos pares existentes dentro da matriz.
14. Faça um programa que leia uma matriz de duas dimensões com 7 linhas e 7 colunas. Ao final apresentar
o total de elementos positivos, o total de elementos negativos e o total de elementos cujo valor é zero.
15. Faça um programa que leia uma matriz numérica de duas dimensões de 5 linhas e 8 colunas. No final
encontrar e apresentar desta matriz o maior valor lido e o menor valor lido.
16. Faça um programa que leia uma matriz de duas dimensões com 5 linhas e 5 colunas. Apresentar o
somatório dos elementos positivos situados na diagonal principal da referida matriz.
8. Programação Estruturada
Funções I
A partir desta aula serão estudados a aplicação e o uso de Funções.
Quando aprendemos conceitos de sub-rotinas em algoritmos, também falávamos sobre Funções.
Estas sub-rotinas também são conhecidas pela denominação de módulos, sub-programas, ou subalgoritmos.
Na linguagem C as sub-rotinas são tratadas como FUNÇÕES.
Na realidade, não importa como são chamadas, o que importa é a forma como funcionam e como devem ser
aplicadas em um programa, e é isto que iremos aprender a partir deste momento.
Iremos rever o conceito de criação estruturada de programas, pois para escrever um programa de computador
necessita-se de estudo (levantamento de todas as necessidades e detalhes do que deverá ser feito) e metodologia
(regras básicas que deverão ser seguidas).
Sem a aplicação de métodos não será possível resolver grandes problemas; quando muito, pequenos
problemas.
As Sub-rotinas
No geral, problemas complexos exigem algoritmos complexos. Mas sempre é possível dividir um problema
grande em problemas menores. Desta forma, cada parte menor tem um algoritmo mais simples, e é esse trecho
menor que é chamado de sub-rotina. Uma sub-rotina é na verdade um programa, e sendo um programa poderá
efetuar diversas operações computacionais (entrada, processamento e saída) e deverá ser tratada como foram
os programas projetados até este momento. As sub-rotinas são utilizadas na divisão de algoritmos complexos,
permitindo assim possuir a modularização de um determinado problema, considerado grande e de difícil
solução.
Quando trabalhamos com esta técnica, pode-se deparar com a necessidade de dividir uma sub-rotina em
outras tantas quantas forem necessárias, buscando uma solução mais simples de uma parte do problema maior.
O processo de dividir sub-rotinas em outras é denominado Método de Refinamento Sucessivo.
64
Fundamentos de Programação
O Método Top-Down
Desde muito tempo este é um dos processos mais simples e mais utilizados pelos programadores.
O processo de programar um computador torna-se bastante simples quando aplicado o método de utilização
de sub-rotinas (módulos de programas). Porém, a utilização dessas sub-rotinas deverá ser feita com aplicação
do método top down.
Um método bastante adequado para a programação de um computador é trabalhar com o conceito de
programação estruturada, pois a maior parte das linguagens de programação utilizadas atualmente também é, o
que facilita a aplicação deste processo de trabalho.
O método mais adequado para a programação estruturada é o Top-Down (De cima para baixo) o qual se
caracteriza basicamente por:
• Antes de iniciar a construção do programa, o programador deverá ter em mente as tarefas principais que
este deverá executar. Não é necessário saber como funcionarão, somente saber quantas são.
• Conhecidas todas as tarefas a serem executadas, tem-se em mente como deverá ser o programa principal,
o qual vai controlar todas as outras tarefas distribuídas em suas sub-rotinas.
• Tendo definido o programa principal, é iniciado o processo de detalhamento para cada sub-rotina. Desta
forma são definidos vários algoritmos, um para cada rotina em separado, para que se tenha uma visão do que
deverá ser executado em cada módulo de programa. Existem programadores que estabelecem o número máximo
de linhas de programa que uma rotina deverá possuir. Se o número de linhas ultrapassa o limite preestabelecido,
a rotina em desenvolvimento é dividida em outra sub-rotina (é neste ponto que se aplica o método de refinamento
sucessivo).
O método Top-Down faz com que o programa tenha uma estrutura semelhante a um organograma.
A utilização do método “de cima para baixo” permite que seja efetuado cada módulo de programa em
separado. Desta forma, cada um pode ser testado separadamente garantindo que o programa completo esteja
sem erro ao seu término.
Outro detalhe a ser considerado é que muitas vezes existem em um programa trechos de códigos que são
repetidos várias vezes. Esses trechos poderão ser utilizados como sub-rotinas, proporcionando um programa
menor e mais fácil de ser alterado num futuro próximo.
A utilização de sub-rotinas e o uso do método Top-Down na programação permitem ao programador elaborar
rotinas exclusivas. Por exemplo, uma rotina somente para entrada, outra para a parte de processamento e outra
para saída dos dados.
Aplicação prática do uso de Sub-Rotinas
As sub-rotinas podem ser subdivididas em dois tipos: Procedimentos e Funções. Entre estes dois tipos de
sub-rotinas existem algumas diferenças, mas o conceito é o mesmo para ambas.
Um Procedimento é um bloco de programa contendo início e fim e será identificado por um nome, por meio
do qual será referenciado em qualquer parte do programa principal ou do programa chamador da rotina.
Quando uma sub-rotina é chamada por um programa, ela é executada e ao seu término o controle de
processamento retorna automaticamente para a primeira linha de instrução após a linha que efetuou a chamada
de sub-rotina.
Uma função também é um bloco de programa, como são os procedimentos, contendo inicio e fim e sendo
identificada por um nome, por meio do qual também será referenciada em qualquer parte do programa principal.
Uma sub-rotina de função é na verdade muito parecida com uma sub-rotina de procedimento. A sua principal
diferença está no fato de uma função retornar um determinado valor.
As funções formam o alicerce da programação em C. Você faz toda a programação C dentro de uma função,
porque todos os programas devem incluir main, que é uma função.
Em outras linguagens como Pascal, são utilizados procedimentos e funções, FORTRAN utiliza somente
funções e a linguagem Assembly utiliza somente procedimentos.
A linguagem C utiliza somente funções com e sem retorno de valores, tornando-se um pouco diferente na
qualificação de sub-rotinas e funções, conforme a lógica de programação.
Mas, não se preocupe, isto não irá mudar a forma como você vai trabalhar na linguagem C.
Exercício de Aula
65
Escola Alcides Maya - Primeiro Módulo
Vamos criar um programa de calculadora que apresente um menu de seleções no programa principal. Esse
menu deverá dar ao usuário a possibilidade de escolher uma entre quatro operações aritméticas. Escolhida a
opção desejada, deverá ser solicitada à entrada de dois números e depois de processada a operação, deverá
ser exibido o resultado.
Este programa deverá ser um conjunto de cinco rotinas, sendo uma principal e quatro secundárias. A rotina
principal efetuará o controle das quatro rotinas secundárias que, por sua vez, pedirão a leitura de dois valores,
farão a operação e apresentarão o resultado obtido. A figura a seguir apresenta um organograma com a idéia de
hierarquização das rotinas do programa. A quinta opção não se caracteriza por ser uma rotina, apenas a opção
que vai encerrar o looping de controle do menu.
Tendo uma idéia da estrutura geral do programa, será escrito em separado cada algoritmo com os seus
detalhes de operação. Primeiro o programa principal e depois as outras rotinas, de preferência na mesma ordem
em que estão mencionadas no organograma.
É ideal que você codifique o programa aos poucos, como por exemplo: na definição do programa acima,
primeiro vamos testar o menu e ver se a interação entre as partes funciona.
Veja no programa a seguir:
main( )
{
/* chave incial da main */
char opcao;
while(opcao != ‘5’)
{
clrscr( );
/* chave inicial do laço while */
printf(“1 - Adicao\n”);
printf(“2 - Subtracao\n”);
printf(“3 - Multiplicacao\n”);
printf(“4 - Divisao\n”);
printf(“5 - Fim do programa\n”);
printf(“Escolha uma opcao: “);
opcao = getch( );
switch(opcao)
{
/* chave inicial do switch */
case ‘1’:
somar( );
break;
case ‘2’:
subtrair( );
break;
case ‘3’:
multiplicar( );
break;
case ‘4’:
dividir( );
break;
case ‘5’:
printf(“\nEncerrando o programa”);
break;
default:
66
Fundamentos de Programação
printf(“\nOpcao invalida”);
}
/* chave final do switch */
printf(“\nPressione uma tecla para continuar”);
getch( );
}
/* chave final do laço while */
}
/* chave final da main */
somar( )
{
printf(“\nFuncao de Soma”);
}
subtrair( )
{
printf(“\nFuncao de Subtracao”);
}
multiplicar( )
{
printf(“\nFuncao de Multiplicacao”);
}
dividir( )
{
printf(“\nFuncao de Divisao”);
}
Agora algumas considerações sobre o programa anterior:
• Na linha char opcao; declaramos a variável do tipo char para armazenar a opção de menu escolhida pelo
usuário.
• Na linha seguinte while(opcao != ‘5’) é o controle do laço de repetição: “Faça enquanto opção diferente de
5”.
• Logo após limpamos a tela e colocamos as opções do menu.
• Para ver a opção do usuário codificamos: opcao = getch( );
• Para verificar qual opção digitada pelo usuário foi escolhida a estrutura switch que é a mais adequada
quanto temos várias opções de um menu.
• No tratamento do primeiro caso, ou seja, se o usuário digitou 1 é para fazer a soma. Colocamos neste
case a linha: somar( ); que é a chamada para a função somar.
• No tratamento dos demais casos utilizamos a chamada para a função
subtrair( ); , multiplicar( ); e dividir( );
• Depois da chave final da função main( ) colocamos a declaração da funções
Se tudo funcionou corretamente nos comandos da função main, vamos agora fazer as modificações
necessárias em cada uma das funções. Devemos, então codificar os comandos para a execução das tarefas de
67
Escola Alcides Maya - Primeiro Módulo
cada uma das funções.
Veja como ficou a parte do programa relativa as funções somar, subtrair, multiplicar e dividir:
somar( )
{
float valorA, valorB, result;
printf(“\nRotina de Soma\n”);
printf(“Digite um valor para A: “);
scanf(“%f”,&valorA);
printf(“Digite um valor para B: “);
scanf(“%f”,&valorB);
result = valorA + valorB;
printf(“A soma de A com B e: %5.2f\n”,result);
}
subtrair( )
{
float valorA, valorB, result;
printf(“\nRotina de Subtracao\n”);
printf(“Digite um valor para A: “);
scanf(“%f”,&valorA);
printf(“Digite um valor para B: “);
scanf(“%f”,&valorB);
result = valorA - valorB;
printf(“A subtracao de A com B e: %5.2f\n”,result);
}
multiplicar( )
{
float valorA, valorB, result;
printf(“\nRotina de Multiplicacao\n”);
printf(“Digite um valor para A: “);
scanf(“%f”,&valorA);
printf(“Digite um valor para B: “);
scanf(“%f”,&valorB);
result = valorA * valorB;
printf(“A multiplicacao de A com B e: %5.2f\n”,result);
}
dividir( )
{
float valorA, valorB, result;
printf(“\nRotina de Divisao\n”);
printf(“Digite um valor para A: “);
scanf(“%f”,&valorA);
68
Fundamentos de Programação
printf(“Digite um valor para B: “);
scanf(“%f”,&valorB);
result = valorA / valorB;
printf(“A divisao de A com B e: %5.2f\n”,result);
}
Novas considerações sobre o programa::
• Na linha float valorA, valorB, result; declaramos as variáveis para ler os valores de A, de B e para armazenar
o resultado da operação matemática.
• Nas linhas seguintes pedidos para o usuário entrar com os dados relativos aos valores de A e de B
• Efetuamos o processamento (cálculo da operação matemática)
• Apresentamos os resultado do cálculo
Funções II
Funções dividem grandes tarefas de computação em tarefas menores. Funções apropriadas podem
freqüentemente esconder detalhes de operação de partes de programa que não necessitam conhecê-las,
esclarecendo o todo, e facilitando mudanças. Você usou a printf( ) sem conhecer detalhes de sua programação.
Provavelmente a principal razão da existência de funções é impedir que o programador tenha de escrever o
mesmo código repetidas vezes.
Funções simples
Vamos recordar como fazemos uma função de maneira bem simples analisando o programa abaixo:
main( )
{
clrscr( );
poemsg( );
printf(“Pressione uma tecla”);
getch( );
}
poemsg( )
{
printf(“Função que põe uma a mensagem na tela\n”);
}
Agora algumas considerações sobre o programa anterior:
• A função principal é sempre a função main( ), é a partir dela que chamamos a função poemsg( ).
• Os comandos da função main( ) estão encapsuladas entre as chaves ({...})
• Os comandos da função poemsg( ) também estão encapsuladas entre as chaves ({...})
• Na primeira linha de comando da função main( ) temos: clrscr( ); onde estamos chamando a função que
limpa a tela
• Na segunda linha de comando da função main( ) temos: poemsg( ); onde estamos chamando a função
que põe uma mensagem na tela.
• Repare que quando chamamos uma função ela vem acompanhada de ponto-e-vírgula (;)
• Após a chave final da função main( ) vem a declaração da função poemsg( )
• Repare que quando declaramos uma função ela não vem acompanhada de ponto-e-vírgula (;)
69
Escola Alcides Maya - Primeiro Módulo
Considerações importantes
Como você pode ver, a estrutura de uma função C é bastante semelhante a da função main( ). A única
diferença é que main( ) possui um nome especial, e é a função que dá inicio ao seu programa.
Todo programa em C começa com a função main( ).
Todas as funções em C começam com um nome seguido de parênteses e, após isto, chaves que envolvem
o corpo da função.
Do mesmo modo que chamamos uma função de biblioteca C (printf( ), getch( ), etc.) chamamos nossas
próprias funções como em poemsg( ).
Os parênteses que seguem o nome são necessários para que o compilador possa diferenciar a chamada a
uma função de uma variável que você esqueceu de declarar.
A chamada a uma função constitui uma instrução de programa, deve ser encerrada por ponto-e-vlrgula.
Entretanto, na definição de uma função, o ponto-e-vírgula não pode ser usado.
Variáveis locais
Cada função pode chamar outras funções. As variáveis que são declaradas dentro de uma função são
chamadas variáveis locais e são conhecidas somente dentro de seu próprio bloco.
Um bloco começa quando o computador encontra uma chave de abertura ({) e termina quando o computador
encontra uma chave de fechamento (}).
Um dos aspectos mais importantes que você deve entender sobre as variáveis locais é que elas existem
apenas durante a execução do bloco de código onde estão declaradas; isto é, uma variável local é criada quando
se entra em seu bloco e destruída na saída.
Vejamos o programa a seguir:
main( ) {
char nome[ ]=”Escola Tecnica Alcides Maya”;
printf(“%s \n”,nome);
poemsg( );
printf(“Pressione uma tecla”);
}
poemsg( )
{
char nome[ ]=”Possui professores dedicados e competentes\n”;
printf(“%s \n”,nome);
}
Agora algumas considerações sobre o programa:
• A variável do tipo string declarada na função main( ), não tem nada a ver com a variável declarada dentro
da função poemsg( ), são duas variáveis distintas entre si, e internas a cada função, por isto que não ocorre erro
ou conflito entre elas, apesar de possuírem os mesmos nomes.
Vejamos mais um exemplo para ficar bem claro estas informações:
main( )
{
char nome1[ ]=”Fred”;
char nome2[ ]=”Vilma”;
printf(“%s e %s são casados\n”, nome1, nome2);
poemsg( );
70
Fundamentos de Programação
printf(“%s e %s se amam\n”, nome1, nome2);
printf(“Pressione uma tecla”);
}
poemsg( )
{
char nome1[ ]=”Barney”;
char nome2[ ]=”Bety”;
printf(“%s e %s são casados\n”, nome1, nome2);
}
Agora algumas considerações sobre o programa:
• Veja que as variáveis nome1 e nome2 da função main( ), permanecem com as mesmas informações antes
e depois da chamada da função poemsg( ).
Variáveis globais
Nos programas utilizados até agora foram utilizadas variáveis declaradas dentro das funções, ou seja, dentro
de seu próprio bloco, consideradas, portanto privadas ao bloco onde foram declarada e nenhuma outra função
tem acesso direto a elas. O mesmo é verdadeiro para variáveis de outras funções.
Cada variável local numa rotina passa a existir somente quando a função é chamada e deixa de existir
quando a função termina.
Devido às variáveis locais virem e irem com a ativação da função, elas não retêm seus valores de uma
chamada para outra, e devem ser explicitamente inicializadas a cada ativação. Se elas não forem inicializadas,
conterão lixo.
Como uma alternativa, é possível definir variáveis que sejam externas a todas as funções, isto é, variáveis
globais que possam ser acessadas pelo nome por qualquer função que assim o desejar.
Visto que as variáveis externas sejam globalmente acessíveis, podem ser usadas, ao invés de listas de
argumentos, para comunicar dados entre funções. Além do mais, devido às variáveis externas existirem
permanentemente, ao invés de aparecerem com a ativação e desativação de funções, elas retêm seus valores
mesmo quando as funções que as acessam deixam de existir.
Uma variável externa deve ser definida fora de qualquer função; isso aloca armazenamento para as mesmas.
A variável deve também ser declarada em cada função que desejar acessa-la; isso pode ser feito por uma
declaração explícita extern ou implicitamente pelo contexto.
Vamos ver um pequeno programa que possa exemplificar o uso de variáveis externas.
char nome1[ ]=”Fred”;
char nome2[ ]=”Vilma”;
main( )
{
extern char nome1[ ];
extern char nome2[ ];
printf(“%s e %s sao casados\n”, nome1, nome2);
poemsg( );
printf(“%s e %s se amam\n”, nome1, nome2);
71
Escola Alcides Maya - Primeiro Módulo
printf(“Pressione uma tecla”);
getch( );
}
poemsg( )
{
extern char nome1[ ];
extern char nome2[ ];
printf(“%s e %s sao casados\n”, nome1, nome2);
}
Agora algumas considerações sobre o programa:
• Veja que a declaração das variáveis nome1 e nome2 antes da função main( ), isto identifica estas variáveis
como sendo variáveis globais, ou seja, externas.
• No inicio da função main( ) e também da função poemsg( ), declaramos o uso das variáveis globais com a
declaração: extern char nome1[ ]; e extern char nome2[ ]; com isto estamos informando ao programa que vamos
usar as variáveis globais declaradas antes de main( ).
Considerações importantes
As variáveis globais costumam ser chamadas de variáveis externas na linguagem C.
Em main( ), as variáveis externas nome1 e nome2 são definidas nas primeiras linhas do exemplo acima, que
definem seus tipos e alocam área de armazenamento para as mesmas.
Sintaticamente definições externas são iguais às declarações que já usamos anteriormente, mas, como
ocorrem fora das funções, as variáveis são externas.
Antes de uma função usar uma variável externa, o nome da mesma deve ser conhecido pela função. Uma
maneira de fazer isso é escrever uma declaração extern na função; a declaração é igual à anterior, exceto que é
precedida da palavra-chave extern
Em certas circunstâncias, a declaração extern pode ser omitida. Se a definição externa de uma variável ocorrer
no arquivo fonte antes de seu uso numa função particular, então não há a necessidade de uma declaração extern
na função. As declarações extern em main( ) e poemsg( ) são, portanto, redundantes.
De fato, a prática comum é colocar a definição de todas as variáveis externas no início do arquivo fonte e,
então, omitir todas as declarações extern.
Se o programa está em vários arquivos fonte, e uma variável é definida em, digamos, arquivo1 e usada
em arquivo2, então uma declaração extern é necessária no arquivo2 para conectar as duas ocorrências da
variável.
Baseado nisto o programa anterior poderia ter sido escrito da seguinte forma:
char nome1[ ]=”Fred”;
char nome2[ ]=”Vilma”;
main( )
{
clrscr( );
printf(“%s e %s sao casados\n”, nome1, nome2);
poemsg( );
printf(“%s e %s se amam\n”, nome1, nome2);
72
Fundamentos de Programação
printf(“Pressione uma tecla”);
getch( );
}
poemsg( )
{
printf(“%s e %s sao casados\n”, nome1, nome2);
}
Você deve observar que estamos usando as palavras declaração e definição cuidadosamente quando nos
referimos a variáveis externas nessa seção. “Definição” refere-se ao local onde a variável está sendo criada ou
à qual é atribuída uma área de armazenamento; “declaração” refere-se ao local onde a natureza da variável é
dada, sem alocação de área de armazenamento.
A propósito, há uma tendência de se fazer com que tudo em vista seja uma variável extern porque simplifica
aparentemente a comunicação – listas de argumentos são curtas e as variáveis estão sempre onde você as quer.
Mas variáveis externas estão sempre lá, mesmo quando você não as quer.
Este estilo de codificação é cheio de perigos porque leva a programas cujas conexões de dados não são
óbvias – variáveis podem ser mudadas de modo inesperado e inadvertidamente, e o programa é difícil de
modificar se o for necessário.
Nós ainda não tratamos funções com passagem de argumentos, mas logo vamos ver como isto funciona, e
ai então, poderemos identificar melhor o uso destas variáveis.
Refinamento Sucessivo
O refinamento sucessivo é uma técnica de programação que possibilita dividir uma função em outras funções.
Deve ser aplicado com muito critério para que o programa a ser construído não se torne desestruturado e difícil
de ser compreendido por você ou por outras pessoas.
Na aula anterior vimos um programa que utilizava um menu na rotina principal e 4 funções para efetuar
cálculos básicos (soma, subtração, multiplicação e divisão).
Neste programa podemos aplicar esta técnica, aliada a declaração de variáveis externas.
Por exemplo: a entrada e a saída são efetuadas com as mesmas variáveis. Observe que as variáveis valorA,
valorB e result são definidas quatro vezes, uma em cada função.
A solução é definir as variáveis valorA, valorB e result como externas e construir mais duas funções, uma para
a entrada e a outra para a saída. As quatro funções atuais serão diminuídas em números de linhas, pois tudo o
que se repete nas funções será retirado.
Veja no programa a seguir a definição das variáveis externas e a definição das duas novas funções de
entrada e de saída. Perceba nas funções estão sendo declaradas as variáveis que serão utilizadas pela função,
fazendo uso do conceito de variáveis externas.
float valorA, valorB, result;
main( )
{
char opcao=0;
while(opcao != ‘5’)
{
clrscr( );
printf(“1 - Adicao\n”);
73
Escola Alcides Maya - Primeiro Módulo
printf(“2 - Subtracao\n”);
printf(“3 - Multiplicacao\n”);
printf(“4 - Divisao\n”);
printf(“5 - Fim do programa\n”);
printf(“Escolha uma opcao: “);
opcao = getch( );
switch(opcao)
{
case ‘1’:
somar( );
break;
case ‘2’:
subtrair( );
break;
case ‘3’:
multiplicar( );
break;
case ‘4’:
dividir( );
break;
case ‘5’:
printf(“\nEncerrando o programa”);
break;
default:
printf(“\nOpcao invalida”);
}
printf(“\nPressione uma tecla para continuar”);
getch( );
}
}
somar( )
{
printf(“\nRotina de Soma\n”);
entrada( );
result = valorA + valorB;
saida( );
}
subtrair( )
{
printf(“\nRotina de Subtracao\n”);
entrada( );
result = valorA - valorB;
saida( );
}
74
Fundamentos de Programação
multiplicar( )
{
printf(“\nRotina de Multiplicacao\n”);
entrada( );
result = valorA * valorB;
saida();
}
dividir( )
{
printf(“\nRotina de Divisao\n”);
entrada( );
result = valorA / valorB;
saida( );
}
entrada( )
{
printf(“Digite um valor para A: “);
scanf(“%f”,&valorA);
printf(“Digite um valor para B: “);
scanf(“%f”,&valorB);
}
saida( )
{
printf(“O resultado de A com B e: %5.2f\n”,result);
}
Agora algumas considerações sobre o programa anterior:
•
•
•
•
•
•
Antes da função main( ), definimos as variáveis externas: float valorA, valorB, result;
Nas funções de cálculo declaramos as variáveis externas: extern float valorA, valorB, result;
Também nas funções de cálculo fizemos a chamada da função de entrada de dados: entrada( );
E conseqüentemente a chamada da função de saída de dados: saida( );
Na nova função de entrada declaramos as variáveis externas: extern float valorA, valorB;
Na nova função de saída declaramos a variável externa: extern float result;
Funções III
As funções formam o alicerce da programação. Conforme você aumentar a sua prática em programação,
seus programas tomarão uma aparência modular quando você começar a programação com funções.
Estilos e Protótipos das Funções
As funções em C foram grandemente modificadas durante o processo de padronização ANSI. Este novo
padrão de C é grandemente baseado no protótipo de funções usado em C++. Conforme você lê vários artigos,
livros, e revistas sobre C, verá diversas variações usadas para descrever as funções.
75
Escola Alcides Maya - Primeiro Módulo
Prevendo a necessidade que você vai encontrar em definir o tipo de função a ser utilizada vamos introduzir
aqui o conhecimento sobre protótipo de funções.
Protótipos de Funções
As declarações de função começam com o protótipo da função C. O protótipo da função é simples e é incluído
no início do código do programa para notificar o compilador do tipo e do número de argumentos que uma função
utilizará.
Embora outras variações sejam legais, sempre que possível você deve utilizar a forma do protótipo de função
que é uma réplica da linha de declaração da função. Vamos fazer isto através de exemplos, então nos próximos
exemplos você terá uma noção mais aprofundada sobre os protótipos das funções.
Funções que não retornam um valor e não recebem argumentos
O programa a seguir exemplifica um programa que não recebe nenhum argumento e não retorna nenhum
valor. A declaração void foi batizada pelo comitê ANSI para a função que não retornam nada e não recebem
nada.
void somar(void);
main( )
{
somar( );
printf(“\nPressione uma tecla para continuar”);
}
void somar(void)
{
int valorA, valorB, result;
printf(“\nRotina de Soma\n”);
printf(“Digite um valor para A: “);
scanf(“%d”,&valorA);
printf(“Digite um valor para B: “);
scanf(“%d”,&valorB);
result = valorA + valorB;
printf(“A soma de A com B e: %d\n”,result);
}
Agora algumas considerações sobre o programa anterior:
• Antes da função main( ), declaramos o protótipo da função somar: void somar(void); onde o primeiro void
está identificando que a função somar não retorna nenhuma informação para a função chamadora. O segundo
void que está entre parênteses informa que a função chamadora não vai passar nenhum argumento para a
função chamada.
• Após a chave final do main (}) é definida a função somar: void somar(void) que deve ser coerente com o
seu protótipo antes da função main.
Funções que retornam um valor
O programa a seguir exemplifica o retorno de uma informação da função chamada.
int somar(void);
76
Fundamentos de Programação
main( )
{
int soma;
soma = somar( );
printf(“A soma de A com B e: %d\n”, soma);
printf(“\nPressione uma tecla para continuar”);
}
int somar(void)
{
int valorA, valorB, result;
printf(“\nRotina de Soma\n”);
printf(“Digite um valor para A: “);
scanf(“%d”,&valorA);
printf(“Digite um valor para B: “);
scanf(“%d”,&valorB);
result = valorA + valorB;
return(result);
}
Agora algumas considerações sobre o programa anterior:
• Antes da função main( ), declaramos o protótipo da função somar: int somar(void); onde identificamos que
a função somar vai retornar um valor inteiro.
• Dentro do main( ) declaramos a variável soma para receber o valor retornado int soma;
• Ainda dentro do main( ) armazenamos o resultado retornado da função somar na variável soma através
da linha de comando: soma = somar( );
• No início da função somar ela está definida da seguinte forma: int somar(void)
• Dentro da função somar temos o retorno de um valor inteiro através linha de comando: return(result);
O comando return
Nos programas anteriores mostramos funções que retornam ao programa que chamou quando encontram a
chave ( } ) que termina a função. Não há necessidade de uma instrução return.
O comando return causa a atribuição de qualquer expressão entre parênteses a função que chamadora.
Então quando somar( ) é chamada por main( ) a variável soma adquire o valor do calculado pela função somar.
A variável soma é local a main( ), mas o valor de result é mandado para main( ) pelo comando return. Este
valor pode, então, ser atribuído a uma variável ou fazer parte de alguma expressão.
O comando return tem dois usos importantes:
Primeiro: você pode usar return( ) para devolver um valor e retornar, imediatamente, para a próxima instrução
do código de chamada.
Segundo: você pode usá-lo, sem os parênteses, para causar uma saída imediata da função na qual ele se
encontra; isto é, return fará com que a execução do programa volte para o código de chamada assim que o
computador encontrar este comando, o que ocorre, em geral, antes da última instrução da função.
Você pode colocar mais de um comando return em suas funções.
Uma das limitações do comando return( ) é que ele pode retornar somente um único valor à função que
chama.
77
Escola Alcides Maya - Primeiro Módulo
Funções que recebem argumentos e retornam um valor
O programa a seguir é uma variação do programa anterior, que exemplifica a passagem de informações entre
a função chamadora e a função chamada.
int somar(int valorA, int valorB);
main( )
{
int soma, valA, valB;
clrscr( );
printf(“Digite um valor para A: “);
scanf(“%d”, &valA);
printf(“Digite um valor para B: “);
scanf(“%d”, &valB);
soma = somar(valA, valB);
printf(“A soma de A com B e: %d\n”, soma);
printf(“\nPressione uma tecla para continuar”);
getch( );
}
int somar(int valorA, int valorB)
{
int result;
printf(“\nRotina de Soma\n”);
result = valorA + valorB;
return(result);
}
Agora algumas considerações sobre o programa:
• Antes da função main( ), declaramos o protótipo da função somar: int somar(int valorA, int valorB); onde
identificamos que a função somar vai retornar um valor inteiro e vai receber como argumento dois valores inteiros
valorA e valorB.
• Dentro do main( ) declaramos a variável soma para receber o valor retornado int soma,valA,valB; e também
as variáveis que onde serão digitados os valores a serem passados como argumentos para a função somar.
• Ainda dentro do main( ) armazenamos o resultado retornado da função somar na variável soma através
da linha de comando: soma = somar(valA, valB);
• No início da função somar ela está definida da seguinte forma: int somar(void)
• Dentro da função somar temos o retorno de um valor inteiro através linha de comando: return(result);
78
Fundamentos de Programação
Funções IV
As funções podem ser utilizadas da forma mais simples possível, como as que não recebem nenhuma
informação e também não retornam nenhuma informação. Mas podem ser um pouco mais sofisticadas podendo
receber informações de quem as chamou e se for necessário retornar uma informação para a função que a
chamou.
Vamos rever estes conceitos, com maiores detalhes, para que você não tenha dúvidas.
Protótipos de Funções
Na aula anterior estudamos que as declarações de uma função começam com o protótipo da função C. O
protótipo da função é simples e é incluído no início do código do programa para notificar o compilador do tipo e
do número de argumentos que uma função utilizará. Veja a sintaxe deste protótipo:
tipo_de_ retorno
nome_da_função( tipo(s)_argum
nome(s)_argum );
Veja o significado desta sintaxe:
• A função pode ser do tipo void, int, float e assim por diante, específicado em tipo_de_retorno.
• O nome_da_função é um nome significativo para descrever a função.
• Se for passado alguma informação para a função, devemos fornecer um tipo_argum seguido por um
nome_argum.
Os tipos de argumentos também podem ser do tipo void, int, float, etc. Podemos passar muitos valores para
a função repetindo o tipo de argumento e nome separados por uma vírgula.
A própria função é um pedaço de código encapsulado que segue a definição da função main .
A função têm a seguinte sintaxe:
tipo_de_retorno nome_da_função( tipo(s)_argum nome(s)_argum )
{
.
.
(declaração de dados e corpo da função)
.
.
return( );
}
Notamos que a primeira linha da função é idêntica (exceto pela ausência do ponto-e-vírgula (;)) à do protótipo
que é listado no início de um programa.
Vejamos um exemplo de um programa utilizando uma função.
int somar( int x, int y );
/* protótipo da função */
main( )
{
int a,b,c;
a=5;
b=93;
c = somar( a, b );
/* chamada da função */
79
Escola Alcides Maya - Primeiro Módulo
printf(“%d + %d = %d\n”, a, b, c);
}
int somar( int x, int y )
{
int z;
/* declaração da função */
z = x + y;
return(z);
}
/* tipo de retorno da função */
Veja algumas considerações sobre o programa acima:
• Antes da função main( ), declaramos o protótipo da função somar: int somar( int x, int y ); onde o protótipo
explica que a função aceitará dois argumentos int e retorna um valor tipo int. Na verdade, o padrão ANSI sugere
que toda a função seja prototipada num arquivo de cabeçalho separado. Como podemos presumir, é assim que
os arquivos de cabeçalho são associados às suas bibliotecas C apropriadas. Para programas simples, você pode
incluir o protótipo da função dentro do corpo do programa
• Na chamada da função: c = somar( a, b ); estamos atribuindo o valor de retorno da função a uma
variável
• Logo após a chave final da função main temos a declaração da função: int somar( int x, int y ) , que não
tem ponto-e-vírgula.
• E finalmente, antes da chave final da função: return(z); retornamos para a função chamadora o resultado
do cálculo.
Chamada por valor
No programa anterior, os argumentos foram passados por valor para a função somar.
Quando variáveis são passadas dessa maneira, uma cópia do valor da variável é passada para a função.
Como uma cópia é passada, a variável no programa de chamada não é alterada.
Chamar uma função por valor é um meio popular de passar informações para uma função e é o método
padrão em C.
A limitação desta técnica (“chamada por valor”) é que somente um valor é retornado pela função.
Chamada por referência
Em uma chamada por referência, o endereço do argumento, e não seu valor, é passado para a função. Esta
passagem exige menos memória pelo programa do que a chamado por valor.
Quando usamos uma chamada por referência, as variáveis na chamada do programa podem ser alteradas.
A vantagem desta técnica (“chamada por referência”) é que mais de um valor pode ser retornado pela
função.
Vejamos o programa anterior utilizando esta técnica:
int somar( int *x, int *y );
main( )
{
int a,b,c;
a=5;
b=93;
80
Fundamentos de Programação
c = somar( &a, &b );
printf(“%d + %d = %d\n”, a, b, c);
}
int somar( int *x, int *y )
{
int z;
z = *x + *y;
return(z);
}
Veja algumas considerações sobre o programa acima:
• Antes da função main( ), declaramos o protótipo da função somar: int somar( int *x, int *y ); onde o protótipo
informa que a função aceitará dois argumentos int passados como uma chamada por referência.
• Na chamada da função: c = somar( &a, &b ); estamos passando os endereços de memória das variáveis
a e b, permitindo que se possa alterar o conteúdo destas variáveis dentro da função chamada, o que não ocorre
no exemplo acima. (No próximo programa vamos ver um exemplo onde isto é realizado)
• Após a função main temos a declaração da função: int somar( int *x, int *y )
• No comando: z = *x + *y; podemos lê-lo da seguinte forma: “O conteúdo apontado pela variável x será
somado ao conteúdo apontado pela variável y e atribuído a variável z”.
• E na linha: return(z); retornamos para a função chamadora o resultado do cálculo.
Vejamos um exemplo, que utiliza melhor esta técnica:
void somar( int *x, int *y, int *z );
main( )
{
int a,b,c;
a = 5;
b = 93;
somar( &a, &b, &c );
printf(“%d + %d = %d\n”, a, b, c);
}
void somar( int *x, int *y, int *z )
{
*x = 10;
*y = 20;
*z = *x + *y;
}
Veja algumas considerações sobre o programa acima:
81
Escola Alcides Maya - Primeiro Módulo
• Na declaração do protótipo da função somar: void somar( int *x, int *y, int *z ); informamos que esta função
não irá retornar nenhum informação (void), e que a função aceitará três argumentos int passados como uma
chamada por referência.
• Note que na função main, antes da chamada da função somar, estamos atribuindo um valor para a variável
a: a = 5; e outro para a variável b: b = 93;
• Na chamada da função: somar( &a, &b, &c ); estamos passando os endereços de memória das variáveis
a, b e c, permitindo que se possa alterar o conteúdo destas variáveis dentro da função chamada. Nesta função
não estamos atribuíndo um valor de retorno a nenhuma variável, porque a função foi declarada como void
• Após a função main temos a declaração da função: void somar( int *x, int *y, int *z )
• Dentro desta função estamos alterando o conteúdo das variáveis a e b, através dos comandos de
atribuição: *x = 10; (Lê-se: “O conteúdo apontado pela variável x recebe o valor 10”, significando que o conteúdo
da variável a será alterado após esta atribuição), o mesmo ocorrendo com a variável b na atribuição: *y = 20;
Neste momento o conteúdo inicial da variável a e b é substituído pelos novos valores atribuidos através da
variáveis que apontam para seus endereços ( *x e *y ).
• No comando: *z = *x + *y; podemos lê-lo da seguinte forma: “O conteúdo apontado pela variável x será
somado ao conteúdo apontado pela variável y e atribuído ao conteúdo apontado pela variável z”.
• E não temos comando de return nesta função.
Funções V
Nesta aula vamos tratar dos Argumentos das Funções, que são parâmetros passados para as funções, ou
seja, informações que são levadas da função chamadora para a função chamada.
Estes argumentos são opcionais, algumas funções podem não receber argumentos enquanto outras podem
receber diversos argumentos.
Os argumentos podem ser misturados, ou seja, podemos utilizar diversos tipos de dados.
Argumentos de Função Formais e Reais
A definição de uma função contém uma lista de argumentos (ou parâmetros) chamada lista de argumentos
formais. A lista pode estar vazia ou pode conter qualquer combinação de tipos, como inteiro, ponto flutuante ou
caracteres.
Quando a função é realmente chamada de dentro do corpo do programa, uma lista de argumentos passa
para a função. Esta lista é chamada de lista de argumentos reais.
Função sem argumentos - void
Na ausência de argumentos da função, podemos usar o void. Usar void é adequado, mas não necessário.
O programa a seguir tem uma função simples chamada poemsg que não recebe argumentos e não retorna
um valor. A função main chama a função poemsg. Quando poemsg completa a sua tarefa, o controle retorna para
a função main.
void poemsg (void);
main( )
{
printf(“Este programa apresenta a soma de dois números\n”);
poemsg( );
}
void poemsg (void)
{
int a = 4;
int b = 7;
int c = 0;
c = a + b;
82
Fundamentos de Programação
printf (“%d + %d = %d” , a, b, c);
}
Algumas considerações sobre o programa acima:
• Na declaração do protótipo da função poemsg: void poemsg (void); informamos que esta função não
requer nenhum argumento de entrada e não irá retornar nenhuma informação (void)
Função com argumento de caracteres - char
Caracteres podem ser passados para uma função. No exemplo a seguir, um caractere será esperado do
teclado na função main e passado para a função poechar. A função getch será utilizada para ler um caracter do
teclado e retornar o valor do caractere digitado, sem apresentá-lo na tela.
Nós estamos acostumados a usar esta função para esperar uma tecla qualquer e seguir na execução do
programa, ou em um menu de escolha, para saber qual a opção teclada pelo usuário.
Na biblioteca padrão da linguagem C, estas outras funções de caractere estão relacionadas com getch: getc,
getchar e getche.
void poechar (char c);
main( )
{
char caracter;
printf(“Pressione uma tecla qualquer\n”);
caracter = getch( );
poechar(caracter);
}
void poechar (char c)
{
printf (“O caracter digitado foi..........................: %c\n” ,c);
printf (“O código ASCII do caracter digitado é: %d\n” ,c);
}
Algumas considerações sobre o programa acima:
• Na declaração do protótipo da função poechar: void poechar (char c); informamos que esta função requer
um dado do tipo char e que não irá retornar nenhuma informação (void)
• Na linha: caracter = getch( ); é lido o valor do caracter digitado
• Na linha: poechar(caracter); é passado para a função poechar o caracter digitado
• Na primeira linha da função poechar é apresentado o caracter digitado com o comando:
printf (“O
caracter digitado foi..........................: %c\n” ,c);
• E aproveitando apresentamos o valor ASCII do caracter digitado utilizando o parâmetro %d do caracter
digitado com o comando: printf (“O código ASCII do caracter digitado é: %d\n” ,c);
Função com argumento de inteiros - int
83
Escola Alcides Maya - Primeiro Módulo
Neste programa, um único int será lido do teclado com a função scanf. Esse int será passado para a função
raio. A função raio utiliza o raio fornecido para calcular e escrever a área de um círculo, o volume da esfera e a
área da superfície da esfera.
void raio (int r);
main( )
{
int vlraio;
printf(“Informe o raio, como um valor inteiro: “);
scanf(“%d”, &vlraio);
raio(vlraio);
}
void raio (int r)
{
float area, volume, superficie;
area
= 3.14159 * (float) (r*r);
superficie = 3.14159 * 4.0 * (float) (r*r);
volume = 3.14159 * 4.0 / 3.0 * (float) (r*r*r);
printf (“O raio ‚......................: %d\n” ,r);
printf (“A área do círculo....: %f\n” ,area);
printf (“A área da esfera .....: %f\n” ,superficie);
printf (“O volume da esfera..: %f\n” ,volume);
}
Algumas considerações sobre o programa acima:
• Na declaração do protótipo da função raio: void raio (int r); informamos que esta função requer um dado
do tipo int e que não irá retornar nenhuma informação (void)
• Na função main vamos ler o valor do raio e chamar a função que faz os cálculos passando como argumento
o valor do raio na linha: raio(vlraio);
• Note que dentro da função raio, estamos recebendo como parâmetro a variável r que possui o raio.
• Veja também que nos cálculos estamos fazendo o uso de um cast (float) na frente da linha que utiliza o
parâmetro r, que é inteiro, forçando o cálculo para ser convertido para float, é isto que significa o cast.
Função com argumento em ponto flutuante - float
Os números em ponto flutuante são tão simples de ser passados como argumentos quanto os inteiros. No
exemplo a seguir vamos ler o salário bruto de uma pessoa e a taxa de INSS para o desconto da previdência
social. A função que calcula o salário líquido vai receber estes dois parâmetros, calcular e apresentar o valor do
salário líquido.
84
Fundamentos de Programação
void calc_sal ( float sb, float tx );
main( )
{
float salbruto, txinss;
printf(“Digite o valor do salário bruto: “);
scanf(“%f”, &salbruto);
printf(“Digite a taxa de desconto do INSS: “);
scanf(“%f”, &txinss);
calc_sal (salbruto, txinss);
}
float calc_sal ( float sb, float tx )
{
float saliq;
saliq = sb - (sb * tx / 100);
printf(“O valor do salário líquido é: %12.2f\n”, saliq);
}
Algumas considerações sobre o programa acima:
• Na declaração do protótipo da função calc_sal: void calc_sal ( float sb, float tx ); informamos que esta
função requer dois dados do tipo float e que não irá retornar nenhuma informação.
• Na função main vamos ler o valor do salário bruto e a taxa de desconto do inss chamamos a função
calc_sal, que calcula e apresenta o salário líquido.
Funções VI
Nesta aula vamos tratar dos inúmeros tipos de funções. Um tipo de função é o tipo de valor retornado pela
função. Na aula anterior os nossos exemplos não retornavam nenhum valor e, portanto elas eram do tipo void.
Agora iremos trabalhar com várias funções que retornam tipos de dados diferentes.
Função do tipo void
Nós já trabalhamos com os tipos de função void, de modo que o próximo exemplo será um pouco mais
elaborado. Na linguagem C a informação numérica pode ser formatada em hexadecimal, decimal e octal, mas
não em binário. A especificação de dados no formato binário é útil quando você estiver usando aritmética binária
ou desenvolvendo máscaras de bits.
A função binario converte um número decimal informado pelo teclado para uma representação binária. Os
dígitos binários são armazenados individualmente numa matriz. Para visualizar o número binário, você precisa
escrever o conteúdo da matriz.
85
Escola Alcides Maya - Primeiro Módulo
void binario ( int numero );
main( )
{
int numero;
printf(“Digite um numero decimal: “);
scanf(“%d”, &numero);
printf(“Este numero em binario e: “);
binario(numero);
}
void binario ( int numero )
{
int i=0;
int matriz[40];
matriz[0]=0;
if(numero)
{
while(numero != 0)
{
matriz[i] = (numero % 2);
numero /= 2;
i++;
}
--i;
}
for( ; i >= 0; i-- )
printf(“%d”, matriz[i]);
}
Algumas considerações sobre o programa acima:
• Na declaração do protótipo da função binario: void binario ( int numero ); informamos que esta função
requer um argumento do tipo inteiro e que a função não irá retornar nenhuma informação;
• A função binario está convertendo o número para binário fazendo divisões sucessivas por dois. O número
na base dez será o quociente da divisão anterior. O resto, após cada divisão, será um ou zero. O resto será o
dígito binário.
86
Fundamentos de Programação
Função do tipo char
A função maiuscula aceita um argumento char e retorna um argumento também char.
char maiuscula ( char letra );
main( )
{
char letramai, letramin;
printf(“Digite uma letra minúscula: “);
scanf( “%c”, &letramin);
letramai = maiuscula ( letramin );
printf( “A letra digitada em maiúsculo é: %c “, letramai);
}
char maiuscula ( char letra )
{
if (letra >= ‘a’ && letra <= ‘z’)
letra = letra + ‘A’ - ‘a’;
return(letra);
}
Algumas considerações sobre o programa acima:
• Na declaração do protótipo da função maiuscula: char maiuscula ( char letra ); informamos que esta
função requer um argumento do tipo char e que a função não irá retornar um argumento também do tipo char;
• Na função main é pedido para o usuário digitar uma letra em minúscula.
• Na função maiuscula, temos a linha: if (letra >= ‘a’ && letra <= ‘z’) onde verificamos se o caracter recebido
é uma letra minúscula e se isto for verdade convertemos a letra para maiúscula na linha: letra = letra + ‘A’ - ‘a’;
caso contrário retornamos o próprio caracter digitado.
Função do tipo int
A função cubo aceita um número gerado em main, eleva este número ao cubo e retorna o valor int para main.
O número original e o cubo serão impressos na tela.
int cubo ( int numero );
main( )
{
int i, num;
for ( i=0; i <= 20; i += 2 )
{
num = cubo ( i );
printf(“O cubo de %d e’ %d \n”, i, num);
}
}
int cubo ( int numero )
{
return(numero * numero * numero);
}
87
Escola Alcides Maya - Primeiro Módulo
Algumas considerações sobre o programa acima:
• Na declaração do protótipo da função cubo: int cubo ( int numero ); informamos que esta função requer um
argumento do tipo int e que a função não irá retornar um argumento também do tipo int;
• Na função o cálculo é realizado dentro do próprio retorno: return(numero * numero * numero);
Exercícios de Fixação
1. Faça um programa que efetue o cálculo de uma prestação em atraso. Para tanto, utilize a fórmula PREST
= VALOR + (VALOR * (TAXA / 100) * TEMPO). O programa deverá chamar uma função que faça a entrada
dos dados e o cálculo da prestação e retorne o valor deste cálculo para a função principal (main). Finalmente
apresentar o valor da prestação.
2. Faça um programa que possua uma função que efetue e permita apresentar o somatório dos N primeiros
números inteiros. (1+2+3+4+5+6+...+N). Esta função deverá receber da função principal (main) o número N e
no final esta mesma função deverá retornar o valor do somatório, que deverá ser apresentado ao usuário pela
função principal (main).
3. Faça um programa que possua uma função para calcular e apresentar o valor de uma potência de um
número qualquer. Ou seja, ao informar para a função o número e sua potência, deverá ser apresentado o
seu resultado. Por exemplo, se for mencionado no programa principal a função POTENCIA(2,3), deverá ser
apresentado o valor 8.
4. Faça um programa que possua uma função para calcular e apresentar a série de Fibonacci de N termos.
A série de Fibonacci é formada pela seqüência: 1, 1, 2, 3, 5, 8, 13, 21, 34,...etc. Está série caracteriza-se pela
soma de um termo posterior com o seu anterior subseqüente. A função main deve apenas chamar a função que
calcula a série de Fibonacci.
5. Faça um programa que efetua a leitura de um número inteiro e apresente uma mensagem informando se
o número é par ou ímpar. Usar uma função que identifique se o número é par ou ímpar.
6. Faça um programa que apresente um menu com as seguintes opções de cálculos:
• Calcular a área do quadrado
• Calcular a área do retângulo
• Calcular a área do circulo
• Encerrar o programa
Estes cálculos devem ser realizados em funções, ou seja, deverá ter uma função para cada tipo de cálculo.
Cada função deverá ter entrada de dados (digitação dos dados para o cálculo), processamento dos dados
(cálculos propriamente ditos) e a saída de dados (apresentação dos resultados dos cálculos).
7. Faça um programa que apresente um menu com as seguintes opções e efetue os respectivos cálculos
através de funções:
• Calcular o volume de uma lata de óleo
• Calcular o volume de uma caixa
• Encerrar o programa
8. Em uma Escola Técnica de Informática, há um professor que faz 6 provas. Faça um programa para
calcular a média dos alunos de uma escola. O programa deverá ter um menu com as seguintes informações:
• Calcular a média
• Encerrar o programa
O cálculo da média deverá ser realizado em uma função onde deverá ser solicitado o valor das 6 notas
escolares, efetuar o cálculo da média e apresentar no final o resultado obtido conforme a tabela a seguir:
[00,05)
- Reprovado
[05,07)
- Recuperação
[07,09)
- Satisfatório
[09,10]
- Ótimo
9. Faça um programa para ler uma temperatura em graus Celsius. Criar uma função que converte a
temperatura de Celsius para Fahrenheit. A fórmula de conversão é F  ( 9 * C + 160 ) / 5, sendo F a temperatura
em Fahrenheit e C a temperatura em Celsius. A função de conversão deve receber como entrada de dados
a temperatura em Celsius em tipo de dado float, fazer a conversão e retornar o valor convertido em graus
Fahrenheit.
88
Fundamentos de Programação
10. Faça um programa para ler uma temperatura em graus Fahrenheit. Criar uma função que converte a
temperatura de Fahrenheit para Celsius. A fórmula de conversão é C  ( F – 32 ) * ( 5 / 9 ), sendo F a temperatura
em Fahrenheit e C a temperatura em Celsius. A função de conversão deve receber como entrada de dados a
temperatura em Fahrenheit em tipo de dado float, fazer a conversão e retornar o valor convertido em graus
Celsius.
11.Faça um programa que leia um caracter do teclado. Criar uma função que irá converter esta letra para uma
letra minúscula e retorna-la.
12. Faça um programa que leia dois números. Criar uma função chamada potencia que eleva o primeiro
número a uma potência inteira do segundo número e retorna o valor calculado. Por exemplo, se for lido os
números 2 e 3, a função irá calcular 2³ ou seja 2 * 2 * 2
13. Faça um programa que leia e calcule a área de um retângulo. O programa deverá ter uma função que
leia a base e a altura do retângulo, calcule a área e retorne o valor do resultado que deverá ser apresentada na
função main. Fórmula: Área do retângulo = base * altura.
14. Faça um programa que leia e calcule a área de um triângulo. O programa deverá ter uma função que
leia a base e a altura do retângulo, calcule a área e retorne o valor do resultado que deverá ser apresentada na
função main. Fórmula: Área do triângulo = (base * altura) / 2.
15. Faça um programa que leia e calcule a área de um trapézio. O programa deverá ter uma função que leia
a base maior, a base menor e a altura do trapézio, calcule a área e retorne o valor do resultado que deverá ser
apresentada na função main. Fórmula: Área do trapézio = ((base maior + base menor) /2) * altura.
16. Faça um programa que leia e calcule a área de um círculo. O programa deverá ter uma função que
leia o raio do círculo, calcule a área e retorne o valor do resultado que deverá ser apresentada na função main.
Fórmula: Área do círculo = PI * r².
Bibliografia utilizada:
1. MANZANO, JOSÉ AUGUSTO N. G. – Algoritmos: Lógica para Desenvolvimento de Programação, Editora
Érica, São Paulo, 2000.
2. MANZANO, JOSÉ AUGUSTO N. G. – Lógica estruturada para Programação, Editora Érica, São Paulo,
2001.
3. BOHI, MARILYN – Guia para programadores, Editora Campus, Rio de Janeiro, 1988.
4. ALCIDES MAYA - Polígrafo Técnicas de Programação – Porto Alegre, 2001
5. ALCIDES MAYA - Polígrafo Algoritmo – Porto Alegre, 2001
6. REIS, ANTONIO – Manual Básico de Linguagem C, Porto Alegre, 2000.
7. Outras fontes – Internet, Revistas e Periódicos.
89