¿Cómo se puede especializar de manera confiable la plantilla con intptr_t en entornos de 32 y 64 bits?

Question

Tengo una plantilla que quiero especializarme con dos tipos de int, uno de ellos simple viejo int y el otro es intptr_t. En la plataforma de 64 bits tienen diferentes tamaños y puedo hacerlo con facilidad, pero en 32 bits ambos tipos son los mismos y el compilador arroja un error sobre la redefinición. ¿Qué puedo hacer para solucionarlo, excepto para desactivar una de las definiciones con el preprocesador?

algún código por ejemplo:

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

Lo que estamos tratando de lograr es fundamentalmente imposible: intptr_t es un typedef para int en sistemas de 32 bits, por lo que el compilador no puede distinguirlos. Sin embargo, su ejemplo podría ser resuelto con sólo el caso especializada vacío:

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

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