寻求需显式调用load/store的std::atomic替代变体

C++标准库并没有提供这种要求必须显式调用load()/store()/CAS的原子类型变体，不过你可以自己封装一个轻量级的包装类，禁用std::atomic的隐式转换和赋值操作，只暴露显式的原子操作接口。

以下是一个简单的实现示例：

#include <atomic>

template<typename T>
class ExplicitAtomic {
private:
    std::atomic<T> impl_;

    // 禁用隐式转换到value_type
    operator T() const = delete;
    // 禁用直接赋值
    ExplicitAtomic& operator=(const T&) = delete;
    // 禁用拷贝构造和拷贝赋值
    ExplicitAtomic(const ExplicitAtomic&) = delete;
    ExplicitAtomic& operator=(const ExplicitAtomic&) = delete;

public:
    // 允许默认构造、移动构造（可选）
    ExplicitAtomic() = default;
    explicit ExplicitAtomic(T val) : impl_(val) {}
    ExplicitAtomic(ExplicitAtomic&&) = default;
    ExplicitAtomic& operator=(ExplicitAtomic&&) = default;

    // 显式原子操作接口
    T load(std::memory_order order = std::memory_order_seq_cst) const noexcept {
        return impl_.load(order);
    }

    void store(T val, std::memory_order order = std::memory_order_seq_cst) noexcept {
        impl_.store(val, order);
    }

    bool compare_exchange_weak(T& expected, T desired,
                               std::memory_order success = std::memory_order_seq_cst,
                               std::memory_order failure = std::memory_order_seq_cst) noexcept {
        return impl_.compare_exchange_weak(expected, desired, success, failure);
    }

    bool compare_exchange_strong(T& expected, T desired,
                                 std::memory_order success = std::memory_order_seq_cst,
                                 std::memory_order failure = std::memory_order_seq_cst) noexcept {
        return impl_.compare_exchange_strong(expected, desired, success, failure);
    }

    // 按需添加其他显式原子操作，比如fetch_add、fetch_sub等
    T fetch_add(T arg, std::memory_order order = std::memory_order_seq_cst) noexcept {
        return impl_.fetch_add(arg, order);
    }
};

关键设计点说明： #

• 把内部的std::atomic<T>作为私有成员，对外隐藏其隐式操作
• 显式删除operator T()和operator=(const T&)，彻底禁止隐式转换和直接赋值
• 只对外暴露load()、store()、compare_exchange_*等显式原子操作，保留内存序参数的默认值，兼顾灵活性和安全性
• 可根据需求扩展其他原子操作（比如fetch_add），但所有操作都必须通过显式函数调用触发

使用示例： #

// 声明显式原子变量
ExplicitAtomic<int> counter(0);

// 必须显式调用store写入
counter.store(1);

// 必须显式调用load读取
int current = counter.load();

// CAS操作也必须显式调用
int expected = 1;
while (!counter.compare_exchange_weak(expected, 2)) {
    // 重试逻辑
}

这种封装方式完全满足需求：所有原子访问操作都必须显式调用指定函数，不会出现无提示的隐式原子操作接管现有代码的情况，同时底层复用标准库的std::atomic实现，保证了原子操作的正确性和性能。

内容的提问来源于stack exchange，提问作者Simon Richter