Just thought of something else. Your class is a template class and this sometimes causes confusion.
Template classes are not classes in themselves like the other classes you create. They are just instructions to the compiler on how to make the real classes. Every time you instantiate a template class with a different type, the compiler creates the real class. This may sound a bit abstract so I'll give an example.
Suppose you create the following:
template<class UserType>
class Printer
{
public:
Printer(UserType const &initialValue);
void Print();
private:
UserType m_value;
};
template<class UserType>
Printer<UserType>:: Printer(UserType const &initialValue)
: m_value(initialValue)
{}
template<class UserType>
void Printer<UserType>:: Print()
{
cout << "The value is: " << m_value << endl;
}
This is just a template of a class, not a real class. If I were to create two versions of this class in the main() function:
void main()
{
Printer<int> integerPrinter;
Printer<float> floatPrinter;
// some other code
}Behind the scenes the compiler will create the real classes for these two instances.
class Printer<int>
{
public:
Printer(int const &initialValue);
void Print();
private:
int m_value;
};
Printer<int>:: Printer(int const &initialValue)
: m_value(initialValue)
{}
void Printer<int>:: Print()
{
cout << "The value is: " << m_value << endl;
}
class Printer<float>
{
public:
Printer(float const &initialValue);
void Print();
private:
float m_value;
};
Printer<float>:: Printer(float const &initialValue)
: m_value(initialValue)
{}
void Printer<float>:: Print()
{
cout << "The value is: " << m_value << endl;
}
This is just an illustration of how the real classes might be created by the compiler. How they are actually created is irrelevant, the fact is that the compiler creates a new class based on the template for each instance that has a new type. If you create four Printer<int> objects and two Printer<float> objects there will only be two new classes created. If you decide to modify your program to also have five Printer<string> objects then the compiler will create the Printer<string> class based on the template (substituting UserType with string)
The reason I'm raising this issue is that ordinary programming convention says that you have to place the class definition (the interface) in a header file and the member function definitions (the implementation) in a separate source file. You cannot do this with template classes.
Because the compiler needs to know everything about a template class (the interface
and the implementation) in order to create new classes based on those templates, you have to include the entirety of your class in every source file that uses it. Thus both the interface and the implementation of template classes
must be in an included header file.
Thus, AndréB, if you have indeed created a destructor, make sure the definition is in the included header file and not in a source file.
