传入一个函数来获取一个或多个返回值

Question

我有一个如下所示的模板：

struct add_node_value_visitor : boost::static_visitor<>
{
    add_node_value_visitor(){}

    template <typename T>
    void operator() ( const T& value) const
    {
        boost::lexical_cast<std::string, T>(value);
    }

};

我遇到的问题是访问者在 for 循环内使用，迭代一堆值，并且生成的值字符串需要是一个字符串，目前这会产生一堆单独的字符串，这不是我想要的，所以为了解决这个问题，我想我应该添加一个指向该结构体的函数指针，以便我可以传入一个函数来连接每个循环迭代的结果字符串并创建一个字符串。然后，如果我想在不需要连接的地方使用这个结构，我仍然可以这样做。问题是我是否应该使用函数指针，或者是否可以使用 boost::lambda 之类的东西来做到这一点？

或者 boost::function 会更容易使用吗？

Answer 1

像这样的东西吗？

struct add_node_value_visitor : public boost::static_visitor<>
{
public:
    typedef std::function<void(const std::string&)> concat_func_t;

    add_node_value_visitor(const concat_func_t& concat) : concat_(concat){}

    template <typename T>
    void operator() ( const T& value) const
    {
        concat_(boost::lexical_cast<std::string, T>(value));
    }

private:
    concat_func_t concat_;
};

Answer 2

为什么不就地执行串联？

struct add_node_value_visitor : boost::static_visitor<>
{
   std::ostringstream st;
   template <typename T>
   void operator() ( const T& value ) {
      // change concatenation logic here if required (separators...)
      st << value;
   }
   std::string const & str() const {
      return st.str();
   }
};

Answer 3

也许更通用的访问者会更合适，将如何处理字符串表示留给调用者。

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

struct to_string : boost::static_visitor<std::string>
{

    template <typename T>
    std::string operator() ( const T& value) const
    {
        return boost::lexical_cast<std::string, T>(value);
    }

};

int main()
{
    std::vector<boost::variant<int, double> > vec;
    vec.push_back(42);
    vec.push_back(3.14);
    std::string result;
    for (size_t i = 0; i != vec.size(); ++i) {
        result += boost::apply_visitor(to_string(), vec[i] ) + ' ';
    }
    std::cout << result;
}