std::initializer_list在类型上是同质的--所有元素都是相同的类型。诀窍是创建一个可以保存不同值的单一类型。这就是std::variant发挥作用的地方。
使用std::variant的棘手之处在于它不是递归的，即它不能保存自己类型的值。有一些递归的变体实现，如rva::variant和Boost。
另外，如果你想了解细节，here是一个关于如何实现递归变体类型的很好的教程。

更新

下面的代码是使用rva::variant作为json类型的粗略草图。原型允许使用自然的初始化语法，就像nlohmann json一样。它使用相同的技术来区分对象和数组。

示例代码

#include <iostream>
#include <map>
#include <string>
#include <vector>
#include "variant.hpp"

using std::cin, std::cout, std::endl;

using JsonBase = rva::variant<
    std::nullptr_t,
    std::string,
    double,
    bool,
    std::map<std::string, rva::self_t>,
    std::vector<rva::self_t>
    >;

class JsonValue : public JsonBase {
public:
    using JsonBase::JsonBase;
    using InitializerList = std::initializer_list<JsonValue>;

    JsonValue(InitializerList init) {
        bool is_object = std::all_of(init.begin(), init.end(), [](const auto& value) {
            if (std::holds_alternative<std::vector<JsonBase>>(value)) {
                const auto& arr = std::get<std::vector<JsonBase>>(value);
                return arr.size() == 2 and std::holds_alternative<std::string>(arr[0]);
            }
            return false;
        });
        if (is_object) {
            std::map<std::string, JsonBase> m;
            for (const auto& value : init) {
                const auto& arr = std::get<std::vector<JsonBase>>(value);
                const auto& key = std::get<std::string>(arr[0]);
                m.emplace(key, arr[1]);
            }
            *this = m;
        } else {
            std::vector<JsonBase> vec;
            for (auto&& value : init)
                vec.emplace_back(value);
            *this = vec;
        }
    }
};

std::ostream& operator<<(std::ostream& os, const JsonBase& value) {
    if (std::holds_alternative<std::nullptr_t>(value))
        os << "{ }";
    else if (std::holds_alternative<std::string>(value))
        os << "\"" << std::get<std::string>(value) << "\"";
    else if (std::holds_alternative<double>(value))
        os << std::get<double>(value);
    else if (std::holds_alternative<bool>(value))
        os << std::boolalpha << std::get<bool>(value);
    else if (std::holds_alternative<std::map<std::string, JsonBase>>(value)) {
        os << "{ ";
        for (const auto& [key, value] : std::get<std::map<std::string, JsonBase>>(value))
            os << "{ " << key << " : " << value << " } ";
        os << "]";
    }
    else if (std::holds_alternative<std::vector<JsonBase>>(value)) {
        os << "[ ";
        for (const auto& elem : std::get<std::vector<JsonBase>>(value))
            os << elem << " ";
        os << "]";
    }
    return os;
}

int main(int argc, const char *argv[]) {
    JsonValue str = "abc";
    cout << str << endl;

    JsonValue dbl = 1.0;
    cout << dbl << endl;

    JsonValue bol = true;
    cout << bol << endl;

    JsonValue vec = {
        "abc", "def", 1.0, true
    };
    cout << vec << endl;

    JsonValue m = {
        { "key0", 2.0 },
        { "key1", true }
    };
    cout << m << endl;
}

输出

"abc"
1
true
[ "abc" "def" 1 true ]
{ { key0 : 2 } { key1 : true } ]