Question

我想实例化一个模板化的抽象类，如下所示：

template <class T>
class non_sense {
public:
    void virtual nonsesnse_func() = 0;
};

要创建此类的整数实例，我尝试了以下操作：

void non_sense<int>::nonsesnse_func(){
}

然后我在main中创建我的实例：

non_sense<int> xx;

所以整个程序如下：

template <class T>
class non_sense {
public:
    void virtual nonsesnse_func() = 0;
};

void non_sense<int>::nonsesnse_func(){
}

void main(){
    non_sense<int> xx;
}

对我来说完全有意义，编译器不接受它，说这个类是抽象的。我不想采用创建一个使用特定模板从这个类继承的新类的路线，关于我试图做的大型应用程序，这将是大量的写入。有人可以向我解释为什么编译器会拒绝这个，除了为我想要的特定实例创建一个新类之外，还有什么方法可以解决这个问题。

Answer 1

non_sense是一个抽象类，因此永远不能将其实例化为对象。

然而，编译并运行：

#include <iostream>

template <class T>
class non_sense {
public:
    virtual void nonsesnse_func();
};

// Specialize the method
template<>
void non_sense<int>::nonsesnse_func(){
    std::cout << "no_sense<int>::nonsense_func" << std::endl;
}


int main(){
    non_sense<int> xx;

    xx.nonsesnse_func();

    return 0;
}

这里的代码显示了如何使用纯抽象类运行（我将nosnsnsense重命名为废话，更容易输入;）：

#include <iostream>

template <class T>
class non_sense {
public:
    virtual void nonsense_func() = 0;
};

template<class T> 
class non_sense_concrete : public non_sense<T> {

    public: 
        void nonsense_func() {
            std::cout << "non_sense_concrete<T> generic code" << std::endl;
        }

};

// Specialize the concrete class
template<>
void non_sense_concrete<int>::nonsense_func(){
    std::cout << "no_sense<int>::nonsense_func" << std::endl;
}


int main(){

    non_sense_concrete<double> objectGeneric;
    objectGeneric.nonsense_func(); 

    non_sense_concrete<int> objectInt;
    objectInt.nonsense_func();


    return 0;
}

Answer 2

看起来很奇怪，纯虚方法可以在C ++中实现。这并没有改变这个方法是纯虚拟的事实，而包含它的类是抽象的。

如果希望类non_sense对除int之外的所有类型都是抽象的，则必须为整个类提供专门化，而不仅仅是纯虚拟成员：

template <class T>
class non_sense {
public:
    virtual void nonsense_func() = 0;
};

template <>
class non_sense<int> {
public:
    virtual void nonsense_func()
    {
        std::cout << "no_sense<int>::nonsense_func" << std::endl;
    }
};

使用更大的类，继承可能会更容易，因为派生类可以继承non_sense中的其他成员，而不必复制整个类（正如您在创建特化时需要做的那样）

Answer 3

如果你有一个具有纯虚函数（即抽象）的类，你必须创建一个实现该虚函数的第二个类。否则你将永远无法使用该类。

在你的代码中，你实现了一个函数，但它不是虚拟的，因为它不在类中。它需要声明并定义为non_sense子类的一部分才能工作。请记住，只有类可以具有虚拟功能。

创建模板化抽象类的实例

3 个答案: