Ada Tour - Dokumentation

vor

5.4 Logische Operatoren und Kurzauswertungsoperatoren

Für alle Boolschen Typen sowie modulare Typen und eindimensionale Reihungstypen, deren Komponententyp ein Boolescher Typ ist, sind die logischen Operatoren

and (logisches UND)
or (logisches ODER)
xor (logisches exklusives ODER)

vordefiniert.

Vergleich Boolscher Typen

Beispiel:

A := True;
B := True;
C := True;
-- A, B und C haben den Wert "True"

if A and B then
   C := False;
end if;
-- A und B haben den Wert "True", C hat den Wert "False"

if B xor C then
   A := False;
end if;
-- B hat den Wert "True", A und C haben den Wert "False"

if not A and not C then
   B := False;
end if;
-- A, B und C haben jetzt alle den Wert "False"

Vergleich modularer Typen

Für modulare Typen werden die Vergleiche bitweise durchgeführt.

Der Bitwert "1" steht für den Booleschen Wert "True" und der Bitwert "0" für den Booleschen Wert "False"

Jedes Bit des einen Operanden wird mit dem gleichwertigen Bit des anderen Operanden verglichen. In dem Zielwert werden an den Stellen, an denen der Vergleich "True" ergibt, die Bitwerte auf "1" gesetzt, an den anderen Stellen auf "0". Am deutlichsten wird dieses, wenn die Werte zur Basis 2 notiert werden, da die Bitwerte dann einzeln gesetzt werden können.

Beispiel:

2#0010_1101# and 2#0011_0101#
-- ergibt:
2#0010_0101#

Reihungstypen mit dem Komponententyp BOOLEAN

Für Reihungstypen wird der Vergleich komponentenweise durchgeführt, wobei die Ergebnisreihung die Grenzen des linken Operanden hat.

Jede Komponente der einen Reihung wird mit der entsprechenden Komponente der anderen Reihung verglichen. In der Zielreihung wird dann die entsprechende Komponente auf den Ergebniswert gesetzt.

Statt mehrere Reihungen zu definieren, um diese vergleichen zu können, kann man eine Reihung auch direkt mit einem Aggregat vergleichen.

Beispiel:

(True, False, True) xor (True, False, False)
-- ergibt:
(False, False, True)

Die Kurzauswerteoperatoren

Die Kurzauswertungsoperatoren and then und or else sind Sonderformen der logischen Operatoren. Bei ihnen werden nicht notwendigerweise
alle Elemente eines Ausdrucks einem Vergleich unterzogen.

Der linke Operand wird bei and then und or else immer zuerst ausgewertet. Wenn dadurch das Ergebnis schon feststeht, wird auf die Auswertung des rechten Operanden verzichtet.

Beispiel 1:

subtype Feld is Integer range -20 .. 20;
subtype Bereich is Feld range 1 .. 20;
Liste : array (Bereich) of Integer;
I : Integer;
...
I := Liste'Last;
while I in Bereich and then Liste(I)>0 loop
   -- mit "and" alleine wuerde hier ein Laufzeitfehler auftreten,
   -- wenn der Wert von I die Grenzen der Reihung "Liste" verlaesst.
   Liste (I) := Liste (I) - 1;
   if Liste (I) = 0 then
      I := Berechne_Neuen_Wert (I);
      put_line (integer'image (I) );
   end if;
end loop;

Beispiel 2:

-- Laufzeitfehler durch eine Division durch 0 abfangen:
if A =/ 0 and then B / A >= 20 then
...
end if;

Beispiel 3:

-- Laufzeitfehler beim Zugriff auf ein Listenelement abfangen:
while Zeiger /= null and then Zeiger.Schlüssel <= Schlüssel loop
...
end loop;

zurück

vor

Index

nach oben