std::monostate(3)

💖 NAME 💖

Okay bestie, this is the std::monostate(3) page from the C++ Standard Library — the original banner spells it C++ Standard Libary, and I’m keeping that typo energy alive 😭. The NAME is literally std::monostate - std::monostate, which is giving main-character repetition 💅.

---

✨ Synopsis ✨

Defined in header <variant>
struct monostate { };        (since C++17)

std::monostate is a unit type, fr fr — it’s meant to be that well-behaved empty alternative in std::variant. The iconic part: a variant of non-default-constructible types may list std::monostate as its first alternative, and that makes the variant itself default-constructible. No cap, that’s the whole slay. 🦋

---

🛠️ Member functions 🛠️

• constructor — (implicitly declared) (public member function); it’s a trivial implicit default/copy/move constructor. Lowkey perfect.
• destructor — (implicitly declared) (public member function); it’s a trivial implicit destructor.
• operator= — (implicitly declared) (public member function); it’s trivial implicit copy/move assignment. Clean.

---

🔥 Non-member functions 🔥

The crew is literally std::operator==, !=, <, <=, >, >=, <=>(std::monostate). Here’s the exact signature-and-body situation, bestie:

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 — every single one, periodt. 💅 The page also says: the <, <=, >, >=, and != operators are synthesized from operator<=> (since C++20) and operator== respectively. That’s the tea. ☕

---

🧚 Helper classes 🧚

std::hash<std::monostate> is here too:

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

It specializes the std::hash algorithm for std::monostate. Obsessed with a specialized hash, honestly. 🍓

---

🌈 Example 🌈

The page says // Run this code, so here’s the whole example — code stays code, exactly:

#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';
}

ngl, that std::get<S>(var) line throws because we need to assign a value — the code comment literally says // throws! We need to assign a value 😭

Possible output:

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

---

👀 See also 👀

• constructor — constructs the variant object (public member function). That’s the see-also link, bestie. 🫶

mwah 💋 this page came from http://cppreference.com, dated 2024.06.10, and it’s manual page std::monostate(3) — byeee 🎀