Pointer template specialization - c++

Question

I'm new to templates in C++, so here is my problem.
I've a generic class ProductItem that will do all the stuff I want, but I need to specialize a part in order to use pointers (for char*).
My code :
typedef unsigned char BYTE;
template<typename T>
class TProductTableItem
{
protected:
int Offset;
int DataLength;
T Value;
public:
virtual bool LoadFromBuffer(const BYTE* buffer, int count)
{
if(Offset + DataLength > count)
return false;
Value = buffer[Offset];
return true;
}
};
// Specialization (doesn't compile)
class TProductTableItemString : public TProductTableItem<char*>
{
bool LoadFromBuffer(const BYTE* buffer, int count)
{
if(Offset + DataLength > count)
return false;
memset(Value, 0, DataLength);
memcpy(Value, (void*)&buffer[Offset], DataLength);
return true;
}
};
When trying to compile this code, I've the following error message:
cannot convert from 'const BYTE' to 'char*'
What I'm doing wrong?
It look like that even for char* type, it tries to use the TProductTableItem::LoadFromBuffer function and not the TProductTableItemString::LoadFromBuffer one.
Thanks.

Answer 1

TProductTableItemString, by inheriting from it, causes an instantiation of TProductTableItem<char*>. In the implementation of TProductTableItem::LoadFromBuffer, this line:
Value = buffer[Offset];
cannot be compiled because buffer[Offset] is a byte, and Value is a char*.
By the way, TProductTableItemString is not a specialization, it is simply inheriting and then hiding LoadFromBuffer. If you really want to specialize, you should write:
template<>
class TProductTableItem<char*>
{
...
};

Answer 2

You are mixing two distinct concepts: inheritance and template specialization.
Your class is not a template specialization but it derives from a template instantiation. However that template cannot be instantiated because when T = char * the statement Value = buffer[offset]; has a type mismatch error.
If you want to write a template specialization then the syntax is
template<>
class ProductTableItem<char *> {
...
};
Note that two templates instantiations are in general unrelated types from an inheritance point of view...
May be a solution for what you are trying to do is something like
// Non-template base class
class ProducTableItemBase {
protected:
...
public:
virtual bool LoadFromBuffer(const BYTE* buffer, int count) = 0;
};
// Template class for all other types
template<typename T>
class ProductTableItem : public ProductTableItemBase {
T Value;
bool LoadFromBuffer(const BYTE* buffer, int count) {
...
}
};
// Template specialization for char*
template<>
class ProductTableItem<char *> : public ProductTableItemBase {
char * Value;
bool LoadFromBuffer(const BYTE* buffer, int count) {
...
}
};
I said may be because indeed it's not clear to me what you are trying to accomplish.

Answer 3

You are confusing the concepts of inheritance and specialisation. Firstly, in order to specialise a template, you don't derive from it - you use this syntax:
template <>
class TProductTableItem<char*>
{...}
The next confusion is that you are trying to use the non-specialised member variables in the specialisation. Template specialisations are are completely seperate to the non-specialised version. For this example, you have only declared the variables Offset, DataLength and Value inside the non-specialised template. You need to add these to the specialisation if you want to have them there:
template <>
class TProductTableItem<char*>
{
int Offset;
int DataLength;
char* Value;
...
}

Answer 4

You want your memcpy line to be more like this:
memcpy(Value, (void*)&buffer[Offset], DataLength);
And likewise when you assign Value:
Value = (T)&buffer[Offset];