C++ boost:：具有多个参数的静态_访问者 typedef boost:：variant Type； 类附加：public boost:：static\u visitor { 公众： void运算符（）（int） {} void运算符（）（双精度） {} }; 类型（1.2）； 访客； boost:：apply_visitor（visitor，type）；

是否可以更改访问者，使其接收以下额外数据：

typedef boost::variant<int, double> Type;
class Append: public boost::static_visitor<>
{
public:
    void operator()(int)
    {}

    void operator()(double)
    {}

};

Type type(1.2);
Visitor visitor;
boost::apply_visitor(visitor, type);

class附加：public boost:：static\u visitor
{
公众：
void运算符（）（int，const std:：string&）
{}
void运算符（）（双精度，常量std:：string&）
{}
};

此字符串值在Append对象的生存期内更改。在这种情况下，通过构造函数传入字符串不是一个选项。

给每个调用的“附加参数”是

this

指针。使用它传递您需要的任何其他信息：

class Append: public boost::static_visitor<>
{
public:
    void operator()(int, const std::string&)
    {}

    void operator()(double, const std::string&)
    {}
};

#包括
typedef boost：：变量类型；
类附加：public boost:：static\u visitor
{
公众：
void运算符（）（int）
{}
void运算符（）（双精度）
{}
字符串参数；
};
int main（）{
类型（1.2）；
追加访客；
visitor.argument=“第一个值”；
boost:：apply_visitor（visitor，type）；
visitor.argument=“新值”；
boost:：apply_visitor（visitor，type）；
}

另一个选项是绑定额外的参数。您的访客类可以如下所示：

#include <boost/variant.hpp>
typedef boost::variant<int, double> Type;
class Append: public boost::static_visitor<>
{
public:
    void operator()(int)
    {}

    void operator()(double)
    {}
    std::string argument;
};

int main() {
    Type type(1.2);
    Append visitor;
    visitor.argument = "first value";
    boost::apply_visitor(visitor, type);
    visitor.argument = "new value";
    boost::apply_visitor(visitor, type);
}

---

这个解决了你的问题：

std::string myString = "foo";
double value = 1.2;
auto visitor = std::bind( Append(), myString, std::placeholders::_1 );
boost::apply_visitor( visitor, value );

#包括
#包括
#包括
typedef boost：：变量类型；
typedef boost：：变量额外；
类附加：public boost:：static\u visitor
{
公众：
void运算符（）（常量int和a1，常量std:：string和a2）常量{
std:：cout为什么它不是一个选项？如果发生变化，您可以用不同的字符串创建另一个Append对象。字符串值在什么时候会变化？我不明白为什么不能用构造函数来完成它。@KennyTM Append类通过它的构造函数获取许多依赖项。如果我在clas中重建Append对象s、 然后这个类还需要通过其构造函数获取Append使用的所有依赖项。我曾希望我的类只需通过其构造函数获取一个Append对象。@Baz:您可以在构造函数中获取一个
Append
对象，然后在每次调用之前在
Append
对象中设置特定值，甚至不需要需要了解任何其他依赖项。@Baz：您可以创建一个助手函数，该函数首先设置
访问者的相关部分，然后调用
apply\u Visitor
。我想不出在类型系统中强制执行它的方法，但您可以保留一个
bool
，用于跟踪助手函数是否已被调用调用，如果没有，则断言。如有必要，成员不必是
std:：string
，但可以是例如可以反弹的
std:：string*
。@LucDanton:事实上，根据具体情况的需要，这个一般概念有很多可能的变化。
std::string myString = "foo";
double value = 1.2;
auto visitor = std::bind( Append(), myString, std::placeholders::_1 );
boost::apply_visitor( visitor, value );

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

typedef boost::variant<int, double> Type;
typedef boost::variant<const std::string> Extra;
class Append: public boost::static_visitor<>
{
public:
    void operator()(const int& a1, const std::string& a2) const {
        std::cout << "arg 1 = "<< a1 << "\n";
        std::cout << "arg 2 = "<< a2 << "\n";
    }

    void operator()(const double& a1, const std::string& a2) const {
        std::cout << "arg 1 = "<< a1 << "\n";
        std::cout << "arg 2 = "<< a2 << "\n";
    }
};

int main()
{
    Type type(1.2);
    Extra str("extra argument");
    boost::apply_visitor(Append(), type, str);
}