C++ Boost递归变体重载apply_visitor

标签 c++ recursion g++ boost-variant

摘要:我希望在包含递归 boost::variant 对象的类中重载 apply_visitor() 方法。

在下面包含的代码中有方法:

template <typename T>
ostream& apply_visitor(const T& fn) const

我想为不同的访问者重载这个方法。像这样:

ostream& apply_visitor(const PrintData& fn) const

但问题是 PrintData 类还没有完成(见下面代码中的注释)。它在 Node 类之后定义。所以我有两个问题(除其他外——我欢迎对这段代码的一般性批评,它正在为我想投入生产的东西建模)。

1) 有没有办法让 apply_visitor(PrintData&) 工作?

2) 我能否重新安排(递归)变体,以便所有访问者方法都在 PrintData 中,并且我不必将 apply_visitor 添加到 Node 类?

/**
 * compiled with gcc (tested with 4.7.2 on linux)
 * requires the boost development headers to be discoverable
 * by the compiler.
 *
 * g++ -otest-recursive-visit -std=c++11 test-recursive-visit.cpp
 * ./test-recursive-visit
 **/

#include <iostream>
#include <map>
#include <string>
#include <vector>

#include "boost/variant.hpp"
#include "boost/variant/recursive_wrapper.hpp"
#include "boost/variant/static_visitor.hpp"

using namespace std;

/// type name demangler (as implemented in g++). For other compilers,
/// we could add more #elif statements, but for now, just return
/// the mangled name.
#ifdef __GNUG__ /// compiler is g++
#include <cxxabi.h>
string type_demangle(const string& name)
{
    int status;
    char* res = abi::__cxa_demangle(
        name.c_str(), NULL, NULL, &status);
    string demangled_name((status==0) ? res : name);
    free(res);
    return demangled_name;
}
#else /// compiler is not g++
string type_demangle(const string& name) { return name; }
#endif

/// forward declaration of the Node class
/// (needed for recursive variant type)
class Node;

/// the actual recursive variant type
/// (typically hidden from the users)
typedef boost::variant<
    boost::recursive_wrapper<Node>,
    vector<int>,
    vector<float>
> data_t;

// forward declaration for PrintData. See note below concerning
// Node::apply_visitor()
class PrintData;

/// this is the object users will see
/// for prototyping, the tree object is public
class Node
{
  public:
    /// sub-nodes are identified by unique strings
    /// which point to one of the objects that data_t
    /// can hold
    map<string,data_t> tree;

    /// constructor for a std::map object, passed to tree
    Node(const initializer_list<pair<const string,data_t>>& l)
    : tree(l)
    {}

    //
    // INTERESTING PART OF THIS EXAMPLE IS HERE
    //
    // I tried to replace T& with PrintData& adding
    // a forward declaration at the top but I get the
    // errors:
    //
    //  line 86:
    //      invalid use of incomplete type ‘const class PrintData’
    //  line 53:
    //      forward declaration of ‘const class PrintData’
    //

    /// This is called by boost::apply_visitor(Visitor(),Node)
    //ostream& apply_visitor(const PrintData& fn) const
    template <typename T>
    ostream& apply_visitor(const T& fn) const
    {
        for (auto i : tree)
        {
            *fn.os << fn.prefix << i.first;
            i.second.apply_visitor(fn);
        }
        return *fn.os;
    }
};

/// the printing visitor to ostream object
class PrintData : public boost::static_visitor<ostream&>
{
  public:
    ostream* os;
    string prefix;

    /// keep a pointer to the ostream and keep
    /// a prefix string which will hold and "indent"
    /// which is something like "  " for every level
    /// of recursion
    PrintData(ostream& out_stream, const string& prefix_str="")
    : os(&out_stream)
    , prefix(prefix_str)
    {}

    /// recurse into the tree, adding indent characters to prefix
    ostream& operator()(Node& n) const
    {
        *os << endl;
        n.apply_visitor(PrintData(*os, prefix+"  "));
        *os;
    }

    /// actual data types that we want to print out
    template <typename T>
    ostream& operator()(const vector<T>& d) const
    {
        *os << " (vector<" << type_demangle(typeid(T).name()) << ">):";
        for (T i : d)
        {
            *os << " " << i;
        }
        *os << endl;
        return *os;
    }
};

/// convenience operator to allow: cout << node;
ostream& operator<<(ostream& os, const Node& n)
{
    return boost::apply_visitor(PrintData(os), n);
}


int main()
{
    /// hooray for initialization lists!!!
    Node n {
        {"X", Node{
            {"a", vector<int>{1,2,3}},
            {"b", vector<float>{2,3,4}}
        }},
        {"Y", vector<int>{3,4,5}},
        {"Z", Node{
            {"A", Node{
                {"c", vector<float>{4,5,6}}
            }}
        }}
    };

    /**
    applying PrintData to n prints out the following:

    X
      a (vector<int>): 1 2 3
      b (vector<float>): 2 3 4
    Y (vector<int>): 3 4 5
    Z
      A
        c (vector<float>): 4 5 6

    **/
    cout << n;
}

最佳答案

我遇到了类似的问题,我使用了 make_recursive_variant然后我用了 map<Key,Value>对于变体而不是 Node 类。最后我的节点类变成了一个实用函数,包装了一个 std::map引用。如:

typedef boost::make_recursive_variant<
    std::map<std::string, boost::recursive_variant_>,
    vector<int>,
    vector<float>
>::type data_t;

// the printing visitor to ostream object
class PrintData : public boost::static_visitor<ostream&>
{
  public:
    ostream* os;
    string prefix;

    /// keep a pointer to the ostream and keep
    /// a prefix string which will hold and "indent"
    /// which is something like "  " for every level
    /// of recursion
    PrintData(ostream& out_stream, const string& prefix_str="")
    : os(&out_stream)
    , prefix(prefix_str)
    {}

    /// recurse into the tree, adding indent characters to prefix
    ostream& operator()(std::map<std::string, data_t>& tree) const
    {
        *os << endl;
        for (auto& i : tree)
        {
            *os << prefix << i.first;
            //you may want to change prefix and use new PrintData instead of *this
            boost::apply_visitor(*this, i.second);
        }
        return *os;
    }

    /// actual data types that we want to print out
    template <typename T>
    ostream& operator()(const vector<T>& d) const
    {
        *os << " (vector<" << type_demangle(typeid(T).name()) << ">):";
        for (T i : d)
        {
            *os << " " << i;
        }
        *os << endl;
        return *os;
    }
};


class Node
{
public:
    //implicit ctor for data_t conversion
    Node(data_t& data) : data(data) { }
    //...
private:
    data_t& data;
};

编辑:我忘了提到您不再需要在 Node 类中使用 apply_visitor,但我不确定 initializer_list Actor 。它可能不适用于 data_t类型。

关于C++ Boost递归变体重载apply_visitor,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/15822031/

相关文章:

C++ WinInet InternetCloseHandle 崩溃

javascript - Node.js 的异步调用和递归

java - 递归平方分割

algorithm - 如何编写用于生成集合的所有子集的迭代算法?

c++ - while循环条件c++中 ","的用途是什么?

c++ - 在 MFC 中显示模态对话框

c++ - 在传出 ICMP 数据包上设置 TTL?

c++ - 为什么 GCC 优化不适用于 valarrays?

c++ - 使用 malloc 初始化一个类

c++ - 如何将 glut 库嵌入到 C++ 项目中?