如何将具有不同成员变量类型的两个类和不同的构造函数制作到派生/基类或模板类中？

Question

class Data
{
public:
    int i;
};
auto cmp = [](const Data& d1, const Data& d2) { return d1.i > d2.i; };

class A
{
private:
    queue<Data> q;
public:
    A() {};

    void func() {
        int cnt = 0;
        while (!q.empty()) {
            std::cout << cnt++ << std::endl;
            q.pop();
        }
    }
};

class B
{
private:
    priority_queue<Data, vector<Data>, decltype(cmp)> q;
public:
    B() :q(cmp) {};

    void func() {
        int cnt = 0;
        while (!q.empty()) {
            std::cout << cnt++ << std::endl;
            q.pop();
        }
    }
};

我定义了两个类别的A和B. As Shis，他们的成员func是相同的，但是具有不同的成员变量类型q和不同的构造函数。

因此，我可以将A和B分为两个基类派生的两个类（但是在基类中使用func）或将它们放入模板类？（也就是说，我只想写<<代码> func 一次..） 如果可以的话，如何？

Answer 1

在这两种情况下，看来您只是在擦除收集类中的项目数量。如果是这样，让我们​​保持简单。

void func() {
    queue<Data> empty_queue;
    cout << "About to erase a queue of size " << q.size() << "\n";
    q.swap(empty_queue);
}

或者

void func() {
    priority_queue<Data, vector<Data>, decltype(cmp)> empty_queue;
    cout << "About to erase a queue of size " << q.size() << "\n";
    q.swap(empty_queue);
}

我要推荐一种继承策略，其中A和B来自基本模板类。但是在编码之后，我不喜欢从表面上的排队课程中得出的想法。您不能诚实地说A或B是队列的“是”。但这是我写的，我不喜欢它。

template <typename T>
class Base
{
protected:
    T q;

public:
    void func()
    {
        T empty_queue;
        q.swap(empty_queue);
    }
};

class A : public Base<queue<Data>>
{
public:
    A() {};
};

class B : public Base<priority_queue<Data, vector<Data>, decltype(cmp)>>
{
public:
    B() {}
};

一种更好的方法可能只编写一个模板函数：

template <typename T>
void EraseCollectionClass(T& t) {
    T empty;
    t.swap(empty);
}

然后保留您的原始实现：

class A
{
private:
    queue<Data> q;
public:
    A() {};

    void func() {
        EraseCollectionClass(q);
    }
};

class B
{
private:
    priority_queue<Data, vector<Data>, decltype(cmp)> q;
public:
    B() :q(cmp) {};

    void func() {
        EraseCollectionClass(q);
    }
};