atomic 注释19：特化版本 _Atomic_integral＜T , 2＞，源代码纠错，类 _Atomic_integral＜T , 4＞，类 _Atomic_integral＜T , 8＞

（53）特化版本 _Atomic_integral《T，2》，处理 short 类型的数据：

// 整数都原子性的支持：加法、a++、++a、a--、--a 以及按位的 与and、或or、异或xor 运算。
template <class _Ty>                        // atomic integral operations using 2-byte intrinsics
struct _Atomic_integral<_Ty, 2> : _Atomic_storage<_Ty>  // 使用内部函数对 2 字节的整数进行原子操作
{ 
    using _Base = _Atomic_storage<_Ty>;
    using typename _Base::_TVal;

    using _Base::_Base;

    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept 
    {
        short _Result;

        // 该函数原子地增加形参 1 的值，但返回值是形参 1 的旧值。
        _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd16, 
            _Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));

        return static_cast<_TVal>(_Result);
    }
/*
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
    _Check_memory_order(_Order);                                   \
    _Result = _Intrinsic(__VA_ARGS__)
*/
    _TVal operator ++ (int) noexcept   // a++  这里应该已经有对应的汇编指令了 inc 
    {
        unsigned short _After = static_cast<unsigned short>(  // 此函数返回变量增加后的值
            _InterlockedIncrement16(_Atomic_address_as<short>(this->_Storage))   );

        --_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator++() noexcept        // ++a
    {
        return static_cast<_TVal>(_InterlockedIncrement16(_Atomic_address_as<short>(this->_Storage)));
    }

    _TVal operator--(int) noexcept     // a--
    {
        unsigned short _After = static_cast<unsigned short>( // 此函数返回变量递减后的值
            _InterlockedDecrement16(_Atomic_address_as<short>(this->_Storage))    );

        ++_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator--() noexcept        // --a
    {
        return static_cast<_TVal>(_InterlockedDecrement16(_Atomic_address_as<short>(this->_Storage)));
    }

    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept 
    {
        short _Result;

        // 该函数原子性的对形参1 进行按位与操作，返回的是形参1 的旧值。
        _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd16, 
            _Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));

        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept 
    {
        short _Result;

        // 该函数原子性的完成对形参1 的或操作，但返回形参 1 的旧值。
        _ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedOr16, 
            _Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));

        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept 
    {
        short _Result;

        // 此函数原子性的完成对形参1 的异或操作，返回的是形参 1 的旧值。
        _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor16, 
            _Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));

        return static_cast<_TVal>(_Result);
    }

};

++ 给出对其成员函数返回值的测试，依然多是返回原子量的旧值：

（54） 源代码纠错，如图，源代码不报错，估计又是条件编译，又是类型推断，导致编译器不再报错。但其父类中并没有类型 A 的定义，我们可以测试一下：：

++ 测试：

（55） 特化版本 _Atomic_integral《T，4》 ，本特化版本优化处理 4 字节的整型数据：

// 整数都原子性的支持：加法、a++、++a、a--、--a 以及按位的 与and、或or、异或xor 运算。
template <class _Ty>       // atomic integral operations using 4-byte intrinsics
struct _Atomic_integral<_Ty, 4> : _Atomic_storage<_Ty> // 使用内部函数对 4 字节的整数进行原子操作
{
    using _Base = _Atomic_storage<_Ty>;
    using typename _Base::_TVal;

    using _Base::_Base;

    // 该函数原子地增加形参 1 的值，但返回值是形参 1 的旧值。
    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept  
    {
        long _Result;

        _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd,
            _Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));

        return static_cast<_TVal>(_Result);
    }
/*
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
    _Check_memory_order(_Order);                                   \
    _Result = _Intrinsic(__VA_ARGS__)
*/
    _TVal operator ++ (int) noexcept  // atomic ++ 
    {
        unsigned long _After = static_cast<unsigned long>( // 此函数返回变量增加后的值
            _InterlockedIncrement(_Atomic_address_as<long>(this->_Storage))  );

        --_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator ++ () noexcept     // ++ atomic
    {
        return static_cast<_TVal>(_InterlockedIncrement(_Atomic_address_as<long>(this->_Storage)));
    }

    _TVal operator--(int) noexcept  // atomic --
    {
        unsigned long _After = static_cast<unsigned long>( // 此函数返回变量递减后的值
            _InterlockedDecrement(_Atomic_address_as<long>(this->_Storage)));

        ++_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator--() noexcept     // -- atomic
    {
        return static_cast<_TVal>(_InterlockedDecrement(_Atomic_address_as<long>(this->_Storage)));
    }

    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept 
    {
        long _Result;

        // 该函数原子性的对形参1 进行按位与操作，返回的是形参1 的旧值。
        _ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedAnd, 
            _Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));

        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept  
    {
        long _Result;

        // 该函数原子性的完成对形参1 的或操作，但返回形参 1 的旧值。
        _ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedOr,
            _Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));

        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept 
    {
        long _Result;

        // 此函数原子性的完成对形参1 的异或操作，返回的是形参 1 的旧值。
        _ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedXor, 
            _Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));

        return static_cast<_TVal>(_Result);
    }

};

++ 给出其成员函数的返回值的测试：

（56）特化版本 _Atomic_integral《T， 8》 ， 此版本的目的是对 8 字节的长整型数据的原子操作，进行优化，源码如下：

// 整数都原子性的支持：加法、a++、++a、a--、--a 以及按位的 与and、或or、异或xor 运算。
template <class _Ty>         // atomic integral operations using 8-byte intrinsics
struct _Atomic_integral<_Ty, 8> : _Atomic_storage<_Ty> // 使用内部函数对 8 字节的整数进行原子操作
{
    using _Base = _Atomic_storage<_Ty>;
    using typename _Base::_TVal;

    using _Base::_Base;

    // 该函数原子地增加形参 1 的值，但返回值是形参 1 的旧值。
    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept 
    {
        long long _Result;

        _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd64,
            _Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));

        return static_cast<_TVal>(_Result);
    }
/*
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
    _Check_memory_order(_Order);                                   \
    _Result = _Intrinsic(__VA_ARGS__)
*/
    _TVal operator ++ (int) noexcept   // a++
    {
        unsigned long long _After = static_cast<unsigned long long>( // 此函数返回变量增加后的值
            _InterlockedIncrement64(_Atomic_address_as<long long>(this->_Storage)));

        --_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator ++ () noexcept      // ++a
    {
        return static_cast<_TVal>(_InterlockedIncrement64(_Atomic_address_as<long long>(this->_Storage)));
    }

    _TVal operator -- (int) noexcept   // a--
    {
        unsigned long long _After = static_cast<unsigned long long>( // 此函数返回变量递减后的值
            _InterlockedDecrement64(_Atomic_address_as<long long>(this->_Storage)));

        ++_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator -- () noexcept      // --a
    {
        return static_cast<_TVal>(_InterlockedDecrement64(_Atomic_address_as<long long>(this->_Storage)));
    }

    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept 
    {
        long long _Result;

        // 该函数原子性的对形参1 进行按位与操作，返回的是形参1 的旧值。
        _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd64, 
            _Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));

        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept 
    {
        long long _Result;

        // 该函数原子性的完成对形参1 的或操作，但返回形参 1 的旧值。
        _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedOr64, 
            _Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));

        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept 
    {
        long long _Result;

        // 此函数原子性的完成对形参1 的异或操作，返回的是形参 1 的旧值。
        _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor64, 
            _Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));

        return static_cast<_TVal>(_Result);
    }

};

++ 测试：

（57）

谢谢