Templates without T parameters in a non-template class - c++

Question

Ok, I read a lot of answers here and there about this problem, but probably since I don't know the proper syntax I can't figure out how to do this.
I have a non-template class which has to implement different static utility functions, mainly for serialization and deserialization. What I currently have is something like this:
class Data_Base : public QObject
{
...
protected:
static QByteArray Serialize(int value);
static int DeserializeInt(QByteArray ser);
static QByteArray Serialize(char *value);
static char *DeserializeCharArr(QByteArray ser);
static QByteArray Serialize(QString value);
static QString DeserializeQString(QByteArray ser);
....
}
Now, I'd prefer to have all the Deserialize* function as a template, since it will be nicer. And as a bonus, have also the Serialize functions as templates, so I will force the user to actually explicitely say which overload to call. Something which can be used this way:
QByteArray ba = Serialize<int>(5);
...
int theValue = Deserialize<int>(ba);
Now, I've tried different approaches, but since all the functions I saw only examples implementing the templates automatically and not one overload at a time I couldn't find out how to make this work.
Of course this is C++, with QT additions.

Answer 1

As stated in the comments, it is called template specialization and looks like this:
class X
{
public:
template<typename T>
static QByteArray Serialize(T const& t);
template<typename T>
static T Deserialize(QByteArray& v);
};
template<>
QByteArray X::Serialize(int const& t)
{
/* ... */
}
template<>
QByteArray X::Serialize(QString const& t)
{
/* ... */
}
template<>
int X::Deserialize(QByteArray& v)
{
/* ... */
}
template<>
QString X::Deserialize(QByteArray& v)
{
/* ... */
}
QByteArray x=X::Serialize(5);
int y=X::Deserialize<int>(x);
When using Serialize you do not need to specify the template parameter because it can be deduced from the argument's
type.
But you cannot deduce by return type, so you need to add the template parameter when using Deserialize.

Answer 2

IMO force your solution with the usage of template specialization could be a bad choice design.
As I've already said in a comment, templates are generally good when your code structure is equal for each data type.
Serialization is a delicate operation (casting, raw memory, etc.) and data structure can define different implicit conversions and produce an UB.
If I had to implement an a "template" behaviour, this would be the first solution (just a scratch!):
struct Foo {
// Some data member variables.
std::string m_nopod;
// Serialize data object. 'It' must to be a output iterator
template<typename It>
void serialize(It out_iterator) {
constexpr size_t BYTES_FOR_SIZE = sizeof(decltype(m_nopod.size()));
constexpr size_t BYTES_FOR_CHAR = sizeof(decltype(m_nopod)::value_type);
// size definitions.
const auto len_str = m_nopod.size();
const auto len_data = BYTES_FOR_CHAR * len_str;
// Temporary memory buffers.
uint8_t memory_size[BYTES_FOR_SIZE];
auto memory_data = std::make_unique<uint8_t[]>(len_data);
// Raw bytes copy.
std::memcpy(memory_size, &len_str, BYTES_FOR_SIZE);
std::memcpy(memory_data.get(), m_nopod.data(), len_data);
// write with the iterator.
for (size_t i = 0; i < BYTES_FOR_SIZE; ++i) {
*out_iterator = memory_size[i];
}
for (size_t i = 0; i < len_data; ++i) {
*out_iterator = memory_data[i];
}
}
};
Where the out_iterator must to be a output_iterator, and ::value_type must to be a implicit convertible type to unsigned char.
The function can be invoked with different data structures (containers):
int main(int argc, char *argv[]) {
std::vector<char> memory_buffer_char;
std::vector<int> memory_buffer_int;
std::string memory_buffer_str;
Foo foo{"a_string"};
foo.serialize(std::back_inserter(memory_buffer_char));
foo.serialize(std::back_inserter(memory_buffer_int));
foo.serialize(std::back_inserter(memory_buffer_str));
return 0;
}
As I've already said, however, I'll never adopt that solution. Rather I'm going to use a simple overloading of function for those various types.
In order avoid writing same thing more than once, I'll define a unique helper function (a private method) which contains the logic of the class.
For example the helper function could create an ordinary buffer of memory in which to serialize the class (array of char) and then overloaded functions should only adapt that array in the proper input data structure.
In that way when the class logic (e.g., data members) changes, you should modify only the helper function.