Quelltext der Seite Logischer Operator

Ein '''Logischer Operator''' ist eine Funktion, die einen [[Wahrheitswert]] liefert. Bei der zweiwertigen, [[Boolesche Algebra|booleschen Logik]] liefert er also ''wahr'' oder ''falsch,'' bei einer [[Mehrwertige Logik|mehrwertigen Logik]] können auch entsprechend andere Werte geliefert werden. Logische [[Operator (Mathematik)|Operatoren]] können eine beliebige Anzahl an [[Operator (Mathematik)#Operand|Operanden]] haben.

Ein typisches Beispiel für einen [[Boolescher Operator|booleschen logischen Operator]] ist die [[Konjunktion (Logik)|Und-Verknüpfung]]: Sie liefert immer dann ''wahr'', wenn alle Operanden ebenfalls wahr sind.

Von besonderer Bedeutung sind die logischen Operatoren in der praktischen Anwendung in [[Programmiersprache]]n und in [[Digitaltechnik|digitalen Schaltungen]]. In Programmiersprachen stehen mit Ausnahme des „NOT“-Operators mit nur einem Operanden meist nur Operatoren mit zwei Operanden zur Verfügung. Dafür gehören neben den booleschen Operatoren auch [[Vergleichsoperator]]en zum Standardrepertoire von höheren Programmiersprachen. In der [[Schaltungstechnik]] sind dagegen „UND“/„ODER“-Verknüpfungen mit mehreren Operanden gängig, die durch [[Logikgatter]] oder Reihen- bzw. Parallelschaltung von Schaltern oder [[Relais]] realisiert werden.

== Logische Operatoren in Programmiersprachen ==
Durch [[logische Verknüpfung]] (meist zweier) logischer Ausdrücke entsteht ein komplexerer logischer Ausdruck. Je nach Art des Verknüpfungsoperators ist der zusammengesetzte Ausdruck zum Beispiel genau dann wahr, wenn ''beide'' verknüpften Ausdrücke wahr sind ([[Konjunktion (Logik)|Und-Verknüpfung]]) oder wenn mindestens einer der verknüpften Ausdrücke wahr ist ([[Disjunktion|Oder-Verknüpfung]]). Von den Junktoren in der [[Aussagenlogik]] unterscheiden sich die logischen Operatoren der Programmiersprachen unter Umständen in der Auswertungsreihenfolge oder in mit zu berücksichtigenden [[#Auswertungsreihenfolge, Kommutativität und Nebeneffekte|Nebeneffekten]].

Hinsichtlich der Art, Anzahl und Schreibweise der logischen Operatoren unterscheiden sich die einzelnen [[Programmiersprache]]n teilweise sehr stark voneinander (siehe Tabelle). Unterschiede gibt es auch hinsichtlich der internen Darstellung der Wahrheitswerte: In den meisten Programmiersprachen wird der Wahrheitswert ''falsch'' als die Zahl 0 dargestellt. Der Wahrheitswert ''wahr'' wird oft als die Zahl&nbsp;1 dargestellt, vielfach wird aber auch jeder von 0 verschiedene Wert als ''wahr'' interpretiert. Eine bemerkenswerte Ausnahme bilden viele [[Kommandozeileninterpreter|Kommandointerpreter]], darunter die verschiedenen [[Unix-Shell]]s, in denen der Erfolg eines ausgeführten Befehls durch den Rückgabewert&nbsp;0, der Misserfolg durch einen von 0 verschiedenen Wert angezeigt wird, der die Art des aufgetretenen Fehlers aufzeigt. In Verallgemeinerung dessen wird in den logischen Ausdrücken dieser Kommandointerpreter der Wert 0 („kein Fehler“) als ''wahr'' interpretiert und jeder von 0 verschiedene Wert („Fehler“) als ''falsch.''

'''Vergleichsoperatoren''' stellen zwei Werte, etwa numerische Größen, einander gegenüber und liefern in Abhängigkeit vom Ausgang des Vergleichs (größer, kleiner usw.) einen Wahrheitswert.

=== Beispiele für logische Operatoren ===
{| class="wikitable"
|-
! <!-- leer --> || Operator || Mathematik
!Python|| Fortran || ABAP || Delphi, Pascal || Visual Basic || C, C++, C#, Java, PHP || Perl || Batch
|-
|rowspan="6" | Vergleiche || größer || <math>></math>, >
|>
| .GT. || GT oder &gt; || &gt; || &gt; || &gt; || &gt;, gt || GTR
|-
| kleiner || <math><</math>, <
|<
| .LT. || LT oder &lt; || &lt; || &lt; || &lt; || &lt;, lt || LSS
|-
| größer oder gleich || <math>\ge</math>, ≥
|>=
| .GE. || GE oder &gt;= || &gt;= || &gt;= || &gt;= || &gt;=, ge || GEQ
|-
| kleiner oder gleich|| <math>\le</math>, ≤
|<=
| .LE. || LE oder &lt;= || &lt;= || &lt;= || &lt;= || &lt;=, le || LEQ
|-
| gleich|| <math>=</math>, =
|==, is
| .EQ. || EQ oder = || = || = || &#61;&#61; || &#61;&#61;, eq || EQU, &#61;&#61;
|-
| ungleich|| <math>\ne</math>, ≠
|<> <sup>1)</sup>, !=, is not|| .NE. || NE oder &lt;&gt; || &lt;&gt; || &lt;&gt; || != || !=, ne || NEQ
|-
|rowspan="3" | Verknüpfungen || Und ([[Konjunktion (Logik)|Konjunktion]]) || <math>\wedge</math>, ∧
|&, and, all()
| .AND. || AND || AND || And, AndAlso<sup>2)</sup> || &amp;, &amp;&amp; || &&, &, and || ''n.&nbsp;a.''
|-
| Oder ([[Disjunktion]]) || <math>\vee</math>, ∨
|<nowiki>|, or, any()</nowiki>
| .OR. || OR || OR || Or, OrElse<sup>2)</sup> || <nowiki>|</nowiki>, <nowiki>||</nowiki> || <nowiki>||</nowiki>, <nowiki>|</nowiki>, ^, or || ''n.&nbsp;a.''
|-
| Nicht ([[Negation]]) || <math>\neg</math>, ¬
| not
| .NOT. || NOT || NOT || Not || ~,! || !, ~, not || NOT
|}
:<sup>1) in Python 2, inzwischen veraltet</sup>
:<sup>2) Neu in .NET-Versionen</sup>

=== Beispiele für logische Ausdrücke ===

     ''IF a&nbsp;&gt;&nbsp;b THEN''
        ''Anweisungen''
     ''ENDIF''

In diesem Fall wird bewertet, ob a größer ist als b. Ist die Aussage ''wahr,'' werden die Anweisungen ausgeführt, die mit ''THEN'' eingeleitet werden. Andernfalls werden die Anweisungen übersprungen.

     ''IF i AND j THEN''
        ''Anweisungen''
     ''ENDIF''

In diesem Fall wird bewertet, ob i ''wahr'' ist und j ''wahr'' ist. Sind i und j ''wahr,'' werden die Anweisungen ausgeführt, die mit ''THEN'' eingeleitet werden. Ist einer der Werte ''falsch'' (oder beide), werden die Anweisungen übersprungen.

=== Auswertungsreihenfolge, Kommutativität und Nebeneffekte ===
Die logischen Operatoren einer Programmiersprache sind keine exakte Entsprechung der [[Junktor]]en in der [[Aussagenlogik]], weil bei der Bewertung von Junktoren keine [[Wirkung (Informatik)|Nebeneffekte]] auftreten können. In einer Programmiersprache kann das sehr wohl der Fall sein, wenn z.&nbsp;B. innerhalb des logischen Ausdrucks Funktionen mit Nebeneffekten aufgerufen werden. In diesem Fall spielt die Auswertungsreihenfolge eine Rolle, d.&nbsp;h. das Gesetz der [[Kommutativität]] (z.&nbsp;B. für die [[Konjunktion (Logik)|Konjunktion]]: a ∧ b = b ∧ a) gilt dann nicht, wenn a oder b nicht nur einen Wert, sondern auch eine [[Wirkung (Informatik)|Wirkung]] haben. Aus diesem Grund definieren die meisten Programmiersprachen eine feste Auswertungsreihenfolge für logische Ausdrücke.

Wenn man eine Konjunktion a&nbsp;∧&nbsp;b von links nach rechts auswertet und dabei feststellt, dass schon a falsch ist, weiß man bereits an dieser Stelle und ohne b näher betrachten zu müssen, dass die ganze Konjunktion falsch sein wird. Dieses Wissen kann man zur Optimierung der Laufzeit benutzen, indem man in diesem Fall gänzlich auf die Auswertung von b verzichtet ([[Lazy Evaluation]])&nbsp;– allerdings um den Preis, dass dann ein eventueller [[Wirkung (Informatik)|Effekt]] von b ausbleibt. Aus diesem Grund ist die unkritische [[Compiler#Programmoptimierung|Ausdrucksoptimierung]] ein Problem. Es gibt zwei Möglichkeiten, damit umzugehen: Ausdrücke bzw. Ausdrucksteile mit Nebeneffekten können von der Optimierung ausgenommen, d.&nbsp;h. stets ausgewertet werden; oder aber das frühzeitige Abbrechen der Auswertung logischer Ausdrücke kann exakt in die Sprachspezifikation aufgenommen werden, sodass der Programmierer zumindest genau vorhersagen kann, welche Nebeneffekte in welcher Situation auftreten und welche nicht.

{{Anker|frühzeitigesAbbrechenAuswertung}}Letzteres ist in Programmiersprachen wie [[C (Programmiersprache)|C]], [[C++]] oder [[Java (Programmiersprache)|Java]] der Fall: Hier ist spezifiziert, dass bei der Auswertung einer Konjunktion a ∧ b, in der Schreibweise dieser Sprachen a&nbsp;&&&nbsp;b, die Auswertung von b unterbleibt, wenn bereits a ''falsch'' ist; und dass bei der Auswertung der [[Disjunktion]] a&nbsp;&or;&nbsp;b, in der Schreibweise dieser Sprachen a&nbsp;||&nbsp;b, die Auswertung von b unterbleibt, wenn bereits a ''wahr'' ist. Dies stellt keinen grundsätzlichen Unterschied zu den jeweiligen aussagenlogischen Junktoren dar, wenn die auszuwertenden Teilausdrücke wirkungsfrei sind.

Andere Programmiersprachen wie [[Ada (Programmiersprache)|Ada]] (oder [[C-Sharp|C#]]) bieten sowohl Konjunktionen und Disjunktionen im aussagenlogischen Sinn an („AND“ und „OR“) als auch Operatoren wie das „&&“ bzw. „||“ in C, in Ada „AND THEN“ bzw. „OR ELSE“ genannt.

== Beispiel für einen Logischen Operator in mehrwertiger Logik ==
Folgendes Beispiel aus der Elektrotechnik entspricht einem logischen Operator mit 10 Operanden in einer 4-wertigen Logik:

An einem [[Bus (Datenverarbeitung)|Bus]] sind 10 Geräte angeschlossen, die jeweils die Wahrheitswerte „high“ (5&nbsp;Volt), „low“ (0&nbsp;Volt) und „Z“ (hochohmig) liefern können. Der Zustand des Busses lässt sich durch folgenden logischen Operator beschreiben:

  O&nbsp;(Gerät1, Gerät2, …, Gerät10):
    „Kurzschluss“ … wenn mindestens ein Gerät „high“ liefert und mindestens ein Gerät „low“
    „high“        … wenn mindestens ein Gerät „high“ liefert und kein Gerät „low“
    „low“         … wenn mindestens ein Gerät „low“ liefert und kein Gerät „high“
    „hochohmig“   … wenn alle Geräte „hochohmig“ liefern

{{siehe auch|Mehrwertige Logik}}

== Siehe auch ==
* [[regulärer Ausdruck]]
* [[Mehrwertige Logik]]

[[Kategorie:Programmiersprachelement]]
[[Kategorie:Digitale Schaltungstechnik]]
[[Kategorie:Schaltalgebra]]
[[Kategorie:Mehrwertige Logik]]