When you delete a node, all of its automatical objects' destructors will be called, including that of the std::strings, which will indeed deallocate themselves, like other STL containters like the std::list in you struct would.
However, the children nodes, or any other heap objects, won't be destroyed unless you delete them yourself, for exemple by creating a destructor for your Node object, ie:
struct Node {
...
list<Node*> mChildren;
virtual ~Node() {
for(auto& child : mChildren) delete child;
}
}
Deleting an object first calls it's destructor, so calling delete on a child node will make it delete it's children nodes, and so on recursively until the leaves.
If the graph is a tree, the modern code would use unique_ptr to automatically destroy a node's children when the node is destroyed :
struct Node {
...
list<unique_ptr<Node>> mChildren;
}
Indeed, unique_ptr assume unique ownership, as such, when their automatic unique_ptr container gets destroyed, they delete their contained pointer's pointed object, which might then destroy it's children recursively, if you built it that way.
You could also use shared_ptr for more complex graph structures, but obviously the problem is that you then need to take care of cyclic references, ie, nodes should only have weak_ptr to the root node in order to not invalidly increasing it's refcount and invalidly making the object's life unlimited.