2

我对重载函数的变体值有疑问。我想根据变量中存储的内容，用 int 或 string 调用重载函数。这就是我想这样做的方式，但我不能：

class X
{
    void foo(int i, int z) { /*use int i and z*/; }
    void foo(const std::string& s, int z) { /*use string s and z*/; }


    struct MyVisitor : public boost::static_visitor<int>  
    // !!! Here is the problem.
    // I can't return int or std::string,
    // so it's impossible to use template operator()
    {
        template<typename Data>
        const Data operator()(const Data data) const { return data; }
    };

public:

    /*somehow m_queue pushed ...*/

    void func_uses_variant(int z)
    {
        boost::variant<int, std::string> v = m_queue.pop();
        foo(boost::apply_visitor(MyVisitor(), v), z);
    }
private:
    SomeQueue m_queue;
}

是否可以使用访问者编写它，或者我应该这样做：

    void func_uses_variant(int z)
    {
        boost::variant<int, std::string> v = m_queue.pop();

        if (int* foo_arg = boost::get<int>(&v))
        {
            foo(*foo_arg, z);
        }
        else if (std::string* foo_arg = boost::get<std::string>(&v))
        {
            foo(*foo_arg, z);
        }
    }

我尝试对 MyVisitor 使用可变参数，但由于 boost::static_visitor 接口而失败。也许有一个解决方案。

int z in function 只是为了表明 foo() 参数中不仅有 boost::variant。

4

2 回答 2

5

访问者的全部意义在于处理变体可能包含的每种不同类型，以不涉及的形式get()，允许泛型，并且很容易告诉你已经处理了所有选项。如果您可以在一个通用函数中处理它们，那么您可以在访问者中编写一个模板函数。如果不是，请更具体：

struct foo_visitor : public boost::static_visitor<std::string>  
{
    std::string operator()(int & i) const { return "this is int"; }
    std::string operator()(std::string &s) const { return "this is string"; }
};

这会从变体中的每个可能类型返回一个公共值。或者您可以使用访问者包装外部函数。回到模板函数：

struct foo_visitor : public boost::static_visitor<void>  
{
    template<typename Data>
    void operator()(const Data &d) const { foo(d); }
};

编辑[看起来这是由库以 , 的形式提供的visitor_ptr，用于单参数函数。我认为boost::visitor_ptr(foo)可能完全等价。]

对于额外的参数，您可以向访问者添加一个构造函数并存储一个额外的数据成员，该成员将传递给包装函数：

struct foo_visitor : public boost::static_visitor<void>  
{
    int z;
    foo_visitor(int z_param) : z(z_param) {};

    template<typename Data>
    void operator()(const Data &d) const { foo(d, z); }
};

{
    boost::variant<int, std::string> v;
    v = 5;
    int z = 0;
    boost::apply_visitor(foo_visitor(z), v);
}

从@Kabik 编辑：

有一种方法可以使用带有 boost make_overloaded_function() 和 lambda 的模式匹配来做到这一点。

链接到实验匹配功能 - http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0050r0.pdf

boost::variant<int, std::string> v;
v = 5;
int z = 0;
boost::apply_visitor(boost::bind<void>(boost::make_overloaded_function(
   [&](const int i) { foo(i, z); },
   [&](const std::string& str) { foo(str, z); }) _1
), v);
于 2016-08-26T16:56:18.403 回答
2

有一种方法可以使用带有 boost make_overloaded_function 和 lambda 的模式匹配来做到这一点。

链接到实验匹配功能 - http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0050r0.pdf

boost::variant<int, std::string> v;
v = 5;
int z = 0;
boost::apply_visitor(boost::bind<void>(boost::make_overloaded_function(
    [&](const int i) { foo(i, z); },
    [&](const std::string& str) { foo(str, z); }) _1
), v);
于 2016-08-29T11:47:00.410 回答