c++ - How is it possible to write a safe atomic object wrapper? -

i've been attempting write wrapper class wrap win32 intrinsic function such interlockedincrement, interlockedexchange. although problem analogous on other platforms support similar intrinsics.

i have basic template type:

template <typename t, size_t w = sizeof(t)> class interlocked {}; 

which partially specialized datatypes of different size. example, here's 32 bit one:

// // partial specialization 32 bit types // template<typename t> class interlocked <t, sizeof(__int32)> { public:      interlocked<t, sizeof(__int32)>() {};      interlocked<t, sizeof(__int32)>(t val) : m_val(val) {}      interlocked<t, sizeof(__int32)>& interlocked<t, sizeof(__int32)>::operator= (t val)     {         interlockedexchange((long volatile *)&m_val, (long)val);         return *this;     }      interlocked<t, sizeof(__int32)> interlocked<t, sizeof(__int32)>::operator++()     {         return static_cast<t>(interlockedincrement((long volatile *)&m_val));     }      interlocked<t, sizeof(__int32)> interlocked<t, sizeof(__int32)>::operator--()     {         return static_cast<t>(interlockeddecrement((long volatile *)&m_val));     }      interlocked<t, sizeof(__int32)>& interlocked<t, sizeof(__int32)>::operator+(t val)     {         interlockedexchangeadd((long volatile *)&m_val, (long) val);         return *this;     }      interlocked<t, sizeof(__int32)>& interlocked<t, sizeof(__int32)>::operator-(t val)     {         interlockedexchangesubtract((long volatile *)&m_val, (long) val);         return *this;     }      operator t()     {         return m_val;     }  private:      t m_val; }; 

however, i'm coming conclusion don't know how safely write such object. specifically, i've realised returning *this after performing interlocked operation allows possibility thread alter variable before it's returned. nullifies point of type. possible write such thing? presumably std::atomic solves problem don't have access in compiler...

if don't have std::atomic, can use boost::atomic (appeared in latest boost 1.53), tested cross-platform implementation.