空对象模式、递归类和前向声明

Question

我有兴趣做以下类似的事情来遵守 Null 对象设计模式并避免大量的 NULL 测试：

class Node;
Node* NullNode;

class Node {
public:
  Node(Node *l=NullNode, Node *r=NullNode) : left(l), right(r) {};
private:
  Node *left, *right;
};

NullNode = new Node();

当然，正如所写，NullNode 在 Node 类声明之前和之后具有不同的内存位置。如果您不想使用默认参数（即删除 Node *r=NullNode），则可以在没有前向声明的情况下执行此操作。

另一种选择是使用一些继承：创建一个带有两个子类（NullNode 和 FullNode）的父类（Node）。那么上面的节点示例将是 FullNode 的代码，并且上面代码中的 NullNode 将是从 Node 继承的 NullNode 类型。我讨厌通过继承来解决简单的问题。

所以，问题是：如何在 C++ 中将 Null 对象模式应用于具有默认参数（即同一类的实例！）的递归数据结构（类）？

Answer 1

使用extern:

extern Node* NullNode;
...
Node* NullNode = new Node();

更好的是，让它成为一个静态成员：

class Node {
public:
  static Node* Null;
  Node(Node *l=Null, Node *r=Null) : left(l), right(r) {};
private:
  Node *left, *right;
};

Node* Node::Null = new Node();

也就是说，在现有代码和上述修改中，您都会泄漏Node 的实例。你可以使用auto_ptr，但这会很危险，因为全局和静态的破坏顺序不确定（一些全局的析构函数可能需要Node::Null，到那时它可能已经消失了，也可能还没有）。

Answer 2

我实际上已经实现了一个递归树（用于 JSON 等）做这样的事情。基本上，您的基类成为“NULL”实现，其接口是派生的所有接口的联合。然后，您就有了实现片段的派生类——“DataNode”实现了数据获取器和设置器等。

这样，您可以对基类接口进行编程并为自己省去很多痛苦。您设置基本实现来为您执行所有样板逻辑，例如

class Node {
    public:
    Node() {}
    virtual ~Node() {}

    virtual string OutputAsINI() const { return ""; }
};

class DataNode {
    private:
    string myName;
    string myData;

    public:
    DataNode(const string& name, const string& val);
    ~DataNode() {}

    string OutputAsINI() const { string out = myName + " = " + myData; return out; }
};

这样我就不需要测试任何东西——我只是盲目地调用“OutputAsINI()”。整个界面的类似逻辑将使大多数空测试消失。

Answer 3

反转层次结构。将空节点放在基层：

class Node {
public:
  Node() {}
  virtual void visit() const {}
};

然后根据需要进行专业化：

template<typename T>
class DataNode : public Node {
public:
  DataNode(T x, const Node* l=&Null, const Node* r=&Null)
    : left(l), right(r), data(x) {}

  virtual void visit() const {
    left->visit();
    std::cout << data << std::endl;
    right->visit();
  }

private:
  const Node *left, *right;
  T data;
  static const Node Null;
};

template<typename T>
const Node DataNode<T>::Null = Node();

示例用法：

int main()
{
  DataNode<char> a('A', new DataNode<char>('B'),
                        new DataNode<char>('C'));

  a.visit();

  return 0;
}

输出：

$ ./node 
B
A
C