atomic 注释22：爷模板类 _Atomic_storage＜T,size_t＞的孙子类 _Atomic_integral_facade＜T&＞这个特化版本及其成员函数的测试结果

原创已于 2024-12-26 22:06:03 修改 · 356 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#c++20 #STL 库

于 2024-12-26 06:34:12 首次发布

c++20 规范的 atomic 头文件的阅读注释专栏收录该内容

32 篇文章

订阅专栏

（61）孙子类 _Atomic_integral_facade《T&》的这个特化版本的源代码如下：

/*类的继承关系如下：
template <class _Ty, size_t >  
struct _Atomic_storage { _Ty _Storage{}; }; // 同时包含了数据类型与引用类型的两种情况

template <class _Ty>       
struct _Atomic_integral<_Ty, size_t> : _Atomic_storage<_Ty>

template <class _Ty>
struct _Atomic_integral_facade<_Ty&> : _Atomic_integral<_Ty&>
*/
// 至此,整数原子性的支持：加减法、*(-1)取反、a++、++a、a--、--a 以及按位的 与and、或or、异或xor 运算;
// 以及复合运算符 : +=、-=、&=、|=、^= 。
template <class _Ty>  
struct _Atomic_integral_facade<_Ty&> : _Atomic_integral<_Ty&> 
{   
    using _Base           = _Atomic_integral<_Ty&>;
    using difference_type = _Ty;

    using _Base::_Base;

    static _Ty _Negate(const _Ty _Value) noexcept // 对形参值乘以 -1 再返回
    { 
        return static_cast<_Ty>(0U - static_cast<make_unsigned_t<_Ty>>(_Value));
    }

    _Ty fetch_add(const _Ty _Operand) const noexcept  // 返回值是原子量中的旧值
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand);
    }

    _Ty fetch_add(const _Ty _Operand, const memory_order _Order) const noexcept 
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand, _Order);
    }

    _Ty fetch_sub(const _Ty _Operand) const noexcept // 依然是返回原子量中的旧值
    {
        return fetch_add(_Negate(_Operand));
    }

    _Ty fetch_sub(const _Ty _Operand, const memory_order _Order) const noexcept
    {
        return fetch_add(_Negate(_Operand), _Order);
    }

    _Ty operator++(int) const noexcept               // a++ 输出原子量中的原值
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++(0);
    }

    _Ty operator++() const noexcept                  // ++a 输出原子量中的新值
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++();
    }

    _Ty operator--(int) const noexcept               // a-- 输出原子量中的原值
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--(0);
    }

    _Ty operator--() const noexcept                  // --a 输出原子量中的新值
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--();
    }

    _Ty operator+=(const _Ty _Operand) const noexcept  // 旧值 + 增量后的结果作为返回值
    {
        return static_cast<_Ty>( fetch_add(_Operand) + _Operand );
    }

    _Ty operator-=(const _Ty _Operand) const noexcept  // 旧值 - 形参后的结果作为返回值
    {
        return static_cast<_Ty>(fetch_sub(_Operand) - _Operand);
    }

    _Ty fetch_and(const _Ty _Operand) const noexcept  // 与，返回原子量中的旧值
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand);
    }

    _Ty fetch_and(const _Ty _Operand, const memory_order _Order) const noexcept 
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand, _Order);
    }

    _Ty fetch_or(const _Ty _Operand) const noexcept // 或，返回原子量中的旧值
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand);
    }

    _Ty fetch_or(const _Ty _Operand, const memory_order _Order) const noexcept 
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand, _Order);
    }

    _Ty fetch_xor(const _Ty _Operand) const noexcept // 异或，返回原子量中的旧值
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand);
    }

    _Ty fetch_xor(const _Ty _Operand, const memory_order _Order) const noexcept 
    {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand, _Order);
    }

    _Ty operator&=(const _Ty _Operand) const noexcept  // 返回与运算的最终结果
    {
        return static_cast<_Ty>(fetch_and(_Operand) & _Operand);
    }

    _Ty operator|=(const _Ty _Operand) const noexcept  // 返回或运算的最终结果
    {
        return static_cast<_Ty>(fetch_or(_Operand) | _Operand);
    }

    _Ty operator^=(const _Ty _Operand) const noexcept // 返回 异或 运算的最终结果
    {
        return static_cast<_Ty>(fetch_xor(_Operand) ^ _Operand);
    }
};