我正在尝试将 boost::variant 与模板类型一起使用。例如，我有一个模板类型 Tag<T> boost::variant AnyTag 包含 Tag<double> 等类型, Tag<int>和 Tag<std::string> .每个Tag<T>有类型 T 的成员。 现在，我想将这些变体放在一个容器中，并在运行时简单地分配值，例如，

for(AnyTag & tag: AllTags) {
    setValue(tag, getValueFromXml()); 
}

函数setValue(AnyTag &tag, T &val)必须使用 AnyTag 标签的运行时类型才能正确地为标签分配正确的值。 我尝试解决这个问题可以在下面找到，它使用了另一个变体，它只包含可以在 AnyTag (TagValueType) 中使用的可能的 T 类型。

template<typename T, typename = void>
class Tag {};

template <typename T>
class Tag<T, EnableIf<std::is_arithmetic<T>>> {
public:
    T value = 0;
    std::string address = "";
    T maxValue = std::numeric_limits<T>::max();
    typedef T value_type;
};

template <typename T>
class Tag<T, DisableIf<std::is_arithmetic<T>>> {
public:
    T value;
    std::string address = "";
    typedef T value_type;
};

typedef boost::variant<Tag<std::string>,
                       Tag<double>,
                       Tag<int>,
                      > AnyTag;

typedef boost::variant<std::string, double, int> TagValueType;

class tag_set_value_visitor: public boost::static_visitor<void>
{
    const TagValueType & value;
public:
    tag_set_value_visitor(const TagValueType & val): value(val){}
    template <typename T>
    void operator()(T & tag) const
    {
        tag.value = boost::get<typename T::value_type>(value);
    }
};

inline void setValue(AnyTag & tag, const TagValueType & val) {
    assert(tag.which() == val.which());
    boost::apply_visitor( tag_set_value_visitor(val), tag );
}

不幸的是，这种方法不是我想要的，因为例如在编译期间，如果我执行以下操作就没有问题:

AnyTag a = Tag<int>();
setValue(a, double(1.3));

但是在运行时，boost 库检测到类型不匹配并导致程序崩溃。

所以，我的解决方案是一种类型删除，只是推迟了问题的发生。

我想要的是一个 setValue(AnyTag &tag, T &val)，其中 T 是 AnyTag 的运行时类型。

我知道这就是变体的访问者试图做的事情，但在这种情况下存在一个问题，因为当我们构造访问者时，我们必须知道我们将要使用的类型。

关于这个问题有什么想法吗？

P.S.:很抱歉发了这么长的帖子，但我找不到用更少的文字来解释我的思维过程的方法。

最佳答案

使用¹二进制访问器。

实现 operator() 除了相应的类型之外什么都不做。

根据口味处理不匹配(我返回一个表示成功的 bool 值):

Live On Coliru

#include <boost/any.hpp>
#include <boost/variant.hpp>
#include <boost/mpl/vector.hpp>
#include <string>

using namespace boost;

template <typename T>
struct Tag {
    T value;
};

using Types   = mpl::vector<std::string, double, int>;
using Tags    = mpl::transform<Types, Tag<mpl::_1> >::type;

using Variant = make_variant_over<Types>::type;
using AnyTag  = make_variant_over<Tags>::type;

namespace mydetail {
    struct assign_to : boost::static_visitor<bool> {
        template <typename V> bool operator()(Tag<V>& tagged, V const& value) const {
            tagged.value = value;
            return true;
        }

        template <typename T, typename V> bool operator()(T&&, V&&) const {
            return false;
        }
    };
}

bool setValue(AnyTag &tag, Variant const& val) {
    return boost::apply_visitor(mydetail::assign_to(), tag, val);
}

int main() {
    AnyTag t;

    t = Tag<std::string>();

    // corresponding type assigns and returns true:
    assert(setValue(t, "yes works"));

    // mismatch: no effect and returns false:
    assert(!setValue(t, 42));
    assert(!setValue(t, 3.1415926));
}

¹ 如果我正确理解了您的目标。我专注于 “我想要的是一个 setValue(AnyTag &tag, T &val)，其中 T 是 AnyTag 的运行时类型。” 请求的一部分。

关于c++ - Boost::variant 的多态 setter ，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30540716/