Question

I want to define a ‘node’ class/struct and then declare a tree of these nodes in code in such a way that the way the code is formatted reflects the tree structure, and there’s not ‘too much’ boiler plate in the way.

Note that this isn’t a question about data structures, but rather about what features of C++ I could use to arrive at a similar style of declarative code to the example below.

Possibly with C++0X this would be easier as it has more capabilities in the area of constructing objects and collections, but I’m using Visual Studio 2008.

Example tree node type:

struct node
{ 
  string name;
  node* children;

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

What I want to do:

Declare a tree so its structure is reflected in the source code

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

NB: what I don’t want to do:

Declare a whole bunch of temporary objects/colls and construct the tree ‘backwards’

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

If you don’t mind excessive copying of the nodes and using parenthesis () instead of square brackets [] then this should work.

Actually you can avoid copying by storing pointers in the node_group rather than copies, but since this is friday afternoon and I’m very lazy, I’ll leave it to you.

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