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

Question

我想知道下一段是什么意思，以及如何执行它。昨天我问了一个问题，这个问题与这里同样的问题有关。在昨天的提问中，我被告知这是不可能的，但我认为下面的段落表明了这一点。

您的方法使用特定的指数方法。然而，指数类是一般抽象指数类的子类。您可以实现这些来使用这个抽象类，只需用一个具体的类实例化它。这将使您可以灵活地试验和/或更改具体使用的指数算法，例如，如果某人在未来发现了更好的结果.

本质上，我有一堆指数化技术，它们的组织方式如下-

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()中使用基类，然后用一个具体的类ExpA或ExpB实例化main()中的基类。

怎样才能做到这一点？在阅读了昨天的答案后，我有一个想法是使用某种包装，但我很难想象它。

Answer 1

我看不出你到底想达到什么目的。但是第一个问题是您需要运行时还是编译时多态。看看你的代码，我想是后者。

因此，对于这个答案，我假设您有模板化的指数类，并在最后编写强制计算程序，这些计算程序将准确地知道它们是在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
}

您可以在此在线演示中测试结果。