Creating an instance of templated abstract class - c++

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 (i.e. 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.