C++共享指针的实现基于map--解决两个共享指针指向同一指针时引用计数不递增问题

希望我们不仅把编程当成一份工作，更要将其当成一份热爱！！！

                                                                                                                                  -----潜意识中有个想成为一名厉害的程序员的梦

前言

本文章只是我突发奇想，写着玩玩，无实际意义哈。

共享指针指向同一指针的计数错误

对于下面这个例子，当两个共享指针指向同一指针时，其引用计数不是我们想象的2而是1，且会造成重复析构 报出异常。（实际上是：这样写法是错误的，哈哈）

//输出结果通过注释的方式写在了代码后面：
int main() {
    int* temp = new int();
    std::shared_ptr<int> sp1(temp);
    std::shared_ptr<int> sp2(temp);

    std::cout << "sp1 use count: " << sp1.use_count() << std::endl; // sp1 use count: 1
    std::cout << "sp3 use count: " << sp2.use_count() << std::endl; // sp1 use count: 1
    return 0; // 异常
}

主要原因在于共享指针的引用计数，基于一个类成员变量 ：int* ref_count; // 引用计数器

这样子，对于每个共享指针对象而言，其统计被指向指针的引用计数是独立的，像上述代码中：sql1和sq2在构造时，各自有各自的ref_count,且都是1。

template <typename T>
class SharedPtr {
private:
    T* ptr;            // 原始指针
    int* ref_count;    // 引用计数器
  public:
    // 默认构造函数
    explicit SharedPtr(T* p = nullptr) : ptr(p), ref_count(new int(1)) {}
...
}

基于map的实现

针对以上问题，我基于map进行共享指针的实现。基于一个静态的map，这样就会使得各个共享指针对象使用同一个map统计被指向指针的引用计数，保证其统计的正确。

实现及其测试代码如下：

#include <iostream>
#include <unordered_map>
#include <memory>

template <typename T>
class SharedPtr {
private:
    T* _ptr;
    static std::unordered_map<void*, unsigned int> ref_count;//全局的引用计数。
public:
    // 构造函数
    SharedPtr(T* ptr) :_ptr(ptr)
    {
        ref_count[_ptr]++;
    }

    // 拷贝构造函数
    SharedPtr(SharedPtr<T>& temp)
    {
        _ptr = temp.get_ptr();
        ref_count[_ptr]++;
    }
    // 拷贝赋值运算符
    SharedPtr<T>& operator==(SharedPtr<T>& temp)
    {
        _ptr = temp.get_ptr();
        ref_count[_ptr]++;
    }

    // 解引用运算符
    T operator*()
    {
        return *_ptr;
    }

    // 指针访问运算符
    T* operator->()
    {
        return _ptr;
    }

    // 获取原始指针
    T* get_ptr()
    {
        return _ptr;
    }

    // 返回当前引用计数
    unsigned int get_count()
    {
        return ref_count[_ptr];
    }

    // 析构函数
    ~SharedPtr() {
        if (ref_count[_ptr]==1)
        {
            delete _ptr;
        }
        else
        {
            ref_count[_ptr]--;
        }
    }
};
// 静态成员变量初始化
template <typename T>
std::unordered_map<void*, unsigned int> SharedPtr<T>::ref_count;

// 示例类
class Test {
public:
    Test() {
        std::cout << "Test object created\n";
    }
    ~Test() {
        std::cout << "Test object destroyed\n";
    }
    void say_hello() {
        std::cout << "Hello, world!\n";
    }
};


int main() {
    Test* temp = new Test();
    SharedPtr<Test> sp3(temp);

    SharedPtr<Test> sp1(temp); // Test object created
    {
        SharedPtr<Test> sp3 = sp1;
        std::cout << "sp1 use count: " << sp1.get_count() << std::endl; // sp1 use count: 3
        sp3->say_hello(); // Hello, world!
    }
    std::cout << "sp1 use count: " << sp1.get_count() << std::endl; // sp1 use count: 2
    std::cout << "sp3 use count: " << sp3.get_count() << std::endl; // sp3 use count: 2
    return 0; // Test object destroyed
}