Namensräume
Varianten
Aktionen

std::experimental::ranges::Boolean

Von cppreference.com
< cpp‎ | experimental‎ | ranges
 
 
 
 
Konzeptbibliothek
Kernsprachen-Konzepte
                              
Objektkonzepte
                              
                              
Vergleichskonzepte
Boolean

Aufrufbare Konzepte
                                        
                              
URNG-Konzept
 
Definiert in Header <experimental/ranges/concepts>
template< class B >

Konzept bool Boolean =
    Movable<std::decay_t<B>> &&
    requires(const std::remove_reference_t<B>& b1,
             const std::remove_reference_t<B>& b2, const bool a) {
        { b1 }       -> ConvertibleTo<bool>&&;
        { !b1 }      -> ConvertibleTo<bool>&&;
        { b1 && a }  -> Same<bool>&&;
        { b1 || a }  -> Same<bool>&&;
        { b1 && b2 } -> Same<bool>&&;
        { a && b2  } -> Same<bool>&&;
        { b1 || b2 } -> Same<bool>&&;
        { a || b2  } -> Same<bool>&&;
        { b1 == b2 } -> ConvertibleTo<bool>&&;
        { b1 == a  } -> ConvertibleTo<bool>&&;
        { a == b2  } -> ConvertibleTo<bool>&&;
        { b1 != b2 } -> ConvertibleTo<bool>&&;
        { b1 != a  } -> ConvertibleTo<bool>&&;
        { a != b2  } -> ConvertibleTo<bool>&&;

    };
(Ranges TS)

Das Konzept Boolean<B> spezifiziert die Anforderungen an einen Typ, der in booleschen Kontexten verwendbar ist. Damit Boolean erfüllt ist, müssen die logischen Operatoren das übliche Verhalten (einschließlich Kurzschlussauswertung) aufweisen. Genauer gesagt, gegeben

wird Boolean<B> nur dann erfüllt, wenn

  • bool(b1) == !bool(!b1);
  • b1 && b2, b1 && bool(b2) und bool(b1) && b2 alle gleich bool(b1) && bool(b2) sind und die gleiche Kurzschlussauswertung haben;
  • b1 || b2, b1 || bool(b2) und bool(b1) || b2 alle gleich bool(b1) || bool(b2) sind und die gleiche Kurzschlussauswertung haben;
  • bool(b1 == b2), bool(b1 == bool(b2)) und bool(bool(b1) == b2) alle gleich (bool(b1) == bool(b2)) sind;
  • bool(b1 != b2), bool(b1 != bool(b2)) und bool(bool(b1) != b2) alle gleich (bool(b1) != bool(b2)) sind.

[bearbeiten] Gleichheitserhaltung

Ein Ausdruck ist gleichheitserhaltend, wenn er bei gleichen Eingaben gleiche Ausgaben liefert.

  • Die Eingaben für einen Ausdruck bestehen aus seinen Operanden.
  • Die Ausgaben eines Ausdrucks bestehen aus seinem Ergebnis und allen von dem Ausdruck modifizierten Operanden (falls vorhanden).

Jeder Ausdruck, der gleichheitserhaltend sein muss, muss außerdem stabil sein: Zwei Auswertungen eines solchen Ausdrucks mit denselben Eingabeobjekten müssen gleiche Ausgaben liefern, solange keine explizite zwischenzeitliche Modifikation dieser Eingabeobjekte erfolgt.

Sofern nicht anders angegeben, muss jeder in einem requires-expression verwendete Ausdruck gleichheitserhaltend und stabil sein, und die Auswertung des Ausdrucks darf nur seine nicht-konstanten Operanden modifizieren. Operanden, die konstant sind, dürfen nicht modifiziert werden.

[bearbeiten] Implizite Ausdrucksvariationen

Ein requires-expression, der einen Ausdruck verwendet, der für einen konstanten lvalue-Operanden nicht-modifizierend ist, erfordert implizit auch zusätzliche Variationen dieses Ausdrucks, die einen nicht-konstanten lvalue oder (möglicherweise konstanten) rvalue für den gegebenen Operanden akzeptieren, es sei denn, eine solche Ausdrucksvariation ist explizit mit abweichender Semantik erforderlich. Diese impliziten Ausdrucksvariationen müssen die gleichen semantischen Anforderungen des deklarierten Ausdrucks erfüllen. Das Ausmaß, in dem eine Implementierung die Syntax der Variationen validiert, ist nicht spezifiziert.

[bearbeiten] Hinweise

Beispiele für Boolean-Typen sind bool, std::true_type und std::bitset<N>::reference. Zeiger sind keine Boolean-Typen.

Eine Deduktionseinschränkung der Form { expression } -> Same<T>&& erfordert effektiv, dass decltype((expression))&& denselben Typ wie T&& hat. Dies schränkt sowohl den Typ des Ausdrucks als auch seine Wertkategorie ein.