Namespaces
Variants

std::experimental::ranges:: Boolean

From cppreference.net
C++
Experimental
Ranges
Concepts library
Definido en el encabezado <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)

El concepto Boolean<B> especifica los requisitos para un tipo utilizable en contextos booleanos. Para que se satisfaga Boolean , los operadores lógicos deben tener el comportamiento habitual (incluyendo cortocircuito). Más precisamente, dado

Boolean<B> se satisface solo si:

  • bool ( b1 ) == ! bool ( ! b1 ) ;
  • b1 && b2 , b1 && bool ( b2 ) y bool ( b1 ) && b2 son todos iguales a bool ( b1 ) && bool ( b2 ) y tienen la misma evaluación de cortocircuito;
  • b1 || b2 , b1 || bool ( b2 ) y bool ( b1 ) || b2 son todos iguales a bool ( b1 ) || bool ( b2 ) y tienen la misma evaluación de cortocircuito;
  • bool ( b1 == b2 ) , bool ( b1 == bool ( b2 ) ) , y bool ( bool ( b1 ) == b2 ) son todos iguales a ( bool ( b1 ) == bool ( b2 ) ) ;
  • bool ( b1 ! = b2 ) , bool ( b1 ! = bool ( b2 ) ) , y bool ( bool ( b1 ) ! = b2 ) son todos iguales a ( bool ( b1 ) ! = bool ( b2 ) ) .

Preservación de la igualdad

Una expresión es equality preserving si produce salidas iguales dadas entradas iguales.

  • Las entradas de una expresión consisten en sus operandos.
  • Las salidas de una expresión consisten en su resultado y todos los operandos modificados por la expresión (si los hay).

Toda expresión que deba preservar la igualdad debe además ser estable : dos evaluaciones de dicha expresión con los mismos objetos de entrada deben producir salidas iguales, a menos que exista una modificación explícita e intermedia de esos objetos de entrada.

A menos que se indique lo contrario, cada expresión utilizada en una requires-expression debe ser de preservación de igualdad y estable, y la evaluación de la expresión solo puede modificar sus operandos no constantes. Los operandos que son constantes no deben modificarse.

Variaciones de expresión implícita

Una requires-expression que utiliza una expresión que es no modificadora para algún operando constante lvalue también requiere implícitamente variaciones adicionales de esa expresión que acepten un lvalue no constante o un rvalue (posiblemente constante) para el operando dado, a menos que dicha variación de expresión sea explícitamente requerida con semántica diferente. Estas variaciones de expresión implícitas deben cumplir los mismos requisitos semánticos de la expresión declarada. El grado en que una implementación valida la sintaxis de las variaciones no está especificado.

Notas

Ejemplos de Boolean tipos incluyen bool , std:: true_type , y std:: bitset < N > :: reference . Los punteros no son Boolean tipos.

Una restricción de deducción de la forma { expression } - > Same < T > && efectivamente requiere que decltype ( ( expression ) ) && sea exactamente el mismo tipo que T&& . Esto restringe tanto el tipo de la expresión como su categoría de valor.