template <typename T>
class memory_manager
 {
  public:
   static T * alloc();
   static void free(T * pt);
 }

template <typename M>
class tree_node
 {
  protected:
   tree_node * left;
   tree_node * right;
   tree_node * parent;
  public:
   tree_node(
    left_init = NULL,
    right_init = NULL,
    parent_init = NULL) :
     left(left_init),
     right(right_init),
     parent(parent_init),
    {
    }
   ~tree_node()
    {
     M::free(left);
     M::free(right);
    }
 }

tree_node<memory_manager<tree_node<memory_manager<tree_node<memory_manager<tree_node<memory_manager<.. :wow: ..> > > > > >

A>Как бы это обойти? Что-то не варит у меня голова

typedef char dummy;

template <typename T = dummy>
class memory_manager
{
  public:
   template <class U> 
   struct rebind 
   { 
       typedef memory_manager<U> other; 
   };

   static T * alloc();
   static void free(T * pt);
};

template <typename M>
class tree_node
 {
  protected:
   tree_node * left;
   tree_node * right;
   tree_node * parent;
  public:
   tree_node()
    {
        left = M::rebind<tree_node<memory_manager<> > >::other::alloc();
    }
   ~tree_node()
    {
     M::rebind<tree_node<memory_manager<> > >::other::free(left);
     M::rebind<tree_node<memory_manager<> > >::other::free(right);
    }
};

//-----------------------------------------------------------------------------
int main(int, char*[])
{
    tree_node<memory_manager<> > t;
}

class memory_manager
{
  template<class T> T* alloc() {...}
  template<class T> void free(T*) {...}
};

A>template <typename T>
A>class memory_manager
A> {
A>  public:
A>   static T * alloc();
A>   static void free(T * pt);
A> }
A>

A>template <typename M>
A>class tree_node
A> {
A>  protected:
A>   tree_node * left;
A>   tree_node * right;
A>   tree_node * parent;
A>  public:
A>   tree_node(
A>    left_init = NULL,
A>    right_init = NULL,
A>    parent_init = NULL) :
A>     left(left_init),
A>     right(right_init),
A>     parent(parent_init),
A>    {
A>    }
A>   ~tree_node()
A>    {
A>     M::free(left);
A>     M::free(right);
A>    }
A> }
A>

A>И всё бы хоршо, но! Для того, чтобы инстациировать класс tree_node мне нужен полностью определённый memory_manager, а ему в свою очередь нужен полностью определённый tree_node. Получается что-то такое

A>tree_node<memory_manager<tree_node<memory_manager<tree_node<memory_manager<tree_node<memory_manager<.. :wow: ..> > > > > >
A>

A>Как бы это обойти? Что-то не варит у меня голова

template <class T, template <class> class MemManager> class TreeNode
{
}
template <class T> class MemManager
{
}

TreeNode<MtType,ConcreteManager>...

template <typename T>
class MemManager
    {
    };
//
class TreeMemManager
    {
        public:
            template <typename T>
            class MMType : public MemManager<T>
                {
                };
    };
//
template <typename M>
class TreeNode
    {
        public:
            typedef typename M::MMType<TreeNode> mm_type;
    };

TreeNode<TreeMemManager> tn;

template <typename M>
class TreeNode
 {
  typedef M<TreeNode> mm_type;
 }

template <template <typename> class MTpl>
class tree_node
{
   typedef MTpl< tree_node<MTpl> > M;
protected:
   tree_node *left;
   tree_node *right;
   tree_node *parent;
public:
   ~tree_node()
   {
     M::free(left);
     M::free(right);
   }
};

memory_manager< tree_node<memory_manager> > mgr;

template <typename memory_manager>
class tree
 {
  protected:
   tree_node<memory_manager> root;
  public:
   //какие-то методы...
 }

class tree_node
 {
   ...
   public:
   ...
   ~tree_node()
    {
    }
 }

template <class M>
class tree
{
  tree_node *create_node()
  {
     return M::alloc();
  }

  void delete_node(tree_node *n)
  {
    if (n)
    {
      M::free(n->left);
      M::free(n->right);
    }
    M::free(n);
  }

  ...
};

a> Как бы это обойти? Что-то не варит у меня голова

// memory_manager такой же как и у тебя

template <template <typename> class M>
class tree_node
{
        struct node_data;
        typedef M<tree_node> node_allocator;

        struct node_data
        {
            tree_node* left;
            tree_node* right;
            tree_node* parent;
            
            ~node_data()
            {
                node_allocator::free(left);
                node_allocator::free(right);
            }
        };

        node_data data_;
public:
    tree_node(tree_node* left_init = NULL, tree_node* right_init = NULL, tree_node* parent_init = NULL)
    {
        data_.left = left_init;
        data_.right = right_init;
        data_.parent = parent_init;
    }

    tree_node* parent() const { return data_.parent; }
};

// используем
int main()
{
    typedef tree_node<memory_manager> node;

    node root;

    node* parent = root.parent();

    return 0;
}

S>  void delete_node(tree_node *n)
S>  {
S>    if (n)
S>    {
S>      M::free(n->left);
S>      M::free(n->right);
S>    }
S>    M::free(n);
S>  }
S>

  void delete_node(tree_node *n)
  {
    if (n)
    {
      delete_node(n->left);
      delete_node(n->right);
    }
    M::free(n);
  }