Question

我想出了一个“模式”或任何被称为“模式”的东西，只是想问问专家这是否是一个好的设计，以及它可能存在什么问题。在我的真实代码中，我具有执行某些矩阵运算的函数。我希望它们可以被各种矩阵实现所模板化，它们都应该具有相同的公共方法。假设要强制执行此公共接口，我想有一个抽象的基类来规定该接口。

代码段显示了这个想法。定义接口的模板化基类。然后，一些派生类都实现了相同的功能（请注意，它们被迫否则将无法实例化）。我使用的很奇怪的是，派生类定义中A的模板参数是派生类本身，不确定是否是个好主意？

请注意，我知道类B，C和D实际上不是从同一类派生的，但这不是我所需要的。我只想对所有派生类强制使用一个通用接口，以明确应实施的内容。

我也知道AddTwoWhatever函数可以很容易地与其他与基类A没有任何关系的模板参数一起使用，但是我也很满意。我并没有试图实现模板限制，只是为A行为的新实现提供了指南。

总而言之，我在所附的代码中显示了设计，我想问一下这是否是一个好主意，是否可行，它可能有什么问题？

template <class T>
class A
{
public:
    virtual void Add(const T& aOther) = 0;
    virtual void PrintValue() const = 0;
};

class B : public A<B>
{
private:
    int mValInt;

public:
    B(int aVal) : mValInt(aVal) { }
    virtual void Add(const B& aOther) override
    {
        mValInt += aOther.mValInt;
    }
    virtual void PrintValue() const override
    {
        std::cout << mValInt << std::endl;
    }
};

class C : public A<C>
{
private:
    double mValDouble;
public:
    C(double aVal) : mValDouble(aVal) { }
    virtual void Add(const C& aOther) override
    {
        mValDouble += aOther.mValDouble;
    }
    virtual void PrintValue() const override
    {
        std::cout << mValDouble<< std::endl;
    }
};

class D : public A<D>
{
private:
    float mValFloat;
};

template <class T>
void AddTwoWhatever(T aFirst, T aSecond)
{
    T aResult(0);

    aResult.Add(aFirst);
    aResult.Add(aSecond);

    aResult.PrintValue();
}

int main(int argc, char **argv) 
{
    B b1(10);

    B b2(11);

    b1.Add(b2);

    b1.PrintValue();

    C c1(13.9);

    C c2(16.3);

    // b1.Add(c1); // gives compile time error as I want it to

    AddTwoWhatever(b1, b2);
    AddTwoWhatever(c1, c2);

    // AddTwoWhatever(b1, c2); // again, gives error as intended

    // D d; // gives compile time error because D is abstract (not implementing A), again, something that I want, enforce the A implementation

    return 0;
}

派生类可以从给定派生类模板化的模板化基类继承吗？这是个好主意吗？

0 个答案: