|
MC102 |
| PROCEDIMENTOS |
Suponha que queremos desenhar na tela dois quadros do tipo:
****
* *
* *
****
|
Como faremos? Pelo que sabemos até agora, temos que:
1) escrever **** 2) escrever * * 3) escrever * * 4) escrever **** 5) escrever uma linha em branco 6) escrever **** 7) escrever * * 8) escrever * * 9) escrever ****Mas esse trabalho pode ser decomposto em duas partes:
Um procedimento é um pedaço de programa que executa um conjunto de comandos. Vejamos como declarar um procedimento:
PROCEDURE nome;
{declarações}
BEGIN
{comandos}
END;
|
Notou a semelhança com o modo como definimos o programa? Pois é, podemos concluir, então, que um programa é um grande procedimento, ou que um procedimento é um pequeno programa dentro do programa.
Agora vamos inserir o código para desenhar um quadrado nesse nosso procedimento:
PROCEDURE dois_quad;
BEGIN
writeln('****');
writeln('* *');
writeln('* *');
writeln('****');
END;
|
Ótimo, mas agora onde colocamos isso no programa?
PROGRAM quad;
PROCEDURE dois_quad;
BEGIN
writeln('****');
writeln('* *');
writeln('* *');
writeln('****');
END;
BEGIN
{comandos}
END.
|
Simples não? Lembre que esse é o lugar da definição de procedimentos.
Mas esse nosso programa não faz nada! Como fazemos para desenhar os dois quadrados? Bom, lembra o nosso segundo algoritmo? Desenho um quadrado, dou uma linha em branco e desenho o outro. Ou seja:
PROGRAM quad;
PROCEDURE dois_quad;
BEGIN
writeln('****');
writeln('* *');
writeln('* *');
writeln('****');
END;
BEGIN
dois_quad;
writeln;
dois_quad;
END.
|
E a saída será:
****
* *
* *
****
****
* *
* *
****
|
Você pode estar se perguntando: mas isso deu mais trabalho do que escrever os 2 quadrados. Sim, para dois deu, mas veja que para 3 não mais e, se o número de quadrados a serem desenhados for grande, você pode poupar muito tempo de trabalho.
Essa é a vantagem do uso de procedimentos, você só precisa escrever códigos repetitivos uma só vez.
Agora, como isso funciona? É, de fato, simples. Cada vez que o computador encontra o nome de um procedimento ele faz um desvio para o início deste procedimento, executa seu código (o que está entre seu BEGIN e END) e, ao terminar o procedimento, retorna ao comando seguinte à chamada deste. A figura abaixo ilustra essa situação:
Por fim, note que declaramos o procedimento antes de usá-lo. Em Pascal temos que fazer isso sempre.
| IDENTIFICADORES |
Um identificador é um nome que damos a algo no pascal, seja um procedimento, o nome do programa etc.
Tais nomes, em Pascal estão sujeitos às seguintes regras:
Vale ressaltar também que é uma boa técnica de programação fazer com que os identificadores sejam uma pista do motivo pelo qual existem, assim como o procedimento "um_quad", que desenha um quadrado na tela.
| EXPRESSÕES |
O computador não serve somente para escrever na tela, podemos pedir para que ele execute operações aritméticas também:
| Comando | Saída |
|---|---|
write(5);
write(3 + 2);
write('3 + 2');
|
5
5
3 + 2
|
Note a terceira linha, que é lida como texto.
As operações permitidas são:
| + | |
| - | |
| * | |
| / | |
| DIV | |
| MOD |
O "-" pode também ser usado para dizer que um número é negativo:
| Comando | Saída |
|---|---|
write(-(3*5));
write(-11 DIV 4);
write(-11 DIV -4);
write(-11 MOD 4);
write(-11 MOD -4);
|
-15
-2
2
-3
-3
|
Agora, vejamos um outro uso do write e writeln (os exemplos abaixo valem para os dois):
| Comando | Saída |
|---|---|
write(5+9,' é a soma');
write('5 + 9 = ',5+9);
write('5 + 9 = ',5+9,' (total)');
|
14 é a soma
5 + 9 = 14
5 + 9 = 14 (total)
|
Note o espaço no início da frase "é a soma". Se ele não existir, a saída será "14é a soma".
Podemos ter, também, operações múltiplas:
| Comando | Saída |
|---|---|
write(5 + 6 + 7);
write(5 + 6 - 7);
write(3 + 4 * 5);
|
18
4
??
|
Ops. E agora? Qual o resultado de 3+4*5? Podemos escolher a operação que será executada antes usando parênteses:
| Comando | Saída |
|---|---|
write(3 + (4 * 5));
write((3 + 4) * 5);
|
23
35
|
Porém, nesse caso simples, onde queremos efetivamente 3 + (4 * 5), não precisamos de parênteses. Como o computador sabe a ordem então? Em pascal, cada operador tem uma precedência, indicando a ordem em que as operações podem ser executadas.
A ordem em que as operações serão executadas é:
|
DIV, MOD, *, / +, - |
Quando dois operadores de igual precedência ocorrem, são executados da esquerda para a direita. Então:
|
3 + 4 * 5 equivale a 3 + (4 * 5) 6 - 7 + 8 equivale a (6 - 7) + 8 |
Mas sempre podemos mudar a precedência, usando parênteses. Por exemplo, fazendo 4 - 6 + 7 estaremos fazendo (4 - 6) + 7. Agora, se colocarmos os seguintes parênteses 4 - (6 + 7) estaremos forçando a adição a ser calculada antes.
Nesse caso, o computador considera como sendo a subtração de dois termos, sendo um deles uma expressão que deve ser calculada antes da subtração.
Isso nos mostra uma característica importante da linguagem: parênteses têm a maior precedência dentre todos os operadores e, se houverem parênteses dentro de parênteses, o mais interno tem precedência maior.
Então, de um modo geral:
| 3 + (4 + (5 + 6)) —› |
5 + 6 = 11 4 + 11 = 15 15 + 3 = 18 |
| 2 + 3 * 5 / 2 —› |
3 * 5 = 15 15 / 2 = 7.5 |
| 2 + 3 * 5 / 2 —› | 2 + 7.5 = 9.5 |
Agora, veja a saída desse comando:
| Comando | Saída |
|---|---|
writeln(2 + 3 / 2);
|
3.500000000000000e+00
|
Naturalmente, essa não é a saída desejada. Gostaríamos que tivesse, por exemplo, apenas 2 casas decimais apenas. Mas como fazer isso?
| Comando | Saída |
|---|---|
writeln(2 + 3 / 2 : 2 : 2);
|
3.50
|
O número após o primeiro ":" indica o tamanho mínimo reservado para a variável, já o número após o segundo ":" indica o número de casas decimais (no caso de variável REAL).