std::shared_ptr 的一个简单实现

参考 C++ 引用计数_vincent-xia的博客-CSDN博客，完善了一些代码，写了一个push-pop程序测试

1.refCount.h

#pragma once
#include 
#include 
#include 
#include 

using namespace std;

template
class Referenced
{
public:
	//初始化这个类，引用计数设为1，并且将p指向传入的地址
	Referenced(T* pi)
	{
		refCount = 1;
		p = pi;
	}

	//引用计数加1
	int ref()
	{
		return ++refCount;
	}

	//引用计数减1
	int unref()
	{
		return --refCount;
	}

	//返回引用计数
	int count()
	{
		return refCount;
	}

	//析构函数，释放掉内存
	~Referenced()
	{
		//cout << "delete referenced" << endl;
		delete p;
		p = nullptr;
	}
public:
	std::atomic refCount = 0;//引用计数，表示有多少个变量引用这块内存
	T* p = nullptr;//真实的指针
};

//对指针进行管理的类，持有一个Referenced类的指针ptr，根据ptr中的
//引用计数来判断是否调用delete来删除掉这个指针ptr

template>
class Ref_ptr
{
public:

	Ref_ptr() {
	
	}

	//使用int*指针初始化ptr，注意必须要放在初始化列表中
	Ref_ptr(T* i) :ptr(new Referenced(i))
	{
		//std::cout << "使用int*指针初始化ptr\n";
	}

	//拷贝构造函数，又有一个变量指向了这块内存
	Ref_ptr(const Ref_ptr& rhs)
	{
		ptr = rhs.ptr;//将右操作数的引用计数对象赋值给左操作数
		ptr->ref();//将它们的应用计数加1
	}

	//赋值操作符，右操作数的引用计数要减1，左操作数的引用计数要加1
	Ref_ptr& operator=(const Ref_ptr& rhs)
	{
		if (&rhs == this)
			return *this;
		if (ptr && ptr->unref() == 0)//赋值操作符，首先将当前类的引用计数减1
		{
			//cout << "delete Ref_ptr" << endl;
			delete ptr;
		}
		ptr = rhs.ptr;//将右操作数的引用计数赋值给当前对象
		ptr->ref();//引用计数加1
		return *this;
	}

	//析构函数，引用计数要减1，如果减为0，删除这块内存
	~Ref_ptr()
	{
		if (!ptr)
			return;
		if (ptr->unref() == 0)
		{
			//cout << "delete Ref_ptr" << endl;
			delete ptr;
			ptr = nullptr;
		}
	}

	using pointer = typename _Get_deleter_pointer_type>::type;
	pointer operator->() const noexcept {
		if(ptr)
			return ptr->p;
	}

	//返回引用计数
	int count()
	{
		if(ptr)
			return ptr->count();
	}

private:
	Referenced* ptr;
};

2.test.cpp

#include "refCount.h"
#include 
Ref_ptr r;
Ref_ptr r1;
std::mutex m;

#include
Ref_ptr print(Ref_ptr str) {
    std::cout << str->size() << std::endl;
    return str;
}

std::queue> strqueue;

void gFunc1() {

    while (1) {
        std::string* str = new std::string("666888999999999999999999999999999999999999999999999999");
        m.lock();
        Ref_ptr r = str;
        strqueue.push(r);
        m.unlock();
    }
}

void gFunc2() {
    while (1) {
        m.lock();
        Ref_ptr str;
        if (!strqueue.empty()) {
            str = strqueue.front();
            r = str;
            strqueue.pop();
            print(str);
        }
        m.unlock();
    }
}

int main()
{
    std::thread th1(gFunc1);
    std::thread th2(gFunc2);
    system("pause");
    return 0;
}

测试过程中内存占用稳定在 1.5MB，说明申请的内存一直在释放，在push-pop过程中做到了内存的自动管理。

 TODO:参照 std::shared_ptr 做的更完善一点，更深入理解std::shared_ptr。