creating a generic instance of a class template in c++ - c++

Question

I'm making a template library in c++. I think it needs to be in the form of a template class because it has to be able to store some data. I would like to be able to create an instance of that class without having to specify a data type.
Here's what the class template would look like
template<class T>
class MyTemplateClass{
public:
void saveData(T data);
private:
T my_data;
};
template<class T>
void MyTemplateClass<T>::saveData(T data){
//bunch of code goes here
}
and here's how I would like to declare it:
class LibraryUser{
public:
void saveDoubleData(double data);
void saveFloatData(float data);
private:
MyTemplateClass<UNKNOWN_TYPE> my_generic_object;
};
and use it:
void LibraryUser::saveDoubleData(double data){
my_generic_object.saveData(data);
}
void LibraryUser::saveFloatData(float data){
my_generic_object.saveData(data);
}
What should UNKNOWN_TYPE be? Is this possible?
EXTRA NOTES: I cannot edit the function prototypes of the LibraryUser class because it is part of an existing plug-in framework. I'd rather not use template specialization because I don't want to double the code in saveData() since it's actually pretty long.

Answer 1

You should make the LibraryUser class a template as well:
template<class T>
class LibraryUser{
public:
void saveData(T data);
private:
MyTemplateClass<T> my_generic_object;
};
Alternatively, you can use boost::any if the type is really unknown, or boost::variant if the type is in a specified set of types.

Answer 2

The template classes are actually different from each other so you can't really change the template type runtime without using some trick. If you don't want to make LibraryUser also a template, you can store multiple variables. In this case, if you want to save yourself the trouble of duplicating every code, but you have a limited number of different types just use multiple variables and store which one is actually used. Not really nice, but saves you from making more template classes.
class LibraryUser{
public:
void saveIntData(int data);
void saveFloatData(float data);
private:
MyTemplateClass<int> my_int;
MyTemplateClass<float> my_float;
};
Use it:
void LibraryUser::saveFloatData(float data){
my_float.saveData(data);
}
void LibraryUser::saveIntData(int data){
my_int.saveData(data);
}

Answer 3

Instead of having a class member, why not use local instances of your template class?
void LibraryUser::saveIntData(float data){
MyTemplateClass<float> saver;
saver.saveData(data);
}
void LibraryUser::saveFloatData(int data){
MyTemplateClass<int> saver;
saver.saveData(data);
}
If MyTemplateClass needs s.th. you want to have initialized once (e.g. a database connection), make a class member for that one separately (in LibraryUser) and pass a reference to the constructor of MyTemplateClass:
template<class T>
class MyTemplateClass{
public:
MyTemplateClass(DBConnection& conn);
void saveData(T data);
private:
T my_data;
DBConnection& my_conn;
};
class LibraryUser{
public:
void saveIntData(int data);
void saveFloatData(float data);
private:
DBConnection my_conn;
};
void LibraryUser::saveIntData(float data){
MyTemplateClass<float> saver(my_conn);
saver.saveData(data);
}
About your EXTRA NOTES:
It is also safe to assume that a given OtherClass object will consistently only call either saveFloatData or saveIntData, not both.
IMHO that's a bad assumption (restriction) made for client usage, if you're going to design a framework.
UPDATE:
Another option I can think of, is to just templating the function in question, not the whole class:
class MyGenericClass{
public:
MyGenericClass();
template<class T>
void saveData(T data);
};