Question

我想定义一个'node'类/结构，然后在代码中声明这些节点的树，这样代码格式化的方式反映了树的结构，并且没有'太多'的锅炉板方式。

请注意，这不是关于数据结构的问题，而是关于我可以使用C ++的哪些功能来获得与下面示例类似的声明性代码样式。

可能使用C ++ 0X这会更容易，因为它在构建对象和集合方面有更多功能，但我使用的是Visual Studio 2008。

示例树节点类型：

struct node
{ 
  string name;
  node* children;

  node(const char* name, node* children);
  node(const char* name);
};

我想做什么：

声明树，使其结构反映在源代码中

node root =
  node("foo",
  [
    node("child1"),
    node("child2", 
    [
      node("grand_child1"),
      node("grand_child2"),
      node("grand_child3"
    ]),
    node("child3")
  ]);

NB：我不想做的事情：

声明一大堆临时对象/ colls并构建树'向后'

node grandkids[] = node[3] 
{
  node("grand_child1"),
  node("grand_child2"),
  node("grand_child3"
};

node kids[] = node[3]
{
  node("child1"),
  node("child2", grandkids) 
  node("child3")
};

node root = node("foo", kids);

Answer 1

如果您不介意过度复制节点并使用括号()而不是方括号[]，那么这应该可行。

实际上你可以通过在node_group而不是副本中存储指针来避免复制，但由于这是星期五下午而且我非常懒，所以我会留给你。

struct node
{
    std::string name;
    std::vector<node> children;

    node(const char* n)
        :   name (n)
    {
    }

    node(const char* n, const class node_group& group);
};

struct node_group
{
    std::vector<node> children;
};

node::node(const char* n, const class node_group& group)
    :   name (n)
    ,   children (group.children)
{
}

node_group operator ,(const node& n1, const node& n2)
{
    node_group group;
    group.children.push_back (n1);
    group.children.push_back (n2);
    return group;
}

node_group operator ,(const node_group& gr, const node& n2)
{
    node_group group (gr);
    group.children.push_back (n2);
    return group;
}


int main ()
{
    node root ("foo",
                (node("child1"),
                node("child2",
                    (node("grand_child1"),
                    node("grand_child2"),
                    node("grand_child3"))
                    ),
                node("child3"))
              );
}

Answer 2

http://en.wikipedia.org/wiki/Expression_templates

使用此技术，您可以获得如下语法：

Node root("bob") =
  (node("child1")
    <<(
      node("grandkid"),
      node("grandkid2")
    )
  ),
  node("child2");

重载operator,和operator<<以构建用于构造根节点的表达式树。

Answer 3

为您想要使用的语法编写解析器并不困难。这是一个简单但有效的代码。我让自己稍微更改了你的node对象，它没有使用指针数组来存储子项，但std::vector

这种方法的优点是您可以根据运行时提供的文本构建树，例如：从配置文件中读取。另请注意，ostream& operator<<(ostream&, const node&)以相同的格式打印树，这对于序列化树（将其写入文件或通过网络发送）或单元测试非常方便。

    #include <stdio.h>
    #include <stdlib.h>
    #include <ctype.h>
    #include <string>
    #include <vector>
    #include <iostream>


    using namespace std;

    struct node
    { 
      string name;
      vector<node*> children;

      node(const string& name, const vector<node*> children);
      node(const string& name);
    };

    ostream& operator<<(ostream& o, const node& n) {
        o << "node('" << n.name << "'";
        if (n.children.size()) {
            o << ", [";
            for (size_t i = 0; i < n.children.size(); ++i)
                o << (i ? "," : "") << *(n.children[i]);
            o << "]";
        }
        o << ")";
        return o;
    }

    node::node(const string& s, const vector<node*> children)
    : name(s), children(children) {}

    char* parseNode(node** n, const char *ss);

    char *skipSpace(const char *ss) {
        char *s = (char *) ss;
        while (isspace(*s))
            ++s;
        return s;
    }

    void expected_error(const char* s) { 
        fprintf(stderr, "Error: expected '%s'\n", s);
        exit(1);
    }

    char *expect(const char *expected, char *s) {
        char *ex = skipSpace(expected);
        s = skipSpace(s);
        for ( ; *ex && *s; ++ex, ++s)
            if (*ex != *s) expected_error(expected);
        if (*ex) expected_error(expected);
        return s;
    }

    char *expectString(string& str, const char *ss)
    {
        char *s = skipSpace(ss);
        s = expect("'", s);
        char *start = s++;
        while (*s != '\'')
            ++s;
        str = string(start, s - start);
        return ++s;
    }

    char * parseChildren(vector<node*>& children, char *s) {
        s = expect("[", s);
        s = skipSpace(s);
        while (*s != ']') {
            node *n = 0;
            s = parseNode(&n, s);
            children.push_back(n);
            s = skipSpace(s);
            if (*s == ',')
                ++s;
            else break;
        }
        s = expect("]", s);
        return s;
    }

    char* parseNode(node** n, const char *ss) {
        char *s = (char *) ss;
        s = expect("node", s);
        s = expect("(", s);
        string name;
        s = expectString(name, s);
        vector<node*> children;
        s = skipSpace(s);
        if (*s == ',') 
            s = parseChildren(children, ++s);
        *n = new node(name, children);
        s = expect(")", s);
        return s;
    }

    int main()
    {
        node * n = 0;
        parseNode(&n,
    " node('foo',"
    "  ["
    "    node('child1'),"
    "    node('child2', "
    "    ["
    "     node('grand_child1'),"
    "     node('grand_child2'),"
    "     node('grand_child3')"
    "    ]),"
    "   node('child3')"
    " ])"
    );
        cout << *n;
        return 0;
    }

如何“声明性地”填充“树”结构

3 个答案: