{"id":5074,"date":"2016-12-12T15:52:51","date_gmt":"2016-12-12T15:52:51","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/specialities-of-std-shared-ptr\/"},"modified":"2023-06-26T12:32:36","modified_gmt":"2023-06-26T12:32:36","slug":"specialities-of-std-shared-ptr","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/specialities-of-std-shared-ptr\/","title":{"rendered":"Specialities of std::shared_ptr"},"content":{"rendered":"

After I draw the big picture of a std::shared_ptr<\/span> in the last post<\/a>, I want to present two special aspects of this smart pointer in this post. First, I show with std::shared_from_this<\/span> how to create a std::shared_ptr<\/span> from an object; second, I’m interested in the question to the answer: Should a function take a std::shared_ptr<\/span> by copy or by reference? The numbers are quite interesting.<\/p>\n

<\/p>\n

 <\/p>\n

std::shared_ptr from this<\/h2>\n

Thanks to std::enable_shared_from_this<\/span>, you can create an object that returns a std::shared_ptr<\/span> from this. Therefore, the class of the objects has to be public derived from std::enable_shared_from_this<\/span>. Now, you have the method shared_from_this<\/span> available, which you can use to create std::shared_ptr<\/span> from this.<\/p>\n

The program shows the theory in practice.<\/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<\/pre>\n<\/td>\n
\n
\/\/ enableShared.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <memory><\/span>\r\n\r\nclass<\/span> ShareMe<\/span>: public<\/span> std::enable_shared_from_this<ShareMe>{\r\npublic:\r\n  std::shared_ptr<ShareMe> getShared(){\r\n    return<\/span> shared_from_this();\r\n  }\r\n};\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  std::shared_ptr<ShareMe> shareMe(new<\/span> ShareMe);\r\n  std::shared_ptr<ShareMe> shareMe1= shareMe->getShared();\r\n  {\r\n    auto<\/span> shareMe2(shareMe1);\r\n    std::cout << \"shareMe.use_count(): \"<\/span>  << shareMe.use_count() << std::endl;\r\n  }\r\n  std::cout << \"shareMe.use_count(): \"<\/span>  << shareMe.use_count() << std::endl;\r\n  \r\n  shareMe1.reset();\r\n  \r\n  std::cout << \"shareMe.use_count(): \"<\/span>  << shareMe.use_count() << std::endl;\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
The smart pointer shareMe<\/span> (line 17) and it copies shareMe1<\/span> (line 18) and shareMe2<\/span> (line 20) reference the very same resource and increment and decrement the reference counter.<\/p>\n
 \"enabledShared\"<\/p>\n
The call shareMe->getShared()<\/span> in line 18 creates a new smart pointer. getShared()<\/span> internally uses (line 9) the function shared_from_this<\/span>.<\/p>\n
There is something very special about the class ShareMe.<\/span><\/p>\n
Curiously recurring template pattern <\/h3>\n
ShareMe<\/span> is the derived class and type argument (line 6) of the base class std::enabled_shared_from_this<\/span>. This pattern is called CRTP, an abbreviation for C<\/strong>uriously R<\/strong>ecurring T<\/strong>emplate P<\/strong>attern. Obviously, there is no recursion because the base class methods will be instantiated when they are called. CRTP is an often-used idiom in C++ to implement static polymorphism. Unlike dynamic polymorphism with virtual run-time methods, static polymorphism occurs at compile time.<\/p>\n
But now, back to the std::shared_ptr.<\/span><\/p>\n<\/p>\n
std::shared_ptr as a function argument<\/h2>\n
Therefore, we are dealing with a quite interesting question. Should a function take its std::shared_ptr<\/span> by a copy of by reference? But first. Why should you care? Does it matter if a function takes its std::shared_ptr<\/span> by copy or reference? Under the hood, all is a reference. My definite answer is yes, and no. Semantically, it makes no difference. From the performance perspective, it makes a difference.<\/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<\/pre>\n<\/td>\n
\n
\/\/ refVersusCopySharedPtr.cpp<\/span>\r\n\r\n#include <memory><\/span>\r\n#include <iostream><\/span>\r\n\r\nvoid<\/span> byReference(std::shared_ptr<int<\/span>>& refPtr){\r\n  std::cout << \"refPtr.use_count(): \"<\/span> << refPtr.use_count() << std::endl;\r\n}\r\n\r\nvoid<\/span> byCopy(std::shared_ptr<int<\/span>> cpyPtr){\r\n  std::cout << \"cpyPtr.use_count(): \"<\/span> << cpyPtr.use_count() << std::endl;\r\n}\r\n\r\n\r\nint<\/span> main(){\r\n\r\n    std::cout <<  std::endl;\r\n\r\n    auto<\/span> shrPtr= std::make_shared<int<\/span>>(2011);\r\n\r\n    std::cout << \"shrPtr.use_count(): \"<\/span> << shrPtr.use_count() << std::endl;\r\n\r\n    byReference(shrPtr);\r\n    byCopy(shrPtr);\r\n    \r\n    std::cout << \"shrPtr.use_count(): \"<\/span> << shrPtr.use_count() << std::endl;\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
The function byReference<\/span> (line 6 – 8) and byCopy<\/span> (line 10 – 12) takes their std::shared_ptr<\/span> by reference and copy. The output of the program emphasizes the critical point.<\/p>\n
 \"refVersusCopySharedPtr\"<\/p>\n
The function byCopy takes its std::shared_ptr<\/span> by copy. Therefore, the reference count increases in the function body to 2 and decreases to 1. The question is now. How expensive is the incrementing and decrementing of the reference counter? Because incrementing the reference counter is an atomic operation, I expect a measurable difference. To be precise. The incrementing of the reference counter is an atomic operation with relaxed semantics<\/a>; the decrementing is an atomic operation with acquire-release semantics.<\/a><\/p>\n
Let’s have a look at the numbers.<\/p>\n
Performance comparison<\/h3>\n
My Linux PC is more powerful than my Windows PC. Therefore, you must read the absolute numbers with a grain of salt. I use GCC 4.8 and Microsoft Visual Studio 15. Additionally, I translate the program with maximum and without optimization. At first, my small test program.<\/p>\n
In the test program, I hand over the std::shared_ptr<\/span> by reference and copying and using the std::shared_ptr<\/span> to initialize another std::shared_ptr.<\/span> This was the most straightforward scenario to cheat the optimizer. I invoke each function 100 million times.<\/p>\n
The program<\/h4>\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
\/\/ performanceRefCopyShared.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <memory><\/span>\r\n#include <iostream><\/span>\r\n\r\nconstexpr long<\/span> long<\/span> mill= 100000000;\r\n\r\nvoid<\/span> byReference(std::shared_ptr<int<\/span>>& refPtr){\r\n  volatile<\/span> auto<\/span> tmpPtr(refPtr);\r\n}\r\n\r\nvoid<\/span> byCopy(std::shared_ptr<int<\/span>> cpyPtr){\r\n  volatile<\/span> auto<\/span> tmpPtr(cpyPtr);\r\n}\r\n\r\n\r\nint<\/span> main(){\r\n\r\n    std::cout <<  std::endl;\r\n    \r\n    auto<\/span> shrPtr= std::make_shared<int<\/span>>(2011);\r\n   \r\n    auto<\/span> start = std::chrono::steady_clock::now();\r\n  \r\n    for<\/span> (long<\/span> long<\/span> i= 0; i <= mill; ++i) byReference(shrPtr);    \r\n    \r\n    std::chrono::duration<double<\/span>> dur= std::chrono::steady_clock::now() - start;\r\n    std::cout << \"by reference: \"<\/span> << dur.count() << \" seconds\"<\/span> << std::endl;\r\n    \r\n    start = std::chrono::steady_clock::now();\r\n    \r\n    for<\/span> (long<\/span> long<\/span> i= 0; i<= mill; ++i){\r\n        byCopy(shrPtr);\r\n    }\r\n    \r\n    dur= std::chrono::steady_clock::now() - start;\r\n    std::cout << \"by copy: \"<\/span> << dur.count() << \" seconds\"<\/span> << std::endl;\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
First, the program is without optimization.<\/p>\n
Without optimization<\/h4>\n
 \"performance\"\"performanceWindows\"<\/p>\n
And now, the one with maximum optimization.<\/p>\n
With maximum optimization<\/h4>\n
\"performanceOptimization\"\"performanceOptimizationWindows\"<\/p>\n
My conclusion<\/h3>\n
\"comparisonEng\"<\/p>\n
The raw numbers of the program performanceCopyShared.cpp speak a clear message.<\/p>\n