C++如何使用std::atomic实现引用计数

std::atomic

std::atomic

std::atomic

std::shared_ptr

std::atomic<long>

std::atomic<int>

#include <atomic>
#include <iostream>
#include <utility> // For std::exchange

template<typename T>
class AtomicSharedPtr {
private:
    T* data_ptr;
    std::atomic<long>* ref_count; // 使用原子类型管理引用计数

    void decrement_and_check() {
        if (ref_count && ref_count->fetch_sub(1, std::memory_order_acq_rel) == 1) {
            // 当引用计数减到1（即即将变为0）时，说明当前是最后一个引用
            delete data_ptr;
            delete ref_count;
            data_ptr = nullptr;
            ref_count = nullptr;
        }
    }

public:
    // 默认构造函数
    AtomicSharedPtr() : data_ptr(nullptr), ref_count(nullptr) {}

    // 接受裸指针的构造函数
    explicit AtomicSharedPtr(T* ptr) : data_ptr(ptr) {
        if (data_ptr) {
            ref_count = new std::atomic<long>(1); // 初始化计数为1
        } else {
            ref_count = nullptr;
        }
    }

    // 拷贝构造函数
    AtomicSharedPtr(const AtomicSharedPtr& other) noexcept :
        data_ptr(other.data_ptr), ref_count(other.ref_count) {
        if (ref_count) {
            ref_count->fetch_add(1, std::memory_order_relaxed); // 增加引用计数
        }
    }

    // 移动构造函数
    AtomicSharedPtr(AtomicSharedPtr&& other) noexcept :
        data_ptr(std::exchange(other.data_ptr, nullptr)),
        ref_count(std::exchange(other.ref_count, nullptr)) {}

    // 拷贝赋值运算符
    AtomicSharedPtr& operator=(const AtomicSharedPtr& other) noexcept {
        if (this != &other) { // 避免自我赋值
            decrement_and_check(); // 先释放当前持有的资源
            data_ptr = other.data_ptr;
            ref_count = other.ref_count;
            if (ref_count) {
                ref_count->fetch_add(1, std::memory_order_relaxed); // 增加新资源的引用计数
            }
        }
        return *this;
    }

    // 移动赋值运算符
    AtomicSharedPtr& operator=(AtomicSharedPtr&& other) noexcept {
        if (this != &other) { // 避免自我赋值
            decrement_and_check(); // 释放当前资源
            data_ptr = std::exchange(other.data_ptr, nullptr);
            ref_count = std::exchange(other.ref_count, nullptr);
        }
        return *this;
    }

    // 析构函数
    ~AtomicSharedPtr() {
        decrement_and_check();
    }

    // 提供访问底层数据的方法
    T* get() const noexcept { return data_ptr; }
    T& operator*() const noexcept { return *data_ptr; }
    T* operator->() const noexcept { return data_ptr; }

    // 获取当前引用计数（仅供调试或特殊场景，非线程安全读取）
    long use_count() const noexcept {
        return ref_count ? ref_count->load(std::memory_order_relaxed) : 0;
    }

    // 检查是否为空
    explicit operator bool() const noexcept {
        return data_ptr != nullptr;
    }
};

// 示例用法
struct MyData {
    int value;
    MyData(int v) : value(v) { std::cout << "MyData(" << value << ") constructed.\n"; }
    ~MyData() { std::cout << "MyData(" << value << ") destructed.\n"; }
};

int main() {
    AtomicSharedPtr<MyData> ptr1(new MyData(100));
    std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n"; // 1

    {
        AtomicSharedPtr<MyData> ptr2 = ptr1; // 拷贝构造
        std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n"; // 2
        std::cout << "ptr2 use_count: " << ptr2.use_count() << "\n"; // 2

        AtomicSharedPtr<MyData> ptr3(new MyData(200));
        ptr3 = ptr1; // 拷贝赋值
        std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n"; // 3
        std::cout << "ptr3 use_count: " << ptr3.use_count() << "\n"; // 3

        // ptr2, ptr3 离开作用域，引用计数减少
    } // ptr2, ptr3 析构，计数变为1

    std::cout << "ptr1 use_count after scope: " << ptr1.use_count() << "\n"; // 1

    AtomicSharedPtr<MyData> ptr4;
    ptr4 = std::move(ptr1); // 移动赋值
    std::cout << "ptr4 use_count: " << ptr4.use_count() << "\n"; // 1
    std::cout << "ptr1 is now empty: " << (ptr1 ? "false" : "true") << "\n"; // true

    // ptr4 离开作用域，MyData(100) 被析构
    return 0;
}

fetch_add

fetch_sub

std::atomic

fetch_sub

delete data_ptr; delete ref_count;

int

int ref_count;

ref_count++;

ref_count--;

++

ref_count

std::atomic

LOCK CMPXCHG

std::atomic

std::shared_ptr

relaxed

acq_rel

seq_cst

std::shared_ptr