Essayer de créer des modèles CAS

Question

au moment où je suis occupé de jongler avec les opérations CAS et verrouillage/algorithmes d'attente sans, et pour ma propre santé mentale j'ai décidé de mettre en œuvre un modèle de manipulation tout le casting pour moi:

VC6:

template <typename T> static inline T CAS(volatile T* pDest, T pCompare, T pValue) 
{ 
    //static_assert(sizeof(T) != sizeof(PVOID),"CAS requires PVOID sized operands"); 
    return reinterpret_cast<T>(InterlockedCompareExchange(reinterpret_cast<PVOID*>(pDest),reinterpret_cast<PVOID>(pValue),reinterpret_cast<PVOID>(pCompare))); 
} 

GCC 4.4.1:

template <typename T> static inline T CAS(volatile T* pDest, T pCompare, T pValue) 
{ 
    static_assert(sizeof(T) != sizeof(long),"CAS32 requires long sized operands"); 
    return reinterpret_cast<T>(InterlockedCompareExchangePointer(reinterpret_cast<volatile long*>(pDest),reinterpret_cast<long>(pValue),reinterpret_cast<long>(pCompare))); 
} 

Cependant, en utilisant un code de test simple, je ne peux pas obtenir ce travail sur une destination volatile, qui est nécessaire pour pr réorganisation d'événement.

Test Code:

volatile int* p; 
int i = 2; 
int* pi = &i; 
CAS(&p,NULL,pi); 

Sous VC6 je reçois cette erreur:

error C2782: 'T __cdecl CAS(volatile T *,T,T)' : template parameter 'T' is ambiguous 
     could be 'int' 
     or  'volatile int *' 

et GCC recrache ceci:

error: no matching function for call to 'CAS(volatile int**, NULL, int*&)' 

est-il possible d'obtenir un modèle pour CAS ops qui ne casse pas lorsque la destination est volatile ou suis-je coincé avec une macro?

Answer 1

OK si j'appelle la fonction CAS comme suit:

CAS<int*>(&p, NULL, pi); 

Puis-je obtenir une autre erreur:

error C2664: 'CAS' : cannot convert parameter 1 from 'volatile int **' to 'int *volatile *' 

Cela donne plus d'un indice quant à ce qui se passe mal.

Une façon de le résoudre serait d'introduire un typedef comme suit:

typedef int* pint_t; 

volatile pint_t p; 
int i = 2; 
pint_t pi = &i; 
CAS<pint_t>(&p, NULL, pi);