Variáveis booleanas são variáveis capazes de conter apenas 1 de 2 valores: verdadeiro ou falso.

Como as condições no IF retornam verdadeiro ou falso são chamadas booleanas. Note que, em x > 2, x não é booleano, mas o resultado da expressão é.

Como defino uma variável booleana?

  VAR v : boolean;
	

E como abasteço um valor nessa variável? Assim, a forma geral do comando IF é:

  PROGRAM abastece;
  var b1,b2 : boolean;
      a,b,c : integer;

  BEGIN
    a := 2;
    b := 3;
    c := 1;
    b1 := true;
    b2 := false;
    b2 := a > b; {aqui b2 é "false", pois a é menor que b}
    b1 := (a>b) AND (b>c); {b1 recebeu false, confira}
    b2 := (a>b) OR NOT (b>c);

    etc
  END.
        

Opa! Quem é esse NOT? É a negação!

  NOT true  = false
  NOT false = true
	

Vejamos um exemplo: suponha que queremos que b1 seja verdadeira se b2 for falsa e vice-versa. Como farei? Um modo horrendo é:

  IF b2 THEN b1 := false
  ELSE b1 := true;
	

Mas isso pode, e DEVE, ser substituído por:

   b1 := NOT b2;
	

O efeito é o mesmo, confira, e o programa fica menor.

Note também que não fiz:

   IF b2 = true THEN b1 := false
   ELSE b1 := true;
        

Por que? Porque é redundante. Quando o IF acima será executado? Quando o resultado de (b2 = true) for verdadeiro, ou seja, true. E, para que isso ocorra, que valor b2 deve ter? true. Então b2 = true equivale a simplesmente ler o valor de b2.

Mas e se quiséssemos que algo fosse executado se uma variável for false? Abaixo você vê as duas maneiras, a segunda é preferível:

   modo 1:
     IF b1=false THEN faz algo;

   modo 2:
     IF NOT b1 THEN faz algo
        

Agora confira e veja que as duas formas agem da mesma maneira: se a condição for verdadeira, faz e, para a condição ser verdadeira, ou b1 é false ou NOT b1 é verdadeiro => b1 é false.

AND, OR e NOT sao operadores booleanos, porque agem em expressoes ou variaveis booleanas.

Suponha que temos duas variaveis booleanas a e b, a seguir temos uma tabela com seus valores e os resultados das operaçoes:

Ou seja:

Essas tabelas sao chamadas de tabelas verdade.

Lembra do nosso programa de chute? Suponha que, ao final do programa queiramos dizer que acabaram-se as chances do usuario, mas queremos dizer isso somente se ele errou todas as vezes. Vomo fazemos? Veja abaixo:

   PROGRAM chute;
   CONST num = 5; {valor a ser adivinhado}
   VAR n       : integer; {o chute do usuário}
       c       : integer; {contador do for}
       acertou : boolean; {indica se o usuario acertou}

   BEGIN
     writeln('Você tem 10 chances');
     acertou := false;

     FOR c := 1 TO 10 DO
     BEGIN
       write('seu chute: ');
       readln(n);
       IF n = valor THEN
       BEGIN
         writeln('acertou"');
	 acertou := true;
         c := 10
       END;
       if n > valor then writeln('seu palpite foi maior');
       if n < valor then writeln('seu palpite foi menor')
     END;

     IF NOT acertou THEN writeln('suas chances acabaram');
   END.
        

Por fim, lembre que as únicas operações permitidas em booleanos são AND, OR e NOT. +, - etc não funcionam porque não tem lógica, afinal, quanto é true + 1? E true + false?

As mesmas operações permitidas com integer podem ser usadas com real. Vale lembrar que "-" pode indicar subtração de dois valores ou indicar que o valor é negativo:

   x := 2.5 - 1.43;
   x := -3.12;
        

Agora vamos ver uma aplicação: vamos calcular quanto tempo passa, pela relatividade, em uma nave se movendo a uma velocidade v, enquanto que na Terra passaram n horas.

A fórmula é:

onde Tn é o tempo na nave, TT é o tempo na Terra e c é a velocidade da luz no vácuo.

Mas, peraí! Como calculo o quadrado e a raíz?

  x := sqr(y);    x recebe y²

  x := sqrt(y);   x recebe √y
	

lembre-se de que x deve ser real. Naturalmente, x := y*y; também funciona.

Então o programa fica:

  PROGRAM relat;
  CONST c = 300000; {km/s}
  VAR tt : real; {tempo na terra (s)}
      tn : real; {tempo na nave (s)}
      v  : real; {velocidade da nave (km/s)}

  BEGIN
    write('vel (km/s): );
    readln(v);

    tt := 60; {1 minuto}
    tn := tt * sqrt(1 - (sqr(v) / sqr(c)));

    writeln('t na nave é: ',tn:4:2,' s, t na terra é ',tt:4:2,' s')
  END.
	

Como fazemos para converter entre real e integer? Para isso, pascal tem as seguintes regras:

• Expressões integer são automaticamente convertidas para real.
• Expressões real devem ser convertidas explicitamente para integer.

  VAR a : integer;
      b : real;

  BEGIN
    b := a;
    b := a/2;

    etc
  END.
	

Mas como convertemos de real para integer? Depende do que você quer que seja feito com o número. Podemos:

• arredondar: por exemplo, de 4.5 para 5; de 4.7 para 5; de 4.3 para 4.
• truncar: de 4.5 para 4; de 4.7 para 4; de 4.3 para 4.

Se quisermos truncar:

  x := trunc(4.7);     x terá 4
	

Se quisermos arredondar:

  x := round(4.7);     x terá 5
	

A forma geral das funções é:

  Trunc(x : real) : longint
  Round(x : real) : longint
	

o que significa que trunc e round recebem um valor real edevolvem um longint.

Mas, e se o número for negativo? Nada muda:

  Trunc(-expressão) = -Trunc(expressão)
  Round(-expressão) = -Round(expressão)
	

Naturalmente, qualquer expressão real pode ser usada dentro de trunc ou round. Vejamos alguns exemplos:

‹— Parte IX — Página da disciplina — Parte XI —›