NAME¶

std::monostate - std::monostate

Synopsis¶

Defined in header <variant>
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.

Member functions¶

constructor trivial implicit default/copy/move constructor
(implicitly declared) (public member function)
destructor trivial implicit destructor
(implicitly declared) (public member function)
operator= trivial implicit copy/move assignment
(implicitly declared) (public member function)

Non-member functions¶

std::operator==, !=, <, <=, >, >=, <=>(std::monostate)

constexpr bool operator==( monostate, monostate ) (1) (since C++17)
noexcept { return true; }
constexpr bool operator!=( monostate, monostate )
noexcept { return false; }

constexpr bool operator< ( monostate, monostate )
noexcept { return false; }
constexpr bool operator> ( monostate, monostate ) (since C++17)
noexcept { return false; } (until C++20)
constexpr bool operator<=( monostate, monostate )
noexcept { return true; }
(2)
constexpr bool operator>=( monostate, monostate )
noexcept { return true; }
constexpr std::strong_ordering operator<=>(
monostate, monostate ) noexcept

{ (since C++20)
return std::strong_ordering::equal;

}

All instances of std::monostate compare equal.

The <, <=, >, >=, and != operators are synthesized from operator<=> (since C++20)
and operator== respectively.

Helper classes¶

std::hash<std::monostate>

template <> (since C++17)
struct std::hash<monostate>;

Specializes the std::hash algorithm for std::monostate.

Example¶

// Run this code

#include <cassert>
#include <iostream>
#include <variant>

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<S>(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<S>(var).i << '\n'
<< "std::hash: " << std::hex << std::showbase
<< std::hash<std::monostate>{}(std::monostate{}) << '\n';
}

Possible output:¶

std::get: wrong index for variant
std::get: 42
std::hash: 0xffffffffffffe19f

See also¶

constructor constructs the variant object
(public member function)