Question

我想知道以下段落的含义以及如何实现。昨天我问了一个与同一问题here有关的问题。在昨天的问题中，有人告诉我这是不可能的，但我认为以下段落表明是这样？

您的方法使用特定的幂运算方法。但是，幂运算类是一般的子类抽象取幂类。您可以实现这些以使用此抽象类，并仅使用其中一个具体类对其进行实例化。这样，您便可以灵活地进行实验和/或准确更改所使用的指数算法，例如，如果将来有人发现更好的算法。...

从本质上讲，我有很多按以下方式组织的求幂技术-

template <class T>
class Exponentiation
{
    public:
    Exponentiation() {};
    virtual ~Exponentiation() {};

    // computes C = A^n
    virtual void power(T& C, const T& A, const int n) = 0;
}

template <class T>
class ExpA : public Exponentiation<T>
{
    public:
    ExpA() {};
    ~ExpA() {};

    void power (T& C, const T& A, const int n);
}

template <class T>
class ExpB : public Exponentiation<T>
{
    protected:
    var1;
    var2;

    public:
    ExpB() {};
    ~ExpB() {};

    func1();
    func2();
    void power (T& C, const T& A, const int n);
}

现在，最初我有一个performExp()，它正在调用特定的幂运算方法，例如-

performExp()
{
    ExpA<long> objA;
    objA.power();

    // or

    ExpB<long> objB;
    objB.func1();
    objB.func2();
    obj.power ()
}

但据我所知，一个更好的选择是使用performExp()中的基类，然后使用其中一个具体类main()实例化ExpA中的基类，或者ExpB。

如何做到这一点？在阅读完昨天的答案后，我有一个想法是使用某种包装材料，但是我很难形象化它。

Answer 1

我看不到您要实现的目标。但是第一个问题是您需要运行时还是编译时多态。查看您的代码，我想是后者。

因此，对于该答案，我假设您拥有模板化的幂运算类，并且您在最终的compelx计算程序中编写了代码，这些程序将确切地知道它们适用于ExpA还是ExpB。

然后我建议将performExp()作为模板函数来实现，以通用方式指示如何执行该操作：

template <class T, template <class U> class Exp>
void performExp(Exp<T>& obj)
{
     obj.power();
}

然后可以为此模板提供专业化或部分专业化：

template <class T>
void performExp(ExpB<T>& obj)
{
     obj.func1();
     obj.func2(); 
     obj.power();
}

然后在代码中使用这些模板时，编译器将推导参数并使用可能存在的任何特殊化：

int main() {
    ExpA<long> a;
    performExp(a);

    ExpB<long> b; 
    performExp(b);       //specialized form will be used
}

您可以在此online demo

中测试结果

如何用具体类之一实例化一个抽象类？

1 个答案: