如何派生/扩展递归类

Question

我有一个递归类，一种树，它有自己的实例作为成员变量。例如：

template<class T>
class Tree {
public: 
  /* Constructors, etc. */
protected:
  T m_value;
  Tree<T> *leftChild;
  Tree<T> *rightChild;
};

如果我想添加一个使用中序遍历打印所有值的方法，我可以这样做：

template <class T>
void Tree<T>::printInOrder()
{
   leftChild->printInOrder();
   std::cout << m_value << std::endl;
   rightChild->printInOrder();
}

但是，如果由于各种原因，我不能或不想更改 Tree 的实现怎么办？如果该类不是递归的，即不包含自身的实例，我可以从 Tree 派生并在派生类中实现一个新方法。但这种方法不适用于 Tree。

template <class T>
class DerivedClass : public Tree<T> {
public:
  void printInOrder();
}

template <class T>
void DerivedClass<T>::
printInOrder()
{
   this->leftChild->printInOrder();
   std::cout << this->m_value << std::endl;
   this->rightChild->printInOrder();
}

leftChild 和 rightChild 是 Tree 的实例，因此没有 printInOrder() 方法。

谁能建议一种在不更改 Tree 实现的情况下以模块化方式执行此操作的方法。可以更改它的一般实现方式，只要您在想要扩展/派生类时不必更改它。通过使模板类 T 具有执行我想要的事情的方法，我可以看到一种可能的方法，但这看起来很难看。一定有更好的办法。

我很高兴有人指出我忽略了一些明显的事情。确实感觉像我一样。

编辑：重点不是如何实现 printInOrder()。那只是一个例子。关键是如何派生一个类，使子类也是派生类。

Answer 1

节点类型上的模板。

template<typename T, typename NodeType = void> class Tree {
    NodeType node;
    T m_data;
};
template<typename T> class Tree<void> {
    struct Node {
        Tree<T, void>* left;
        Tree<T, void>* right;
    };
    Node node;
    T m_data;
};
template<typename T> struct DerivedNode {
     DerivedTree<T>* left;
     DerivedTree<T>* right;
};
template<typename T> class DerivedTree : public Tree<T, DerivedNode<T>> {
     // now left and right are of type DerivedTree<T>*.
};

这基于两个不变量 - Tree<T, NodeT> 为所有 NodeT 提供相同的接口，并且 DerivedTree<T> 继承自 Tree<T, ...>。

编辑：该死，为了防止 Tree<T, NodeType> 的递归实例化需要付出很多努力。

Answer 2

将printInOrder 设为virtual 函数并使其在Tree 中可用。

这意味着树孩子可以是Tree 的任意后代，并且在它们上调用printInOrder 将始终调用被覆盖的实现，如果它们提供的话。

主要缺点是所有方法都需要在Tree 中声明。

Answer 3

如果你想要非侵入式打印，只需为其指定一个普通的模板函数：

template <typename T>
void TreePrinter(const Tree<T>& tree)
{
    TreePrinter(tree.leftChild);
    std::cout << tree.m_value << std::endl;
    TreePrinter(tree.rightChild);
}

你显然需要一个 TreePrinter 作为朋友：

template<class T>
class Tree {
public: 
  /* Constructors, etc. */
protected:
  T m_value;
  Tree<T> *leftChild;
  Tree<T> *rightChild;

  friend template <typename U>
  TreePrinter(const Tree<U>&);
};

或者，如果您不将其作为朋友，请提供访问器来获取值以及树的左右节点。

Answer 4

你可以接受吗？

template <class T>void DerivedClass<T>::printInOrder()
{   
    ((DerivedClass<T>*)leftChild)->printInOrder();   
    std::cout << this->m_value << std::endl;   
    ((DerivedClass<T>*)rightChild)->printInOrder();
}

Answer 5

您可以简单地编写一个成员函数来打印实例：

template <class T>
void DerivedClass::printInOrderHelper(const Tree<T>& tree)
{
    printInOrderHelper(tree->leftChild);
    std::cout << tree->m_value << std::endl;
    printInOrderHelper(tree->rightChild);
}

在零参数重载中使用它：

template <class T>
void DerivedClass::printInOrder()
{
    printInOrderHelper(*this);
}