Capitulo 5 - Comandos Sequenciais

Fundamentos de Programação em C: Uma Abordagem Algorítmica
“ Quase todos os homens podem enfrentar

adversidades, mas se quisermos testar o
carácter de um homem, é necessário dar-lhe
poder. ”
- Abraham Lincoln -
Comando
3 Sequencial
Sumário:
3.1- Motivação
3.2- Comando de Atribuição Simples
3.3- Conversão Automática de Expressões
3.4- Conversão Explícita
3.5- Operador Unário
3.6- Comando de Atribuição Múltiplo
3.7- Comando Sequencial
3.8- Estrutura de um Programa em C
3.9- Funções de Entrada e Saída
3.10- Exemplo de Programas Simples
3.11- Documentação de Programas
3.12-Funções Matemáticas
3.13- Funções para Converter Caracteres
3.14- Importância dos Nomes dos Identificadores
3.15- Exercícios Resolvidos
3.16- Exercícios Propostos
3.17-Trabalhos de Programação
Faculdade de Engenharia de Universidade Católica de Angola - Manuel Menezes 26

Este capítulo tem por finalidade, iniciar o estudo dos comandos da linguagem
C. No seu término, o leitor deverá ser capaz de:
 Saber utilizar o comando de atribuição simples;

 Dominar as regras de conversão de expressões;
 Saber utilizar as funções de entrada e saída de dados;
 Desenvolver programas simples com o comando sequencial;
 Documentar programas;
 Conhecer algumas funções da biblioteca ANSI;
 Saber escrever os nomes das variáveis de forma correcta e intuitiva;
 Descrever o mecanismo de simulação de programas.
3.1- Motivação
Antes de iniciarmos o estudo sobre comandos sequenciais, vamos recordar a
resolução do problema de mudar o pneu de um carro, visto no primeiro
capítulo. Vimos que a resolução desse problema baseava-se nos seguintes
passos:
1- Retirar o macaco, as chaves de rodas e o pneu de socorro

2- Desenroscar as porcas
3- Levantar o carro
4- Retirar o pneu furado
5- Colocar o pneu de socorro
6- Enroscar as porcas
7- Baixar o carro
8- Guardar a ferramenta e o pneu furado
e que esses passos são executados em ordem sequencial, ou seja,

executamos o primeiro, em seguida o segundo, e por aí em diante.
3.2- Comando de Atribuição Simples

O comando de atribuição simples é a instrução mais elementar que existe em
qualquer linguagem de programação. Sua sintaxe é definida por:
variável = expressão;
e caracteriza-se por:
1º- Calcular o valor da expressão;

2º- Substituir o valor da variável pelo valor da expressão.
Em termos de linguagem algorítmica, esse comando é interpretado pelas

seguintes sentenças:

Armazenar o conteúdo da expressão na variável;

ou
Atribuir a variável o conteúdo da expressão;
ou ainda
Calcular variável = expressão;
Para consolidar este conceito, veremos em seguida, alguns exemplos

ilustrativos.
O comando
i = 2;
armazena o valor 2 na variável i. Mas se antes dessa operação essa variável

tivesse o valor 1, por exemplo, esse valor seria apagado.
O comando
j = j + 1;
adiciona uma unidade ao conteúdo da variável j. Suponhamos sem perda da

generalidade que essa variável tivesse o valor 3. Com esse comando ela
passaria a ter o valor 4.
O comando
k = a + 6/b – 2;
armazena na variável k o valor da expressão a + 6/b - 2. Suponhamos sem

perda da generalidade que a = 5 e b = 3. O cálculo dessa expressão é
determinado por:
a + 6/b - 2
= 5 + (6/3) – 2
= 5+2–2
= 7- 2
=5
logo, a variável k passará a armazenar o valor 5.
Na linguagem C, o comando de atribuição de valor é uma expressão que

denomina-se por operador de atribuição.
Em função desse conceito, podemos afirmar que uma expressão é falsa

quando o seu valor for igual a zero e verdadeira no caso contrário. Essa
propriedade, levanta um aspecto muito curioso dessa linguagem.

Na Lógica Matemática, a propriedade da dupla negação ~~a = a é um axioma

(conceito universalmente válido). Mas para linguagem C isso não é verdade,
porque ! ! 6 = !(!6) = !0 = 1.
3.3- Conversão Automática de Expressões

Numa expressão podemos realizar operações com tipos de dados diferentes.
Mas para que essas operações possam realizar-se é necessário converter as
variáveis com o tipo de dados menos abrangente para o tipo de dados mais
abrangente.
Antes de definirmos o processo de conversão, veremos o conceito de tipos de

dados menos ou mais abrangente. Por exemplo, se tivermos numa expressão
variáveis do tipo inteiro e variávies do tipo real, as variáveis do tipo inteiro são
menos abrangentes do que as variáveis do tipo real.
Agora, estamos em condições de definir o processo de conversão. Este

processo é caracterizado pelos seguintes passos: converter em primeiro lugar,
as variáveis para o tipo de dados mais abrangente; calcular em seguida, o valor
da expressão e converter esse valor para o tipo de dados da variável à
esquerda, se existir; para terminar, armazenar esse valor nessa variável. Por
exemplo:
int x;
x = 2/1.5;
a expressão x = 2/1.5 possui a seguinte regra de cálculo:
x = 2/1.5;
= 2.0/1.5 Converter o valor 2 para o tipo real
= 1.3333333 Calcular o valor da expressão
=1 Converter o valor 1.333333 para tipo inteiro
Alguns compiladores exibem uma mensagem de advertência quando a

conversão significa a perda de precisão.
3.4- Conversão Explícita (Cast)

O operador de molde (cast) permite que o programador instrua de forma
explicita, o tipo de conversão que deve ser efectuado. Para isso, ele deve
colocar como prefixo da expressão, o tipo de dados a ser convertido. Por
exemplo:
int peso, altura;

float massa;
Ao executarmos as expressões:
peso = (int) 3.7;

altura = (int) 3.5 / 2;
a variável peso armazenará o valor 3, enquanto a variável altura armazenará o

valor 1. Se executarmos em seguida a expressão:
massa = (float)(peso*altura + 7)/ peso;
a variável massa armazenará o valor 1.57142857
Esta liberdade que a linguagem C possui, pode incentivar as más práticas de

programação. Conversões para tipos mais abrangentes e mistura de tipos
podem afectar a precisão dos resultados de um programa.
3.5- Operador Unário

O operador unário é utilizado para mudar o sinal algébrico do conteúdo de uma
expressão. Por exemplo:
x= - 8;
x = -x;
o conteúdo de x é igual a -(-8) que por sua vez é igual a 8.
3.6- Comando de Atribuição Múltiplo

Em programação, temos muitas vezes a necessidade de atribuir o mesmo valor
à várias variáveis. Para essas situações utilizamos o comando de atribuição
múltiplo, que possui a seguinte sintaxe:
variável1 = variável2 = … = variáveln = expressão;
e caracteriza-se por:
1- Calcular o valor da expressão;

2- Atribuir esse valor à variáveln, depois à variáveln-1, e assim por diante.
Para consolidar os conhecimentos, veremos em seguida alguns exemplos

ilustractivos.
O comando:

soma = maximo = total = 0;
atribui às variáveis total, maximo e soma o valor zero. Na literatura da ciência

de computação, diz-se que essas variáveis foram inicializadas.
Os comandos:
h = 10;
a = b = d = h * 2 - 1;
atribui à variável h o valor 10. Em seguida, atribui às variáveis d, b e a o valor

da expressão h * 2 – 1, ou seja, o número 19.
Os comandos:
d = 5;
b = 2;
a = b +( c = d +3 );
atribui à variável d o valor 5 e à variável b o valor 2. Em seguida, atribui à

variável c o valor 8 e para terminar, atribui à variável a o valor 10. Este
comando é equivalente a:
d = 5;
b = 2;
c = d + 3;
a = b + c;
No comando de atribuição múltiplo todas as expressões de atribuição devem

ser o mesmo tipo de dados e o processo de atribuição é feito da direita para a
esquerda.
3.7- Comando Sequencial

O comando sequencial ou bloco de comandos, possui a seguinte sintaxe:
{
Comando1;
Comando2;
.
.
Comandon;
}
e é interpretado pelas seguintes acções: calcular em primeiro lugar o

comando1. Ao encontrar o caracter ; interpretar que esse comando foi
executado com sucesso e iniciar a execução do comando2. Ao encontrar o

caracter; interpretar que o comando foi executado com sucesso e iniciar a

execução do comando3. Seguir esse processo até encontrar o caracter }.
Os caracteres { e } denotam o início e o término de um bloco de comandos,

por esse facto, são denominados por delimitadores de blocos.
Os delimitadores de blocos só devem ser utilizados se o bloco de comandos

possuir mais do que uma instrução.
Em termos de linguagem algorítmica, esse comando é descrito pela seguinte

sintaxe:
inicio
Comando1;
Comando2;
.
.
Comandon;
fim
3.8- Estrutura de um Programa em C
Qualquer programa em C possui o seguinte esquema:
Directivas de pré-processamento
int main()
{
Declaração de constantes;
Declaração de variáveis;
Comandos que resolvem o problema;
return 0;
}
onde:
pré-processamento é um programa que examina o nosso programa e executa

certas modificações com base em instruções chamadas de directivas. Toda a
directiva começa com o caracter # e termina sem o ponto-e-vírgula.
A palavra reservada main() indica o início do programa. Todo programa deve

possuir uma e apenas uma linha com essa palavra seguida de parênteses
curvos.
As declarações das constantes e das variáveis são os elementos passivos da

linguagem. Essas declarações não são executadas. O seu objectivo é dar
informações sobre as características dos identificadores que o programa irá
utilizar. Ao declarar um identificador, o compilador reserva um espaço na

memória, para que o programa possa guardar as informações referentes a

esse identificador. Inicialmente esse espaço contem valor indefinido, que
denominamos por lixo.
Os comandos são os elementos activos da linguagem. Eles indicam as

operações que devem ser executadas para resolver um determinado problema.
Os comandos são colocados depois da declaração dos identificadores e
executados na ordem que são escritos, a menos que exista uma instrução para
alterar esse processo.
Os comentários servem para facilitar a leitura e compreensão de um programa.

Existem várias formas de colocar comentários num programa. As mais comuns
são:
Numa determinada linha do programa, depois do delimitador de fim de
comando, colocar o delimitador de início de comentário, descrever em seguida
o que se pretende com essa instrução e fechar com o delimitador de fim de
comentário.
Antes ou depois do main(), colocar o delimitador de início de comentário

e escrever as seguintes informações:
Objectivo do programa: Uma descrição resumida sobre a finalidade do

algoritmo que não deve ser superior a três linhas.
Entrada de dados: Uma descrição com o nome das entidades de entrada

do problema.
Saída de dados: Uma descrição sobre a informação que o programa

devolve.
Autor: O nome do programador
Data de implementação: A data do início de desenvolvimento do

programa no formato dd-mm-aaaa.
Para terminar, colocar o delimitador de fim de comentário.
3.9- Funções de Entrada e Saída

A linguagem C não possui comandos de leitura e de impressão. Veremos nesta
secção como ler os dados via teclado e mostrar os resultados no monitor.
O teclado é o dispositivo de entrada de dados padrão. Para ler os números e

os caracteres digitados pelo utilizador, utilizamos uma função com a seguinte
sintaxe:
scanf (formato, &variavel1, &variável2, …,&variáveln);

onde, formato é uma cadeia de caracteres que indica o tipo de dado que será
lido.
É obrigatório colocar o caracter & antes de cada variável.

sintaxe:
ler (variavel1, variável2, …,variáveln);

ilustractivos:
scanf(" %d ", &soma);

Espera que o utilizador entre com um número inteiro e o armazena na variável
soma.
scanf(" %d %f ", &numeroFuncionario, &salarioFuncionario);

Espera que o utilizador entre com dois números, um inteiro e outro real.
Armazena o valor inteiro na variável numeroFuncionario e o valor real na
variável salarioFuncionario. Observe que o formato %d relaciona-se com a
variável numeroFuncionario enquanto o formato %f relaciona-se com a variável
salarioFuncionario.
Apresentamos em seguida, os formatos mais importantes:
%d Especifica um inteiro
%f Especifica um real
%c Especifica um caracter
%s Especifica uma cadeia de caracteres
O número de formatos deve ser sempre igual ao número de variáveis.
O monitor (tela) é o dispositivo de saída de dados padrão. Para imprimir os

números e os caracteres no monitor, utilizaremos uma função com a seguinte
sintaxe:
printf(formato,variavel1, variável2, …,variáveln);
onde, formato representa a mensagem com os tipos de dados que serão

impressos e as respectivas posições.

sintaxe:
imprimir (variavel1, variável2, …,variáveln);
Para além dos formatos que vimos, podemos inserir caracteres especiais e
controlar o movimento do cursor. Os caracteres mais importantes são:

\n Saltar para nova linha

\t Tabulação
\b Retroceder na mesma linha
%% Percentagem
\? Interrogação
\' Apóstrofos
\" Aspas

ilustractivos:
printf(" %d %f ", 33, 42.1);

Imprime os valores 33 e 42.1 e o cursor fica na mesma linha.
printf(" Inteiro = %d Real = %f ", 33, 52.15);

Imprime a mensagem: Inteiro = 33 Real = 5.215 e o cursor fica na mesma
linha.
printf(" Um caracter %c e um inteiro %d ",'D',120);

printf("\n");
Imprime a mensagem: Um caracter D e um inteiro 120 e ao executar o próximo
comando, o cursor vai para a próxima linha.
printf(" \n %s exemplo \n ","Este");

Move o cursor para a próxima linha, imprime a mensagem: Este exemplo e
move em seguida o cursor para a próxima linha. Observe que o formato %s
está relacionado com a cadeia de caracteres "Este".
printf(" %s %d %% \b ","Juros de ",10);

Imprime a mensagem: Juros de 10%. O formato \b, faz com que o cursor volte
para o ínicio da linha.
printf(" \n %.2f ", salario);

Move o cursor para a próxima linha e imprime o valor do salário com um ponto
e duas casas decimais.
printf(" A letra J pronuncia-se "JOTA" \n");

Imprime a mensagem: A letra J pronuncia-se "JOTA" e move o cursor para a
próxima linha.
Para utilizar as funções printf() e scanf() necessitamos de declarar na directiva

de pré-processamento a biblioteca <stddio.h>.

3.10- Exemplos de Programas Simples

Vejamos em primeiro lugar um exemplo muito simples.
/*--------------------------------------------------------------------------------------------------------
Objectivo: Mostrar uma mensagem no monitor
--------------------------------------------------------------------------------------------------------*/
#include <stdio.h> /* Incluir a função printf() */
int main()
{
printf ("Ola! Eu estou a programar computadores. Viva \n");
return 0;
}
Vamos analisar em seguida cada linha desse programa.
- Todas as linhas que estão entre /* e */ são consideradas de comentário.
- A directiva #include provoca a inclusão de um outro arquivo no nosso

programa. Na verdade, o compilador substitui a linha que contém essa directiva
pelo conteúdo do arquivo stdio.h (neste caso). No arquivo stdio.h temos as
definições e as declarações necessárias para utilizarmos as funções de leitura
e impressão. Os símbolos < e > fazem com que o compilador procure esse
arquivo na pasta INCLUDE, criada na instalação do compilador.
- A linha int main() define uma função que é identificada pelo nome main que
indica o início do programa. Os comandos dessa função estão delimitados
pelos colchetes { e }. Como o main() é uma função do tipo inteiro e toda função
deve devolver um valor ( veremos esse assunto mais tarde), por consistência, a
última linha do programa deve devolver o valor zero através da instrução
return, embora esse valor não tem qualquer utilidade.
A única coisa que este programa faz é chamar (invocar) a função printf(), para
mostrar na tela a frase: Ola! Eu estou a programar computadores. Viva! e
mover o cursor para a próxima linha.
Todos os comandos em C terminam com um ponto-e-vírgula.
Vamos desenvolver em seguida um programa um pouco mais complicado. Ler

o número de dias e mostrar na tela o correspondente número de anos.
/*--------------------------------------------------------------------------------------------------------
Objectivo: Converter o número de dias em anos
Entrada : Número de dias
Saida : Número de anos
Autor : Manuel Meneses
Data : 21-05-2011
--------------------------------------------------------------------------------------------------------*/
#include <stdio.h> /* incluir a função printf() e scanf() */
int main()

{
int dias;
float anos;
printf(" Entre com o numero de dias : "); scanf(" %d ", &dias);
anos = dias/365.25;
printf(" \n %d dias equivalem a %f anos ", dias, anos);
return 0;
}
Vamos, mais uma vez, explicar algumas linhas desse programa.
- Nas duas linhas a seguir a abertura de bloco, declaramos as variáveis dias e

anos. A primeira é do tipo inteiro e a segunda do tipo real.
- A função printf() a seguir, emite uma mensagem a solicitar a entrada do

numero de dias, observe que o número não tem acento.
- A função scanf() lê esse número de dias. O formato %d indica que vamos ler
um número inteiro. O símbolo & indica o endereço de memória da variável dias,
ou seja, o lugar na memória do computador onde esse valor será armazenado.
- Na próxima linha temos um operador de atribuição que converte o valor inteiro

para real. Lembre-se que 365.25 é um número real.
- Para terminar temos a função printf() que imprime uma mensagem a dar-nos
o correspondente número de anos.
Apresentaremos a seguir um programa com alguns erros de sintaxe. Erros de

sintaxe são cometidos no processo de digitação do programa.
/*--------------------------------------------------------------------------------------------------------
Objectivo: Calcular a soma de dois números inteiros
Entrada : Dois números
Saida : Soma
--------------------------------------------------------------------------------------------------------*/
#include <stdio.h> /* incluir a função printf() */
int main()
{
int a, b, soma;
a = 5;
b = 10
Soma = (a + b);
printf(" \n a Soma de %d com %d é igual a %d ",a, b, soma);
return 0;
}
Ao compilar este programa, terá alguns erros nas linhas que estão em
vermelho. Estes erros devem-se aos seguintes factos: Falta o delimitador; na
instrução b = 10 e a variável Soma não está definida. Na Linguagem C as
letras maiúsculas são diferentes das letras minúsculas, logo Soma ≠ soma.

Toda a linguagem que distingue as letras maiúsculas das minúsculas é

denominada por Case Sensitive.
Para terminar, veremos mais um exemplo de um programa com erros de

lógica.
/*--------------------------------------------------------------------------------------------------------
Objectivo: Calcular o produto de dois números inteiros
Entrada : Dois números
Saida : Produto
--------------------------------------------------------------------------------------------------------*/
#include <stdio.h> /* incluir a função printf() */
int main()
{
int n1, n2, prod;
n1 = 5;
prod = n1 * n2;
printf(" \n A multiplicacao de %d com %d = %d ",n1, n2, prod);
return 0;
}
Como o programa não tem erros de sintaxe, o compilador gera o código

objecto, ou seja, converte o programa para a linguagem máquina. Mas ao
executarmos, ele devolve algumas vezes resultados que não esperamos. Esse
comportamento deve-se ao facto do programa possuir erros de lógica, pois
vejamos. Quando executamos o comando prod = n1*n2 as variáveis n1 e n2
devem possuir nesse instante um determinado valor. Qual o conteúdo da
variável n2? De facto, não sabemos, essa variável foi declarada, mas não
recebeu nenhum valor.
Vimos que durante o processo de compilação, associamos cada variável a uma

ou várias posições de memória. Mas, durante a execução de qualquer
programa, as posições de memória associadas as suas variáveis são acedidas
de forma exclusiva. Isso quer dizer que em programação, não existe a
possibilidade de dois programas acederem ao mesmo tempo as mesmas
posições de memória. Contudo, poderemos ter a possibilidade de programas
que já terminaram, deixaram alguma informação nas posições que lhe estão
adstritas e o programa que estamos a executar utilizar essas posições de
memória. Para esse caso, esses valores que chamamos de lixo residual, são
os responsáveis pelo funcionamento irregular do programa anterior.
Um dos erros mais comuns em programação é a existência de variáveis com

valores indefinidos.

3.11- Documentação de Programas

Segundo P. Feofiloff (2009), " muitos programadores pensam que uma boa
documentação consiste em colocar muitos comentários no programa. Este
princípio está totalmente errado. Uma boa documentação limita-se a explicar o
que o programa faz, não perde tempo a explicar como isso é feito, porque o
leitor interessado nesse assunto, deverá ser capaz de ler e interpretar as
instruções do programa. Uma documentação é um mini-manual que dá
instruções precisas e completas de sua utilização. A primeira parte desse mini-
manual deve dizer o que o programa recebe e o que devolve".
Uma documentação correta mostra uma actitude de honestidade intelectual,

pois coloca nas mãos do leitor a real possibilidade de encontrar erros que o
autor tenha porventura cometido ao escrever o programa.
3.12- Funções Matemáticas

O arquivo-cabeçalho <math.h> da biblioteca ANSI, possui um conjunto de
funções matemáticas que podem ser utilizadas em aplicações científicas.
Descrevemos em seguida as funções mais utilizadas:
double sin(double x); Devolve o seno de x em radianos.
double cos(double x); Devolve o cosseno de x em radianos.
double atan(double x); Devolve o arco tangente do x em radianos.
double exp(double x); Devolve o exponencial de x, ou seja, ex.
double log(double x); Devolve o logaritmo natural de x, para x > 0.
double log10(double x); Devolve o logaritmo na base 10 de x, se x >0.

2
double sqrt(double x); Devolve √𝑥, para x > 0.
double pow(double x, double y); Devolve xy . Não pode ser utilizado se for
x=0 e y <0 ou x <0 y não é um inteiro.
double fabs(double x); Devolve o valor absoluto de x.
double floor ( double x); Devolve o maior inteiro menor do que x.
double ceil ( double x); Devolve o menor inteiro maior do que x.

3.13- Funções para Converter Caracteres

O arquivo-cabeçalho <ctype.h> da biblioteca ANSI, possui um conjunto de
funções que permitem manipular caracteres. Descrevemos em seguidas as
funções mais utilizadas:
int isdigit(int c); Se c for um dígito devolve verdadeiro, caso contrário devolve
falso.
int isalpha(int c); Se c for uma letra devolve verdadeiro, caso contrário devolve
falso.
int isalnum(int c); Se c for um dígito ou uma letra devolve verdadeiro, caso
contrário devolve falso.
int islower(int c); Se c for uma letra minúscula devolve verdadeiro, caso
int isupper(int c); Se c for uma letra maiúscula devolve verdadeiro, caso
int tolower(int c); Se c for uma letra maiúscula converte para letra minúscula,
caso contrário não faz nada.
int toupper(int c); Se c for uma letra minúscula converte para letra maiúscula,
caso contrário não faz nada.
3.14- Importância do Nome dos Identificadores
Segundo Kernighan e Plauger (1976), "A nossa experiência mostra que a

legibilidade é o único e o melhor critério para a qualidade de um programa: se
um programa é fácil de ler ele é provavelmente um bom programa; se ele é
difícil de ler, provavelmente ele não é bom".
Isso quer dizer que devemos ter muito cuidado com os nomes dos
identificadores e estabelecer alguns critérios. Programadores inexperientes,
têm a tendência de não dar a devida importância a este ponto crucial do
desenvolvimento de software de boa qualidade.
Os nomes dos identificadores devem explicar com a máxima clareza a

verdadeira função da entidade que ele representa. Por exemplo, no algoritmo
para calcular a área de uma circunferência, a escolha do nome raio está
perfeita, ele não deixa a menor dúvida sobre a finalidade dessa entidade. Se o
programador tivesse escolhido a letra x para representar essa variável, essa
escolha seria péssima. A letra x, não dará qualquer informação ao profissional
que fará a revisão do programa. Mas se o programador tivesse escolhido a
letra r, ela certamente daria ao profissional uma vaga ideia sobre essa variável.

Portanto é importante que não se tenha a preguiça de pensar em nomes

corretos e escrever nomes mais compridos. Por exemplo, numeroDoAluno ou
numero_aluno é muito melhor do que numaluno. Quanto menor for o esforço
mental que um profissional em programação fizer a rever um programa, maior
serão os ganhos a médio e longo prazo. A economia de alguns segundos que
obtemos com a utilização de nomes abreviados pode facilmente tornar-se em
horas de dor de cabeça no futuro.
O nome das variáveis com mais de uma palavra podem ajudar a tornar um
programa mais legível. Devemos evitar a junção de palavras separadas como
totalpagamentos, em vez disso, separar as palavras com o caracter undescore
como total_pagamentos ou começar o identificador com uma letra minúscula e
a primeira letra da palavra seguinte com uma letra maiúscula como
totalDePagamentos.
3.15- Exercícios Resolvidos

Problema 3.15.1: Escreva um programa para calcular a área de uma
circunferência.
Resolução: O conhecimento matemático necessário para resolver este

problema é determinado pela seguinte fórmula:
Área = π.r2 onde π = 3.14
Numa primeira abordagem, a solução deste problema é descrita pelos

seguintes passos:
Versão 1
1- ler o raio;
2- calcular a área da circunferência;
3- imprimir a área;
Pelo enunciado, temos uma constante que denominaremos por pi e duas

variáveis. Uma que recebe o valor digitado pelo utilizador, denominada por raio
e outra que mostra o valor da circunferência, denominada por área. Em
seguida, vamos relacionar esses identificadores aos seus tipos de dados.
const float pi = 3.14;

int raio;
float area;
Com base nessas declarações e na formalização (descrição) das operações de

leitura e impressão, estamos em condições de refinar a versão anterior.
Versão 2:
1- declarar constante pi;

2- declarar area, raio;

3- ler (raio);
4- calcular a área da circunferência;
5- imprimir (area);
No próximo passo, vamos escrever um método para calcular a área da

circunferência. Esse método consiste em converter a fórmula matemática no
comando de atribuição de valor.
Versão 3:
1- declarar constante pi;
2- declarar area, raio;
3- ler (raio);
4- calcular area = pi*raio*raio;
5- imprimir (area);
Como todas as linhas do nosso algoritmo estão claras e sem ambiguidade o

processo de refinamento termina e podemos codificá-lo para um programa na
linguagem C.
/*--------------------------------------------------------------------------------------------------------
Objectivo : Calcular a área de uma circunferência
Entrada : Raio
Saida : Área
-------------------------------------------------------------------------------------------------------*/
#include <stdio.h> /* Incluir as funções printf() e scanf() */
int main()
{
int raio;
float area;
printf(" \n Entre com o valor do raio: "); scanf("%d",&raio);
area = pi*(raio*raio);
printf(" \n Circunferência de raio %d possui a área %.2f \n ",raio, area);
return 0;
}
Para consolidar a prática de programação, tente compilar e executar este

programa. Verá que a informação impressa não é perceptível. Para resolver
esse problema, basta incluir o arquivo cabeçalho-padrão <stdlib.h> e utilizar a
função system("PAUSE"), ou seja:
#include <stdio.h> /* incluir as funções printf() e scanf() */

#include <stdlib.h> /* incluir as funções system() */
int main()
{
int raio;
float area;
printf(" Entre com o valor do raio: "); scanf(" %d ",&raio);

system("PAUSE");
return 0;
}
Volte a correr o programa e verá que as letras com acentos são impressas com
caracteres estranhos. Para resolver esse problema basta incluir a arquivo-
cabeçalho <locale.h> e utilizar a função setlocale(LC_ALL, “Portuguese”), ou
seja:
#include <stdio.h> /* incluir as funções scanf() e printf() */

#include <stdlib.h> /* incluir a função system() */
#include <locale.h> /* incluir a função setlocale() /*
int main()
{
setlocale(LC_ALL, “Portuguese”);
int raio;
float area;
printf(" Entre com o valor do raio: "); scanf(" %d ",&raio);
system("PAUSE");
return 0;
}
Problema 3.15.2: Dado um número inteiro positivo, obtenha o último

algarismo.
Resolução: Numa primeira abordagem a solução deste problema é descrita

pelos seguintes passos:
Versão 1
1- ler um número inteiro;
2- separar o último algarismo;
3- imprimir o último algarismo;
Pelo enunciado, fazem parte dos dados de entrada um número inteiro positivo
e da informação de saída, o último algarismo desse número. Vamos relacionar
essas variáveis aos seus tipos de dados.
int numero, algarismo;
Com a declaração das variáveis e a formalização das operações de leitura e

impressão, estamos em condições de refinar a versão anterior.
Versão 2
1- declarar numero, algarismo;

2- ler (numero);
3- separar o último algarismo;
4- imprimir (algarismo);
No próximo passo, vamos escrever um método para separar o último

algarismo. Na numeração decimal, o último algarismo é representado pelas
unidades, logo esse valor é obtido pelo resto da divisão desse número por 10.
Versão 3
1- declarar numero, algarismo;
2- ler (numero);
3- calcular algarismo = numero % 10;
4- imprimir (algarismo);

linguagem C.
/*--------------------------------------------------------------------------------------------------------
Objectivo: Determinar o algarismo das unidades de um número inteiro
Entrada : Número
Saida : Algarismo
-------------------------------------------------------------------------------------------------------*/
#include <locale.h> /* incluir a função setlocale() */
int main()
{
int numero, algarismo;
printf(" \n Entre com um inteiro positivo: "); scanf(" %d ",&numero);
algarismo = numero % 10;
printf(" \n O algarismo das unidades é igual a % d ",algarismo);
system("PAUSE");
return 0;
}
Exemplo 3.15.3: Desenvolva um conversor de graus Celcius para Kelvin e

Fahrenheit.
Resolução: Segundo a física elementar, essas temperaturas satisfazem a

seguinte relação:
𝐹−32 𝐶 𝐾−273
= =
9 5 5
9
logo F = C+32 e k = C+273.
5


seguintes passos:
Versão 1
1- ler a temperatura em graus Celsius;
2- calcular a conversão;
3- imprimir os resultados;
Pelo enunciado fazem parte dos dados de entrada a temperatura em graus

celsius e da informação de saída, a temperatura em graus kelvin e fahrenheit.
Vamos relacionar essas variáveis aos seus tipos de dados.
int celsius, fahrenheit;

float kelvin;
Com essas declarações e com a formalização das operações de leitura e

impressão, estamos em condições de refinar a versão anterior.
Versão 2
1- declarar celsius, kelvin, fahrenheit;
2- ler (celsius);
3- calcular a conversão;
4- imprimir (kelvin, fahrenheit);
No próximo passo, vamos descrever um método para converter essa

temperatura. Essa conversão consiste em escrever as fórmulas anteriores no
comando de atribuição de valor.
Versão 3
1- declarar celcius, kelvin, fahrenheit;
2- ler (celsius);
3- calcular fahrenheit = 9/5*celcius + 32;
4- calcular kelvin= celsius + 273;
5- imprimir (kelvin, fahrenheit);

linguagem C.
/*--------------------------------------------------------------------------------------------------------
Objectivo: Converter graus Celsius em Kelvin e Fahrenheit
Entrada : Temperatura em graus Celsius
Saida : Temperatura em graus Kelvin e Fahrenheit
-------------------------------------------------------------------------------------------------------*/
int main()
{

int celsius, kelvin;

float fahrenheit;
printf(" \n Entre com a temperatura em Célsuis:"); scanf(" %d ",&celsius);
kelvin = celsius + 273;
fahrenheit = 9.0/5.0*celsius + 32;
printf(" \n Célsius %d ", celsius);
printf(" \n Kelvin %d ",kelvin);
printf(" \n Fahrenheit %f ", fahrenheit);
system("PAUSE");
return 0;
}
Problema 3.15.4: Numa determinada Universidade, as notas finais para

disciplinas de Introdução à Programação de Computadores são calculadas com
base na seguinte fórmula:
Média final = 30 % nota freq + 20% trabalho laboratório + 50% exame final
Essas notas são fornecidas pelos serviços académicos e baseiam-se nos

seguintes dados: número do estudante, nota de frequência, nota de laboratório
e nota do exame final. Cada nota varia entre 0 a 100. Os resultados serão
mostrados na tela e consistem nos seguintes campos: número do estudante,
notas da avaliação e média final.
Resolução: Numa primeira abordagem, a solução deste problema é descrita

pelos seguintes passos:
Versão 1
1- ler os dados do estudante;
2- calcular média final;
3- imprimir o passe, notas da avaliação e a média final;
Pelo enunciado fazem parte dos dados de entrada, o número do estudante, a

nota parcial, a nota de laboratório e a nota final. Fazem parte da informação de
saída, o número do estudante, as notas recebidas e a média final. Vamos
relacionar essas variáveis aos seus tipos de dados.
int notaFreq, notaLabo, notaFinal, passe;

float mediaFinal;
Com a declaração dessas variáveis e a formalização das operações de leitura

e impressão, estamos em condições de refinar a versão anterior.
Versão 2
1- declarar passe, notaFreq, notaLabo, notaFinal;
2- declarar mediaFinal;
3- ler (passe, notaFreq, notaLabo, notaFinal);
4- calcular à media final;
5- imprimir (passe, mediaFinal);

No próximo passo, vamos descrever um método para calcular a média final.

Também podemos definir nesta fase, o layout da informação a ser mostrada na
tela.
Versão 3
1- declarar passe, notaFreq, notaLabo, notaFinal;
2- declarar mediaFinal;
3- ler (passe, notaFreq, notaLabo, notaFinal);
4- calcular mediaFinal= 0.30*notaFreq + 0.20*notaLabo + 0.50*notaFinal;
5- imprimir ("Passe =", passe);
6- imprimir ("Nota Frequencia = ", notaFreq);
7- imprimir ("Nota laboratório = ", notaLabo);
8- imprimir ("Nota Final ",notaFinal);
9- imprimir (" Media Final = ",mediaFinal);

linguagem C.
/*--------------------------------------------------------------------------------------------------------
Objectivo: Calcular a nota final de um aluno com base na média ponderada
Entrada : Passe, nota parcial, laboratório e exame
Saida : Nota final
-------------------------------------------------------------------------------------------------------*/
int main()
{
int notaFreq, notaLabo, notaFinal, passe;
float mediaFinal;
printf("\n Entre com o passe do aluno:"); scanf("%d",&passe);
prinft("\n Entre com a nota Frequência :"); scanf("%d",&notaFreq);
printf("\n Entre com a nota Laboratório:"); scanf("%d",&notaLabo);
printf("\n Entre com a nota Final:"); scanf("%d",&notaFinal);
mediaFinal = 0.30*notaFreq + 0.20*notaLabo + 0.50*notaFinal;
printf(" \n Passe = %d ",passe);
printf(" \n Nota Parcial = %d ",notaFreq);
printf(" \n Nota Laboratório = %d ",notaLabo);
printf(" \n Nota Final = %d ",notaFinal);
printf(" \n");
printf(" \n Nota Media Final = %f ",mediaFinal);
system("PAUSE");
return 0;
}
Terminada a implementação do programa é importante saber se ele devolve os

resultados que esperamos.

Uma forma de testar o seu funcionamento é executá-lo manualmente com

apenas lápis e papel, e registar o valor das variáveis em cada passo. A essa
forma de teste dá-se o nome de simulação, rasteio ou testes de mesa.
A simulação de um programa consiste em criar uma bateria de dados que

satisfaz os requisitos do problema. Com base nesses dados, vamos executar o
programa de forma sequencial, comando por comando e registar os valores
das suas variáveis. Para registar esses valores, precisamos de construir uma
tabela bidimensional. Cada coluna representa uma variável e cada linha o
instante que essa variável foi alterada. Ao terminar um comando, deve-se
registar na coluna que representa a variável e na linha que representa o
instante de execução o seu novo valor. Com isso, teremos os valores de todas
as variáveis em todos os instantes da execução do programa.
Vamos simular o funcionamento do programa anterior para os seguintes dados:
Nota Parcelar :12

Nota laboratório: 8
Exame Final: 9
Inicialmente (passo 0), são criadas as variáveis do problema. Isto consiste em

formar uma tabela bidimensional com 6 colunas: Instante, Passe, Nota
Frequência, Nota laboratório, Nota final e Média Final. Em seguida o programa
executa o comando de leitura. Esse comando é interpretado no (instante 1) e
regista-se nas colunas que representam essas variáveis os valores recebidos.
Para terminar, (instante 2), o programa calcula a média final. O valor desse
cálculo é registado na coluna que faz referência a essa variável e na linha que
faz referência a esse instante. Em termos gráficos temos:
Instante Passe N. Frequência N. Laboratório N. Final Media Final

1 3201 12 8 9
2 9.7
Nos testes é muito importante experimentar valores extremos. Normalmente

estes valores mostram possíveis inconsistências do programa. Por exemplo,
suponha que o nosso estudante tenha a nota 100 em todas as provas. Sua
nota final deveria ser 100. O programa devolve esse valor? Numa simples
inspecção verificamos que sim. Agora, suponha que o estudante tenha a nota
zero em todas as provas. Verifique se o resultado que o algoritmo devolve é o
esperado.
Segundo Edsger Wybe Dijkastra "os teste apenas mostram a presença de

erros e não a sua ausência, mas eles podem ser os nossos grandes aliados no
desenvolvimento do software."
Intuitivamente, quanto mais testes fizermos ao programa e quanto mais

abrangentes eles forem, mais confiáveis serão os nossos resultados.
Problema 3.15.5: O Instituto Nacional de Estatística pretende estimar a taxa de

inflação mensal. Para obter esse indicador, definiu-se um conjunto de artigos

que serão monitorizados por pesquisadores. Fazem parte destes artigos, a

cesta básica de alimentação da população angolana. No início de cada mês é
feito um inquérito para apurar o preço de venda. Este inquérito possui os
seguintes dados: código do artigo, preço do mês anterior e o preço do mês do
inquérito.
Resolução: Para calcular a taxa de inflação, necessitamos de dois indicadores

estatísticos:
Diferença algébrica = preço do mês actual – preço do mês anterior

e
Diferença algébrica
Inflação = x 100
Preço do mês actual

seguintes passos:
Versão 1
1- ler os dados do inquérito;
2- calcular a taxa de inflação;
3- imprimir os resultados;
Pelo enunciado fazem parte dos dados de entrada, o código do artigo, o preço
em vigor e o preço do mês anterior. Fazem parte da informação de saída, o
código do artigo e a taxa de inflação. Mas, para calcular a taxa de inflação,
necessitamos de uma variável auxiliar que irá receber o valor da diferença
algébrica. Vamos associar essas variáveis aos seus tipos de dados.
int codArtigo;
float precoActual, precoAnterior, difAlgebrica, taxaInflacao;
Com a declaração das variáveis, a descrição mais rigorosa do calculo da taxa

de inflação e a formalização das operações de leitura e impressão, estamos em
condições de refinar a versão anterior.
Versão 2
1- declarar codArtigo;
2- declarar precoActual, precoAnterior, difAlgebrica, taxaInflacao;
3- ler (codArtigo, precoActual, precoAnterior);
4- calcular a diferença algébrica;
5- calcular a taxa de inflação;
6- imprimir (codArtigo, taxaInflacao);
No próximo passo, vamos descrever com mais rigor o método para calcular a
taxa de inflação mensal.
Versão 3
1- declarar codArtigo;
2- declarar precoActual, precoAnterior, difAlgebrica, taxaInflacao;
3- ler (codArtigo, precoActual, precoAnterior);

4- calcular difAlgebrica = precoActual - precoAnterior;

5- calcular taxaInflacao = difAlgebrica/precoActual * 100;
6- imprimir (codArtigo, taxaInflacao);

linguagem C.
/*--------------------------------------------------------------------------------------------------------
Objectivo: Calcular a taxa de inflação mensal
Entrada : Código do artigo, preço no mês anterior e preço actual
Saida : Taxa de inflação
-------------------------------------------------------------------------------------------------------*/
int main()
{
float precoActual, precoAnterior, difAlgebrica, taxaInflacao;
int codArtigo;
printf("\n Entre com o código do artigo :"); scanf("%d",&codArtigo);
printf("\n Entre com o preço actual:"); scanf("%d",&precoActual);
printf("\n Entre com o preço anterior :"); scanf("%d",&precoAnterior);
difAlgebrica = precoActual – precoAnterior;
taxaInflacao = difAlgebrica/precoActual * 100;
printf(" \n Código do artigo : %d ", codArtigo);
printf("\n Taxa de Inflação : %d ",(int)taxaInflacao);
system("PAUSE");
return 0;
}

Capitulo 5 - Comandos Sequenciais

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Capitulo 5 - Comandos Sequenciais

Загружено:

Авторское право:

Доступные форматы

Fundamentos de Programação em C: Uma Abordagem Algorítmica

“ Quase todos os homens podem enfrentar

Faculdade de Engenharia de Universidade Católica de Angola - Manuel Menezes 26

 Saber utilizar o comando de atribuição simples;

1- Retirar o macaco, as chaves de rodas e o pneu de socorro

e que esses passos são executados em ordem sequencial, ou seja,

3.2- Comando de Atribuição Simples

1º- Calcular o valor da expressão;

Em termos de linguagem algorítmica, esse comando é interpretado pelas

Faculdade de Engenharia de Universidade Católica de Angola - Manuel Menezes 27

Armazenar o conteúdo da expressão na variável;

Para consolidar este conceito, veremos em seguida, alguns exemplos

armazena o valor 2 na variável i. Mas se antes dessa operação essa variável

adiciona uma unidade ao conteúdo da variável j. Suponhamos sem perda da

armazena na variável k o valor da expressão a + 6/b - 2. Suponhamos sem

logo, a variável k passará a armazenar o valor 5.

Na linguagem C, o comando de atribuição de valor é uma expressão que

Em função desse conceito, podemos afirmar que uma expressão é falsa

Faculdade de Engenharia de Universidade Católica de Angola - Manuel Menezes 28

Na Lógica Matemática, a propriedade da dupla negação ~~a = a é um axioma

3.3- Conversão Automática de Expressões

Antes de definirmos o processo de conversão, veremos o conceito de tipos de

Agora, estamos em condições de definir o processo de conversão. Este

a expressão x = 2/1.5 possui a seguinte regra de cálculo:

Alguns compiladores exibem uma mensagem de advertência quando a

3.4- Conversão Explícita (Cast)

int peso, altura;

Faculdade de Engenharia de Universidade Católica de Angola - Manuel Menezes 29

peso = (int) 3.7;

a variável peso armazenará o valor 3, enquanto a variável altura armazenará o

massa = (float)(peso*altura + 7)/ peso;

a variável massa armazenará o valor 1.57142857

Esta liberdade que a linguagem C possui, pode incentivar as más práticas de

3.5- Operador Unário

o conteúdo de x é igual a -(-8) que por sua vez é igual a 8.

3.6- Comando de Atribuição Múltiplo

variável1 = variável2 = … = variáveln = expressão;

1- Calcular o valor da expressão;

Para consolidar os conhecimentos, veremos em seguida alguns exemplos

Faculdade de Engenharia de Universidade Católica de Angola - Manuel Menezes 30

soma = maximo = total = 0;

atribui às variáveis total, maximo e soma o valor zero. Na literatura da ciência

atribui à variável h o valor 10. Em seguida, atribui às variáveis d, b e a o valor

atribui à variável d o valor 5 e à variável b o valor 2. Em seguida, atribui à

No comando de atribuição múltiplo todas as expressões de atribuição devem

3.7- Comando Sequencial

e é interpretado pelas seguintes acções: calcular em primeiro lugar o

Faculdade de Engenharia de Universidade Católica de Angola - Manuel Menezes 31

caracter; interpretar que o comando foi executado com sucesso e iniciar a

Os caracteres { e } denotam o início e o término de um bloco de comandos,

Os delimitadores de blocos só devem ser utilizados se o bloco de comandos

Em termos de linguagem algorítmica, esse comando é descrito pela seguinte

3.8- Estrutura de um Programa em C

Qualquer programa em C possui o seguinte esquema:

pré-processamento é um programa que examina o nosso programa e executa

A palavra reservada main() indica o início do programa. Todo programa deve

As declarações das constantes e das variáveis são os elementos passivos da

Faculdade de Engenharia de Universidade Católica de Angola - Manuel Menezes 32

memória, para que o programa possa guardar as informações referentes a

Os comandos são os elementos activos da linguagem. Eles indicam as

Os comentários servem para facilitar a leitura e compreensão de um programa.

Antes ou depois do main(), colocar o delimitador de início de comentário