How can I default construct a variant with non-default-constructible types?

If you have a std::variant that contains types that are not default-constructible, you can still default construct the variant by including std::monostate as one of the variant's alternative types.

std::monostate is a special type designed for this purpose. It's an empty struct that is always default-constructible. By including it as the first alternative in your variant, you ensure that the variant itself is default-constructible, even if the other types are not.

Here's an example:

1#include <variant>
2
3struct NonDefaultConstructible {
4  NonDefaultConstructible() = delete;
5  NonDefaultConstructible(int x) {}
6};
7
8int main() {
9  // This fails because NonDefaultConstructible
10  // is not default-constructible
11  std::variant<NonDefaultConstructible> v;
12
13  // This works because std::monostate is
14  // default-constructible
15  std::variant<std::monostate,
16    NonDefaultConstructible> v;
17
18  // You can still emplace other types
19  v.emplace<NonDefaultConstructible>(42);
20}

1error: 'std::variant<NonDefaultConstructible>::variant': no appropriate default constructor available

When you default construct a variant with std::monostate, the variant will initially hold a std::monostate value. You can then assign or emplace one of the other types into the variant as needed.

Keep in mind that std::monostate is a distinct type, so you need to handle it in your visitor functions or when retrieving values from the variant. But it's a small price to pay for the ability to default construct variants with non-default-constructible types.