Namespaces
Variants

std::experimental::ranges:: Boolean

From cppreference.net
C++
Experimental
Ranges
Concepts library
Défini dans l'en-tête <experimental/ranges/concepts>
template < class B >

concept 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)

Le concept Boolean<B> spécifie les exigences pour un type utilisable dans des contextes booléens. Pour que Boolean soit satisfait, les opérateurs logiques doivent avoir le comportement habituel (incluant l'évaluation en court-circuit). Plus précisément, étant donné

Boolean<B> est satisfait uniquement si :

  • bool ( b1 ) == ! bool ( ! b1 ) ;
  • b1 && b2 , b1 && bool ( b2 ) et bool ( b1 ) && b2 sont tous égaux à bool ( b1 ) && bool ( b2 ) et possèdent la même évaluation en court-circuit ;
  • b1 || b2 , b1 || bool ( b2 ) et bool ( b1 ) || b2 sont tous égaux à bool ( b1 ) || bool ( b2 ) et possèdent la même évaluation en court-circuit ;
  • bool ( b1 == b2 ) , bool ( b1 == bool ( b2 ) ) , et bool ( bool ( b1 ) == b2 ) sont tous égaux à ( bool ( b1 ) == bool ( b2 ) ) ;
  • bool ( b1 ! = b2 ) , bool ( b1 ! = bool ( b2 ) ) , et bool ( bool ( b1 ) ! = b2 ) sont tous égaux à ( bool ( b1 ) ! = bool ( b2 ) ) .

Préservation de l'égalité

Une expression est préservatrice d'égalité si elle produit des résultats égaux pour des entrées égales.

  • Les entrées d'une expression consistent en ses opérandes.
  • Les sorties d'une expression consistent en son résultat et tous les opérandes modifiés par l'expression (le cas échéant).

Toute expression devant préserver l'égalité doit en outre être stable : deux évaluations d'une telle expression avec les mêmes objets d'entrée doivent produire des sorties égales en l'absence de toute modification explicite intervenant entre-temps sur ces objets d'entrée.

Sauf indication contraire, toute expression utilisée dans une requires-expression doit être égalité-préservante et stable, et l'évaluation de l'expression ne peut modifier que ses opérandes non constants. Les opérandes constants ne doivent pas être modifiés.

Variations d'expressions implicites

Une requires-expression qui utilise une expression non modifiante pour un opérande constant lvalue donné exige également implicitement des variations supplémentaires de cette expression qui acceptent un lvalue non constant ou un rvalue (éventuellement constant) pour l'opérande spécifié, sauf si une telle variation d'expression est explicitement exigée avec une sémantique différente. Ces variations d'expression implicites doivent satisfaire aux mêmes exigences sémantiques que l'expression déclarée. La mesure dans laquelle une implémentation valide la syntaxe des variations n'est pas spécifiée.

Notes

Exemples de Boolean types incluent bool , std:: true_type , et std:: bitset < N > :: reference . Les pointeurs ne sont pas des Boolean types.

Une contrainte de déduction de la forme { expression } - > Same < T > && exige effectivement que decltype ( ( expression ) ) && soit exactement le même type que T&& . Cela contraint à la fois le type de l'expression et sa catégorie de valeur.