{"id":108619,"date":"2023-08-18T07:00:00","date_gmt":"2023-08-18T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=108619"},"modified":"2023-08-18T06:58:23","modified_gmt":"2023-08-18T13:58:23","slug":"20230818-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20230818-00\/?p=108619","title":{"rendered":"Phantom and indulgent shared pointers"},"content":{"rendered":"

Last time, we looked at various ways to convert among different shared_ptr<\/code>s<\/a>. We finished with this diagram:<\/p>\n\n\n\n\n\n
\u00a0<\/th>\nNull control block<\/th>\nNon-null control block<\/th>\n<\/tr>\n
Null stored pointer<\/th>\nEmpty<\/td>\nPhantom<\/td>\n<\/tr>\n
Non-null stored pointer<\/th>\nIndulgent<\/td>\nFull<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

You are familiar with an empty shared pointer, which manages no object and has no stored pointer. You are also familiar with a full shared pointer, which manages an object and has a non-null stored pointer (to the managed object, or something whose lifetime is controlled by the managed object). But what about those other two guys?<\/p>\n

In the upper right corner, you have the case of a shared pointer that manages an object but whose stored pointer is null, which I’ve called a phantom<\/i> shared pointer. If you convert the shared pointer to a bool<\/code>, it produces false<\/code>, because you can’t use it to access anything. The phantom shared pointer looks empty at a casual glance, but it secretly manages an object behind the scenes. That secretly-managed object remains alive for no visible reason. There is no way to access that secretly-managed object, but it’s still there. It’s a phantom which follows you around.<\/p>\n

struct Sample\r\n{\r\n    int value;\r\n};\r\nstd::shared_ptr<Sample> p = std::make_shared<Sample>();\r\nstd::shared_ptr<char> q = std::shared_ptr<char>(p, nullptr);\r\np = nullptr;\r\n<\/pre>\n
In the above example, we start by creating a shared pointer to a freshly-constructed Sample<\/code> object. We then use this shared pointer to provide the control block to a new aliasing shared pointer whose stored pointer is nullptr<\/code>. Finally, we clear the original shared pointer, so that the only reference to the Sample<\/code> is in the phantom shared pointer q<\/code>. The Sample<\/code> is now being kept alive by what looks like a null pointer!<\/p>\n
In the opposite corner, you have a shared pointer with no control block, but with a non-null stored pointer, which I’ve called an indulgent<\/i> shared pointer because it points to something, yet owns nothing. “Go ahead, have fun with this pointer all you like, I don’t care!”<\/p>\n
int globalVariable;\r\n\r\nstd::shared_ptr<int> p(std::shared_ptr<int>(), &globalVariable);\r\n<\/pre>\n
We use the aliasing constructor for shared_ptr<int><\/code> which takes another shared_ptr<int><\/code> (which provides the control block) and a raw pointer (which serves as the stored pointer). The donor shared_ptr<\/code> is empty and has no control block. We give that nonexistent control block to the aliasing constructor, and the result is a shared pointer that owns nothing, yet which points to something, namely, globalVariable<\/code>.<\/p>\n
This style of shared pointer is useful if you need a shared pointer that points to memory with static storage duration. The pointer is valid for the duration of the process, so you don’t need a control block to manage the object’s lifetime: The object’s lifetime is “forever”.<\/p>\n
How can you detect whether you have one of these unusual shared pointers?<\/p>\n
If you treat a shared_ptr<\/code> as a bool<\/code>, the resulting value tells you whether the stored pointer is non-null. On the other hand, if you ask use_count()<\/code>, it will return a nonzero value if there is a managed object. Now we can finish our table:<\/p>\n\n\n\n\n\n
\u00a0<\/th>\nNull control block
\n(use_count() == 0)<\/th>\n		Non-null control block
\n(use_count() != 0)<\/th>\n<\/tr>\n
Null stored pointer
\n(falsy)<\/th>\n		Empty<\/td>\nPhantom<\/td>\n<\/tr>\n
Non-null stored pointer
\n(truthy)<\/th>\n		Indulgent<\/td>\nFull<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Note that phantom shared pointers are falsy, and indulgent shared pointers are truthy. I couldn’t think of a synonym for indulgent that begins with a “t”, sorry.<\/p>\n
In code, we can detect the four cases by using use_count()<\/code> and get()<\/code> (or equivalently, converting to bool<\/code>).<\/p>\n
void detect(std::shared_ptr<T> const& p)\r\n{\r\n    bool has_control_block = p.use_count();\r\n    bool has_pointer = p.get();\r\n    \/\/ equivalently, has_pointer = static_cast<bool>(p);\r\n\r\n    if (has_control_block && has_pointer) {\r\n        \/\/ full\r\n    } else if (has_control_block && !has_pointer) {\r\n        \/\/ phantom\r\n    } else if (!has_control_block && has_pointer) {\r\n        \/\/ indulgent\r\n    } else { \/\/ !has_control_block && !has_pointer)\r\n        \/\/ empty\r\n    }\r\n}\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
The phantom controls something yet holds nothing. The indulgent holds something but controls nothing.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-108619","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
The phantom controls something yet holds nothing. The indulgent holds something but controls nothing.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108619","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=108619"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108619\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=108619"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=108619"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=108619"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}