std::monostate - cppreference.com (original) (raw)
| Defined in header | ||
|---|---|---|
| Defined in header | (since C++26) | |
| struct monostate { }; | (since C++17) |
Unit type intended for use as a well-behaved empty alternative in std::variant. In particular, a variant of non-default-constructible types may list std::monostate as its first alternative: this makes the variant itself default-constructible.
Contents
- 1 Member functions
- 2 Non-member functions
- 3 std::operator==, !=, <, <=, >, >=, <=>(std::monostate)
- 4 std::hashstd::monostate
[edit] Member functions
| (constructor)(implicitly declared) | trivial implicit default/copy/move constructor (public member function) |
|---|---|
| (destructor)(implicitly declared) | trivial implicit destructor (public member function) |
| operator=(implicitly declared) | trivial implicit copy/move assignment (public member function) |
[edit] Non-member functions
std::operator==, !=, <, <=, >, >=, <=>(std::monostate)
| constexpr bool operator==( monostate, monostate ) noexcept { return true; } | (1) | (since C++17) |
|---|---|---|
| (2) | ||
| constexpr bool operator!=( monostate, monostate ) noexcept { return false; } constexpr bool operator< ( monostate, monostate ) noexcept { return false; } constexpr bool operator> ( monostate, monostate ) noexcept { return false; } constexpr bool operator<=( monostate, monostate ) noexcept { return true; } constexpr bool operator>=( monostate, monostate ) noexcept { return true; } | (since C++17) (until C++20) | |
| constexpr std::strong_ordering operator<=>( monostate, monostate ) noexcept { return std::strong_ordering::equal; } | (since C++20) |
All instances of std::monostate compare equal.
| The <, <=, >, >=, and != operators are synthesized from operator<=> and operator== respectively. | (since C++20) |
|---|
[edit] Helper classes
std::hashstd::monostate
| template <> struct std::hash<monostate>; | | (since C++17) | | ------------------------------------------------------------------------------------------------------------------ | | ------------- |
Specializes the std::hash algorithm for std::monostate.
[edit] Example
#include
#include
#include
struct S
{
S(int i) : i(i) {}
int i;
};
int main()
{
// Without the monostate type this declaration will fail.
// This is because S is not default-constructible.
std::variant<std::monostate, S> var;
assert(var.index() == 0);
try
{
std::get(var); // throws! We need to assign a value
}
catch(const std::bad_variant_access& e)
{
std::cout << e.what() << '\n';
}
var = 42;
std::cout << "std::get: " << std::get(var).i << '\n'
<< "std::hash: " << std::hex << std::showbase
<< std::hashstd::monostate{}(std::monostate{}) << '\n';
}
Possible output:
std::get: wrong index for variant std::get: 42 std::hash: 0xffffffffffffe19f