{"id":5067,"date":"2016-12-11T06:11:51","date_gmt":"2016-12-11T06:11:51","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/std-shared-ptr\/"},"modified":"2023-06-26T12:32:57","modified_gmt":"2023-06-26T12:32:57","slug":"std-shared-ptr","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/std-shared-ptr\/","title":{"rendered":"std::shared_ptr"},"content":{"rendered":"

std::shared_ptr’<\/span>s share the resource. The shared reference counter counts the number of owners. Copying a std::shared_ptr <\/span> increases the reference count by one. Destroying a std::shared_ptr<\/span> decreases the reference count by one. If the reference count becomes zero, the resource will automatically be released. <\/p>\n

<\/p>\n

 <\/p>\n

Before I deal with the details of the std::shared_ptr<\/span>, I will bring you on the same page and explain the basics.<\/p>\n

 <\/p>\n

The Basics<\/h2>\n

Copying a std::shared_ptr<\/span> increases the reference count by one. Both smart pointers use the same resource afterwards. I depicted this scenario.<\/p>\n

\"sharedPtr\"<\/p>\n

Thanks to shared1 shared2<\/span> are initialized. Ultimately, the reference count is 2, and both smart pointers have the same resource.<\/p>\n

The application<\/h3>\n

The program shows the typical usage of smart pointers. To get a visual idea of the life cycle of the resource, I put a short message in the constructor and destructor of MyInt<\/span> (lines 8 – 16).<\/p>\n

 <\/p>\n

<\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42<\/pre>\n<\/td>\n
\n
\/\/ sharedPtr.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <memory><\/span>\r\n\r\nusing<\/span> std::shared_ptr;\r\n\r\nstruct<\/span> MyInt{\r\n  MyInt(int<\/span> v):val(v){\r\n    std::cout << \"  Hello: \"<\/span> << val << std::endl;\r\n  }\r\n  ~MyInt(){\r\n    std::cout << \"  Good Bye: \"<\/span> << val << std::endl;\r\n  }\r\n  int<\/span> val;\r\n};\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  shared_ptr<MyInt> sharPtr(new<\/span> MyInt(1998));\r\n  std::cout << \"    My value: \"<\/span> << sharPtr->val << std::endl;\r\n  std::cout << \"sharedPtr.use_count(): \"<\/span> << sharPtr.use_count() << std::endl;\r\n\r\n\r\n  {\r\n    shared_ptr<MyInt> locSharPtr(sharPtr);\r\n    std::cout << \"locSharPtr.use_count(): \"<\/span> << locSharPtr.use_count() << std::endl;\r\n  }\r\n  std::cout << \"sharPtr.use_count(): \"<\/span><<  sharPtr.use_count() << std::endl;\r\n\r\n  shared_ptr<MyInt> globSharPtr= sharPtr;\r\n  std::cout << \"sharPtr.use_count(): \"<\/span><<  sharPtr.use_count() << std::endl;\r\n  globSharPtr.reset();\r\n  std::cout << \"sharPtr.use_count(): \"<\/span><<  sharPtr.use_count() << std::endl;\r\n\r\n  sharPtr= shared_ptr<MyInt>(new<\/span> MyInt(2011));\r\n\r\n  std::cout << std::endl;\r\n  \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
Here is the screenshot of the program.<\/p>\n
\"sharedPtr\" <\/p>\n
I create in line 22 MyInt(1998). <\/span>This is the resource the smart pointer should take care of. By using sharPtr->val<\/span> I have direct access to the resource (line 23). The output of the program shows the numbers of the reference counter. It starts in line 24 with one, becomes by the local copy shartPtr<\/span> in line 28 two, and goes after the block (lines 27 – 40) back to one. As a reset call, the copy assignment in line 33 modifies the reference counter. The expression sharPtr= shared_ptr<MyInt>(new MyInt(2011))<\/span> <\/span>i<\/span>n line 38 is more interesting. Firstly, the resource MyInt(2011)<\/span><\/span> is created and assigned to <\/span>sharPtr.<\/span><\/span> Consequently, the destructor of sharPtr<\/span> is invoked. sharedPtr<\/span> was the exclusive owner of the resource new MyInt(1998)<\/span> (line<\/span> 22). The last resource new MyInt(2011)<\/span>, <\/span>will be destroyed at the end of the main.<\/p>\n
The program should not be too challenging. Now we can dig deeper.<\/p>\n
The control block<\/h3>\n
The std::shared_ptr<\/span>‘s share is more than a resource and a reference counter. They share a resource and a control block. The control block has two counters and, eventually, more data. Two counters? The control block has a counter for the std::shared_ptr<\/span> and the std::weak_ptr <\/span>referencing the std::shared_ptr.<\/span> That’s the first time I’m speaking about the std::weak_ptr<\/span>. Their job is to break cyclic references. I will write a separate post about cyclic references. Once more, the overview.<\/span><\/p>\n
The control block has<\/p>\n