ALGORITMOS COM PASCAL

 

Prof. Miguel Jonathan – Dept. Ciência da Computação – IM/UFRJ – 2003 – versão 1.1

 

CAPíTULO 3

 

Estrutura de um programa em Pascal

 

Um texto contendo um programa na linguagem Pascal deve obedecer a regras de sintaxe (forma) bem específicas, para que o compilador possa reconhecer as suas diversas partes, e convertê-lo (traduzir) para uma seqüência equivalente de comandos em linguagem de máquina.

 

Nas definições abaixo, as palavras e símbolos que não estão entre os sinais de < e > são considerados como elementos da linguagem Pascal e devem ser escritos literalmente. As frases entre os sinais <  e  > são explicações em português do que deve entrar no lugar delas. Dizemos que essas frases estão escritas na meta-linguagem (a linguagem que usamos para definir uma outra linguagem).

 

program <identificador>;

<declarações de constantes>

<declarações de variáveis>

<declarações de funções e procedimentos>

<bloco>

.

 

Funções e procedimentos serão vistos em um capitulo mais à frente.

Note a primeira palavra deve ser program e que o último caractere deve ser um ponto-final, após o <bloco>.

 

Na estrutura acima, definimos:

<declarações de constantes>  = const  <lista de definições de constantes>

 Exemplo:

const  pi=3.1415;  n = 30;

Note que o sinal de igualdade é usado, e que tipos não são declarados. O compilador deduz os tipos pelo formato dos valores usados nas declarações. O ponto-e-vírgula deve terminar cada declaração de constante.

 

<declarações de variáveis> = var  <lista de definições de variáveis>

Exemplo:

var 

  x,y:integer;

  w,z:real; 

  letra1:char;

  terminou: boolean;

 

Observações:

Tanto faz escrever as declarações em uma ou em várias linhas.

O tipo de cada variável deve ser indicado após o sinal de dois-pontos.

Várias variáveis de um mesmo tipo podem ser declaradas juntas, separadas por virgulas.

O tipo boolean é o equivalente em Pascal a um valor lógico.

O tipo char indica que a variável contém o valor de um caractere.

 

O bloco de comandos:

O programa em si está contido no <bloco> que é definido como:

<bloco> =  begin <lista de comandos>  end

 <lista de comandos> = <comando-1>; <comando-2>; .....; <comando-n>   onde n>=0

 

Note que, pela definição acima, um programa pode ter zero comandos, e ainda ser um programa “bem formado”, embora não sirva para nada.

 

Exemplo de um programa:

program exemplo;

const

 n1= 5;

 n2= 3;

var

 x,y:integer;

 comp: boolean;

begin

 writeln('Digite um multiplo de ',n1, ' e outro multiplo de ', n2, ': ');

 read(x,y);

 comp:= x > y;

 writeln(x, ' > ', y, ' = ', comp);

 readln; readln;

end.

 

No programa acima, o bloco de comandos que é executado começa logo após o begin.

O bloco contém 6 comandos. Os dois últimos estão escritos na mesma linha, mas apenas por conveniência. Cada comando deve ser separado do seguinte por um ponto-e-vírgula.

Após o ultimo comando de um bloco o ponto-e-vírgula é opcional.

No exemplo acima, n1 e n2 poderiam também ter sido declaradas como variáveis inteiras, em vez de constantes. Nesse caso, seus valores deveriam entrar como comandos de atribuição, dentro do bloco, como abaixo. O efeito seria exatamente o mesmo.

O exemplo mostra o uso de comentário delimitado por (*  e  *)  . Comentários podem também ser delimitados por {  e  } .

 

program exemplo2;

(******************************************************************

 Este exemplo evita usar constantes.

 Mas mostra o uso de comentários.

*******************************************************************)

var

 n1,n2,x,y:integer;

 comp: boolean;

begin

 n1:=5;

 n2:=3;

 writeln('Digite um multiplo de ',n1, ' e outro multiplo de ', n2, ': ');

 read(x,y);

 comp:= x > y;

 writeln(x, ' > ', y, ' = ', comp);

 readln; readln;

end.

 

Comandos de controle do fluxo de instruções:

 

COMANDOS DE DESVIO CONDICIONAL

 

a) se <expressão lógica>  então <comando-verdade>

b) se <expressão lógica>  então <comando-verdade>  senão <comando-falso>

 

No primeiro caso,  o valor da expressão lógica é calculado, e caso  seja Verdade (True) o <comando-verdade> é executado, caso seja Falso nada é feito.

 

No segundo caso, caso o valor da expressão lógica for Falso, o <comando-verdade> não é executado, mas o <comando-falso> é executado.

 

Exemplo:

 

Seja o comando:

 

se  (x mod 2 = 0) e (x < y) então escrever (x div 2) senão escrever (x+y)

 

Supondo que os valores de x e y sejam respectivamente 10 e 15 no momento da execução do comando acima, então teremos:

 

Cálculo da expressão lógica:

(x mod 2= 0)  e (x <y)

(10 mod 2 = 0) e (10 < 15)

   (0 = 0) e  Verdade

  Verdade e Verdade

          Verdade

 

Como o valor calculado foi Verdade, o comando após a palavra-chave então será executado, e será impresso o valor de x div 2, ou seja, 10 div 2 que é 5.

 

Mas se os valores de x  e  y forem 11 e 15, o valor da expressão será outro:

(x mod 2= 0)  e (x <y)

(11 mod 2 = 0) e (11 < 15)

   (1 = 0) e  Verdade

  Falso e Verdade

          Falso

 

E nesse caso o comando após a palavra-chave senão será executado, sendo escrito na tela o valor de x+y, ou seja 11+15 que é 26.

 

 

Na linguagem Pascal, esses comandos são escritos assim:

 

a) if  <expressão lógica>  then <comando-verdade>

b) if  <expressão lógica>  then <comando-verdade>  else <comando-falso>

 

 

 

 

c) Comando case:

 

O comando case é um comando que permite selecionar um ou mais comandos para serem executados conforme o valor de uma expressão escalar (ou seja, o valor deve ser simples, não pode ser, por exemplo, uma string). Somente os tipos inteiro, caractere, lógico, e tipos enumerados (não vistos ainda) podem ser usados.

 

Neste comando o valor da expressão é comparado com os valores dos casos previstos de execução. No máximo um caso pode ser verdadeiro.

 

Os valores dos casos podem ser:

-          um valor de uma constante escalar.

-          uma lista de valores escalares, separados por vírgulas.

-          uma faixa de valores da forma <valor-1> .. <valor-2>, significando o conjunto de valores contidos no intervalo de <valor-1> a <valor-2>.

-          uma combinação de faixas de valores e listas de valores, separados por virgulas.

 

Alem disso os valores não podem ser repetidos, ou seja, um valor só pode aparecer em apenas um dos casos.

 

Sintaxe:

 

case  <expressão>  of

Lista Constantes Escalares-1: Comando-1;

Lista Constantes Escalares-2: Comando -2;

. . .

Lista Constantes Escalares-k: Comando-k;

else

Comando;

. . .

Comando;

end

 

OBS: A parte do else pode não existir. Nesse caso, nada ocorrerá se nenhum dos casos for verificado.

 

Exemplo:

No exemplo abaixo, a expressão é uma variável c , do tipo caractere. O primeiro caso é uma lista com duas faixas de valores,  e inclui todas as letras maiúsculas entre A e Z, e todas as letras minúsculas entre a e z.  O segundo caso inclui os dígitos de 0 a 9. O terceiro caso inclui uma lista com 4 valores , que são os caracteres usados para as operações aritméticas. Caso a expressão c não tenha nenhum desses valores, os dois comandos após o else serão executados.

 

program exemplo;

 var c: char;

 begin

 write('Entre com um caractere: ');

 readln(c);

 case c of

 'A'..'Z','a'..'z': writeln('Caractere lido e'' letra.');

 '0'..'9': begin

           writeln('Caractere lido e'' um digito ');

           writeln('entre 0 e 9');

           end;

 '+','-','*','/': writeln('Caractere lido e'' um operador matematico.');

 else writeln('O caractere lido nao e'' letra, nem digito,');

      writeln('nem operador matematico.');

 end;

end.

 

Para melhor compreender o exemplo acima, segue abaixo o programa equivalente usando comandos if..then...else equivalentes:

 

program exemplo_if;

 var c: char;

 begin

 write('Entre com um caractere: ');

 readln(c);

 if (c>='A') and (c <= 'Z') or (c>= 'a') and (c <= 'z')

  then writeln('Caractere lido e'' letra.')

  else if (c>='0') and (c<= '9')

       then  begin

             writeln('Caractere lido e'' um digito ');

             writeln('entre 0 e 9');

             end

       else if (c='+') or (c='-') or (c='*') or (c= '/')

            then writeln('Caractere lido e'' um operador matematico.')

            else begin

                 writeln('O caractere lido nao e'' letra, nem digito,');

                 writeln('nem operador matematico.');

                 end;

 end.

 

 

Note bem que:

Todo comando case pode ser transformado em um comando if...then ...else equivalente, mas o reverso não é verdade.

O comando case deve ser usado onde um comando if equivalente só teria expressões lógicas do tipo:

     <expressão> = <constante-escalar>

e sempre usando a mesma expressão.

 

Caso a expressão não corresponda a nenhum dos casos, então o efeito do comando case é nulo.

 

 

EXERCÍCIOS DE FIXAÇÃO:

 

1)      Escrever um programa em Pascal que solicita do usuário os coeficientes a, b e c da equação de segundo grau:  

           

ax2 + bx + c = 0

 

e imprime uma das seguintes respostas na tela:

a)      Existem duas raízes reais com valores <valor 1>  e  <valor 2>

b)      Existe apenas uma raiz real, com valor <valor único>

c)      Não existem valores reais.

 

O programa deve calcular inicialmente o determinante b2 – 4*a*c.  Caso seja positivo, calcula os valores (–b + sqrt(b*b-4*a*c))/(2*a)  e  (-b-sqrt(b*b-4*a*c))/(2*a)  e imprime a primeira resposta. Caso seja nulo, calcula o valor –b /(2*a)  e imprime a segunda resposta. E caso seja negativo, imprime a terceira resposta.

 

2)      Escrever um programa em Pascal que calcula o Imposto de Renda anual de um contribuinte pessoa física. O usuário deve digitar os seguintes valores reais:

a)      o rendimento bruto tributável recebido no ano;

b)      o total de deduções a que tem direito;

c)      o valor de Imposto de Renda na fonte, já pago durante o ano.

 

Como resposta, o programa deve escrever uma das frases abaixo:

a)      Imposto a pagar:  <valor em reais e centavos>

b)      Imposto a receber por devolução:  <valor em reais e centavos>

 

O valor do cálculo do Imposto usa  a tabela progressiva divulgada pelo Governo, que neste ano é a seguinte:

 

Base de cálculo anual em R$

Alíquota (%)

Parcela a deduzir do imposto em R$

Até 12.696,00

-

-

De 12.696,01 até 25.380,00

15,0

1.904,40

Acima de 25.380,00

27,5

5.076,90

 

A Base de cálculo acima é obtida subtraindo o total das deduções do rendimento bruto tributável recebido no ano. O imposto é calculado em partes, um valor para cada faixa de rendimentos.