{"id":5078,"date":"2016-12-14T20:51:28","date_gmt":"2016-12-14T20:51:28","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/std-weak-ptr\/"},"modified":"2023-06-26T12:32:15","modified_gmt":"2023-06-26T12:32:15","slug":"std-weak-ptr","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/std-weak-ptr\/","title":{"rendered":"std::weak_ptr"},"content":{"rendered":"

std::unique_ptr<\/a><\/span> models the concept of exclusive ownership, std::shared_ptr<\/a><\/span> the concept of shared ownership. If I stick to this picture then std::weak_ptr<\/span> models the concept of temporary ownership because it borrows the resource from a std::shared_ptr.<\/span> There is one dominant reason for having a std::weak_ptr<\/span> in C++: breaking of cyclic references of std::shared_ptr<\/span>‘s. <\/span><\/p>\n

<\/p>\n

If you study the interface of the smart pointer std::weak_ptr<\/span>, you will recognize: the std::weak_ptr<\/span> is not so smart. std::weak_ptr<\/span> has a minimal interface.<\/p>\n

The interface<\/h2>\n

std::weak_ptr<\/span> doesn’t change – in opposite to the std::shared_ptr<\/span> – the reference counter of the shared variable. Have a look.<\/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<\/pre>\n<\/td>\n
\n
\/\/ weakPtr.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <memory><\/span>\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::boolalpha << std::endl;\r\n\r\n  auto<\/span> sharedPtr=std::make_shared<int<\/span>>(2011);\r\n  std::weak_ptr<int<\/span>> weakPtr(sharedPtr);\r\n  \r\n  std::cout << \"weakPtr.use_count(): \"<\/span> << weakPtr.use_count() << std::endl;\r\n  std::cout << \"sharedPtr.use_count(): \"<\/span> << sharedPtr.use_count() << std::endl;\r\n  std::cout << \"weakPtr.expired(): \"<\/span> << weakPtr.expired() << std::endl;\r\n\r\n  if<\/span>( std::shared_ptr<int<\/span>> sharedPtr1 = weakPtr.lock() ) {\r\n    std::cout << \"*sharedPtr: \"<\/span> << *sharedPtr << std::endl;\r\n    std::cout << \"sharedPtr1.use_count(): \"<\/span> << sharedPtr1.use_count() << std::endl;\r\n  }\r\n  else<\/span>{\r\n    std::cout << \"Don't get the resource!\"<\/span> << std::endl;\r\n  }\r\n\r\n  weakPtr.reset();\r\n  if<\/span>( std::shared_ptr<int<\/span>> sharedPtr1 = weakPtr.lock() ) {\r\n    std::cout << \"*sharedPtr: \"<\/span> << *sharedPtr << std::endl;\r\n    std::cout << \"sharedPtr1.use_count(): \"<\/span> << sharedPtr1.use_count() << std::endl;\r\n  }\r\n  else<\/span>{\r\n    std::cout << \"Don't get the resource!\"<\/span> << std::endl;\r\n  }\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
I create in line 11 a std::weak_ptr<\/span> which borrows the resource from the std::shared_ptr.<\/span> The output of the program shows that the reference counter is 1 (lines 13 and 14). That means in particular that std::weak<\/span> doesn’t increment the counter. The call weakPtr.expired()<\/span> checks if the resource was already deleted. That is equivalent to the expression weakPtr.use_count() == 0.<\/span> If the std::weak_ptr<\/span> shared temporary a resource, you can use weakPtr.lock()<\/span> to create a std::shared_ptr<\/span> out of it. Now, the reference counter will be increased to 2 (line 18). After resetting the weakPtr<\/span> (line 25), the call weakPtr.lock()<\/span> fails.<\/p>\n
\"weakPtr\"<\/p>\n
That was almost the whole story of the std::weak_ptr.<\/span> Almost, because the std::weak_ptr<\/span> has an extraordinary job. It helps to break cyclic references of std::shared_ptr’s.<\/span><\/p>\n<\/p>\n
Cyclic references<\/h2>\n
You will get cyclic references of std::shared_ptr<\/span> if the std::shared_ptr<\/span> reference each other.<\/p>\n
The issue<\/h3>\n
If you have a cyclic reference of std::shared_ptr,<\/span> the reference counter will never become 0. Therefore, the resource will automatically be deleted. But that is precisely the reason, why we use std::shared_ptr’<\/span>s. Need an example?<\/p>\n
There are two cycles in the graphic. First, between the mother and her daughter; second, between the mother and her son. The subtle difference is, however, that the mother references her daughter with a std::weak_ptr.<\/span> Therefore, the std::shared_ptr<\/span> cycle is broken.<\/p>\n
\"cycle\"<\/p>\n
If you don’t like pictures, here is the corresponding source code.<\/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\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49<\/pre>\n<\/td>\n
\n
\/\/ cycle.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <memory><\/span>\r\n\r\nstruct<\/span> Son;\r\nstruct<\/span> Daughter;\r\n\r\nstruct<\/span> Mother{\r\n  ~Mother(){\r\n    std::cout << \"Mother gone\"<\/span> << std::endl;\r\n  }\r\n  void<\/span> setSon(const<\/span> std::shared_ptr<Son> s ){\r\n    mySon=s;\r\n  }\r\n  void<\/span> setDaughter(const<\/span> std::shared_ptr<Daughter> d ){\r\n    myDaughter=d;\r\n  }\r\n  std::shared_ptr<const<\/span> Son> mySon;\r\n  std::weak_ptr<const<\/span> Daughter> myDaughter;\r\n};\r\n\r\nstruct<\/span> Son{\r\n  Son(std::shared_ptr<Mother> m):myMother(m){}\r\n  ~Son(){\r\n    std::cout << \"Son gone\"<\/span> << std::endl;\r\n  }\r\n  std::shared_ptr<const<\/span> Mother> myMother;\r\n};\r\n\r\nstruct<\/span> Daughter{\r\n  Daughter(std::shared_ptr<Mother> m):myMother(m){}\r\n  ~Daughter(){\r\n    std::cout << \"Daughter gone\"<\/span> << std::endl;\r\n  }\r\n  std::shared_ptr<const<\/span> Mother> myMother;\r\n};\r\n\r\nint<\/span> main(){\r\n  std::cout << std::endl;\r\n  {\r\n    std::shared_ptr<Mother> mother= std::shared_ptr<Mother>( new<\/span> Mother);\r\n    std::shared_ptr<Son> son= std::shared_ptr<Son>( new<\/span> Son(mother) );\r\n    std::shared_ptr<Daughter> daughter= std::shared_ptr<Daughter>( new<\/span> Daughter(mother) );\r\n    mother->setSon(son);\r\n    mother->setDaughter(daughter);\r\n  }\r\n  std::cout << std::endl;\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
Thanks to the artificial scope in lines 41 – 47, the lifetime of the mother,<\/span> the son,<\/span> and the daughter<\/span> is limited. Or to say it the other way around. Mother,<\/span> son,<\/span> and daughter<\/span> go out of scope, and therefore the destructor of the class Mother<\/span> (lines 10 – 12), Son<\/span> (lines 25 – 27), and Daughter<\/span> (lines 33 – 35) should automatically be invoked.<\/p>\n
Should, because only the destructor of the class Daughter<\/span> is called.<\/p>\n
\"cycle\"<\/p>\n
The graphic or the source code shows it. We have a cyclic reference of std::shared_ptr<\/span> between mother<\/span> and son.<\/span> Therefore, the reference counter is always greater than 0, and the destructor will not automatically be invoked. That observation is not true for mother<\/span> and daughter.<\/span> If daughter<\/span> goes out of scope, the reference counter of the std::shared_ptr<\/span> myMother<\/span> (line 36) becomes 0 and the resource will automatically be deleted.<\/p>\n
What’s next?<\/h2>\n
The Standard Template Library (STL) containers automatically manage their memory. This holds true for the associative and the sequential container. Especially powerful is the automatic memory management of the sequential container std::vector<\/span> and std::string.<\/span> Although the std::string<\/span> is not a sequential container of the STL, it has much in common with a std::vector<char>.<\/span> So, there are many reasons for me to have in the next post <\/a>a closer look at the memory management of both containers.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
<\/span><\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
std::unique_ptr models the concept of exclusive ownership, std::shared_ptr the concept of shared ownership. If I stick to this picture then std::weak_ptr models the concept of temporary ownership because it borrows the resource from a std::shared_ptr. There is one dominant reason for having a std::weak_ptr in C++: breaking of cyclic references of std::shared_ptr‘s.<\/p>\n","protected":false},"author":21,"featured_media":5075,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[364],"tags":[498,400,399,511],"class_list":["post-5078","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-embedded","tag-memory","tag-shared_ptr","tag-smart-pointers","tag-weak_ptr"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5078","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5078"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5078\/revisions"}],"predecessor-version":[{"id":6913,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5078\/revisions\/6913"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5075"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5078"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5078"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5078"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}