#include "stdio.h"
#define null 0

struct Branch
{
   Branch(float testProperty);
   ~Branch();

   void Process();

   Branch* parent;
   Branch* child;
   Branch* sibling;

   float testProperty;
};

Branch::Branch(float testProperty):
   parent(null),
   child(null),
   sibling(null),
   testProperty(testProperty)
{}

void Branch::Process()
{
   printf(">>> %f\n", testProperty);
}

/* Game Programming Wiki, commentation:
   You can even utilize the recursion principle to delete entire hierarchical branches in a very elegant way.
*/

Branch::~Branch()
{
   // Recursive magic!
   // This is capable of deleting all of the nodes under a certain parent node or even an entire tree.
   // It is recursive because similar branch instances are also destructed, which in turn may call even more destructors until every leaf node under the original branch is deleted (free'd from memory)!

   // This is unecessary if the instances are not dynamic. Only do this when you know you're always dealing with dynamic memory (i.e. in an isolated/internal implementation).

#ifdef DynamicDestructors
   delete child;
   delete sibling;

   // Just so you can test to see if it really happens for yourself:
   static int destructCount = 0;
   printf("Destructed %i instances.\n", destructCount++);
#endif
}

void ProcessHierarchyDynamicStack(Branch* treeTrunk)
{
   struct StackLink
   {
      Branch* node;
      StackLink* next;

      StackLink(Branch* node):
         node(node),
         next(null)
      {}
   };

   StackLink* stack = new StackLink(treeTrunk);
   StackLink* top = stack;

   while (stack)
   {
      stack->node->Process();

      if (stack->node->child)
      {
         top->next = new StackLink(stack->node->child);
         top = top->next;
      }

      if (stack->node->sibling)
      {
         top->next = new StackLink(stack->node->sibling);
         top = top->next;
      }

      StackLink* stack_t = stack->next;
      delete stack;
      stack = stack_t;
   }
}

void ProcessHierarchyRecursive(Branch* parent)
{
   // TODO.
}

int main()
{
   Branch tree(0.0f);
   Branch steve(22.0f);
   Branch paul(450.0f);
   Branch toast(3.0f);
   Branch pie(9001.0f);
   Branch berry(-5.0f);

   tree.child = &steve;
   steve.sibling = &paul;
   steve.child = &toast;
   toast.sibling = &pie;
   pie.child = &berry;

   ProcessHierarchyDynamicStack(&tree);

   // Pause at end.
   puts("\nPress <ENTER> to quit program.");
   getchar();

   return 0;
}

      if (stack->node->child)
      {
         top->next = new StackLink(stack->node->child);
         top = top->next;
      }

      if (stack->node->sibling)
      {
         top->next = new StackLink(stack->node->sibling);
         top = top->next;
      }

void ProcessHierarchyDynamicStack(Branch* treeTrunk)
{
   std::stack<Branch*> branchStack;

   branchStack.push(treeTrunk);

   Branch* cursor;

   while (!branchStack.empty())
   {
      cursor = branchStack.top();
      branchStack.pop();

      cursor->Process();

      if (cursor->child)
      {
         branchStack.push(cursor->child);
      }

      if (cursor->sibling)
      {
         branchStack.push(cursor->sibling);
      }
   }
}

   tree.child = &steve;
   steve.child = &tree;