创建模板化抽象类的实例

Question

I would like to instantiate a templated abstract class, like the following one:

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

to make an integer instance of this class I tried the following:

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

and then I make my instance in main :

non_sense<int> xx;

so the whole program is as follow:

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

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

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

It totally make sense to me, the compiler doesn't accept it though, saying the class is abstract. I don't want to take the route of creating a new class inheriting from this class using a specific template, regarding the big application I am trying to make this will be massive writting. Can somebody explain to me why the compiler rejects this, and is there any way arround this apart from creating a new class for the specific instance I want.

Answer 1

non_sense is an abstract class, so it can never be instantiated into an object.

This compiles and runs, however:

#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;
}

And here's code showing how to make this run with a pure abstract class (I've renamed nosnsnsense to nonsense, it's easier to type ;) :

#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

Odd as it might seem, pure virtual methods can have an implementation in C++. That does not change the fact that the method is pure virtual and the class containing it is abstract.

If you want the class non_sense to be abstact for all types except int , you will have to provide a specialisation for the entire class, not just for the pure virtual members:

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;
    }
};

With a larger class, inheritance would probably be easier, because then the derived class can inherit the other members from non_sense , instead of having to duplicate the entire class (as you need to do when creating a specialisation).

Answer 3

If you have an class with a pure virtual function (ie abstract) you MUST create a second class that implements that virtual function. Otherwise you will never be able to use that class.

In your code you implemented a function alright, but it's not virtual because it is not inside of a class. It needs to be declared and defined as part of a sub-class off of non_sense in order to work. Please keep in mind that only classes can have virtual functions.