Namespaces
Variants

Logical operators

From cppreference.net
C++
C++ language
General topics
Flow control
Conditional execution statements
Iteration statements (loops)
Jump statements
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications ( until C++17* )
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Memory allocation
Classes
Class-specific function properties
Special member functions
Templates
Miscellaneous
Expressions
General
Literals
Operators
Conversions

Gibt das Ergebnis einer booleschen Operation zurück.

Operatorname Syntax Überladbar Prototyp-Beispiele (für class T )
Innerhalb der Klassendefinition Außerhalb der Klassendefinition
Negation not a

! a

Ja bool T :: operator ! ( ) const ; bool operator ! ( const T & a ) ;
UND a and b

a && b

Ja bool T :: operator && ( const T2 & b ) const ; bool operator && ( const T & a, const T2 & b ) ;
Inklusives ODER a or b

a || b

Ja bool T :: operator || ( const T2 & b ) const ; bool operator || ( const T & a, const T2 & b ) ;
Hinweise
  • Die schlüsselwortartigen Formen ( and , or , not ) und die symbolartigen Formen ( && , || , ! ) können austauschbar verwendet werden (siehe alternative Darstellungen ).
  • Alle eingebauten Operatoren geben bool zurück, und die meisten benutzerdefinierten Überladungen geben ebenfalls bool zurück, damit die benutzerdefinierten Operatoren auf die gleiche Weise wie die eingebauten verwendet werden können. In einer benutzerdefinierten Operatorüberladung kann jedoch jeder Typ als Rückgabetyp verwendet werden (einschließlich void ).
  • Eingebaute Operatoren && und || führen Kurzschlussauswertung durch (werten den zweiten Operanden nicht aus, wenn das Ergebnis nach Auswertung des ersten bekannt ist), aber überladene Operatoren verhalten sich wie reguläre Funktionsaufrufe und werten immer beide Operanden aus.

Inhaltsverzeichnis

Erklärung

Die logischen Operatorausdrücke haben die Form

! rhs (1)
lhs && rhs (2)
lhs || rhs (3)
1) Logisches NICHT
2) Logisches UND
3) Logisches inklusives ODER

Wenn der Operand kein bool ist, wird er mittels kontextueller Konvertierung zu bool in bool umgewandelt: Dies ist nur wohlgeformt, wenn die Deklaration bool t(arg) für ein temporäres, erfundenes t wohlgeformt ist.

Das Ergebnis ist ein bool Prvalue.

Für den eingebauten logischen NOT-Operator ist das Ergebnis true , wenn der Operand false ist. Andernfalls ist das Ergebnis false .

Für den eingebauten logischen UND-Operator ist das Ergebnis true , wenn beide Operanden true sind. Andernfalls ist das Ergebnis false . Dieser Operator arbeitet nach dem Kurzschlussprinzip : wenn der erste Operand false ist, wird der zweite Operand nicht ausgewertet.

Für den eingebauten logischen ODER-Operator ist das Ergebnis true , wenn entweder der erste oder der zweite Operand (oder beide) true ist. Dieser Operator ist kurzschließend: wenn der erste Operand true ist, wird der zweite Operand nicht ausgewertet.

Beachten Sie, dass bitweise logische Operatoren kein Short-Circuiting durchführen.

Ergebnisse

a true false
! a false true
and a
true false
b true true false
false false false
**Anmerkung:** Da es sich bei allen Textinhalten um C++-Schlüsselwörter (`and`, `a`, `b`, `true`, `false`) handelt, die gemäß den Anweisungen nicht übersetzt werden dürfen, bleibt der gesamte Inhalt unverändert. Die HTML-Struktur und Formatierung wurden exakt beibehalten.
or a
true false
b true true true
false true false
**Erklärung:** - Alle HTML-Tags und Attribute wurden unverändert beibehalten - Text innerhalb der ` ` Tags (C++ Code) wurde nicht übersetzt - C++-spezifische Begriffe (`or`, `true`, `false`) blieben in englischer Originalform - Die Tabellenstruktur und Formatierung wurde vollständig erhalten

Bei Überlagerungsauflösung gegenüber benutzerdefinierten Operatoren nehmen die folgenden integrierten Funktionssignaturen an der Überlagerungsauflösung teil:

bool operator ! ( bool )
bool operator && ( bool , bool )
bool operator || ( bool , bool )

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <sstream>
#include <string>
int main()
{
    int n = 2;
    int* p = &n;
    // pointers are convertible to bool
    if (    p && *p == 2  // "*p" is safe to use after "p &&"
        || !p &&  n != 2) // || has lower precedence than &&
        std::cout << "true\n";
    // streams are also convertible to bool
    std::stringstream cin;
    cin << "3...\n" << "2...\n" << "1...\n" << "quit";
    std::cout << "Enter 'quit' to quit.\n";
    for (std::string line;    std::cout << "> "
                           && std::getline(cin, line)
                           && line != "quit";)
        std::cout << line << '\n';
}

Ausgabe: 

true
Enter 'quit' to quit.
> 3...
> 2...
> 1...
>

Standardbibliothek

Da die Kurzschluss-Eigenschaften von operator&& und operator|| nicht für Überladungen gelten und da Typen mit boolescher Semantik unüblich sind, überladen nur zwei Standardbibliotheksklassen diese Operatoren:

Wendet einen unären arithmetischen Operator auf jedes Element des valarray an
(öffentliche Mitgliedsfunktion von std::valarray<T> )
Wendet binäre Operatoren auf jedes Element von zwei valarrays oder einem valarray und einem Wert an
(Funktionstemplate)
Überprüft, ob ein Fehler aufgetreten ist (Synonym für fail() )
(öffentliche Mitgliedsfunktion von std::basic_ios<CharT,Traits> )

Siehe auch

Operator-Präzedenz

Operatorüberladung

Funktionsobjekt, das x && y implementiert
(Klassentemplate)
Funktionsobjekt, das x || y implementiert
(Klassentemplate)
Funktionsobjekt, das ! x implementiert
(Klassentemplate)
Häufige Operatoren
Zuweisung Inkrement
Dekrement 		Arithmetik Logisch Vergleich Member
Zugriff 		Sonstige

a = b
a + = b
a - = b
a * = b
a / = b
a % = b
a & = b
a | = b
a ^ = b
a <<= b
a >>= b

++ a
-- a
a ++
a --

+ a
- a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

! a
a && b
a || b

a == b
a ! = b
a < b
a > b
a <= b
a >= b
a <=> b

a [ ... ]
* a
& a
a - > b
a. b
a - > * b
a. * b

Funktionsaufruf

a ( ... )
Komma

a, b
Bedingungsoperator

a ? b : c
Spezielle Operatoren

static_cast konvertiert einen Typ in einen anderen verwandten Typ
dynamic_cast konvertiert innerhalb von Vererbungshierarchien
const_cast fügt cv -Qualifizierer hinzu oder entfernt sie
reinterpret_cast konvertiert einen Typ in einen unverwandten Typ
C-style cast konvertiert einen Typ in einen anderen durch eine Kombination von static_cast , const_cast und reinterpret_cast
new erzeugt Objekte mit dynamischer Speicherdauer
delete zerstört zuvor durch den new-Ausdruck erzeugte Objekte und gibt den belegten Speicherbereich frei
sizeof ermittelt die Größe eines Typs
sizeof... ermittelt die Größe eines Pack (seit C++11)
typeid ermittelt die Typinformationen eines Typs
noexcept prüft, ob ein Ausdruck eine Exception werfen kann (seit C++11)
alignof ermittelt die Ausrichtungsanforderungen eines Typs (seit C++11)

C-Dokumentation für Logische Operatoren