Question

我想在基类中实现pop（），并让pop（）从派生类中调用正确的派生类heapifyUp（）方法。我意识到我可以为每个派生出一个pop（），但我对如何解决这个问题感兴趣。

如何使用“通用”方式将minHeap或maxHeap实例传递给pop（）？

class Heap
{
    public :

    int size;
    int *items;
    Heap(int n) { this->items = new int[n]; this->size = 0; }
    ~Heap() { delete[] items; }
    int peek() { return items[0]; }

    int _pop()
    {
        int top = items[0];
        items[0] = items[size - 1];
        --size;
        heapifyDown();
        return top;
    }
}

class minHeap : Heap
{
    public :

    minHeap(int capacity) : Heap(capacity) {}

    void heapifyUp()
    {
        int index = size - 1;
        while(hasParent(index) && (parent(index) > items[index]))
        {
            swap(getParentIndex(index), index);
            index = getParentIndex(index);
        }
    }

    void heapifyDown()
    {

    }
}

class maxHeap : Heap
{
public:
    maxHeap(int capacity) : Heap(capacity) {}
    ~maxHeap() {}

    void heapifyUp()
    {

    }

    void heapifyDown()
    {

    }

};

Answer 1

我想在基类中实现pop()，并让pop()从派生类中调用正确的派生类heapifyUp()方法。

这是设计不佳的标志。名称heapifyUp和heapifyDown暗示/采取策略。

你可以坚持糟糕的设计并创造

virtual heapifyUp() = 0;
virtual heapifyDown() = 0;

在基类中，并在派生类中实现它们。

另一种选择是使用virtual辅助函数，可以在派生类中重写它们，以便在利用基类的通用性的同时完成自己的特殊事务。

class Heap
{
    public :

    ...

    int _pop()
    {
       return _pop_impl();
    }

    private:

    virtual int _pop_impl()
    {
        int top = items[0];
        items[0] = items[size - 1];
        --size;
        return top;
    }
}

class minHeap : Heap
{
   ...

   virtual int _pop_impl()
   {
      // Additional code for this class.
      // ...

      int ret = Heap::_pop_impl();

      // Additional code for this class.
      // ...
      return ret;
   }
}

class maxHeap : Heap
{
   ...

   virtual int _pop_impl()
   {
      // Additional code for this class.
      // ...

      int ret = Heap::_pop_impl();

      // Additional code for this class.
      // ...
      return ret;
   }
}

将派生实例传递给base以调用派生方法

1 个答案: