The C++ standard library comes with a few smart pointer types.<\/p>\n
The simplest one is The complication is that there is also a deleter object in the The Visual Studio debugger has a visualizer that understands Next up is are the buddies The control block keeps track of how many shared and weak pointers exist, but in a somewhat unusual way. The na\u00efve approach would be to have You can solve this by having Here’s how the fundamental operations play out with this design:<\/p>\n Create the first shared pointer: Create a new control block with Copy a nonempty weak pointer: Atomically increment the Copy a nonempty shared pointer: Atomically increment both Convert a nonempty shared pointer to a weak pointer: Atomically increment the Convert a nonempty weak pointer to a shared pointer: Atomically increment the Destruct a nonempty weak pointer: Atomically decrement the Destruct a nonempty shared pointer: Atomically decrement the This design works, but it turns out you can be more clever about it: Instead of counting all shared pointers toward the So here’s our optimized version:<\/p>\n Create the first shared pointer: Create a new control block with Copy a nonempty weak pointer: Atomically increment the Copy a nonempty shared pointer: Atomically increment the Convert a nonempty shared pointer to a weak pointer: Atomically increment the Convert a nonempty weak pointer to a shared pointer: Atomically increment the Destruct a nonempty weak pointer: Atomically decrement the Destruct a nonempty shared pointer: Atomically decrement the There’s a lesser-known feature of shared and weak pointers: The aliasing contructor<\/i>. This lets you create a The shared pointer Internally, you create an aliasing shared pointer by using the same control block as the source shared pointer (incrementing the Again, the Visual Studio debugger understands all of this and gives you a nice visualization. If you’re debugging at a lower level, then here’s what it looks like in the debugger:<\/p>\n Here’s how the names we used map to the names in the Microsoft implementation of the C++ standard library:<\/p>\n When inspecting a A weak pointer looks pretty much identical in the debugger:<\/p>\n When inspecting a weak pointer in the debugger, you have to check the control block’s shared pointer count to know whether or not the object is still valid. If the shared pointer count is zero, then the weak pointer has expired, and the object pointer points to freed memory.<\/p>\n Next time, we’ll look at Bonus viewing<\/b>: Stephan T. Lavavej’s lecture on unique_ptr<\/code>: This class babysits a raw pointer and remembers to delete it at destruction (in an appropriate manner). Dumping the contents of a unique_ptr<\/code> is just looking at the raw pointer inside.<\/p>\nunique_ptr<\/code>. This deleter object is usually an empty class, so it is stored as part of a compressed pair.<\/p>\nunique_ptr<\/code>, but here’s what it looks like at a low level in the Microsoft implementation:<\/p>\n0:000< ?? p\r\nclass std::unique_ptr<S,std::default_delete<S> >\r\n +0x000 _Mypair : std::_Compressed_pair<std::default_delete<S>,S *,1>\r\n0:000< ?? p._Mypair\r\nclass std::_Compressed_pair<std::default_delete<S>,S *,1>\r\n +0x000 _Myval2 : 0x0000020a`11f08490 S\r\n0:000< ?? p._Mypair._Myval2\r\nstruct S * 0x0000020a`11f08490 \u2190 here is the unique object\r\n +0x000 a : 0n42\r\n<\/pre>\n
shared_ptr<\/code> and weak_ptr<\/code>. These guys are just alternate policies around the same design, which centers around a “control block”.<\/p>\nstruct control_block\r\n{\r\n virtual void Dispose() = 0;\r\n virtual void Delete() = 0;\r\n std::atomic<unsigned long> shareds;\r\n std::atomic<unsigned long> weaks;\r\n};\r\n\r\ntemplate<typename T>\r\nstruct shared_ptr\r\n{\r\n T* object;\r\n control_block* control;\r\n};\r\n\r\ntemplate<typename T>\r\nstruct weak_ptr\r\n{\r\n T* object;\r\n control_block* control;\r\n};\r\n<\/pre>\nshareds<\/code> and weaks<\/code> count the number of shared and weak pointers, respectively. However, this ends up being more complicated because detecting when the last pointer to the control block has been destroyed would require us to perform atomic checks on two<\/i> member variables simultaneously.<\/p>\nweaks<\/code> be the number of shared pointers plus<\/i> the number of weak pointers. This is the total number of things keeping the control block alive. A test of a single atomic variable will tell you when the last pointer has been destroyed.<\/p>\nstruct control_block\r\n{\r\n virtual void Dispose() = 0;\r\n virtual void Delete() = 0;\r\n std::atomic<unsigned long> shareds;\r\n std::atomic<unsigned long> refs;\r\n};\r\n<\/pre>\nshareds<\/code> and refs<\/code> both initialized to 1.<\/p>\nrefs<\/code>. (We know that the refs<\/code> is at least one, because it includes the weak pointer we are copying from.)<\/p>\nshareds<\/code> and refs<\/code>. (We know that both are already at least one, because they includes the shared pointer we are copying from.)<\/p>\nrefs<\/code>. (We know that the refs<\/code> is at least one, because it includes the weak pointer we are copying from.)<\/p>\nshareds<\/code>, but only if it was originally nonzero.\u00b9 If successful, then also increment the refs<\/code>. If shareds<\/code> was zero, then produce an empty shared pointer instead.<\/p>\nrefs<\/code>. If this decrements to zero, then call Delete()<\/code> to delete the control block.<\/p>\nshareds<\/code>. If this decrements to zero, then call Dispose()<\/code> to destruct the managed object. Next, atomically decrement the refs<\/code>. If this also decrements to zero, then call Delete()<\/code> to delete the control block.<\/p>\nrefs<\/code>, count only one shared pointer toward the refs<\/code>, and update refs<\/code> only when the number of shareds<\/code> transitions between 1 and 0.<\/p>\nstruct control_block\r\n{\r\n virtual void Dispose() = 0;\r\n virtual void Delete() = 0;\r\n std::atomic<unsigned long> shareds;\r\n std::atomic<unsigned long> weaks;\r\n};\r\n<\/pre>\nshareds<\/code> and weaks<\/code> both initialized to 1.<\/p>\nweaks<\/code>. (We know that the weaks<\/code> is at least one, because it includes the weak pointer we are copying from.)<\/p>\nshareds<\/code>. (We know that the shareds<\/code> is at least one, because it includes the shared pointer we are copying from.)<\/p>\nweaks<\/code>. (We know that the weaks<\/code> is at least one, because it includes the weak pointer we are copying from.)<\/p>\nshareds<\/code>, but only if it was originally nonzero.\u00b9 If it was zero, then produce an empty shared pointer instead.<\/p>\nweaks<\/code>. If this decrements to zero, then call Delete()<\/code> to delete the control block.<\/p>\nshareds<\/code>. If this decrements to zero, then there’s extra work to do: Destroy the associated object and decrement the weaks<\/code>. If weaks<\/code> also decrements to zero, then call Delete()<\/code> to delete the control block.<\/p>\nshared_ptr<\/code> that dereferences to an object that is different from the one managed by the control block. For example, you can do this:<\/p>\nstruct S { int a = 42; int b = 99; };\r\n\r\nauto s = std::make_shared<S>();\r\nauto i = std::shared_ptr<int>(s, &s->b);\r\n<\/pre>\ni<\/code> points to the b<\/code> member of the shared S<\/code> object, but using the lifetime of the S<\/code> object controlled by the pre-existing shared pointer s<\/code>.<\/p>\nshareds<\/code>, naturally), but setting the object pointer to the second constructor parameter.<\/p>\n0:000> ?? p2\r\nclass std::shared_ptr<S>\r\n +0x000 _Ptr : 0x0000020a`11f084e0 S\r\n +0x008 _Rep : 0x0000020a`11f084d0 std::_Ref_count_base\r\n0:000> ?? p2._Ptr\r\nstruct S * 0x0000020a`11f084e0\r\n +0x000 a : 0n42\r\n0:000> ?? p2._Rep\r\nclass std::_Ref_count_base * 0x0000020a`11f084d0\r\n +0x000 __VFN_table : 0x00007ff7`9e788758\r\n +0x008 _Uses : 1\r\n +0x00c _Weaks : 1\r\n<\/pre>\n
\n\n
\n Our name<\/th>\n MSVC name<\/th>\n Notes<\/th>\n<\/tr>\n \n object<\/code><\/td>\n_Ptr<\/code><\/td>\nPointer to managed object<\/td>\n<\/tr>\n \n control<\/code><\/td>\n_Rep<\/code><\/td>\nPointer to control block<\/td>\n<\/tr>\n \n shareds<\/code><\/td>\n_Uses<\/code><\/td>\nNumber of shared pointers<\/td>\n<\/tr>\n \n weaks<\/code><\/td>\n_Weaks<\/code><\/td>\nNumber of weak pointers
\n+ 1 if there are any shared pointers<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\nshared_ptr<\/code>, you can just follow the _Ptr<\/code> to get to the managed object. You know that the pointer is valid because this is a shared pointer which keeps the object alive. (If the _Ptr<\/code> is nullptr<\/code>, then the shared pointer is empty.)<\/p>\n0:000> ?? p3\r\nclass std::weak_ptr<S>\r\n +0x000 _Ptr : 0x0000020a`11f084e0 S\r\n +0x008 _Rep : 0x0000020a`11f084d0 std::_Ref_count_base\r\n0:000> ?? p3._Ptr\r\nstruct S * 0x0000020a`11f084e0\r\n +0x000 a : 0n42\r\n0:000> ?? p3._Rep\r\nclass std::_Ref_count_base * 0x0000020a`11f084d0\r\n +0x000 __VFN_table : 0x00007ff7`9e788758\r\n +0x008 _Uses : 1\r\n +0x00c _Weaks : 2\r\n<\/pre>\n
std::std::shared_ptr<\/code> and unique_ptr<\/code><\/a>. He also gave an advanced lecture, which I cannot find.<\/p>\n