Como fazemos se quisermos que o usuário nos dê uma informação? Por exemplo, se quisermos calcular a média de um aluno, como fizemos até hoje?

Bom, até hoje, modificávamos o programa, abastecendo, para cada aluno, as notas, compilando e executando o programa. Bastante besta não?

O que gostaríamos de fazer é escrever o programa uma só vez e então executá-lo e deixar que ele peça as notas. Como fazemos isso? Com os comandos read e readln.

Considere o programa:

    PROGRAM teste_read;
    VAR n : real;
    BEGIN
      write('digite um número: ');
      readln(n);
      writeln('você digitou ',n:3:2)
    END.

    Saída:

    digite um número: 5
    você digitou 5.00
        

E se trocarmos readln por read?

    PROGRAM teste_read;
    VAR n : real;
    BEGIN
      write('digite um número: ');
      read(n);
      writeln('você digitou ',n:3:2)
    END.

    Saída:

    digite um número: 5você digitou 5.00
        

Viu a diferença?

Então:

• read lê a entrada e posiciona o cursor após o final desta.
• readln lê a entrada e dá uma nova linha, ou seja, posiciona o cursor na linha de baixo.

    PROGRAM p;
    BEGIN
      readln
    END.
        

não terminará até que "enter" seja pressionado, aí o sistema dá uma nova linha e sai. Se usarmos "read;" em vez de "readln;", a nova linha não será dada. Cabe a você decidir quando usar cada um.

Então, basicamente:

read(n) e readln(n) lêem uma entrada que o usuário digitou e, após ele dar "enter" o comando guarda essa entrada em n. Naturalmente, se o tipo de entrada dada for diferente do tipo de n, o programa gerará um erro.

Por exemplo, se n for integer e o usuário digitar "3.5", na hora que o read for ler dará erro. Tem como evitar esse erro, mas é assunto para um curso mais avançado.

Vamos, então, escrever o programa de notas:

    PROGRAM notas;
    VAR p1,p2,p3 : real; {notas das provas}
        m        : real; {média das provas}
    BEGIN
      write('nota p1: ');
      readln(p1);
      write('nota p2: ');
      readln(p2);
      write('nota p3: ');
      readln(p3);

      m := (2*p1 + 3*p2 + 5*p3) / 10;

      writeln('a média é ',m:4:2)
    END.
        

Nesse caso, queremos somente 3 dados. Mas, e se quisermos usar um número de dados que não é conhecido quando escrevemos o programa? Por exemplo, suponha que queremos achar a média aritmética simples de n dados, onde n é uma entrada do usuário. Considere o programa:

    PROGRAM notas;
    VAR n     : integer; {número de dados}
        num   : real;    {número digitado}
        media : real;    {média dos dados}
        cont  : integer; {contador do for}
        soma  : real;    {soma dos dados}
    BEGIN
      write('Quantos dados serão? ');
      readln(n);
      soma := 0;

      FOR cont := 1 TO n DO
      BEGIN
        write('entre um dado: ');
        readln(num);
        soma := soma + num
      END;

      media := soma / n;
      writeln('a média é ',media:4:2)
    END.
        

Percebeu o que aconteceu? O usuário disse quantos números ía dar e depois entrou cada um dos números. O oprograma, então, somava-os à medida que estes eram dados pelo usuário e, no final, apresentava a média.

Ou seja, o que o programa fez foi calcular

onde n e cada di foi dado pelo usuário quando da execução do programa.

Suponha que queremos que uma determinada variável tenha sempre o mesmo valor no programa, sem que possamos modificar esse valor. Mas então não queremos uma variável, e sim uma constante.

Como defino uma constante em Pascal? Quase como uma variável:

    PROGRAM nome;
    CONST cte1 = valor1;
          cte2 = valor2;
    VAR v1 : tipo1;
        v2 : tipo2;

    PROCEDURE ...

    BEGIN
      ...
    END.
        

Assim, por exemplo, se faço CONST l = 3.5;, l terá sempre esse valor no programa, não podendo ser modificada, ou seja, se eu fizer l:=2; em algum lugar do programa, um erro será dado.

Mas afinal, por que usar uma constante em vez de por diretamente seu valor no programa? Ou seja, por que fazer CONST cte = 10; e não por 10 em todo lugar que precisar no programa? Suponha que usamos esse valor 50 vezes no programa. Agora suponha que precisamos rodar esse programa mas com um valor diferente. Temos que fazer 50 substituições. Se tivéssemos usado a constante, só precisaríamos substituir o valor na linha CONST.

De resto, uma constante pode ser usada como usaríamos um valor qualquer.

Vamos ver agora um exemplo:

Vamos calcular o fatorial de um número dado pelo usuário. Como faremos?

• leio o número, n
• faço 1 × 2 × 3 × ... × n

    PROGRAM fatorial;
    VAR n : integer; {o número cujo fatorial é calculado}
        c : integer; {contador para o for}
        r : integer; {resultado do fatorial}

    BEGIN
      write('número: ');
      readln(n);
      r := 1; {inicializo r}

      {calculo o fatorial de n}
      FOR c := 1 TO n DO r := r * c;

      writeln('resultado: ',r)
    END.
        

O que esse programa fez, foi n! = n × (n-1)!, onde o (n-1)! era guardado em r a cada iteração. De fato, para calcular 5!, calculamos os 5 primeiros fatoriais.

Mas, e se n = 0? Nesse caso o laço FOR não será executado. E qual o valor de r? 1, exatamente 0!.

‹— Parte VI — Página da disciplina — Parte VIII —›