How to reliably specialize template with intptr_t in 32 and 64 bit environments?

Question

I have a template I want to specialize with two int types, one of them plain old int and another one is intptr_t. On 64 bit platform they have different sizes and I can do that with ease but on 32 bit both types are the same and compiler throws an error about redefinition. What can I do to fix it except for disabling one of definitions off with preprocessor?

Some code as an example:

template<typename T>
type * convert();

template<>
type * convert<int>() { return getProperIntType(sizeof(int)); }

template<>
type * convert<intptr_t>() { return getProperIntType(sizeof(intptr_t)); }

//this template can be specialized with non-integral types as well, 
// so I can't just use sizeof() as template parameter.
template<>
type * convert<void>() { return getProperVoidType(); }

Answer 1

What you're trying to achieve is fundamentally impossible: intptr_t is a typedef for int on 32 bit systems, so the compiler can't distinguish them. However, your example could be solved by just specializing the void case:

template<typename T>
type * convert() { return getProperIntType(sizeof(T)); }

template<>
type * convert<void>() { return getProperVoidType(); }