1. Fixed compilation with MSVC 2003.

2. Fixed incorrect reinterpret_casts in constexpr constructors that could result in buffer overruns. The initializing constructors for non-integral atomics are not constexpr yet because memcpy must be used inside. 3. Made atomic_flag default constructors constexpr. This is not by the standard but we do not implement ATOMIC_FLAG_INIT yet, so the default constructor is needed and it should be constexpr when possible. 4. Fixed a few syntax errors and cleaned up the code a bit. 5. Moved operator value_type() to the interface class in order not to duplicate it in base_atomic specializations. 6. The return type of operator=() changed to follow the standard. [SVN r83096]
2026-02-02 20:32:09 +00:00 · 2013-02-23 14:21:19 +00:00
parent 546ff8d616
commit f9c4249c8e
15 changed files with 376 additions and 243 deletions
--- a/include/boost/atomic/atomic.hpp
+++ b/include/boost/atomic/atomic.hpp
@@ -17,6 +17,10 @@
 #include <boost/atomic/detail/platform.hpp>
 #include <boost/atomic/detail/type-classification.hpp>
 #include <boost/type_traits/is_signed.hpp>
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1400
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/mpl/and.hpp>
+#endif

 #ifdef BOOST_ATOMIC_HAS_PRAGMA_ONCE
 #pragma once
@@ -83,23 +87,48 @@ inline void atomic_signal_fence(memory_order order)

 template<typename T>
 class atomic :
-    public atomics::detail::base_atomic<T, typename atomics::detail::classify<T>::type, atomics::detail::storage_size_of<T>::value, boost::is_signed<T>::value >
+    public atomics::detail::base_atomic<
+        T,
+        typename atomics::detail::classify<T>::type,
+        atomics::detail::storage_size_of<T>::value,
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1400
+        boost::is_signed<T>::value
+#else
+        // MSVC 2003 has problems instantiating is_signed on non-itegral types
+        mpl::and_< boost::is_integral<T>, boost::is_signed<T> >::value
+#endif
+    >
 {
 private:
    typedef T value_type;
-    typedef atomics::detail::base_atomic<T, typename atomics::detail::classify<T>::type, atomics::detail::storage_size_of<T>::value, boost::is_signed<T>::value > super;
+    typedef atomics::detail::base_atomic<
+        T,
+        typename atomics::detail::classify<T>::type,
+        atomics::detail::storage_size_of<T>::value,
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1400
+        boost::is_signed<T>::value
+#else
+        // MSVC 2003 has problems instantiating is_signed on non-itegral types
+        mpl::and_< boost::is_integral<T>, boost::is_signed<T> >::value
+#endif
+    > super;
 public:
    atomic(void) BOOST_NOEXCEPT : super() {}
-    BOOST_CONSTEXPR atomic(value_type v) BOOST_NOEXCEPT: super(v) {}
+    BOOST_CONSTEXPR atomic(value_type v) BOOST_NOEXCEPT : super(v) {}

-    atomic & operator=(value_type v) volatile BOOST_NOEXCEPT
+    value_type operator=(value_type v) volatile BOOST_NOEXCEPT
    {
-        super::operator=(v);
-        return *const_cast<atomic *>(this);
+        this->store(v);
+        return v;
+    }
+
+    operator value_type(void) volatile const BOOST_NOEXCEPT
+    {
+        return this->load();
    }

-private:
 #ifdef BOOST_NO_CXX11_DELETED_FUNCTIONS
+private:
    atomic(const atomic &) /* =delete */ ;
    atomic & operator=(const atomic &) volatile /* =delete */ ;
 #else
--- a/include/boost/atomic/detail/base.hpp
+++ b/include/boost/atomic/detail/base.hpp
@@ -24,18 +24,6 @@
 #endif

 #define BOOST_ATOMIC_DECLARE_BASE_OPERATORS \
-    operator value_type(void) volatile const BOOST_NOEXCEPT \
-    { \
-        return load(memory_order_seq_cst); \
-    } \
-     \
-    this_type & \
-    operator=(value_type v) volatile BOOST_NOEXCEPT \
-    { \
-        store(v, memory_order_seq_cst); \
-        return *const_cast<this_type *>(this); \
-    } \
-     \
    bool \
    compare_exchange_strong( \
        value_type & expected, \
@@ -53,7 +41,6 @@
    { \
        return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); \
    } \
-     \

 #define BOOST_ATOMIC_DECLARE_ADDITIVE_OPERATORS \
    value_type \
@@ -138,7 +125,8 @@ calculate_failure_order(memory_order order)
 }

 template<typename T, typename C, unsigned int Size, bool Sign>
-class base_atomic {
+class base_atomic
+{
 private:
    typedef base_atomic this_type;
    typedef T value_type;
@@ -148,8 +136,7 @@ private:
 public:
    base_atomic(void) {}

-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT:
-        v_(v)
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(v)
    {}

    void
@@ -224,8 +211,7 @@ public:
 private:
    char * storage_ptr() volatile const BOOST_NOEXCEPT
    {
-        const char volatile * ptr = reinterpret_cast<const char volatile *>(&v_);
-        return const_cast<char *>(ptr);
+        return const_cast<char *>(&reinterpret_cast<char const volatile &>(v_));
    }

    base_atomic(const base_atomic &) /* = delete */ ;
@@ -235,14 +221,15 @@ private:
 };

 template<typename T, unsigned int Size, bool Sign>
-class base_atomic<T, int, Size, Sign> {
+class base_atomic<T, int, Size, Sign>
+{
 private:
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
    typedef lockpool::scoped_lock guard_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -360,14 +347,15 @@ private:
 };

 template<typename T, unsigned int Size, bool Sign>
-class base_atomic<T *, void *, Size, Sign> {
+class base_atomic<T *, void *, Size, Sign>
+{
 private:
    typedef base_atomic this_type;
    typedef T * value_type;
    typedef ptrdiff_t difference_type;
    typedef lockpool::scoped_lock guard_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -452,13 +440,14 @@ private:
 };

 template<unsigned int Size, bool Sign>
-class base_atomic<void *, void *, Size, Sign> {
+class base_atomic<void *, void *, Size, Sign>
+{
 private:
    typedef base_atomic this_type;
    typedef void * value_type;
    typedef lockpool::scoped_lock guard_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
--- a/include/boost/atomic/detail/cas32strong.hpp
+++ b/include/boost/atomic/detail/cas32strong.hpp
@@ -29,13 +29,14 @@ namespace detail {
 /* integral types */

 template<typename T, bool Sign>
-class base_atomic<T, int, 1, Sign> {
+class base_atomic<T, int, 1, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -156,13 +157,14 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, int, 2, Sign> {
+class base_atomic<T, int, 2, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -283,12 +285,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -407,12 +410,13 @@ private:
 /* pointer types */

 template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef void * value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -502,12 +506,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T * value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -599,14 +604,16 @@ private:
 /* generic types */

 template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }

    base_atomic(void) {}

@@ -688,14 +695,16 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }

    base_atomic(void) {}

@@ -778,14 +787,16 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }

    base_atomic(void) {}

--- a/include/boost/atomic/detail/cas32weak.hpp
+++ b/include/boost/atomic/detail/cas32weak.hpp
@@ -26,13 +26,14 @@ namespace detail {
 /* integral types */

 template<typename T, bool Sign>
-class base_atomic<T, int, 1, Sign> {
+class base_atomic<T, int, 1, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -161,13 +162,14 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, int, 2, Sign> {
+class base_atomic<T, int, 2, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -296,12 +298,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -428,12 +431,13 @@ private:
 /* pointer types */

 template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef void * value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -513,12 +517,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T * value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -618,14 +623,17 @@ private:
 /* generic types */

 template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
+
    base_atomic(void) {}

    void
@@ -715,14 +723,17 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
+
    base_atomic(void) {}

    void
@@ -812,14 +823,17 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
+
    base_atomic(void) {}

    void
--- a/include/boost/atomic/detail/cas64strong.hpp
+++ b/include/boost/atomic/detail/cas64strong.hpp
@@ -29,12 +29,13 @@ namespace detail {
 /* integral types */

 template<typename T, bool Sign>
-class base_atomic<T, int, 8, Sign> {
+class base_atomic<T, int, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -153,12 +154,13 @@ private:
 /* pointer types */

 template<bool Sign>
-class base_atomic<void *, void *, 8, Sign> {
+class base_atomic<void *, void *, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef void * value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -248,12 +250,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T *, void *, 8, Sign> {
+class base_atomic<T *, void *, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef T * value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -345,21 +348,23 @@ private:
 /* generic types */

 template<typename T, bool Sign>
-class base_atomic<T, void, 8, Sign> {
+class base_atomic<T, void, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint64_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
    base_atomic(void) {}

    void
    store(value_type const& value, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        storage_type value_s = 0;
-        memcpy(&value_s, &value, sizeof(value_s));
+        memcpy(&value_s, &value, sizeof(value_type));
        platform_fence_before_store(order);
        platform_store64(value_s, &v_);
        platform_fence_after_store(order);
@@ -371,7 +376,7 @@ public:
        storage_type value_s = platform_load64(&v_);
        platform_fence_after_load(order);
        value_type value;
-        memcpy(&value, &value_s, sizeof(value_s));
+        memcpy(&value, &value_s, sizeof(value_type));
        return value;
    }

--- a/include/boost/atomic/detail/gcc-alpha.hpp
+++ b/include/boost/atomic/detail/gcc-alpha.hpp
@@ -88,7 +88,8 @@ inline void platform_atomic_thread_fence(memory_order order)
 }

 template<typename T>
-class atomic_alpha_32 {
+class atomic_alpha_32
+{
 public:
    typedef T integral_type;
    BOOST_CONSTEXPR atomic_alpha_32(T v) BOOST_NOEXCEPT: i(v) {}
@@ -204,7 +205,8 @@ private:
 };

 template<typename T>
-class atomic_alpha_64 {
+class atomic_alpha_64
+{
 public:
    typedef T integral_type;
    BOOST_CONSTEXPR atomic_alpha_64(T v) BOOST_NOEXCEPT: i(v) {}
@@ -320,7 +322,9 @@ private:
 };

 template<typename T>
-class platform_atomic_integral<T, 4> : public build_atomic_from_typical<build_exchange<atomic_alpha_32<T> > > {
+class platform_atomic_integral<T, 4> :
+    public build_atomic_from_typical<build_exchange<atomic_alpha_32<T> > >
+{
 public:
    typedef build_atomic_from_typical<build_exchange<atomic_alpha_32<T> > > super;
    BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
@@ -328,7 +332,9 @@ public:
 };

 template<typename T>
-class platform_atomic_integral<T, 8> : public build_atomic_from_typical<build_exchange<atomic_alpha_64<T> > > {
+class platform_atomic_integral<T, 8> :
+    public build_atomic_from_typical<build_exchange<atomic_alpha_64<T> > >
+{
 public:
    typedef build_atomic_from_typical<build_exchange<atomic_alpha_64<T> > > super;
    BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
@@ -336,7 +342,9 @@ public:
 };

 template<typename T>
-class platform_atomic_integral<T, 1>: public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> {
+class platform_atomic_integral<T, 1> :
+    public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T>
+{
 public:
    typedef build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> super;
    BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
@@ -344,7 +352,9 @@ public:
 };

 template<typename T>
-class platform_atomic_integral<T, 2>: public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> {
+class platform_atomic_integral<T, 2> :
+    public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T>
+{
 public:
    typedef build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> super;
    BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
--- a/include/boost/atomic/detail/gcc-armv6plus.hpp
+++ b/include/boost/atomic/detail/gcc-armv6plus.hpp
@@ -192,13 +192,14 @@ atomic_signal_fence(memory_order)
    __asm__ __volatile__ ("" ::: "memory");
 }

-class atomic_flag {
+class atomic_flag
+{
 private:
    atomic_flag(const atomic_flag &) /* = delete */ ;
    atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
    uint32_t v_;
 public:
-    atomic_flag(void) BOOST_NOEXCEPT: v_(false) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}

    void
    clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
--- a/include/boost/atomic/detail/gcc-cas.hpp
+++ b/include/boost/atomic/detail/gcc-cas.hpp
@@ -102,13 +102,14 @@ platform_cmpxchg32_strong(T & expected, T desired, volatile T * ptr)
    return success;
 }

-class atomic_flag {
+class atomic_flag
+{
 private:
    atomic_flag(const atomic_flag &) /* = delete */ ;
    atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
    uint32_t v_;
 public:
-    atomic_flag(void) BOOST_NOEXCEPT: v_(false) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}

    void
    clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
--- a/include/boost/atomic/detail/gcc-ppc.hpp
+++ b/include/boost/atomic/detail/gcc-ppc.hpp
@@ -105,13 +105,14 @@ ppc_fence_after_store(memory_order order)
 }
 }

-class atomic_flag {
+class atomic_flag
+{
 private:
    atomic_flag(const atomic_flag &) /* = delete */ ;
    atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
    uint32_t v_;
 public:
-    atomic_flag(void) BOOST_NOEXCEPT: v_(false) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}

    void
    clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
@@ -196,13 +197,14 @@ namespace detail {
 /* integral types */

 template<typename T>
-class base_atomic<T, int, 1, true> {
+class base_atomic<T, int, 1, true>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef int32_t storage_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -416,13 +418,14 @@ private:
 };

 template<typename T>
-class base_atomic<T, int, 1, false> {
+class base_atomic<T, int, 1, false>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -637,13 +640,14 @@ private:
 };

 template<typename T>
-class base_atomic<T, int, 2, true> {
+class base_atomic<T, int, 2, true>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef int32_t storage_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -858,13 +862,14 @@ private:
 };

 template<typename T>
-class base_atomic<T, int, 2, false> {
+class base_atomic<T, int, 2, false>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -1079,12 +1084,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -1295,12 +1301,13 @@ private:
 #if defined(__powerpc64__)

 template<typename T, bool Sign>
-class base_atomic<T, int, 8, Sign> {
+class base_atomic<T, int, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -1515,11 +1522,12 @@ private:
 #if !defined(__powerpc64__)

 template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef void * value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -1643,12 +1651,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T * value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -1812,11 +1821,12 @@ private:
 #else

 template<bool Sign>
-class base_atomic<void *, void *, 8, Sign> {
+class base_atomic<void *, void *, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef void * value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -1940,12 +1950,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T *, void *, 8, Sign> {
+class base_atomic<T *, void *, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef T * value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -2111,14 +2122,16 @@ private:
 /* generic */

 template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
    base_atomic(void) {}

    void
@@ -2260,14 +2273,16 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }

    base_atomic(void) {}

@@ -2410,14 +2425,16 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }

    base_atomic(void) {}

@@ -2562,14 +2579,16 @@ private:
 #if defined(__powerpc64__)

 template<typename T, bool Sign>
-class base_atomic<T, void, 8, Sign> {
+class base_atomic<T, void, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint64_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }

    base_atomic(void) {}

--- a/include/boost/atomic/detail/gcc-sparcv9.hpp
+++ b/include/boost/atomic/detail/gcc-sparcv9.hpp
@@ -83,13 +83,14 @@ platform_fence_after_load(memory_order order)
 }
 }

-class atomic_flag {
+class atomic_flag
+{
 private:
    atomic_flag(const atomic_flag &) /* = delete */ ;
    atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
    uint32_t v_;
 public:
-    atomic_flag(void) : v_(false) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}

    void
    clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
@@ -100,7 +101,7 @@ public:
    }

    bool
-    test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT BOOST_NOEXCEPT
+    test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
    {
        atomics::detail::platform_fence_before(order);
        uint32_t tmp = 1;
@@ -174,13 +175,14 @@ namespace detail {
 /* integral types */

 template<typename T>
-class base_atomic<T, int, 1, true> {
+class base_atomic<T, int, 1, true>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
    typedef int32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -192,7 +194,7 @@ public:
    }

    value_type
-    load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
+    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
    {
        value_type v = const_cast<const volatile storage_type &>(v_);
        platform_fence_after_load(order);
@@ -296,13 +298,14 @@ private:
 };

 template<typename T>
-class base_atomic<T, int, 1, false> {
+class base_atomic<T, int, 1, false>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -314,7 +317,7 @@ public:
    }

    value_type
-    load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
+    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
    {
        value_type v = const_cast<const volatile storage_type &>(v_);
        platform_fence_after_load(order);
@@ -418,13 +421,14 @@ private:
 };

 template<typename T>
-class base_atomic<T, int, 2, true> {
+class base_atomic<T, int, 2, true>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
    typedef int32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -436,7 +440,7 @@ public:
    }

    value_type
-    load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
+    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
    {
        value_type v = const_cast<const volatile storage_type &>(v_);
        platform_fence_after_load(order);
@@ -540,13 +544,14 @@ private:
 };

 template<typename T>
-class base_atomic<T, int, 2, false> {
+class base_atomic<T, int, 2, false>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -558,7 +563,7 @@ public:
    }

    value_type
-    load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
+    load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
    {
        value_type v = const_cast<const volatile storage_type &>(v_);
        platform_fence_after_load(order);
@@ -662,12 +667,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -783,11 +789,12 @@ private:
 /* pointer types */

 template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef void * value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -858,12 +865,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T * value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) : v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -955,12 +963,13 @@ private:
 /* generic types */

 template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) : v_(0)
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
    {
        memcpy(&v_, &v, sizeof(value_type));
    }
@@ -1044,12 +1053,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) : v_(0)
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
    {
        memcpy(&v_, &v, sizeof(value_type));
    }
@@ -1133,12 +1143,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) : v_(0)
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
    {
        memcpy(&v_, &v, sizeof(value_type));
    }
--- a/include/boost/atomic/detail/gcc-x86.hpp
+++ b/include/boost/atomic/detail/gcc-x86.hpp
@@ -151,7 +151,7 @@ private:
    atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
    uint32_t v_;
 public:
-    atomic_flag(void) : v_(0) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}

    bool
    test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
@@ -246,12 +246,13 @@ namespace atomics {
 namespace detail {

 template<typename T, bool Sign>
-class base_atomic<T, int, 1, Sign> {
+class base_atomic<T, int, 1, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -383,12 +384,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, int, 2, Sign> {
+class base_atomic<T, int, 2, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -520,12 +522,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -658,12 +661,13 @@ private:

 #if defined(__x86_64__)
 template<typename T, bool Sign>
-class base_atomic<T, int, 8, Sign> {
+class base_atomic<T, int, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -801,11 +805,12 @@ private:
 #if !defined(__x86_64__)

 template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef void * value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -878,12 +883,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T * value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -985,11 +991,12 @@ private:
 #else

 template<bool Sign>
-class base_atomic<void *, void *, 8, Sign> {
+class base_atomic<void *, void *, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef void * value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -1062,12 +1069,13 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T *, void *, 8, Sign> {
+class base_atomic<T *, void *, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef T * value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
    base_atomic(void) {}

    void
@@ -1169,13 +1177,14 @@ private:
 #endif

 template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint8_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<uint8_t*>(&v))
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT :
+        v_(reinterpret_cast<storage_type const&>(v))
    {}
    base_atomic(void) {}

@@ -1268,13 +1277,14 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint16_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<uint16_t*>(&v))
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT :
+        v_(reinterpret_cast<storage_type const&>(v))
    {}
    base_atomic(void) {}

@@ -1367,14 +1377,16 @@ private:
 };

 template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint32_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT
-        : v_(*reinterpret_cast<uint32_t*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
    base_atomic(void) {}

    void
@@ -1467,14 +1479,16 @@ private:

 #if defined(__x86_64__)
 template<typename T, bool Sign>
-class base_atomic<T, void, 8, Sign> {
+class base_atomic<T, void, 8, Sign>
+{
    typedef base_atomic this_type;
    typedef T value_type;
    typedef uint64_t storage_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&tmp, &v, sizeof(value_type));
+    }
    base_atomic(void) {}

    void
--- a/include/boost/atomic/detail/generic-cas.hpp
+++ b/include/boost/atomic/detail/generic-cas.hpp
@@ -118,7 +118,8 @@ namespace detail {

 #ifdef BOOST_ATOMIC_HAVE_CAS32
 template<typename T>
-class atomic_generic_cas32 {
+class atomic_generic_cas32
+{
 private:
    typedef atomic_generic_cas32 this_type;
 public:
@@ -168,7 +169,9 @@ private:
 };

 template<typename T>
-class platform_atomic_integral<T, 4> : public build_atomic_from_exchange<atomic_generic_cas32<T> > {
+class platform_atomic_integral<T, 4> :
+    public build_atomic_from_exchange<atomic_generic_cas32<T> >
+{
 public:
    typedef build_atomic_from_exchange<atomic_generic_cas32<T> > super;
    explicit platform_atomic_integral(T v) : super(v) {}
@@ -176,7 +179,9 @@ public:
 };

 template<typename T>
-class platform_atomic_integral<T, 1>: public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> {
+class platform_atomic_integral<T, 1> :
+   public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T>
+{
 public:
    typedef build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> super;

@@ -185,7 +190,9 @@ public:
 };

 template<typename T>
-class platform_atomic_integral<T, 2>: public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> {
+class platform_atomic_integral<T, 2> :
+    public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T>
+{
 public:
    typedef build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> super;

--- a/include/boost/atomic/detail/interlocked.hpp
+++ b/include/boost/atomic/detail/interlocked.hpp
@@ -2,7 +2,7 @@
 #define BOOST_ATOMIC_DETAIL_INTERLOCKED_HPP

 //  Copyright (c) 2009 Helge Bahmann
-//  Copyright (c) 2012 Andrey Semashev
+//  Copyright (c) 2012, 2013 Andrey Semashev
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -14,7 +14,7 @@
 #pragma once
 #endif

-#if defined(_WIN32_WCE)
+#if defined(_WIN32_WCE) || (defined(_MSC_VER) && _MSC_VER < 1400)

 #include <boost/detail/interlocked.hpp>

@@ -25,30 +25,24 @@
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) BOOST_INTERLOCKED_EXCHANGE_POINTER(dest, newval)
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_INTERLOCKED_EXCHANGE_ADD((long*)(dest), byte_offset))

-#elif defined(_MSC_VER)
+#elif defined(_MSC_VER) && _MSC_VER >= 1400

 #include <intrin.h>

 #pragma intrinsic(_InterlockedCompareExchange)
 #pragma intrinsic(_InterlockedExchangeAdd)
 #pragma intrinsic(_InterlockedExchange)
-
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend))
-#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval))
-
-#if _MSC_VER >= 1400
-
 #pragma intrinsic(_InterlockedAnd)
 #pragma intrinsic(_InterlockedOr)
 #pragma intrinsic(_InterlockedXor)

+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend))
+#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval))
 #define BOOST_ATOMIC_INTERLOCKED_AND(dest, arg) _InterlockedAnd((long*)(dest), (long)(arg))
 #define BOOST_ATOMIC_INTERLOCKED_OR(dest, arg) _InterlockedOr((long*)(dest), (long)(arg))
 #define BOOST_ATOMIC_INTERLOCKED_XOR(dest, arg) _InterlockedXor((long*)(dest), (long)(arg))

-#endif // _MSC_VER >= 1400
-
 #if _MSC_VER >= 1600

 // MSVC 2010 and later provide intrinsics for 8 and 16 bit integers.
@@ -108,15 +102,15 @@
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) _InterlockedExchangePointer((void**)(dest), (void*)(newval))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64((long*)(dest), byte_offset))

-#else // defined(_M_AMD64)
+#else // defined(_M_AMD64) || defined(_M_IA64)

 #define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)_InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare)))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) ((void*)_InterlockedExchange((long*)(dest), (long)(newval)))
 #define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD((long*)(dest), byte_offset))

-#endif // defined(_M_AMD64)
+#endif // defined(_M_AMD64) || defined(_M_IA64)

-#else // defined(_MSC_VER)
+#else // defined(_MSC_VER) && _MSC_VER >= 1400

 #if defined(BOOST_USE_WINDOWS_H)

--- a/include/boost/atomic/detail/linux-arm.hpp
+++ b/include/boost/atomic/detail/linux-arm.hpp
@@ -133,13 +133,14 @@ atomic_signal_fence(memory_order)
    __asm__ __volatile__ ("" ::: "memory");
 }

-class atomic_flag {
+class atomic_flag
+{
 private:
    atomic_flag(const atomic_flag &) /* = delete */ ;
    atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
    uint32_t v_;
 public:
-    atomic_flag(void) BOOST_NOEXCEPT: v_(false) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}

    void
    clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
--- a/include/boost/atomic/detail/windows.hpp
+++ b/include/boost/atomic/detail/windows.hpp
@@ -3,7 +3,7 @@

 //  Copyright (c) 2009 Helge Bahmann
 //  Copyright (c) 2012 Andrey Semashev
-//  Copyright (c) 2013 Tim Blechmann
+//  Copyright (c) 2013 Tim Blechmann, Andrey Semashev
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -25,10 +25,6 @@
 #pragma warning(disable: 4100)
 #endif

-namespace boost {
-namespace atomics {
-namespace detail {
-
 #if defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_IX86))
 extern "C" void _mm_pause(void);
 #pragma intrinsic(_mm_pause)
@@ -43,6 +39,23 @@ extern "C" void _mm_mfence(void);
 #pragma intrinsic(_mm_mfence)
 #endif

+// Define compiler barriers
+#if defined(__INTEL_COMPILER)
+#define BOOST_ATOMIC_COMPILER_BARRIER __memory_barrier();
+#elif defined(_MSC_VER) && _MSC_VER >= 1310 && !defined(_WIN32_WCE)
+extern "C" void _ReadWriteBarrier(void);
+#pragma intrinsic(_ReadWriteBarrier)
+#define BOOST_ATOMIC_COMPILER_BARRIER() _ReadWriteBarrier()
+#endif
+
+#ifndef BOOST_ATOMIC_COMPILER_BARRIER
+#define BOOST_ATOMIC_COMPILER_BARRIER()
+#endif
+
+namespace boost {
+namespace atomics {
+namespace detail {
+
 BOOST_FORCEINLINE void hardware_full_fence(void)
 {
 #if defined(_MSC_VER) && (defined(_M_AMD64) || (defined(_M_IX86) && defined(_M_IX86_FP) && _M_IX86_FP >= 2))
@@ -58,41 +71,41 @@ BOOST_FORCEINLINE void hardware_full_fence(void)
 #if defined(_MSC_VER) && _MSC_VER >= 1310 && !defined(_WIN32_WCE)
 extern "C" void _ReadWriteBarrier();
 #pragma intrinsic(_ReadWriteBarrier)
-#define BOOST_ATOMIC_READ_WRITE_BARRIER() _ReadWriteBarrier()
+#define BOOST_ATOMIC_COMPILER_BARRIER() _ReadWriteBarrier()
 #endif

-#ifndef BOOST_ATOMIC_READ_WRITE_BARRIER
-#define BOOST_ATOMIC_READ_WRITE_BARRIER()
+#ifndef BOOST_ATOMIC_COMPILER_BARRIER
+#define BOOST_ATOMIC_COMPILER_BARRIER()
 #endif

 BOOST_FORCEINLINE void
 platform_fence_before(memory_order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
 }

 BOOST_FORCEINLINE void
 platform_fence_after(memory_order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
 }

 BOOST_FORCEINLINE void
 platform_fence_before_store(memory_order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
 }

 BOOST_FORCEINLINE void
 platform_fence_after_store(memory_order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
 }

 BOOST_FORCEINLINE void
 platform_fence_after_load(memory_order order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();

    // On x86 and x86_64 there is no need for a hardware barrier,
    // even if seq_cst memory order is requested, because all
@@ -113,7 +126,7 @@ platform_fence_after_load(memory_order order)
 BOOST_FORCEINLINE void
 atomic_thread_fence(memory_order order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
    if (order == memory_order_seq_cst)
        atomics::detail::hardware_full_fence();
 }
@@ -122,10 +135,10 @@ atomic_thread_fence(memory_order order)
 BOOST_FORCEINLINE void
 atomic_signal_fence(memory_order)
 {
-    BOOST_ATOMIC_READ_WRITE_BARRIER();
+    BOOST_ATOMIC_COMPILER_BARRIER();
 }

-#undef BOOST_ATOMIC_READ_WRITE_BARRIER
+#undef BOOST_ATOMIC_COMPILER_BARRIER

 class atomic_flag
 {
@@ -134,7 +147,7 @@ private:
    atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
    uint32_t v_;
 public:
-    atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
+    BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}

    bool
    test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
@@ -196,7 +209,7 @@ class base_atomic<T, int, 1, Sign>
 #endif
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
    base_atomic(void) {}

    void
@@ -382,7 +395,7 @@ class base_atomic<T, int, 2, Sign>
 #endif
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
    base_atomic(void) {}

    void
@@ -560,7 +573,7 @@ class base_atomic<T, int, 4, Sign>
    typedef value_type storage_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
    base_atomic(void) {}

    void
@@ -713,7 +726,7 @@ class base_atomic<T, int, 8, Sign>
    typedef value_type storage_type;
    typedef T difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
    base_atomic(void) {}

    void
@@ -867,7 +880,7 @@ class base_atomic<void*, void*, sizeof_pointer, Sign>
    typedef base_atomic this_type;
    typedef void* value_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
    base_atomic(void) {}

    void
@@ -939,7 +952,7 @@ class base_atomic<T*, void*, sizeof_pointer, Sign>
    typedef T* value_type;
    typedef ptrdiff_t difference_type;
 public:
-    BOOST_CONSTEXPR base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
+    BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
    base_atomic(void) {}

    void
@@ -1040,9 +1053,16 @@ class base_atomic<T, void, 1, Sign>
    typedef uint32_t storage_type;
 #endif
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(reinterpret_cast< storage_type const& >(v))
+    {
+    }
+#else
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
+#endif
    base_atomic(void) {}

    void
@@ -1144,9 +1164,16 @@ class base_atomic<T, void, 2, Sign>
    typedef uint32_t storage_type;
 #endif
 public:
-    BOOST_CONSTEXPR base_atomic(value_type const& v) BOOST_NOEXCEPT:
-        v_(*reinterpret_cast<storage_type*>(&v))
-    {}
+#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16
+    BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(reinterpret_cast< storage_type const& >(v))
+    {
+    }
+#else
+    explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
+    {
+        memcpy(&v_, &v, sizeof(value_type));
+    }
+#endif

    base_atomic(void) {}