在链表

Question

我制作了双向和二维链表。我的节点称为chunk s，它们的左，右，底部和顶部包含指向chunks的指针。

class chunk;
typedef std::shared_ptr<chunk> chunk_ptr;
typedef std::weak_ptr<chunk> chunk_wptr;

class chunk
{
public:
    chunk(wanted_id) : id(wanted_id) {}

    chunk_ptr left() const { return _left.lock(); }
    chunk_ptr right() const { return _right.lock(); }
    chunk_ptr top() const { return _top.lock(); }
    chunk_ptr bottom() const { return _bottom.lock(); }

    void left(const chunk_ptr set) { _left = set; }
    void right(const chunk_ptr set) { _right = set; }
    void top(const chunk_ptr set) { _top = set; }
    void bottom(const chunk_ptr set) { _bottom = set; }

    int id() const { return _id; }

private:
    chunk_wptr _left, _right, _top, _bottom;
    int _id;
    void id(const int id) { _id = id; }
};

现在，让我们假设我构建了以下结构：

如果我想从1到4导航，我可以使用以下代码行：

id4 = id1->right()->right()->bottom();

现在让我们假设已经删除了块3，例如id2->right == id4->top == nullptr：

如果我想访问id4然后对其执行某些操作，则会出现运行时错误。为避免在每一步执行检查，我想介绍一个中性块元素：

auto null_chunk = std::make_shared<chunk>(-1); // Let's define its id as -1
null_chunk->left(null_chunk);
null_chunk->right(null_chunk);
null_chunk->top(null_chunk);
null_chunk->bottom(null_chunk);

因此，以下陈述将成功运行：

id4 = id1->right()->right()->bottom();

然后id4 == null_chunk。

但是，我不太清楚如何在我的代码中集成这样的元素。

我可以使用静态变量：

// This is a public static method
chunk_ptr chunk::null_chunk()
{
    static auto ptr = instanciate_null_chunk();
    return ptr;
}
// This is a private static method
chunk_ptr chunk::instanciate_null_chunk()
{
    auto ptr = std::make_shared<chunk>(-1);
    ptr->left(ptr);
    ptr->right(ptr);
    ptr->top(ptr);
    ptr->bottom(ptr);
    return ptr;
}

现在，我想在构造函数中使用null_chunk初始化left，right，top和bottom：

chunk(wanted_id) : id(wanted_id) 
{
    this->left(null_chunk());
    this->right(null_chunk());
    this->top(null_chunk());
    this->bottom(null_chunk());
}

这会导致递归堆栈溢出（null_chunk调用构造函数调用null_chunk等...）。

这迫使我为null_chunk()定义一个特定的私有构造函数，但由于我使用的是共享指针，我的构造函数必须公开才能使用make_shared ...

因此，有一个设计流程。 实施此类功能的最佳方式是什么？

Answer 1

实现null节点的一种可能解决方案是使用静态成员。该成员使用另一个静态函数初始化一次，该函数创建一个带有空块的共享指针，并将所有传出连接重定向到块本身。

在构造任何其他块时，所有传出连接也指向空块。

如上面的评论所述，请确保不会因循环引用而泄漏任何内存。

你必须像你提到的那样创建第二个构造函数。但是，使用私有结构作为参数可防止在类外部对此构造函数进行任何调用。

class chunk { 
public: 
  using chunk_ptr = std::shared_ptr<chunk>; 
  using chunk_wptr = std::weak_ptr<chunk>;

private:
  int _id; 
  chunk_wptr _left, _right, _top, _bottom; 
  static chunk_ptr nullchunk;
  struct pctor {};

  static chunk_ptr gennull() {
    chunk_ptr pnullchunk {std::make_shared<chunk>(pctor{})};
    pnullchunk->_left = pnullchunk;
    pnullchunk->_right = pnullchunk;
    pnullchunk->_top = pnullchunk;
    pnullchunk->_bottom = pnullchunk;
    return pnullchunk;
  }

public:
  chunk(pctor) : _id(-1) {}
  chunk(int id) :   _id(id), 
                    _left(chunk::nullchunk),
                    _right(chunk::nullchunk),
                    _top(chunk::nullchunk),
                    _bottom(chunk::nullchunk) {}

  bool isNullNode() const 
  { return this == chunk::nullchunk.get(); } 

  //
  // Further functions omitted
  //
}; 

chunk::chunk_ptr chunk::nullchunk {chunk::gennull()};