c++智能指针-shared_ptr的尴尬-诞生weak_ptr

#include <iostream>
#include <memory>
#include <cassert>

//auto ptr
//shared_ptr
//unique_ptr
//weak_ptr

class Parent; //采用前置声明

using ParentPtr = std::shared_ptr<Parent>;
typedef std::weak_ptr<Parent> WeakParentPtr;

class Child {
	public:
//		ParentPtr father; //内存泄露
		WeakParentPtr father; //采用弱指针,则可以释放内存,不造成内存泄露
		Child() { std::cout << "Child!!" << std::endl; }
		~Child();
};

typedef std::shared_ptr<Child> ChildPtr;
typedef std::weak_ptr<Child> WeakChildPtr;

class Parent {
	public:
		Parent() { std::cout << "Parent!!" << std::endl; }
		ChildPtr son;
//		WeakChildPtr son;

		void print() const { std::cout << "use_count: " << this->son.use_count() << std::endl;}
		~Parent();
};

class Object {
	public:
		Object(int id) : m_id(id) { std::cout << "init obj " << m_id << std::endl; };
		~Object() { std::cout << "bye bye " << m_id << std::endl; }
		int id() const { return m_id; }
	private:
		int m_id = 0;
};
using ObjectPtr = std::shared_ptr<Object>;

Child::~Child() { std::cout << "bye child!" << std::endl; }
Parent::~Parent() { std::cout << "bye parent!" << std::endl; }
//----------------------------------------------
void testParentAndChild() {
	ParentPtr p(new Parent());
	ChildPtr c(new Child());

//采用这种方式,造成内存泄露
	p->son = c; //智能指针拷贝, use_count + 1, c 的use_count 为 2
	p->print();
	c->father = p; //p 的 use_count 也为 2 了

//智能指针析构之后use_count  -1
//智能指针特性: 只有当use_count 变为0 时,才能释放掉管理的资源
//所以智能指针析构后,use_count 不为0,则造成了内存泄露
	////////////
//只要打破环状的引用,则share_ptr就会很好的管理内存
}
//----------------------------------------------
//为了解决以上问题, 采用weak_ptr来解决
void sharedPtrWithWeakPtr() {
	ObjectPtr obj(new Object(1));
	typedef std::weak_ptr<Object> WeakObjectPtr;
	WeakObjectPtr weakObj(obj);//弱指针依赖于share_ptr,若share_ptr是有效的,则wake_ptr也是有效的.
	WeakObjectPtr weakObj2(obj);
	//而wake_ptr在进行赋值的操作运算的时候,并不影响use_count, 相当于只是作为监听者

	
	std::cout << "obj use count is " << obj.use_count() << std::endl;
	{
		auto p = weakObj.lock(); //相当于返回了一个 ObjectPtr类型,
		std::cout << "expired: " << weakObj.expired() << std::endl; //expierd() 查看监控的资源过期没有过期
		if(p) {
			std::cout << p.unique() << std::endl; //false, use_count >= 2, 因为auto p = ...,进行了一次指针拷贝, 
			//所以use_count + 1, 而weakObj.lock()返回若是有效的话,则use_count >= 1, 否则返回nullptr
			//则总体的就use_count >= 2
			//do what you wanna do	
		}else {
		
		
		}
	}
	obj.reset(); //obj 放弃管理的资源
	std::cout << "endl;";
	auto p2 = weakObj.lock(); //返回空,因为,obj不管理资源了
	
	obj.reset(new Object(2)); //重新管理另一个资源
	{
		auto p = weakObj.lock();
		if(p) {
			assert(false);
		}else {
			//要么资源已经释放,要么obj管理的资源跟换了.
			std::cout << "changed!" << std::endl;
		}

	}
	std::cout << "expired: " << weakObj.expired() << std::endl; //expierd() 查看监控的资源过期没有过期
}
int main(void) {
	testParentAndChild();
//	sharedPtrWithWeakPtr();
	return 0;
}