Comment se spécialiser de manière fiable avec intptr_t dans les environnements 32 et 64 bits?

Question

J'ai un modèle que je veux spécialiser avec deux types d'int, l'un d'entre eux plaine vieux int et un autre est intptr_t. Sur la plate-forme 64 bits, ils ont des tailles différentes et je peux le faire avec facilité mais sur 32 bits les deux types sont les mêmes et le compilateur lance une erreur sur la redéfinition. Que puis-je faire pour le réparer, sauf pour désactiver une des définitions avec préprocesseur?

Certains code comme exemple:

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

Qu'est-ce que vous essayez d'atteindre est fondamentalement impossible: intptr_t est un typedef pour int sur les systèmes 32 bits, de sorte que le compilateur ne peut pas les distinguer. Cependant, votre exemple pourrait être résolu en spécialisant simplement le cas de vide:

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

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