使用两个c++类的堆代码，无需重写

Question

我正在尝试为两个不同的类实现堆代码，我不想重写堆代码，因为它已经可以工作（经过测试和工作）

所以我有第一个（原始）类，我们将其称为具有多个属性的

Job

。 然后我将其修改为抽象的，并让两个类实现这个

Job

类：

class Job {
protected:
    long long value1;
    long long value2;

    ...

public:
    Job(long long value1, long long value2) : value1(value1), value2(value2) {};
    virtual void setValue(long long value);
    virtual long long getValue();
};

class AvailableJob : public Job{

public:
    AvailableJob (long long value1, long long value2): Job(value1, value2) {};

    void setValue(long long value) {
        if (value == -1)
            return;
        value1 = value;
    }

    long long getValue() {
        return value1;
    }
};

class UsedJob : public Job{

public:
    UsedJob (long long value1, long long value2): Job(value1, value2) {};

    void setValue(long long value) {
        if (value == -1)
            return;
        value2 = value;
    }

    long long getValue() {
        return value2 ;
    }
};

该类有更多属性和方法，但这些与这个问题无关。

问题是我使用

HeapStruct

类创建了两棵最小堆树，但我想要一个使用

value1

作为参考值的最小堆，另一个使用

value2

的最小堆

所以我认为这会起作用：

class HeapStruct{
    private:
        vector<Job> heap;
        long long size;
        long long maxSize;
...
    public:
    HeapStruct(long long maxSize) : maxSize(maxSize) {
    // initialize heap
    }
    long long getValueAt(long long i) {
        return heap.at(i).getValue();
    }
    
    void siftUp(long long i) {
        // siftUp using job::getValue and job::setValue methods
    }

    void siftDown(){};
    Job getMin(){};
    void insertNode(){};
    removeNode(){};
};

我认为使用方法

Job::getValue

和

Job::setValue

就足够了，但是我如何告诉

HeapStruct

使用

AvailableJob

或

UsedJob

。现在正在抱怨抽象类的使用。

此外，如果这不是最好的方法并且您知道更好的方法，我愿意尝试不同的方法。

Answer 1

类成员

vector<Job> heap;

只能存储

Job

，不能存储派生类，如果您需要单个Job类型的容器，您可以使HeapStruct成为与任何T一起使用的模板：

template <class T>
class HeapStruct {
private:
        vector<T> heap;
        //...
public:
     T getMin();   // should  we really returning a copy here?
};

甚至将其限制为使用 C++20 的作业

template <std::derived_from<Job> T>
class HeapStruct {

如果您必须对任何作业使用相同的类型，但不能将它们混合在一起，您可以在那里添加一个虚拟基类：

class HeapStructBase {
public:
   virtual Job& getMin() = 0;
};

template <std::derived_from<Job> T>
class HeapStruct : HeapStructBase {
private:
        vector<T> heap;
public:
     T& getMin() override;   // T derived from Job
}