std::boolean

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Concepts library

Core language concepts same_as (C++20) derived_from (C++20) convertible_to (C++20) common_reference_with (C++20) common_with (C++20) integral (C++20) signed_integral (C++20) unsigned_integral (C++20) floating_point (C++20) swappableswappable_with (C++20)(C++20) destructible (C++20) constructible_from (C++20) default_initializable (C++20)   move_constructible (C++20) copy_constructible (C++20) assignable_from (C++20)

Comparison concepts equality_comparableequality_comparable_with (C++20)(C++20) totally_orderedtotally_ordered_with (C++20)(C++20) Object concepts movable (C++20) copyable (C++20) semiregular (C++20) regular (C++20) Callable concepts invocableregular_invocable (C++20)(C++20) predicate (C++20) relation (C++20) equivalence_relation (C++20) strict_weak_order (C++20)

Exposition-only concepts boolean-testable  (C++20)

 

Defined in header <concepts>
template<class B>   concept boolean =     std::movable<std::remove_cvref_t<B>> &&     requires(const std::remove_reference_t<B>& b1,              const std::remove_reference_t<B>& b2, const bool a) {       { b1 } -> std::convertible_to<bool>;       { !b1 } -> std::convertible_to<bool>;       { b1 && b2 } -> std::same_as<bool>;       { b1 &&  a } -> std::same_as<bool>;       {  a && b2 } -> std::same_as<bool>;       { b1 || b2 } -> std::same_as<bool>;       { b1 ||  a } -> std::same_as<bool>;       {  a || b2 } -> std::same_as<bool>;       { b1 == b2 } -> std::convertible_to<bool>;       { b1 ==  a } -> std::convertible_to<bool>;       {  a == b2 } -> std::convertible_to<bool>;       { b1 != b2 } -> std::convertible_to<bool>;       { b1 !=  a } -> std::convertible_to<bool>;       {  a != b2 } -> std::convertible_to<bool>;     };		(since C++20)

The concept boolean<B> specifies the requirements for a type usable in Boolean contexts. For boolean to be satisfied, the logical operators must have the usual behavior (including short-circuiting). More precisely, given

• b1, b2, two lvalues of type const std::remove_reference_t<B>,

boolean<B> is satisfied only if:

• bool(b1) == !bool(!b1)
• b1 && b2, b1 && bool(b2) and bool(b1) && b2 are all equal to bool(b1) && bool(b2) and have the same short-circuit evaluation;
• b1 || b2, b1 || bool(b2) and bool(b1) || b2 are all equal to bool(b1) || bool(b2) and have the same short-circuit evaluation;
• bool(b1 == b2), bool(b1 == bool(b2)), and bool(bool(b1) == b2) are all equal to (bool(b1) == bool(b2));
• bool(b1 != b2), bool(b1 != bool(b2)), and bool(bool(b1) != b2) are all equal to (bool(b1) != bool(b2)).

Equality preservation

Expressions declared in requires expressions of the standard library concepts are required to be equality-preserving (except where stated otherwise).

Implicit expression variations

A requires expression that uses an expression that is non-modifying for some constant lvalue operand also requires implicit expression variations.

Notes

Examples of boolean types include bool, std::true_type, and std::bitset<N>::reference. Pointers are not boolean types.