c++ how to reduce the amout of identical template specializations? - c++

Question

I have this functor:
struct functor
{
template<class T> void operator()(T value) // (*)
{
// process the value
}
template<> void operator()<const wchar_t *>(const wchar_t *value) // (**)
{
if (value)
{
// process the value
}
}
template<> void operator()<const char *>(const char *value) // (**)
{
if (value)
{
// process the value
}
}
template<> void operator()<wchar_t *>(wchar_t *value) // (**)
{
if (value)
{
// process the value
}
}
template<> void operator()<char *>(char *value) // (**)
{
if (value)
{
// process the value
}
}
};
As you can see, I have 4 identical template specializations. Is there a technique to specify all of them once, meaning somehow to partition all the possible types into the main group (*) and the specialized one (**)?
Thanks.
EDIT
Oops, fixed some typos.

Answer 1

You can get away with a simpler scheme - overloading!
template<class T>
void foo(T value){ // general
// ...
}
template<class T>
void foo(T* value){ // for pointers!
if(value)
foo(*value); // forward to general implementation
}
Also, I'd recommend to make the parameter a reference - const if you don't need to modify it (or maybe both, depending on what you actually need to do):
template<class T>
void foo(T& value){ // general, may modify parameter
// ...
}
template<class T>
void foo(T const& value){ // general, will not modify parameter
// ...
}
If you want to have a special implementation for a certain set of types (i.e., one implementation for the whole set), traits and tag dispatching can help you:
// dispatch tags
struct non_ABC_tag{};
struct ABC_tag{};
class A; class B; class C;
template<class T>
struct get_tag{
typedef non_ABC_tag type;
};
// specialization on the members of the set
template<> struct get_tag<A>{ typedef ABC_tag type; };
template<> struct get_tag<B>{ typedef ABC_tag type; };
template<> struct get_tag<C>{ typedef ABC_tag type; };
// again, consider references for 'value' - see above
template<class T>
void foo(T value, non_ABC_tag){
// not A, B or C ...
}
template<class T>
void foo(T value, ABC_tag){
// A, B, or C ...
}
template<class T>
void foo(T value){
foo(value, typename get_tag<T>::type()); // dispatch
}
Bottom line is, you'll need atleast some amount of duplication (tags, overloads, ...) if you want to group types that have nothing in common.

Answer 2

You mean like this?
struct functor
{
template<class T> void operator()(T value)
{
// process the value
}
template<class T> void operator()(T* value) // overload, not specialization
{
if (value) {
// process the value
}
}
};
http://ideone.com/P8GLp
If you want only those types, something else
struct functor
{
protected:
template<class T> void special(T* value) // overload, not specialization
{
if (value) {
// process the value
}
}
public
template<class T> void operator()(T value)
{
// process the value
}
void operator()(char* value) {special(value);}
void operator()(wchar_t* value) {special(value);}
void operator()(const char* value) {special(value);}
void operator()(const wchar_t* value) {special(value);}
};