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);
    }

};

我面临的问题是,访问者被利用在一股价值中进行游说,由此形成的价值观的扼杀必须是一种扼杀,目前,这将产生一组不同的扼杀,这不是我想要的,以便解决这个问题。我认为,我会给这一结构的导师增加一个职能点,以便我能够发挥职能,减轻由此造成的对每一 lo虫的扼杀和形成一种扼杀。然后,如果我想在我不需要加固的情况下使用这一结构,我就能够这样做。问题是,我是否应当使用一个职能点,还是有可能用诸如推动:lambda?

或者会增强:功能更容易使用?

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;
}

友情链接