{"id":1958,"date":"2024-06-22T09:28:03","date_gmt":"2024-06-22T09:28:03","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=1958"},"modified":"2024-06-22T09:28:13","modified_gmt":"2024-06-22T09:28:13","slug":"how-to-implement-smart-pointers-in-cpp","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/","title":{"rendered":"How to Implement Smart Pointers in C++"},"content":{"rendered":"\n<p>Smart pointers are a key feature of modern C++ that help manage dynamic memory and prevent common errors such as memory leaks and dangling pointers. They automate the process of memory management by automatically deallocating memory when it is no longer needed. This tutorial will guide you through the implementation and use of various types of smart pointers in C++.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">1. Introduction to Smart Pointers<\/h2>\n\n\n\n<p>Smart pointers are objects that manage the lifecycle of dynamically allocated memory. They ensure that memory is properly freed when it is no longer in use. The three main types of smart pointers provided by the C++ Standard Library are <code>std::unique_ptr<\/code>, <code>std::shared_ptr<\/code>, and <code>std::weak_ptr<\/code>.<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong><code>std::unique_ptr<\/code><\/strong>: Manages a single object. Ownership is unique and cannot be shared. When the <code>std::unique_ptr<\/code> goes out of scope, it deletes the managed object.<\/li>\n\n\n\n<li><strong><code>std::shared_ptr<\/code><\/strong>: Manages a shared object. Multiple <code>std::shared_ptr<\/code> instances can share ownership of the same object. The object is deleted when the last <code>std::shared_ptr<\/code> goes out of scope.<\/li>\n\n\n\n<li><strong><code>std::weak_ptr<\/code><\/strong>: Holds a non-owning reference to an object managed by <code>std::shared_ptr<\/code>. It can be used to break circular references.<\/li>\n<\/ul>\n\n\n\n<h2 class=\"wp-block-heading\">2. Unique Pointer (<code>std::unique_ptr<\/code>)<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Implementing a Simple Unique Pointer<\/h3>\n\n\n\n<p>A <code>std::unique_ptr<\/code> is designed for unique ownership of a resource. It is non-copyable but movable, meaning ownership can be transferred.<\/p>\n\n\n\n<p>Here&#8217;s a basic implementation of a unique pointer:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-1\" data-shcb-language-name=\"C++\" data-shcb-language-slug=\"cpp\"><span><code class=\"hljs language-cpp\"><span class=\"hljs-keyword\">template<\/span>&lt;<span class=\"hljs-keyword\">typename<\/span> T&gt;\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">UniquePtr<\/span> {<\/span>\n<span class=\"hljs-keyword\">private<\/span>:\n    T* ptr; <span class=\"hljs-comment\">\/\/ raw pointer to the resource<\/span>\n\n<span class=\"hljs-keyword\">public<\/span>:\n    <span class=\"hljs-comment\">\/\/ Constructor<\/span>\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">explicit<\/span> <span class=\"hljs-title\">UniquePtr<\/span><span class=\"hljs-params\">(T* p = <span class=\"hljs-literal\">nullptr<\/span>)<\/span> : <span class=\"hljs-title\">ptr<\/span><span class=\"hljs-params\">(p)<\/span> <\/span>{}\n\n    <span class=\"hljs-comment\">\/\/ Destructor<\/span>\n    ~UniquePtr() {\n        <span class=\"hljs-keyword\">delete<\/span> ptr;\n    }\n\n    <span class=\"hljs-comment\">\/\/ Delete copy constructor and copy assignment operator<\/span>\n    UniquePtr(<span class=\"hljs-keyword\">const<\/span> UniquePtr&amp;) = <span class=\"hljs-keyword\">delete<\/span>;\n    UniquePtr&amp; <span class=\"hljs-keyword\">operator<\/span>=(<span class=\"hljs-keyword\">const<\/span> UniquePtr&amp;) = <span class=\"hljs-keyword\">delete<\/span>;\n\n    <span class=\"hljs-comment\">\/\/ Move constructor<\/span>\n    UniquePtr(UniquePtr&amp;&amp; other) <span class=\"hljs-keyword\">noexcept<\/span> : ptr(other.ptr) {\n        other.ptr = <span class=\"hljs-literal\">nullptr<\/span>;\n    }\n\n    <span class=\"hljs-comment\">\/\/ Move assignment operator<\/span>\n    UniquePtr&amp; <span class=\"hljs-keyword\">operator<\/span>=(UniquePtr&amp;&amp; other) <span class=\"hljs-keyword\">noexcept<\/span> {\n        <span class=\"hljs-keyword\">if<\/span> (<span class=\"hljs-keyword\">this<\/span> != &amp;other) {\n            <span class=\"hljs-keyword\">delete<\/span> ptr;\n            ptr = other.ptr;\n            other.ptr = <span class=\"hljs-literal\">nullptr<\/span>;\n        }\n        <span class=\"hljs-keyword\">return<\/span> *<span class=\"hljs-keyword\">this<\/span>;\n    }\n\n    <span class=\"hljs-comment\">\/\/ Overload dereference and arrow operators<\/span>\n    T&amp; <span class=\"hljs-keyword\">operator<\/span>*() <span class=\"hljs-keyword\">const<\/span> { <span class=\"hljs-keyword\">return<\/span> *ptr; }\n    T* <span class=\"hljs-keyword\">operator<\/span>-&gt;() <span class=\"hljs-keyword\">const<\/span> { <span class=\"hljs-keyword\">return<\/span> ptr; }\n\n    <span class=\"hljs-comment\">\/\/ Get the raw pointer<\/span>\n    <span class=\"hljs-function\">T* <span class=\"hljs-title\">get<\/span><span class=\"hljs-params\">()<\/span> <span class=\"hljs-keyword\">const<\/span> <\/span>{ <span class=\"hljs-keyword\">return<\/span> ptr; }\n\n    <span class=\"hljs-comment\">\/\/ Release ownership of the pointer<\/span>\n    <span class=\"hljs-function\">T* <span class=\"hljs-title\">release<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n        T* temp = ptr;\n        ptr = <span class=\"hljs-literal\">nullptr<\/span>;\n        <span class=\"hljs-keyword\">return<\/span> temp;\n    }\n\n    <span class=\"hljs-comment\">\/\/ Reset the pointer<\/span>\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">reset<\/span><span class=\"hljs-params\">(T* p = <span class=\"hljs-literal\">nullptr<\/span>)<\/span> <\/span>{\n        <span class=\"hljs-keyword\">delete<\/span> ptr;\n        ptr = p;\n    }\n};<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-1\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">C++<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">cpp<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h3 class=\"wp-block-heading\">Usage and Best Practices<\/h3>\n\n\n\n<p>Using <code>UniquePtr<\/code> in practice:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-2\" data-shcb-language-name=\"C++\" data-shcb-language-slug=\"cpp\"><span><code class=\"hljs language-cpp\"><span class=\"hljs-meta\">#<span class=\"hljs-meta-keyword\">include<\/span> <span class=\"hljs-meta-string\">&lt;iostream&gt;<\/span><\/span>\n\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">MyClass<\/span> {<\/span>\n<span class=\"hljs-keyword\">public<\/span>:\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">display<\/span><span class=\"hljs-params\">()<\/span> <span class=\"hljs-keyword\">const<\/span> <\/span>{\n        <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">cout<\/span> &lt;&lt; <span class=\"hljs-string\">\"MyClass object\\n\"<\/span>;\n    }\n};\n\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    <span class=\"hljs-function\">UniquePtr&lt;MyClass&gt; <span class=\"hljs-title\">ptr1<\/span><span class=\"hljs-params\">(<span class=\"hljs-keyword\">new<\/span> MyClass())<\/span><\/span>;\n    ptr1-&gt;display();\n\n    UniquePtr&lt;MyClass&gt; ptr2 = <span class=\"hljs-built_in\">std<\/span>::move(ptr1); <span class=\"hljs-comment\">\/\/ transfer ownership<\/span>\n    <span class=\"hljs-keyword\">if<\/span> (!ptr1.get()) {\n        <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">cout<\/span> &lt;&lt; <span class=\"hljs-string\">\"ptr1 is empty\\n\"<\/span>;\n    }\n\n    ptr2-&gt;display();\n    ptr2.reset(<span class=\"hljs-keyword\">new<\/span> MyClass()); <span class=\"hljs-comment\">\/\/ reset with new object<\/span>\n    ptr2-&gt;display();\n\n    <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-number\">0<\/span>;\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-2\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">C++<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">cpp<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h3 class=\"wp-block-heading\">Best Practices<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Use <code>std::make_unique<\/code><\/strong>: Prefer using <code>std::make_unique<\/code> to create <code>std::unique_ptr<\/code> instances as it is exception-safe and more efficient.<\/li>\n\n\n\n<li><strong>Avoid Raw Pointers<\/strong>: Use <code>std::unique_ptr<\/code> instead of raw pointers wherever possible to ensure proper resource management.<\/li>\n\n\n\n<li><strong>Ownership Transfer<\/strong>: Use <code>std::move<\/code> to transfer ownership explicitly, making the transfer of ownership clear.<\/li>\n<\/ul>\n\n\n\n<h2 class=\"wp-block-heading\">3. Shared Pointer (<code>std::shared_ptr<\/code>)<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Implementing a Simple Shared Pointer<\/h3>\n\n\n\n<p>A <code>std::shared_ptr<\/code> allows multiple pointers to share ownership of the same resource. The resource is destroyed when the last <code>std::shared_ptr<\/code> goes out of scope.<\/p>\n\n\n\n<p>Here&#8217;s a basic implementation of a shared pointer with reference counting:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-3\" data-shcb-language-name=\"C++\" data-shcb-language-slug=\"cpp\"><span><code class=\"hljs language-cpp\"><span class=\"hljs-keyword\">template<\/span>&lt;<span class=\"hljs-keyword\">typename<\/span> T&gt;\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">SharedPtr<\/span> {<\/span>\n<span class=\"hljs-keyword\">private<\/span>:\n    T* ptr;\n    <span class=\"hljs-keyword\">unsigned<\/span>* ref_count;\n\n<span class=\"hljs-keyword\">public<\/span>:\n    <span class=\"hljs-comment\">\/\/ Constructor<\/span>\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">explicit<\/span> <span class=\"hljs-title\">SharedPtr<\/span><span class=\"hljs-params\">(T* p = <span class=\"hljs-literal\">nullptr<\/span>)<\/span> : <span class=\"hljs-title\">ptr<\/span><span class=\"hljs-params\">(p)<\/span>, <span class=\"hljs-title\">ref_count<\/span><span class=\"hljs-params\">(<span class=\"hljs-keyword\">new<\/span> <span class=\"hljs-keyword\">unsigned<\/span>(<span class=\"hljs-number\">1<\/span>))<\/span> <\/span>{}\n\n    <span class=\"hljs-comment\">\/\/ Destructor<\/span>\n    ~SharedPtr() {\n        release();\n    }\n\n    <span class=\"hljs-comment\">\/\/ Copy constructor<\/span>\n    SharedPtr(<span class=\"hljs-keyword\">const<\/span> SharedPtr&amp; other) : ptr(other.ptr), ref_count(other.ref_count) {\n        ++(*ref_count);\n    }\n\n    <span class=\"hljs-comment\">\/\/ Copy assignment operator<\/span>\n    SharedPtr&amp; <span class=\"hljs-keyword\">operator<\/span>=(<span class=\"hljs-keyword\">const<\/span> SharedPtr&amp; other) {\n        <span class=\"hljs-keyword\">if<\/span> (<span class=\"hljs-keyword\">this<\/span> != &amp;other) {\n            release();\n            ptr = other.ptr;\n            ref_count = other.ref_count;\n            ++(*ref_count);\n        }\n        <span class=\"hljs-keyword\">return<\/span> *<span class=\"hljs-keyword\">this<\/span>;\n    }\n\n    <span class=\"hljs-comment\">\/\/ Overload dereference and arrow operators<\/span>\n    T&amp; <span class=\"hljs-keyword\">operator<\/span>*() <span class=\"hljs-keyword\">const<\/span> { <span class=\"hljs-keyword\">return<\/span> *ptr; }\n    T* <span class=\"hljs-keyword\">operator<\/span>-&gt;() <span class=\"hljs-keyword\">const<\/span> { <span class=\"hljs-keyword\">return<\/span> ptr; }\n\n    <span class=\"hljs-comment\">\/\/ Get the raw pointer<\/span>\n    <span class=\"hljs-function\">T* <span class=\"hljs-title\">get<\/span><span class=\"hljs-params\">()<\/span> <span class=\"hljs-keyword\">const<\/span> <\/span>{ <span class=\"hljs-keyword\">return<\/span> ptr; }\n\n<span class=\"hljs-keyword\">private<\/span>:\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">release<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n        <span class=\"hljs-keyword\">if<\/span> (--(*ref_count) == <span class=\"hljs-number\">0<\/span>) {\n            <span class=\"hljs-keyword\">delete<\/span> ptr;\n            <span class=\"hljs-keyword\">delete<\/span> ref_count;\n        }\n    }\n};<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-3\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">C++<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">cpp<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h3 class=\"wp-block-heading\">Reference Counting Mechanism<\/h3>\n\n\n\n<p>The reference counting mechanism ensures that the resource is only deleted when there are no more <code>SharedPtr<\/code> instances pointing to it. Each <code>SharedPtr<\/code> instance increments the reference count upon creation and decrements it upon destruction. When the reference count reaches zero, the resource is deleted.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Usage and Best Practices<\/h3>\n\n\n\n<p>Using <code>SharedPtr<\/code> in practice:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-4\" data-shcb-language-name=\"C++\" data-shcb-language-slug=\"cpp\"><span><code class=\"hljs language-cpp\"><span class=\"hljs-meta\">#<span class=\"hljs-meta-keyword\">include<\/span> <span class=\"hljs-meta-string\">&lt;iostream&gt;<\/span><\/span>\n\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">MyClass<\/span> {<\/span>\n<span class=\"hljs-keyword\">public<\/span>:\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">display<\/span><span class=\"hljs-params\">()<\/span> <span class=\"hljs-keyword\">const<\/span> <\/span>{\n        <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">cout<\/span> &lt;&lt; <span class=\"hljs-string\">\"MyClass object\\n\"<\/span>;\n    }\n};\n\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    <span class=\"hljs-function\">SharedPtr&lt;MyClass&gt; <span class=\"hljs-title\">ptr1<\/span><span class=\"hljs-params\">(<span class=\"hljs-keyword\">new<\/span> MyClass())<\/span><\/span>;\n    {\n        SharedPtr&lt;MyClass&gt; ptr2 = ptr1; <span class=\"hljs-comment\">\/\/ shared ownership<\/span>\n        ptr2-&gt;display();\n        <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">cout<\/span> &lt;&lt; <span class=\"hljs-string\">\"Exiting inner scope\\n\"<\/span>;\n    } <span class=\"hljs-comment\">\/\/ ptr2 goes out of scope, but the object is not deleted<\/span>\n\n    ptr1-&gt;display();\n    <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">cout<\/span> &lt;&lt; <span class=\"hljs-string\">\"Exiting main\\n\"<\/span>;\n    <span class=\"hljs-comment\">\/\/ ptr1 goes out of scope, object is deleted<\/span>\n\n    <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-number\">0<\/span>;\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-4\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">C++<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">cpp<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h3 class=\"wp-block-heading\">Best Practices<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Use <code>std::make_shared<\/code><\/strong>: Prefer using <code>std::make_shared<\/code> to create <code>std::shared_ptr<\/code> instances as it is more efficient and exception-safe.<\/li>\n\n\n\n<li><strong>Avoid Circular References<\/strong>: Be cautious of circular references which can prevent resources from being freed.<\/li>\n\n\n\n<li><strong>Use When Sharing Ownership<\/strong>: Use <code>std::shared_ptr<\/code> when you need shared ownership semantics.<\/li>\n<\/ul>\n\n\n\n<h2 class=\"wp-block-heading\">4. Weak Pointer (<code>std::weak_ptr<\/code>)<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Implementing a Simple Weak Pointer<\/h3>\n\n\n\n<p>A <code>std::weak_ptr<\/code> provides a way to refer to an object managed by <code>std::shared_ptr<\/code> without participating in the reference counting. It is used to break circular references.<\/p>\n\n\n\n<p>Here&#8217;s a basic implementation of a weak pointer:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-5\" data-shcb-language-name=\"C++\" data-shcb-language-slug=\"cpp\"><span><code class=\"hljs language-cpp\"><span class=\"hljs-keyword\">template<\/span>&lt;<span class=\"hljs-keyword\">typename<\/span> T&gt;\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">WeakPtr<\/span> {<\/span>\n<span class=\"hljs-keyword\">private<\/span>:\n    T* ptr;\n    <span class=\"hljs-keyword\">unsigned<\/span>* ref_count;\n\n<span class=\"hljs-keyword\">public<\/span>:\n    <span class=\"hljs-comment\">\/\/ Constructor<\/span>\n    WeakPtr() : ptr(<span class=\"hljs-literal\">nullptr<\/span>), ref_count(<span class=\"hljs-literal\">nullptr<\/span>) {}\n\n    <span class=\"hljs-comment\">\/\/ Construct from SharedPtr<\/span>\n    WeakPtr(<span class=\"hljs-keyword\">const<\/span> SharedPtr&lt;T&gt;&amp; sharedPtr) : ptr(sharedPtr.get()), ref_count(sharedPtr.ref_count) {}\n\n    <span class=\"hljs-comment\">\/\/ Overload dereference and arrow operators<\/span>\n    T&amp; <span class=\"hljs-keyword\">operator<\/span>*() <span class=\"hljs-keyword\">const<\/span> { <span class=\"hljs-keyword\">return<\/span> *ptr; }\n    T* <span class=\"hljs-keyword\">operator<\/span>-&gt;() <span class=\"hljs-keyword\">const<\/span> { <span class=\"hljs-keyword\">return<\/span> ptr; }\n\n    <span class=\"hljs-comment\">\/\/ Check if the resource is still available<\/span>\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">bool<\/span> <span class=\"hljs-title\">expired<\/span><span class=\"hljs-params\">()<\/span> <span class=\"hljs-keyword\">const<\/span> <\/span>{ <span class=\"hljs-keyword\">return<\/span> !ref_count || *ref_count == <span class=\"hljs-number\">0<\/span>; }\n\n    <span class=\"hljs-comment\">\/\/ Convert to SharedPtr<\/span>\n    <span class=\"hljs-function\">SharedPtr&lt;T&gt; <span class=\"hljs-title\">lock<\/span><span class=\"hljs-params\">()<\/span> <span class=\"hljs-keyword\">const<\/span> <\/span>{\n        <span class=\"hljs-keyword\">return<\/span> expired() ? SharedPtr&lt;T&gt;(<span class=\"hljs-literal\">nullptr<\/span>) : SharedPtr&lt;T&gt;(*<span class=\"hljs-keyword\">this<\/span>);\n    }\n};<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-5\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">C++<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">cpp<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h3 class=\"wp-block-heading\">Usage and Best Practices<\/h3>\n\n\n\n<p>Using <code>WeakPtr<\/code> in practice:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-6\" data-shcb-language-name=\"C++\" data-shcb-language-slug=\"cpp\"><span><code class=\"hljs language-cpp\"><span class=\"hljs-meta\">#<span class=\"hljs-meta-keyword\">include<\/span> <span class=\"hljs-meta-string\">&lt;iostream&gt;<\/span><\/span>\n\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">MyClass<\/span> {<\/span>\n<span class=\"hljs-keyword\">public<\/span>:\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">display<\/span><span class=\"hljs-params\">()<\/span> <span class=\"hljs-keyword\">const<\/span> <\/span>{\n        <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">cout<\/span> &lt;&lt; <span class=\"hljs-string\">\"MyClass object\\n\"<\/span>;\n    }\n};\n\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    <span class=\"hljs-function\">SharedPtr&lt;MyClass&gt; <span class=\"hljs-title\">sharedPtr<\/span><span class=\"hljs-params\">(<span class=\"hljs-keyword\">new<\/span> MyClass())<\/span><\/span>;\n    WeakPtr&lt;MyClass&gt; weakPtr = sharedPtr;\n\n    <span class=\"hljs-keyword\">if<\/span> (!weakPtr.expired()) {\n        SharedPtr&lt;MyClass&gt; tempPtr = weakPtr.lock();\n        tempPtr-&gt;display();\n    }\n\n    <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-number\">0<\/span>;\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-6\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">C++<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">cpp<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h3 class=\"wp-block-heading\">Best Practices<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Use to Break Cycles<\/strong>: Use <code>std::weak_ptr<\/code> to break cycles of <code>std::shared_ptr<\/code> references.<\/li>\n\n\n\n<li><strong>Check Expiration<\/strong>: Always check if the <code>std::weak_ptr<\/code> has expired before using it.<\/li>\n<\/ul>\n\n\n\n<h2 class=\"wp-block-heading\">5. Custom Deleters<\/h2>\n\n\n\n<p>Smart pointers can be customized with<\/p>\n\n\n\n<p>custom deleters to manage resources other than memory (e.g., file handles, sockets).<\/p>\n\n\n\n<p>Example with <code>std::unique_ptr<\/code>:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-7\" data-shcb-language-name=\"C++\" data-shcb-language-slug=\"cpp\"><span><code class=\"hljs language-cpp\"><span class=\"hljs-meta\">#<span class=\"hljs-meta-keyword\">include<\/span> <span class=\"hljs-meta-string\">&lt;iostream&gt;<\/span><\/span>\n<span class=\"hljs-meta\">#<span class=\"hljs-meta-keyword\">include<\/span> <span class=\"hljs-meta-string\">&lt;memory&gt;<\/span><\/span>\n\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">struct<\/span> <span class=\"hljs-title\">FileDeleter<\/span> {<\/span>\n    <span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">operator<\/span><span class=\"hljs-params\">()<\/span><span class=\"hljs-params\">(FILE* file)<\/span> <span class=\"hljs-keyword\">const<\/span> <\/span>{\n        <span class=\"hljs-keyword\">if<\/span> (file) {\n            fclose(file);\n            <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">cout<\/span> &lt;&lt; <span class=\"hljs-string\">\"File closed\\n\"<\/span>;\n        }\n    }\n};\n\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    <span class=\"hljs-function\"><span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">unique_ptr<\/span>&lt;FILE, FileDeleter&gt; <span class=\"hljs-title\">filePtr<\/span><span class=\"hljs-params\">(fopen(<span class=\"hljs-string\">\"example.txt\"<\/span>, <span class=\"hljs-string\">\"w\"<\/span>))<\/span><\/span>;\n    <span class=\"hljs-keyword\">if<\/span> (filePtr) {\n        <span class=\"hljs-built_in\">fputs<\/span>(<span class=\"hljs-string\">\"Hello, World!\"<\/span>, filePtr.get());\n    }\n    <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-number\">0<\/span>;\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-7\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">C++<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">cpp<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h2 class=\"wp-block-heading\">6. Advanced Topics<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Circular References<\/h3>\n\n\n\n<p>Circular references occur when two or more objects reference each other through <code>std::shared_ptr<\/code>, preventing them from being destroyed.<\/p>\n\n\n\n<p>Example:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-8\" data-shcb-language-name=\"C++\" data-shcb-language-slug=\"cpp\"><span><code class=\"hljs language-cpp\"><span class=\"hljs-meta\">#<span class=\"hljs-meta-keyword\">include<\/span> <span class=\"hljs-meta-string\">&lt;iostream&gt;<\/span><\/span>\n<span class=\"hljs-meta\">#<span class=\"hljs-meta-keyword\">include<\/span> <span class=\"hljs-meta-string\">&lt;memory&gt;<\/span><\/span>\n\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">B<\/span>;<\/span> <span class=\"hljs-comment\">\/\/ Forward declaration<\/span>\n\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">A<\/span> {<\/span>\n<span class=\"hljs-keyword\">public<\/span>:\n    <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">shared_ptr<\/span>&lt;B&gt; ptrB;\n    ~A() { <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">cout<\/span> &lt;&lt; <span class=\"hljs-string\">\"A destroyed\\n\"<\/span>; }\n};\n\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">B<\/span> {<\/span>\n<span class=\"hljs-keyword\">public<\/span>:\n    <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">shared_ptr<\/span>&lt;A&gt; ptrA;\n    ~B() { <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">cout<\/span> &lt;&lt; <span class=\"hljs-string\">\"B destroyed\\n\"<\/span>; }\n};\n\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    <span class=\"hljs-keyword\">auto<\/span> a = <span class=\"hljs-built_in\">std<\/span>::make_shared&lt;A&gt;();\n    <span class=\"hljs-keyword\">auto<\/span> b = <span class=\"hljs-built_in\">std<\/span>::make_shared&lt;B&gt;();\n    a-&gt;ptrB = b;\n    b-&gt;ptrA = a;\n\n    <span class=\"hljs-comment\">\/\/ Neither A nor B will be destroyed<\/span>\n    <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-number\">0<\/span>;\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-8\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">C++<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">cpp<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>To fix this, use <code>std::weak_ptr<\/code> to break the cycle:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-9\" data-shcb-language-name=\"C++\" data-shcb-language-slug=\"cpp\"><span><code class=\"hljs language-cpp\"><span class=\"hljs-meta\">#<span class=\"hljs-meta-keyword\">include<\/span> <span class=\"hljs-meta-string\">&lt;iostream&gt;<\/span><\/span>\n<span class=\"hljs-meta\">#<span class=\"hljs-meta-keyword\">include<\/span> <span class=\"hljs-meta-string\">&lt;memory&gt;<\/span><\/span>\n\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">B<\/span>;<\/span> <span class=\"hljs-comment\">\/\/ Forward declaration<\/span>\n\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">A<\/span> {<\/span>\n<span class=\"hljs-keyword\">public<\/span>:\n    <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">shared_ptr<\/span>&lt;B&gt; ptrB;\n    ~A() { <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">cout<\/span> &lt;&lt; <span class=\"hljs-string\">\"A destroyed\\n\"<\/span>; }\n};\n\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">B<\/span> {<\/span>\n<span class=\"hljs-keyword\">public<\/span>:\n    <span class=\"hljs-built_in\">std<\/span>::weak_ptr&lt;A&gt; ptrA; <span class=\"hljs-comment\">\/\/ weak_ptr to break the cycle<\/span>\n    ~B() { <span class=\"hljs-built_in\">std<\/span>::<span class=\"hljs-built_in\">cout<\/span> &lt;&lt; <span class=\"hljs-string\">\"B destroyed\\n\"<\/span>; }\n};\n\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">int<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n    <span class=\"hljs-keyword\">auto<\/span> a = <span class=\"hljs-built_in\">std<\/span>::make_shared&lt;A&gt;();\n    <span class=\"hljs-keyword\">auto<\/span> b = <span class=\"hljs-built_in\">std<\/span>::make_shared&lt;B&gt;();\n    a-&gt;ptrB = b;\n    b-&gt;ptrA = a;\n\n    <span class=\"hljs-comment\">\/\/ Both A and B will be destroyed<\/span>\n    <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-number\">0<\/span>;\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-9\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">C++<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">cpp<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h3 class=\"wp-block-heading\">Performance Considerations<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong><code>std::unique_ptr<\/code><\/strong> is lightweight and has no overhead other than the memory for the pointer itself.<\/li>\n\n\n\n<li><strong><code>std::shared_ptr<\/code><\/strong> has a slight overhead due to the reference counting mechanism. Use <code>std::make_shared<\/code> for efficient memory allocation.<\/li>\n\n\n\n<li><strong><code>std::weak_ptr<\/code><\/strong> has minimal overhead and is useful for breaking cycles.<\/li>\n<\/ul>\n\n\n\n<h2 class=\"wp-block-heading\">7. Conclusion<\/h2>\n\n\n\n<p>Smart pointers are an essential feature of modern C++, providing automatic memory management and preventing common errors like memory leaks and dangling pointers. By understanding and using <code>std::unique_ptr<\/code>, <code>std::shared_ptr<\/code>, and <code>std::weak_ptr<\/code>, you can write safer and more efficient C++ code.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Smart pointers are a key feature of modern C++ that help manage dynamic memory and prevent common errors such as memory leaks and dangling pointers. They automate the process of memory management by automatically deallocating memory when it is no longer needed. This tutorial will guide you through the implementation and use of various types [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[9,4],"tags":[],"class_list":{"0":"post-1958","1":"post","2":"type-post","3":"status-publish","4":"format-standard","6":"category-cplusplus","7":"category-programming-languages","8":"entry"},"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.4 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>How to Implement Smart Pointers in C++<\/title>\n<meta name=\"description\" content=\"Smart pointers are a key feature of modern C++ that help manage dynamic memory and prevent common errors such as memory leaks and dangling pointers.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How to Implement Smart Pointers in C++\" \/>\n<meta property=\"og:description\" content=\"Smart pointers are a key feature of modern C++ that help manage dynamic memory and prevent common errors such as memory leaks and dangling pointers.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-06-22T09:28:03+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-06-22T09:28:13+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"3 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-smart-pointers-in-cpp\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-smart-pointers-in-cpp\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"How to Implement Smart Pointers in C++\",\"datePublished\":\"2024-06-22T09:28:03+00:00\",\"dateModified\":\"2024-06-22T09:28:13+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-smart-pointers-in-cpp\\\/\"},\"wordCount\":596,\"articleSection\":[\"C++\",\"Programming Languages\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-smart-pointers-in-cpp\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-smart-pointers-in-cpp\\\/\",\"name\":\"How to Implement Smart Pointers in C++\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2024-06-22T09:28:03+00:00\",\"dateModified\":\"2024-06-22T09:28:13+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"Smart pointers are a key feature of modern C++ that help manage dynamic memory and prevent common errors such as memory leaks and dangling pointers.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-smart-pointers-in-cpp\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-smart-pointers-in-cpp\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-smart-pointers-in-cpp\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"C++\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/cplusplus\\\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"How to Implement Smart Pointers in C++\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"How to Implement Smart Pointers in C++","description":"Smart pointers are a key feature of modern C++ that help manage dynamic memory and prevent common errors such as memory leaks and dangling pointers.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/","og_locale":"en_US","og_type":"article","og_title":"How to Implement Smart Pointers in C++","og_description":"Smart pointers are a key feature of modern C++ that help manage dynamic memory and prevent common errors such as memory leaks and dangling pointers.","og_url":"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/","article_published_time":"2024-06-22T09:28:03+00:00","article_modified_time":"2024-06-22T09:28:13+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"3 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"How to Implement Smart Pointers in C++","datePublished":"2024-06-22T09:28:03+00:00","dateModified":"2024-06-22T09:28:13+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/"},"wordCount":596,"articleSection":["C++","Programming Languages"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/","url":"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/","name":"How to Implement Smart Pointers in C++","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2024-06-22T09:28:03+00:00","dateModified":"2024-06-22T09:28:13+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"Smart pointers are a key feature of modern C++ that help manage dynamic memory and prevent common errors such as memory leaks and dangling pointers.","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-smart-pointers-in-cpp\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"C++","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/cplusplus\/"},{"@type":"ListItem","position":4,"name":"How to Implement Smart Pointers in C++"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1776115684","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1958","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=1958"}],"version-history":[{"count":2,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1958\/revisions"}],"predecessor-version":[{"id":1960,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1958\/revisions\/1960"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=1958"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=1958"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=1958"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}