Übergeben Sie die Instanz von abgeleitet an die Basis, um die abgeleitete Methode

Question

aufzurufen Ich möchte pop() in der Basisklasse implementieren und pop() rufen Sie die richtige abgeleitete Klasse HeapifyUp() -Methode aus der abgeleiteten Klasse. Mir ist klar, dass ich für jede Ableitung ein Pop() machen kann, aber mich interessiert, wie man das lösen soll.

Wie kann ich eine "generische" Möglichkeit schaffen, entweder minHeap- oder maxHeap-Instanzen an pop() zu übergeben?

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

Ich mag pop() in der Basisklasse implementieren und pop() Ruf hat die richtigen abgeleitete Klasse heapifyUp() Methode aus der abgeleiteten Klasse.

Das ist ein Zeichen für schlechtes Design. Die Namen heapifyUp und heapifyDown deuten auf eine Strategie hin.

Sie können mit den Armen Design-Stick und

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

in der Basisklasse erstellen und sie in der abgeleiteten Klasse implementieren. Eine andere Möglichkeit ist es, eine virtual Hilfsfunktion zu verwenden, die in den abgeleiteten Klassen außer Kraft gesetzt werden kann, um ihre eigenen speziellen Dinge zu tun, während sie die Gemeinsamkeit der Basisklasse ausnutzt.

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; 
    } 
}