利用boost-variant通过boost::mpl::for_each创建泛型工厂方法

Question

在我的一个项目中，我需要将boost::variant which()-Function的int映射到boost::variant的类型。

由于某些原因，地图不包含正确的TVar类型？为什么会这样呢？

#include <boost/mpl/for_each.hpp>
#include <boost/variant.hpp>
#include <string>
#include <map>
#include <iostream>

using TVar = boost::variant<std::string, int, double>;

namespace Helper {
    struct createMap {
        std::map<int, TVar> map;
        template<typename T>
        void operator()(const T& t) {
            auto x = TVar(t);
            map[x.which()] = x;
        }
    };
}


bool createObject(int which, TVar& var) {
    Helper::createMap c;
    boost::mpl::for_each<TVar::types>(boost::ref(c));
    if (c.map.find(which) != c.map.end()) {
        var = c.map[which];
        return true;
    }
    else {
        return false;
    }
}

int main() {
    TVar var;
    bool ok=createObject(0, var);
    return 0;
}

Answer 1

如果我理解正确的话，您希望为变量分配一个默认构造的值，该值将在运行时通过索引变量的可能类型来确定，那么您将查找以下内容：

#include <boost/mpl/at.hpp>
#include <boost/mpl/size.hpp>

#include <boost/variant.hpp>
#include <string>


template <typename VariantT, int L, int R>
struct assign_default_constructed
{
    static bool call(int which, VariantT& var)
    {
        static int const M = L + (R - L + 1) / 2;
        if (which < M) {
            return assign_default_constructed<VariantT, L, M - 1>::call(which, var);
        }
        else {
            return assign_default_constructed<VariantT, M, R>::call(which, var);
        }
    }
};

template <typename VariantT, int I>
struct assign_default_constructed<VariantT, I, I>
{
    static bool call(int /*which*/, VariantT& var)
    {
        //assert(which == I);
        var = typename boost::mpl::at_c<typename VariantT::types, I>::type();
        return true;
    }
};

template <typename VariantT>
bool createObject(int which, VariantT& var)
{
    static int const N = boost::mpl::size<typename VariantT::types>::value;
    if (which < 0 || which >= N) return false;
    return assign_default_constructed<VariantT, 0, N - 1>::call(which, var);
}

int main() {
    boost::variant<std::string, int, double> var;
    bool ok = createObject(1, var);
    return ok ? var.which() : -1;
}