shared_ Repeated release heap object of PTR hidden danger

It was thought that smart pointers could completely ensure the correct reference and release of heap objects , But smart pointers are not omnipotent . With shared_ptr For example , The following usage cases will make the code repeatedly release heap objects .

1. Abuse of primitive pointer construction shared_ptr

#include <iostream>
#include <memory>

class A {
    };
using Ptr = std::shared_ptr<A>;

int main()
{
    
	A *ps = new A();
	Ptr p1(ps);
	Ptr p2(p1);
	Ptr p3 = p2;
	Ptr p4;
	p4 = p3;
	
	Ptr p5(ps);

	std::cout << p1.use_count() << std::endl;	
	std::cout << p2.use_count() << std::endl;	
	std::cout << p3.use_count() << std::endl;	
	std::cout << p4.use_count() << std::endl;	
	std::cout << p5.use_count() << std::endl;	

	return 0;
}

The operation results are as follows ：

You can see , In the use of Copy structure Or assignment operator = When ,shared_ptr The control block will be shared and updated . And when you use Primitive pointer construction A new shared_ptr when , A new control block will be created and initialized .

So at the end of the program , When shared_ptr When you want to parse the heap object you point to , Memory will be released repeatedly , This causes runtime errors .

structure shared_ptr when , If the object it points to has been replaced by another shared_ptr To refer to , Please initialize the new pointer with copy construction or assignment .

2. The class contains... That points to itself shared_ptr

#include <iostream>
#include <memory>

class A;
using SPtr = std::shared_ptr<A>;
using WPtr = std::weak_ptr<A>;

class A {
    
public:
	A() : sptr(this), wptr(sptr)
	{
    
		std::cout << "in construct :" << std::endl;
		std::cout << sptr.use_count() << std::endl;
		std::cout << this << " " << sptr << " " << wptr.lock() << std::endl;
	}
private:
	SPtr sptr;
	WPtr wptr;
};

int main()
{
    
	A *p = new A();
	SPtr ptr(p);	
	std::cout << "in main :" << std::endl;
	std::cout << ptr.use_count() << std::endl;

	return 0;
}

The operation results are as follows ：

The reason is similar to the above , A heap object By Two shared_ptr Control block management , Eventually, memory is repeatedly released .

If main The function is like this , There will also be running errors . The reason is when the object is delete When released , Object shared_ptr Also released , At this time, the object it points to (this) Will be released again .

int main()
{
    
	A *p = new A();
	std::cout << p << std::endl;
	delete p;

	return 0;
}

Please don't use this wonderful usage .