能否用大括号初始化列表初始化std::variant类型的vector？

Hey there, let's break down why your braced initialization for the std::vector<std::variant<Struct1, Struct2>> isn't working, and how to fix it.

The Root Cause #

When you use braced initialization for the vector, the compiler needs to implicitly convert each Struct1/Struct2 instance into a std::variant<Struct1, Struct2>. While std::variant does have a constructor that accepts convertible types, the context of an initialization list complicates things: the compiler can't automatically resolve the type conversion for mixed-element lists (since each element is a different type), leading to a deduction failure.

Let's start with a minimal reproduction of your setup to make this concrete:

#include <variant>
#include <vector>
#include <string>
#include <iostream>

// Your structs with JSON serialization
struct Struct1 {
    int id;
    std::string name;

    std::string to_json() const {
        return "{\"id\": " + std::to_string(id) + ", \"name\": \"" + name + "\"}";
    }
};

struct Struct2 {
    double value;
    bool active;

    std::string to_json() const {
        return "{\"value\": " + std::to_string(value) + ", \"active\": " + (active ? "true" : "false") + "}";
    }
};

The problematic initialization looks like this (and will fail to compile):

// ❌ Compile error: no viable conversion from 'Struct1' to 'std::variant<Struct1, Struct2>'
std::vector<std::variant<Struct1, Struct2>> v3 = {Struct1{1, "Alice"}, Struct2{3.14, true}};

Fixes That Work #

1. Explicitly Construct std::variant Instances #

The simplest fix is to wrap each struct instance in an explicit std::variant constructor call. This removes ambiguity for the compiler:

// ✅ Works: explicitly tell the compiler to convert each struct to a variant
std::vector<std::variant<Struct1, Struct2>> v3 = {
    std::variant<Struct1, Struct2>{Struct1{1, "Alice"}},
    std::variant<Struct1, Struct2>{Struct2{3.14, true}}
};

2. Use std::in_place_type for Efficient In-Place Construction #

If you want to avoid unnecessary copies/moves, use std::in_place_type to construct the structs directly inside the variant. This is more efficient and keeps your code clean:

// ✅ Works: construct structs directly inside the variant
std::vector<std::variant<Struct1, Struct2>> v3 = {
    std::in_place_type<Struct1>, 1, "Alice",  // Initializes Struct1 in-place
    std::in_place_type<Struct2>, 3.14, true   // Initializes Struct2 in-place
};

3. C++20+: Simplify with Class Template Argument Deduction (CTAD) #

If you're using C++20 or later, you can omit the std::variant template parameters thanks to CTAD. This reduces boilerplate while still being explicit:

// ✅ C++20+: CTAD deduces the variant type automatically
std::vector v3 = {
    std::variant{Struct1{1, "Alice"}},
    std::variant{Struct2{3.14, true}}
};

Verify the Fix Works #

Once you've initialized the vector correctly, your existing iteration logic will work as expected. For example:

// Your existing traversal code works perfectly with any of the above fixes
for (const auto& var : v3) {
    std::visit([](const auto& obj) {
        std::cout << obj.to_json() << std::endl;
    }, var);
}

Key Takeaway #

The braced initialization fails because the compiler can't implicitly resolve mixed-type conversions to std::variant in an initialization list. Explicitly constructing the variant (either directly or via in-place construction) removes this ambiguity and lets you populate the vector as intended.

内容的提问来源于stack exchange，提问作者p0fi