如何消除variant wrapper构造函数的initializer_list重载歧义？

我希望通过花括号初始化列表初始化container，且无需显式指定类型。但嵌套初始化的场景下，我的variant wrapper（vwrapper）的两个std::initializer_list重载构造函数导致编译器无法确定调用哪个——明明只有keyval类接受string作为第一个参数，理论上应该匹配std::initializer_list<keyval>的重载，却不知道如何让编译器识别这一点。

原代码如下：

#include <string>
#include <variant>

template <typename... T> struct vwrapper;

using val = vwrapper<std::monostate, struct array, struct obj, int, bool>;

template <typename... T>
struct vwrapper : public std::variant<T...>
{
    vwrapper(int);
    vwrapper(bool);
    vwrapper(std::initializer_list<struct keyval>);
    vwrapper(std::initializer_list<val>);
    // vwrapper(obj);
    // vwrapper(array);
    vwrapper(std::monostate);
};

struct obj
{
    obj() = default;
    obj(std::initializer_list<struct keyval> init) {

    }
};

struct array
{
    array() = default;
    array(std::initializer_list<val> init) {

    }
};

struct keyval
{
    keyval() = default;
    keyval(std::string, val);
};

template <typename... T>
vwrapper<T...>::vwrapper(int) {}

template <typename... T>
vwrapper<T...>::vwrapper(bool) {}

template <typename... T>
vwrapper<T...>::vwrapper(std::initializer_list<val>) {}

template <typename... T>
vwrapper<T...>::vwrapper(std::initializer_list<struct keyval>) {}

// template <typename... T>
// vwrapper<T...>::vwrapper(obj) {}

// template <typename... T>
// vwrapper<T...>::vwrapper(array) {}

keyval::keyval(std::string str, val value) {  }

struct container : public array, public obj
{
    using array::array;
    using obj::obj;
};


int main()
{
    container some_container = { 1, 2, true, false, 2, { { "hello", 2 }, { "mogli", true }}};
}

问题根源 #

编译器在处理{ {"hello", 2}, {"mogli", true} }这种嵌套初始化时，会同时尝试匹配两个重载：

1. 把列表看作std::initializer_list<keyval>（每个元素直接构造keyval）
2. 把列表看作std::initializer_list<val>（每个元素尝试构造val）

虽然业务逻辑上只有第一种情况合理，但编译器的重载决议阶段不会深入判断构造可行性，只会认为两个重载都符合要求，因此产生歧义。

解决方案：模板构造函数+编译期分支判断 #

我们可以把两个initializer_list重载合并为一个模板构造函数，通过constexpr分支根据元素类型选择对应的处理逻辑，同时打开原本注释的obj和array构造函数，让vwrapper能直接持有这两种类型的实例：

#include <string>
#include <variant>
#include <type_traits>

template <typename... T> struct vwrapper;

// 提前声明所需类型
struct obj;
struct array;
struct keyval;

using val = vwrapper<std::monostate, array, obj, int, bool>;

struct keyval
{
    keyval() = default;
    keyval(std::string, val);
};

struct obj
{
    obj() = default;
    obj(std::initializer_list<keyval> init) {}
};

struct array
{
    array() = default;
    array(std::initializer_list<val> init) {}
};

template <typename... T>
struct vwrapper : public std::variant<T...>
{
    vwrapper(int);
    vwrapper(bool);
    vwrapper(obj);
    vwrapper(array);
    vwrapper(std::monostate);

    // 统一处理初始化列表的模板构造函数
    template <typename U>
    vwrapper(std::initializer_list<U> init) {
        if constexpr (std::is_convertible_v<U, keyval>) {
            // 元素可转为keyval，构造obj并存入variant
            *this = obj(init);
        } else if constexpr (std::is_convertible_v<U, val>) {
            // 元素可转为val，构造array并存入variant
            *this = array(init);
        } else {
            static_assert(!std::is_same_v<U, U>, "初始化列表元素必须可转换为keyval或val");
        }
    }
};

template <typename... T>
vwrapper<T...>::vwrapper(int) {}

template <typename... T>
vwrapper<T...>::vwrapper(bool) {}

template <typename... T>
vwrapper<T...>::vwrapper(obj o) : std::variant<T...>(std::move(o)) {}

template <typename... T>
vwrapper<T...>::vwrapper(array a) : std::variant<T...>(std::move(a)) {}

template <typename... T>
vwrapper<T...>::vwrapper(std::monostate) {}

keyval::keyval(std::string str, val value) {}

struct container : public array, public obj
{
    using array::array;
    using obj::obj;
};

int main()
{
    container some_container = { 1, 2, true, false, 2, { { "hello", 2 }, { "mogli", true }}};
}

这种方式通过编译期类型判断，明确了不同初始化列表对应的处理逻辑，彻底消除了重载歧义，同时保持了代码的简洁性和易用性。

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