<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: llzzz</title>
    <description>The latest articles on DEV Community by llzzz (@z6123).</description>
    <link>https://dev.to/z6123</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4200729%2Fd61b01c6-1025-4937-a0be-2a228fe3443b.png</url>
      <title>DEV Community: llzzz</title>
      <link>https://dev.to/z6123</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/z6123"/>
    <language>en</language>
    <item>
      <title>The most important idiom in C++</title>
      <dc:creator>llzzz</dc:creator>
      <pubDate>Mon, 16 Nov 2026 14:53:16 +0000</pubDate>
      <link>https://dev.to/z6123/the-most-important-idiom-in-c-2hj3</link>
      <guid>https://dev.to/z6123/the-most-important-idiom-in-c-2hj3</guid>
      <description>&lt;p&gt;&lt;em&gt;If you don't know the RAII idiom, you don't know modern C++&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;RAII (Resource Acquisition Is Initialization) is the idiom that defines modern C++. If you want to move from legacy code to modern C++, this is the place to start.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Core Concept
&lt;/h2&gt;

&lt;p&gt;RAII is C++'s fundamental idiom for deterministic resource management. It ties the lifetime of a resource — memory, file handles, mutexes, sockets — directly to the lifetime of a stack-allocated object. When that object goes out of scope, its destructor automatically releases the resource, guaranteeing cleanup even when exceptions are thrown.&lt;/p&gt;

&lt;p&gt;RAII works by leveraging two automatic language behaviors:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Construction&lt;/strong&gt;: When a stack object is created, its constructor runs. You acquire the resource inside the constructor. If acquisition fails, you throw an exception, and the object is never considered fully constructed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Destruction&lt;/strong&gt;: When the object's scope ends (normal exit or stack unwinding due to an exception), the destructor is invoked automatically. You release the resource inside the destructor.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;This eliminates the need for manual cleanup code (like &lt;code&gt;delete&lt;/code&gt;, &lt;code&gt;fclose&lt;/code&gt;, or &lt;code&gt;unlock&lt;/code&gt;) scattered across every possible exit path. The resource is tied to the object's scope, so it cannot leak.&lt;/p&gt;

&lt;h3&gt;
  
  
  What RAII Manages
&lt;/h3&gt;

&lt;p&gt;RAII is not limited to memory. It applies to &lt;strong&gt;any&lt;/strong&gt; resource that must be acquired and later released. Some common examples are:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Resource Type&lt;/th&gt;
&lt;th&gt;Acquire&lt;/th&gt;
&lt;th&gt;Release&lt;/th&gt;
&lt;th&gt;Standard RAII Wrapper&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Heap Memory&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;new&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;delete&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;std::unique_ptr&lt;/code&gt;, &lt;code&gt;std::shared_ptr&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Mutex Lock&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;lock()&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;unlock()&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;std::lock_guard&lt;/code&gt;, &lt;code&gt;std::unique_lock&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;File Handle&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;fopen&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;fclose&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Custom wrapper (e.g., &lt;code&gt;unique_ptr&amp;lt;FILE, decltype(&amp;amp;fclose)&amp;gt;&lt;/code&gt;)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Thread&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;std::thread&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;join()&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;std::jthread&lt;/code&gt; (C++20)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h3&gt;
  
  
  Example of the Release Half
&lt;/h3&gt;

&lt;p&gt;Without RAII, managing a mutex is error-prone and annoying because every return or exception path requires an &lt;code&gt;unlock()&lt;/code&gt;. If you miss one, you have unsafe code — a deadlock, a leak, or worse.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Manual management (fragile)&lt;/span&gt;
&lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;bad_function&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;mtx&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;lock&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;error&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="c1"&gt;// Oops... forgot to unlock here&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="c1"&gt;// ... if an exception throws here, mtx stays locked forever ...&lt;/span&gt;
    &lt;span class="n"&gt;mtx&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;unlock&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;With RAII, the cleanup is guaranteed:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="c1"&gt;// RAII (robust)&lt;/span&gt;
&lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;good_function&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;lock_guard&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;mutex&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="nf"&gt;lock&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;mtx&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// Acquires&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;error&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// Automatically unlocks via destructor&lt;/span&gt;
    &lt;span class="c1"&gt;// ... exception thrown here? Stack unwinding destroys 'lock', unlocking safely ...&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Rules and Pitfalls
&lt;/h3&gt;

&lt;p&gt;To implement RAII correctly in your own classes, you must follow strict rules:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Destructors must not throw exceptions.&lt;/strong&gt; If a destructor throws during stack unwinding (while another exception is active), the program will terminate. Release operations in destructors should be designed to never fail, or must swallow errors. Be aware that a failed release means the resource may leak silently.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Handle Copying Carefully (Rule of Three/Five).&lt;/strong&gt; If your RAII class owns a resource, the default copy behavior (which copies the raw handle) leads to &lt;strong&gt;double-free&lt;/strong&gt; bugs. You must either:

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Delete&lt;/strong&gt; the copy constructor and copy assignment (for unique ownership, like &lt;code&gt;unique_ptr&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Implement deep copying&lt;/strong&gt; (if the resource should be cloned).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Implement move semantics&lt;/strong&gt; (transferring ownership).&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The Rule of Zero.&lt;/strong&gt; The best practice is to avoid writing your own RAII classes at all. Instead, compose your classes using existing standard RAII wrappers (like &lt;code&gt;std::vector&lt;/code&gt;, &lt;code&gt;std::string&lt;/code&gt;, &lt;code&gt;std::unique_ptr&lt;/code&gt;). If your class has no raw resources, you don't need to write a destructor, and the compiler-generated copy and move operations will work correctly. In modern C++, the Rule of Zero is the most preferred approach.&lt;/li&gt;
&lt;/ol&gt;

&lt;h3&gt;
  
  
  What RAII Cannot Do
&lt;/h3&gt;

&lt;p&gt;RAII is not a garbage collector. It relies on deterministic scope exit. It &lt;strong&gt;cannot&lt;/strong&gt; manage resources that are not acquired at initialization or whose lifetime does not align with a lexical scope. Examples include CPU time, network bandwidth, or resources that must outlive the function's scope but have no clear owner.&lt;/p&gt;

&lt;h2&gt;
  
  
  Resource Acquisition
&lt;/h2&gt;

&lt;p&gt;This is the part a lot of people overlook. Many C++ developers only know the release half, not the acquisition half. Here is what it means.&lt;/p&gt;

&lt;p&gt;The RAII idiom says a resource should be acquired during initialization — in essence, in the constructor. The key principles are:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Acquire in the member initializer list.&lt;/li&gt;
&lt;li&gt;If acquisition fails, throw — so the object is never considered constructed, and no destructor runs on a half-built object.&lt;/li&gt;
&lt;li&gt;The object is fully valid immediately after construction — no separate &lt;code&gt;open()&lt;/code&gt; or &lt;code&gt;init()&lt;/code&gt; two-phase setup that callers can forget.&lt;/li&gt;
&lt;li&gt;Acquisition and release are symmetric — every acquired resource has exactly one owner responsible for releasing it.&lt;/li&gt;
&lt;/ol&gt;

&lt;h3&gt;
  
  
  Example
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="c1"&gt;// BUGGY: leaks 'a' if acquiring 'b' throws&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;TwoResources&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nc"&gt;ResourceA&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// raw pointer, maybe heap allocated&lt;/span&gt;
    &lt;span class="nc"&gt;ResourceB&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;public&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="nc"&gt;TwoResources&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;acquire_a&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;      &lt;span class="c1"&gt;// succeeds&lt;/span&gt;
        &lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;acquire_b&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;      &lt;span class="c1"&gt;// throws! 'a' is leaked, destructor won't run&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="o"&gt;~&lt;/span&gt;&lt;span class="nc"&gt;TwoResources&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nf"&gt;release_b&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="nf"&gt;release_a&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  The Idiomatic Way
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="c1"&gt;// each member is itself an RAII type&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;TwoResources&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;ResourceA&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// RAII member&lt;/span&gt;
    &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;ResourceB&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// RAII member&lt;/span&gt;
&lt;span class="k"&gt;public&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="nc"&gt;TwoResources&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;a&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;acquire_a&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;   &lt;span class="c1"&gt;// if this throws, nothing to clean up&lt;/span&gt;
          &lt;span class="nf"&gt;b&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;acquire_b&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;    &lt;span class="c1"&gt;// if this throws, 'a' is destroyed automatically&lt;/span&gt;
    &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="c1"&gt;// No user-defined destructor needed (Rule of Zero)&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Two-Phase Construction Anti-Pattern
&lt;/h3&gt;

&lt;p&gt;If you have worked in a legacy codebase, you may have seen people writing things like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="c1"&gt;// ANTI-PATTERN: two-phase init&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;File&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kt"&gt;FILE&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;nullptr&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;public&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="kt"&gt;bool&lt;/span&gt; &lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="kt"&gt;char&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;fopen&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"r"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="kc"&gt;nullptr&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="o"&gt;~&lt;/span&gt;&lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;fclose&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="nc"&gt;File&lt;/span&gt; &lt;span class="n"&gt;file&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;file&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"data.txt"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="cm"&gt;/* handle error */&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;  &lt;span class="c1"&gt;// caller can forget to check&lt;/span&gt;
&lt;span class="c1"&gt;// ... or forget to call open() entirely, leaving f == nullptr ...&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The code above looks innocent enough. It compiles. It runs. It even has a destructor that cleans up. So what's the problem?&lt;/p&gt;

&lt;p&gt;The problem is that the object now has a hidden third logical state. Observationally, the &lt;code&gt;FILE*&lt;/code&gt; is either null or valid — two states the destructor handles gracefully thanks to the &lt;code&gt;if (f)&lt;/code&gt; guard. But logically, there are three situations the caller must keep in their head:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Constructed but never opened (the &lt;code&gt;FILE*&lt;/code&gt; is &lt;code&gt;nullptr&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;Opened successfully (the &lt;code&gt;FILE*&lt;/code&gt; is valid)&lt;/li&gt;
&lt;li&gt;Opened and failed (the &lt;code&gt;FILE*&lt;/code&gt; is &lt;code&gt;nullptr&lt;/code&gt; again, but you were &lt;em&gt;supposed&lt;/em&gt; to check)&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;States 1 and 3 are indistinguishable from the outside, and neither the object nor the caller can tell them apart. Every function that receives a &lt;code&gt;File&lt;/code&gt; now has to ask: "Has someone called &lt;code&gt;open()&lt;/code&gt; on this yet? Did it work?" That's not a resource management problem anymore — that's a social contract, and social contracts are exactly what RAII exists to replace with compiler-enforced guarantees.&lt;/p&gt;

&lt;p&gt;There is a second, quieter problem: because the class declares a destructor, it silently loses its implicit move operations. So this "harmless" anti-pattern also makes the type expensive to pass around.&lt;/p&gt;

&lt;p&gt;The RAII-correct version throws on failure, so the object is either fully usable or it doesn't exist:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;File&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kt"&gt;FILE&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;public&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;explicit&lt;/span&gt; &lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="kt"&gt;char&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;f&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;fopen&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"r"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;throw&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;runtime_error&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"cannot open file"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="o"&gt;~&lt;/span&gt;&lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;fclose&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;delete&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="k"&gt;operator&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;delete&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

    &lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;noexcept&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;f&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;nullptr&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="k"&gt;operator&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;noexcept&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kc"&gt;this&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;fclose&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
            &lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
            &lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;nullptr&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="kc"&gt;this&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Now there is no "half-open" state. There is no &lt;code&gt;open()&lt;/code&gt; to forget. There is no boolean to check. The constructor either gives you a working file or throws an exception, and your code never has to wonder which one happened.&lt;/p&gt;

&lt;h3&gt;
  
  
  When You Genuinely Need Deferred Acquisition
&lt;/h3&gt;

&lt;p&gt;Sometimes you really do want to delay acquisition — for example, a resource that should only be opened on first use, or a member that is optional depending on runtime configuration. The RAII-friendly answer is not a two-phase &lt;code&gt;init()&lt;/code&gt; method. It is one of these:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A factory function&lt;/strong&gt; that returns a fully constructed object:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="nf"&gt;open_file&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="kt"&gt;char&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// throws on failure&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;file&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;open_file&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"data.txt"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// valid or exception, never half-built&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;&lt;code&gt;std::optional&lt;/code&gt;&lt;/strong&gt; for a resource that may legitimately be absent:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;optional&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;maybe_file&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;config&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;use_file&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;maybe_file&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;emplace&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;config&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// constructs in place, throws on failure&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="c1"&gt;// later:&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;maybe_file&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="cm"&gt;/* use it */&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;A &lt;code&gt;unique_ptr&lt;/code&gt; that starts null&lt;/strong&gt; and is populated by a factory call:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;file&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;config&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;use_file&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;file&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;File&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;config&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;In all three cases, the acquisition itself still happens inside a constructor. The deferral is about &lt;em&gt;whether&lt;/em&gt; to construct the object, not about constructing it in a broken state and hoping someone remembers to fix it later.&lt;/p&gt;

&lt;h3&gt;
  
  
  The Acquisition Checklist
&lt;/h3&gt;

&lt;p&gt;If you take nothing else from this article, take this. When you write or review an RAII class, ask:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Does the constructor acquire everything the object needs, or does it leave the object in a "not yet ready" state?&lt;/li&gt;
&lt;li&gt;If a later acquisition fails, does the earlier acquisition get cleaned up automatically? (Hint: use RAII members, not raw members.)&lt;/li&gt;
&lt;li&gt;Can the object be copied? If so, does copying duplicate the resource or share it? If you can't answer clearly, delete the copy operations.&lt;/li&gt;
&lt;li&gt;Can the object be moved? Does the move constructor leave the source in a valid, destructible state (usually by nulling out the handle)?&lt;/li&gt;
&lt;li&gt;Does the destructor ever throw? It shouldn't. If a release operation can fail, swallow the error or log it — but do not let it escape.&lt;/li&gt;
&lt;li&gt;Could you have used a standard type (&lt;code&gt;unique_ptr&lt;/code&gt;, &lt;code&gt;vector&lt;/code&gt;, &lt;code&gt;lock_guard&lt;/code&gt;, &lt;code&gt;jthread&lt;/code&gt;) instead of writing this class at all? If yes, do that. Rule of Zero beats Rule of Five every time.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The Bottom Line
&lt;/h2&gt;

&lt;p&gt;RAII is not just "use a destructor to clean up." It is a contract: &lt;em&gt;the object's lifetime is the resource's lifetime, and the object is valid from the moment it exists.&lt;/em&gt; The release half gets all the attention because it's the half that prevents leaks. But the acquisition half is what makes the contract airtight — it's what guarantees there is never an object that exists but doesn't work.&lt;/p&gt;

&lt;p&gt;That's the idiom. That's why it defines modern C++. And that's why, if you don't know RAII — both halves of it — you don't know modern C++.&lt;/p&gt;

</description>
      <category>cpp</category>
      <category>programming</category>
      <category>softwaredevelopment</category>
    </item>
    <item>
      <title>Everything about `[[maybe_unused]]`</title>
      <dc:creator>llzzz</dc:creator>
      <pubDate>Sat, 14 Nov 2026 12:42:50 +0000</pubDate>
      <link>https://dev.to/z6123/everything-about-maybeunused-5aj9</link>
      <guid>https://dev.to/z6123/everything-about-maybeunused-5aj9</guid>
      <description>&lt;p&gt;Modern C++ development is built on a foundation of strict compiler checks. For most professional codebases, enabling &lt;code&gt;-Wall -Wextra -Werror&lt;/code&gt; (or their MSVC equivalents) is a non-negotiable standard. These flags act as a first line of defense, catching silent bugs like declaring a variable but forgetting to use it.&lt;/p&gt;

&lt;p&gt;But this strictness comes with a cost: the compiler lacks context. It cannot distinguish between a variable you forgot to use and a variable you intentionally ignored due to API contracts, debug-only assertions, or conditional compilation.&lt;/p&gt;

&lt;p&gt;Managing this tension between strict compilation and developer intent has driven significant changes in the C++ standard. Here is the complete guide to handling unused entities, tracking the evolution from C++17’s &lt;code&gt;[[maybe_unused]]&lt;/code&gt; attribute to the paradigm-shifting updates in C++26.&lt;/p&gt;




&lt;h2&gt;
  
  
  Pre-C++17 Workarounds
&lt;/h2&gt;

&lt;p&gt;Before C++17, developers had no standardized way to tell the compiler that a variable was intentionally ignored. This led to codebases littered with compiler-specific macros or hacky casts.&lt;/p&gt;

&lt;p&gt;To silence warnings, developers typically relied on casting the variable to &lt;code&gt;void&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;on_mouse_click&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;button_id&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;void&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="n"&gt;button_id&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// Hack to silence the unused variable warning&lt;/span&gt;
    &lt;span class="nb"&gt;printf&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Clicked at %d, %d\n"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Other alternatives included wrapping code in &lt;code&gt;#pragma&lt;/code&gt; directives or using non-standard compiler extensions like &lt;code&gt;__attribute__((unused))&lt;/code&gt;. These solutions were noisy, fragmented, and failed to clearly communicate developer intent to anyone reading the code.&lt;/p&gt;




&lt;h2&gt;
  
  
  C++17: Formalizing Intent with &lt;code&gt;[[maybe_unused]]&lt;/code&gt;
&lt;/h2&gt;

&lt;p&gt;C++17 revolutionized this space by introducing standard attributes, and chief among them was &lt;code&gt;[[maybe_unused]]&lt;/code&gt;. This attribute provides a clean, standard-compliant way to express intent: &lt;em&gt;"I am aware this entity might not be used in all compilation paths, and that is deliberate."&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The beauty of &lt;code&gt;[[maybe_unused]]&lt;/code&gt; lies in its versatility. It can be applied to almost any declaration in the language.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. The &lt;code&gt;assert&lt;/code&gt; Idiom (Local Variables)
&lt;/h3&gt;

&lt;p&gt;The most frequent use case for &lt;code&gt;[[maybe_unused]]&lt;/code&gt; is handling variables that exist only to support &lt;code&gt;assert&lt;/code&gt; macros. Because &lt;code&gt;assert&lt;/code&gt; is stripped out of Release builds (when &lt;code&gt;NDEBUG&lt;/code&gt; is defined), any variable used exclusively inside an assertion will trigger an unused variable warning in production.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;process_data&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;vector&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;maybe_unused&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="kt"&gt;bool&lt;/span&gt; &lt;span class="n"&gt;is_valid&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;validate_data&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nf"&gt;assert&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;is_valid&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="s2"&gt;"Data validation failed!"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; 

    &lt;span class="c1"&gt;// In Release mode, is_valid is never evaluated or read,&lt;/span&gt;
    &lt;span class="c1"&gt;// but [[maybe_unused]] prevents the compiler from complaining.&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  2. API Contracts (Function Parameters)
&lt;/h3&gt;

&lt;p&gt;When implementing a virtual function, fulfilling a concept, or writing a callback, the interface dictates the parameters you must accept—even if your specific implementation doesn't need them all.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="cp"&gt;#include &amp;lt;iostream&amp;gt;&lt;/span&gt;

&lt;span class="c1"&gt;// Marked [[maybe_unused]]&lt;/span&gt;
&lt;span class="c1"&gt;// but never instantiate Widget -&amp;gt; avoids -Wunused warnings.&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;maybe_unused&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="nc"&gt;Widget&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
   &lt;span class="k"&gt;public&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;render&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;cout&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class="s2"&gt;"Rendering widget\n"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nc"&gt;Widget&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// ok&lt;/span&gt;
    &lt;span class="c1"&gt;// w.render();&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  3. Conditional Compilation (Functions and Types)
&lt;/h3&gt;

&lt;p&gt;Helper functions or structs that are only invoked under specific build configurations (like debug-only logging) often trigger unused function warnings.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;maybe_unused&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="kd"&gt;static&lt;/span&gt; &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;print_debug_state&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c1"&gt;// ...&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;enum&lt;/span&gt; &lt;span class="nf"&gt;class&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;maybe_unused&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="nc"&gt;InternalState&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nc"&gt;Active&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nc"&gt;Idle&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Edge cases
&lt;/h3&gt;

&lt;p&gt;if you done any multi-threading in C++, you may know that there is mutex that use RAII pattern in C++. For example like the following:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="cp"&gt;#include &amp;lt;iostream&amp;gt;&lt;/span&gt;
&lt;span class="cp"&gt;#include &amp;lt;mutex&amp;gt;&lt;/span&gt;

&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;mutex&lt;/span&gt; &lt;span class="n"&gt;mtx&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;safe_increment&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;lock_guard&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;mutex&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="nf"&gt;lock&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;mtx&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

    &lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nf"&gt;safe_increment&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

    &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;cout&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You may notice that the mutex is completely unnecessary in this example, but that's not the point. The point is that you see the &lt;code&gt;lock&lt;/code&gt; variable is actually unused. But there is no error/warning even if you turn on &lt;code&gt;-Wall -Wextra -Werror&lt;/code&gt;. Why is that? It is not required by the standard, but it usually won't warn for variables whose type has a &lt;code&gt;non-trivial destructor&lt;/code&gt;, because:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;The destructor has observable side effects (in lock_guard's case, unlocking the mutex).&lt;/li&gt;
&lt;li&gt;The variable is effectively "used" by virtue of its lifetime having meaning — it's an RAII guard.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;So &lt;code&gt;std::lock_guard&amp;lt;std::mutex&amp;gt; lock(mtx);&lt;/code&gt; is a deliberately unused variable, but the compiler recognizes the pattern and stays silent. For type that has a trivial destructor, it will warn. If you want to warn for for type that has trivial destructor, you can reference the following example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="cp"&gt;#include &amp;lt;iostream&amp;gt;&lt;/span&gt;

&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="nf"&gt;__attribute__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;warn_unused&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nc"&gt;Object&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nc"&gt;Object&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;use&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nc"&gt;Object&lt;/span&gt; &lt;span class="n"&gt;myObject&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// will give : warning: unused variable 'myObject' [-Wunused-variable]&lt;/span&gt;
    &lt;span class="c1"&gt;//myObject.use(); // uncomment to hide this warning&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;but the attribute &lt;code&gt;__attribute__((warn_unused))&lt;/code&gt; is only available in clang/gcc. Running the same script in MSVC will likely give you a compile error.&lt;/p&gt;

&lt;h3&gt;
  
  
  The Structured Bindings Bottleneck
&lt;/h3&gt;

&lt;p&gt;Despite its utility, &lt;code&gt;[[maybe_unused]]&lt;/code&gt; had a glaring limitation in C++17 through C++23: it did not play well with structured bindings. If you wanted to unpack a tuple but ignore one of the values, the standard did not allow applying the attribute to an individual binding.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="c1"&gt;// You could apply it to the whole binding:&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;maybe_unused&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="kd"&gt;auto&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;get_coordinates&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; 

&lt;span class="c1"&gt;// But you could NOT standardly do this:&lt;/span&gt;
&lt;span class="c1"&gt;// auto [x, [[maybe_unused]] y] = get_coordinates(); &lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;






&lt;h2&gt;
  
  
  C++26: unnamed placeholder (Name-Independent Declarations)
&lt;/h2&gt;

&lt;p&gt;C++26 fundamentally shifts how we handle unused local variables by adopting a feature long loved by Python, Rust, and Go developers: &lt;strong&gt;Name-Independent Declarations&lt;/strong&gt; (introduced via P2169).&lt;/p&gt;

&lt;p&gt;In C++26, the single underscore &lt;code&gt;_&lt;/code&gt; becomes a special placeholder. It signals to the compiler that a variable is intentionally unnamed and unused. This drastically reduces the verbosity of &lt;code&gt;[[maybe_unused]]&lt;/code&gt; in local scopes.&lt;/p&gt;

&lt;p&gt;Furthermore, you can declare multiple variables named &lt;code&gt;_&lt;/code&gt; in the same scope without triggering a redefinition error.&lt;/p&gt;

&lt;h3&gt;
  
  
  Revolutionizing Structured Bindings
&lt;/h3&gt;

&lt;p&gt;C++26 finally solves the structured binding limitation gracefully. Instead of awkward workarounds, you simply use the underscore for values you want to discard.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="c1"&gt;// C++26: Ignoring the second return value&lt;/span&gt;
&lt;span class="kd"&gt;auto&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;do_something&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Cleaning Up RAII and Guards
&lt;/h3&gt;

&lt;p&gt;RAII objects like &lt;code&gt;std::lock_guard&lt;/code&gt; are often instantiated solely for their side effects (locking a mutex on creation, unlocking on destruction). They are never explicitly referenced by name, which historically required giving them dummy names or using &lt;code&gt;[[maybe_unused]]&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;In C++26, the syntax becomes elegantly minimal:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;thread_safe_operation&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c1"&gt;// C++26: No [[maybe_unused]], no dummy name needed&lt;/span&gt;
    &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;lock_guard&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;my_mutex&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; 

    &lt;span class="c1"&gt;// Perform operations...&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;






&lt;h2&gt;
  
  
  Summary: When to Use What?
&lt;/h2&gt;

&lt;p&gt;As we move into the C++26 era, the toolkit for handling unused entities has never been richer. Here is a quick reference guide to modern best practices:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Use &lt;code&gt;_&lt;/code&gt; (C++26 onwards):&lt;/strong&gt; For local RAII guards (locks, scoped timers), discarding specific elements in structured bindings, and ignoring return values.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Use &lt;code&gt;[[maybe_unused]]&lt;/code&gt;:&lt;/strong&gt; For function parameters in APIs/callbacks, functions that are conditionally compiled out, class/enum definitions, and template parameters heavily reliant on &lt;code&gt;if constexpr&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Avoid &lt;code&gt;(void)var;&lt;/code&gt;:&lt;/strong&gt; Completely retire this C-style hack in modern codebases.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The journey from hacky void casts to standard attributes, and finally to name-independent declarations, highlights C++'s ongoing commitment to expressiveness. By leveraging &lt;code&gt;[[maybe_unused]]&lt;/code&gt; and the new C++26 &lt;code&gt;_&lt;/code&gt; placeholder, you can maintain the rigorous safety of &lt;code&gt;-Werror&lt;/code&gt; while keeping your code clean, intentional, and highly readable. If you want to know more about it, you can have a look at the standard draft &lt;a href="https://eel.is/c++draft/dcl.attr.unused" rel="noopener noreferrer"&gt;here&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>cpp</category>
      <category>programming</category>
      <category>softwaredevelopment</category>
    </item>
    <item>
      <title>C++ `[[nodiscard]]`: A Complete Guide (C++17 to C++26)</title>
      <dc:creator>llzzz</dc:creator>
      <pubDate>Thu, 05 Nov 2026 01:34:10 +0000</pubDate>
      <link>https://dev.to/z6123/everything-about-nodiscard-194a</link>
      <guid>https://dev.to/z6123/everything-about-nodiscard-194a</guid>
      <description>&lt;p&gt;&lt;code&gt;[[nodiscard]]&lt;/code&gt; is one of the most practical attributes in modern C++. It lets you tell the compiler: &lt;em&gt;"If the caller ignores this return value, please warn them."&lt;/em&gt; Since its introduction in C++17, it has grown in power—now applying to functions, types, constructors, and even carrying custom messages. This guide covers every behavior, from the basics to the C++26 &lt;code&gt;_&lt;/code&gt; placeholder.&lt;/p&gt;




&lt;h3&gt;
  
  
  1. Basic Syntax and Semantics
&lt;/h3&gt;

&lt;p&gt;The attribute has two forms:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="p"&gt;[[&lt;/span&gt;&lt;span class="n"&gt;nodiscard&lt;/span&gt;&lt;span class="p"&gt;]]&lt;/span&gt;                    &lt;span class="c1"&gt;// C++17&lt;/span&gt;
&lt;span class="p"&gt;[[&lt;/span&gt;&lt;span class="n"&gt;nodiscard&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"reason string"&lt;/span&gt;&lt;span class="p"&gt;)]]&lt;/span&gt;   &lt;span class="c1"&gt;// C++20&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It can appear on a &lt;strong&gt;function declaration&lt;/strong&gt;, an &lt;strong&gt;enum declaration&lt;/strong&gt;, or a &lt;strong&gt;class declaration&lt;/strong&gt; .&lt;/p&gt;

&lt;p&gt;The core rule: if a &lt;strong&gt;discarded-value expression&lt;/strong&gt; calls a &lt;code&gt;[[nodiscard]]&lt;/code&gt; function (or a function returning a &lt;code&gt;[[nodiscard]]&lt;/code&gt; type by value), the compiler &lt;strong&gt;is encouraged to issue a warning&lt;/strong&gt;. Casting the result to &lt;code&gt;void&lt;/code&gt; is the explicit way to suppress this, signaling intent .&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="p"&gt;[[&lt;/span&gt;&lt;span class="n"&gt;nodiscard&lt;/span&gt;&lt;span class="p"&gt;]]&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;compute&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="mi"&gt;42&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;compute&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;           &lt;span class="c1"&gt;// warning: ignoring return value&lt;/span&gt;
    &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;void&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="n"&gt;compute&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;     &lt;span class="c1"&gt;// OK: explicit discard&lt;/span&gt;
    &lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;compute&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;  &lt;span class="c1"&gt;// OK: value used&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;






&lt;h3&gt;
  
  
  2. Applying &lt;code&gt;[[nodiscard]]&lt;/code&gt; to Functions
&lt;/h3&gt;

&lt;p&gt;The most common use case. Place it before the function declaration:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="p"&gt;[[&lt;/span&gt;&lt;span class="n"&gt;nodiscard&lt;/span&gt;&lt;span class="p"&gt;]]&lt;/span&gt; &lt;span class="kt"&gt;bool&lt;/span&gt; &lt;span class="nf"&gt;is_ready&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
&lt;span class="p"&gt;[[&lt;/span&gt;&lt;span class="n"&gt;nodiscard&lt;/span&gt;&lt;span class="p"&gt;]]&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;error_code&lt;/span&gt; &lt;span class="nf"&gt;try_open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;const&lt;/span&gt; &lt;span class="kt"&gt;char&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is ideal for functions where the return value carries essential information—error codes, success flags, or newly allocated resources.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Important nuance:&lt;/strong&gt; The warning is &lt;em&gt;encouraged&lt;/em&gt;, not guaranteed by the standard. All major compilers (GCC, Clang, MSVC) implement it, but diagnostic details vary . If you can using one of the major compilers, you can pair it with the compiler flag -Werror. Which will turn all the warnings to errors. This is very useful if you want be as rigorous as possible.&lt;/p&gt;




&lt;h3&gt;
  
  
  3. Applying &lt;code&gt;[[nodiscard]]&lt;/code&gt; to Classes and Enums
&lt;/h3&gt;

&lt;p&gt;When you mark a &lt;strong&gt;type&lt;/strong&gt; as &lt;code&gt;[[nodiscard]]&lt;/code&gt;, any function that returns that type &lt;strong&gt;by value&lt;/strong&gt; triggers the warning if discarded.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="p"&gt;[[&lt;/span&gt;&lt;span class="n"&gt;nodiscard&lt;/span&gt;&lt;span class="p"&gt;]]&lt;/span&gt; &lt;span class="n"&gt;ErrorInfo&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;ErrorInfo&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="n"&gt;ErrorInfo&lt;/span&gt; &lt;span class="nf"&gt;do_something&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; 
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;ErrorInfo&lt;/span&gt;&lt;span class="p"&gt;{};&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;  &lt;span class="c1"&gt;// returns by value&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;do_something&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;  &lt;span class="c1"&gt;// warning: discarding a nodiscard type&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Critical detail:&lt;/strong&gt; The attribute propagates only through &lt;strong&gt;by-value returns&lt;/strong&gt;. If a function returns a reference to a &lt;code&gt;[[nodiscard]]&lt;/code&gt; type, no warning is generated, because the reference doesn't construct a new object that could be "discarded" .&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="p"&gt;[[&lt;/span&gt;&lt;span class="n"&gt;nodiscard&lt;/span&gt;&lt;span class="p"&gt;]]&lt;/span&gt; &lt;span class="n"&gt;ErrorInfo&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;ErrorInfo&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="n"&gt;ErrorInfo&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;do_something&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ErrorInfo&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; 
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;  &lt;span class="c1"&gt;// returns by reference&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;ErrorInfo&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;{};&lt;/span&gt;
    &lt;span class="n"&gt;do_something&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;  &lt;span class="c1"&gt;// no warning: returned by reference&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The same logic applies to enums:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;enum&lt;/span&gt; &lt;span class="p"&gt;[[&lt;/span&gt;&lt;span class="n"&gt;nodiscard&lt;/span&gt;&lt;span class="p"&gt;]]&lt;/span&gt; &lt;span class="n"&gt;Status&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;Ok&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Failed&lt;/span&gt; &lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="n"&gt;Status&lt;/span&gt; &lt;span class="nf"&gt;check&lt;/span&gt;&lt;span class="p"&gt;(){&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;Status&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Ok&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;check&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;  &lt;span class="c1"&gt;// warning&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;






&lt;h3&gt;
  
  
  4. Constructors and Explicit Conversions (C++17 DR, C++20)
&lt;/h3&gt;

&lt;p&gt;Originally, &lt;code&gt;[[nodiscard]]&lt;/code&gt; on constructors had no effect. This was fixed via defect report &lt;strong&gt;P1771R1&lt;/strong&gt;, applied retroactively to C++17 .&lt;/p&gt;

&lt;p&gt;Now, if a &lt;code&gt;[[nodiscard]]&lt;/code&gt; constructor is invoked through &lt;strong&gt;explicit type conversion&lt;/strong&gt; or &lt;code&gt;static_cast&lt;/code&gt;, and the resulting object is discarded, a warning may fire:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Guard&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
   &lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="p"&gt;[[&lt;/span&gt;&lt;span class="n"&gt;nodiscard&lt;/span&gt;&lt;span class="p"&gt;]]&lt;/span&gt; &lt;span class="n"&gt;Guard&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{};&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;Guard&lt;/span&gt; &lt;span class="n"&gt;g&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;                &lt;span class="c1"&gt;// Ok&lt;/span&gt;
    &lt;span class="n"&gt;Guard&lt;/span&gt;&lt;span class="p"&gt;{};&lt;/span&gt;                &lt;span class="c1"&gt;// warning: temporary discarded&lt;/span&gt;
    &lt;span class="n"&gt;Guard&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;                &lt;span class="c1"&gt;// warning: temporary discarded&lt;/span&gt;
    &lt;span class="k"&gt;static_cast&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Guard&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Guard&lt;/span&gt;&lt;span class="p"&gt;{});&lt;/span&gt;  &lt;span class="c1"&gt;// warning if result unused&lt;/span&gt;
    &lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;g2&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;static_cast&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Guard&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Guard&lt;/span&gt;&lt;span class="p"&gt;{});&lt;/span&gt;  &lt;span class="c1"&gt;// Ok, result used&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The same applies to initializing an object of a &lt;code&gt;[[nodiscard]]&lt;/code&gt; enum or class type via explicit conversion .&lt;/p&gt;




&lt;h3&gt;
  
  
  5. The C++20 String Message
&lt;/h3&gt;

&lt;p&gt;Since C++20, you can attach a reason string:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="p"&gt;[[&lt;/span&gt;&lt;span class="n"&gt;nodiscard&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"Check the error code—ignoring it may cause data loss"&lt;/span&gt;&lt;span class="p"&gt;)]]&lt;/span&gt;
&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;write_data&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="mi"&gt;42&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;write_data&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This string is &lt;em&gt;unevaluated&lt;/em&gt; and typically included verbatim in compiler warnings. It's a documentation feature embedded in diagnostics—useful for library authors .&lt;/p&gt;




&lt;h3&gt;
  
  
  6. &lt;code&gt;std::ignore&lt;/code&gt;: The Intentional Discard
&lt;/h3&gt;

&lt;p&gt;Sometimes you genuinely don't care about a return value, but you still want to avoid warnings. Casting to &lt;code&gt;void&lt;/code&gt; works, but &lt;code&gt;std::ignore&lt;/code&gt; offers another path:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="cp"&gt;#include&lt;/span&gt; &lt;span class="cpf"&gt;&amp;lt;tuple&amp;gt;&lt;/span&gt;&lt;span class="cp"&gt;
&lt;/span&gt;
&lt;span class="p"&gt;[[&lt;/span&gt;&lt;span class="n"&gt;nodiscard&lt;/span&gt;&lt;span class="p"&gt;]]&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;dont_ignore_me&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="mi"&gt;42&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;


&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;ignore&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;dont_ignore_me&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;  &lt;span class="c1"&gt;// suppresses nodiscard warning&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;std::ignore&lt;/code&gt; is an object to which any value can be assigned with no effect. Some coding guidelines recommend it for &lt;code&gt;[[nodiscard]]&lt;/code&gt; suppression, though it was originally designed for &lt;code&gt;std::tie&lt;/code&gt; tuple unpacking .&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which should you use?&lt;/strong&gt; &lt;code&gt;(void)expr&lt;/code&gt; is the most direct and idiomatic signal of intentional discard. &lt;code&gt;std::ignore = expr&lt;/code&gt; is also acceptable and arguably more explicit. Both are recognized by compilers as intentional suppression.&lt;/p&gt;




&lt;h3&gt;
  
  
  7. C++26: The Unnamed Placeholder &lt;code&gt;_&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;A long-standing annoyance: if you want to name a variable but ignore its value, you write &lt;code&gt;auto _ = f();&lt;/code&gt;. But under &lt;code&gt;-Wunused-variable&lt;/code&gt;, the compiler complains that &lt;code&gt;_&lt;/code&gt; is unused. The workaround is &lt;code&gt;[[maybe_unused]] auto _ = f();&lt;/code&gt;—verbose and ugly .&lt;/p&gt;

&lt;p&gt;C++26 introduces &lt;strong&gt;P2169R4&lt;/strong&gt;, "A Nice Placeholder With No Name." It makes &lt;code&gt;_&lt;/code&gt; a &lt;strong&gt;name-independent placeholder&lt;/strong&gt; usable in most places where an identifier is expected, including structured bindings .&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;                     &lt;span class="c1"&gt;// OK in C++26: _ is a placeholder, no unused warning&lt;/span&gt;
&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;tie&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;inserted&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;set&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;insert&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"x"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;  &lt;span class="c1"&gt;// also works&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Critical relationship to &lt;code&gt;[[nodiscard]]&lt;/code&gt;:&lt;/strong&gt; The committee explicitly discussed whether &lt;code&gt;auto _ = f()&lt;/code&gt; should suppress &lt;code&gt;[[nodiscard]]&lt;/code&gt; warnings. The consensus (and the proposal's direction) is that &lt;strong&gt;it should not be treated as a blessed suppression mechanism&lt;/strong&gt; for &lt;code&gt;[[nodiscard]]&lt;/code&gt;. Using &lt;code&gt;_&lt;/code&gt; is a placeholder for &lt;em&gt;unused variables&lt;/em&gt;, not a tool for ignoring important return values. The standard &lt;code&gt;[[nodiscard]]&lt;/code&gt; semantics remain: assigning to &lt;code&gt;_&lt;/code&gt; still counts as using the value, so no warning is generated—but this is a side effect, not the intended use case .&lt;/p&gt;

&lt;p&gt;For intentional suppression, stick with &lt;code&gt;(void)&lt;/code&gt; or &lt;code&gt;std::ignore&lt;/code&gt;.&lt;/p&gt;




&lt;h2&gt;
  
  
  8. Best Practices
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Do:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Apply &lt;code&gt;[[nodiscard]]&lt;/code&gt; to pure functions returning computed results (&lt;code&gt;empty()&lt;/code&gt;, &lt;code&gt;size()&lt;/code&gt;, &lt;code&gt;find()&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;Use it on error-handling returns (&lt;code&gt;std::error_code&lt;/code&gt;, &lt;code&gt;bool&lt;/code&gt; success flags).&lt;/li&gt;
&lt;li&gt;Use the C++20 message for non-obvious cases.&lt;/li&gt;
&lt;li&gt;Mark classes that represent resources or state that must not be dropped (&lt;code&gt;std::lock_guard&lt;/code&gt;-like types).&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Don't:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Apply it to functions with side effects where ignoring is reasonable (logging, notification).&lt;/li&gt;
&lt;li&gt;Use it on every function—warning fatigue reduces its value.&lt;/li&gt;
&lt;li&gt;Rely on &lt;code&gt;_&lt;/code&gt; (C++26) as a &lt;code&gt;[[nodiscard]]&lt;/code&gt; escape hatch.&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  Summary Table
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Context&lt;/th&gt;
&lt;th&gt;Syntax&lt;/th&gt;
&lt;th&gt;Behavior&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Function&lt;/td&gt;
&lt;td&gt;&lt;code&gt;[[nodiscard]] int f();&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Warns if call result discarded&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Function (C++20)&lt;/td&gt;
&lt;td&gt;&lt;code&gt;[[nodiscard("msg")]] int f();&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Warning includes &lt;code&gt;"msg"&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Class&lt;/td&gt;
&lt;td&gt;&lt;code&gt;struct [[nodiscard]] S {};&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Warns if &lt;code&gt;S&lt;/code&gt; returned by value is discarded&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Enum&lt;/td&gt;
&lt;td&gt;&lt;code&gt;enum [[nodiscard]] E {};&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Same as class&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Constructor&lt;/td&gt;
&lt;td&gt;&lt;code&gt;[[nodiscard]] S();&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Warns on discarded temporary via explicit conversion&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Suppression&lt;/td&gt;
&lt;td&gt;&lt;code&gt;(void)f();&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Explicit discard, no warning&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Suppression&lt;/td&gt;
&lt;td&gt;&lt;code&gt;std::ignore = f();&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Intentional discard via tuple placeholder&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;C++26&lt;/td&gt;
&lt;td&gt;&lt;code&gt;auto _ = f();&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Placeholder variable; not a &lt;code&gt;[[nodiscard]]&lt;/code&gt; suppressor by design&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

</description>
      <category>cpp</category>
      <category>programming</category>
      <category>software</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>Everything about `std::forward`</title>
      <dc:creator>llzzz</dc:creator>
      <pubDate>Mon, 02 Nov 2026 12:08:48 +0000</pubDate>
      <link>https://dev.to/z6123/everything-about-stdforward-3b9e</link>
      <guid>https://dev.to/z6123/everything-about-stdforward-3b9e</guid>
      <description>&lt;p&gt;&lt;code&gt;std::forward&lt;/code&gt; is similar to &lt;code&gt;std::move&lt;/code&gt;. It is just a static_cast to &lt;code&gt;rvalue reference&lt;/code&gt;. But it is slightly different than &lt;code&gt;std::move&lt;/code&gt;, &lt;code&gt;std::forward&lt;/code&gt; is a conditional cast that only cast the type to &lt;code&gt;rvalue-reference&lt;/code&gt; if some condition is satisify. Let dive deeper in it!&lt;/p&gt;

&lt;p&gt;First of all, let look at a custom implementation of &lt;code&gt;std::forward&lt;/code&gt;, this is not the exact definition in the STL, but it is close enough.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;namespace&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;template&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;typename&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="n"&gt;__attribute__&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="n"&gt;always_inline&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
    &lt;span class="k"&gt;constexpr&lt;/span&gt; &lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;forward&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;remove_reference_t&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;noexcept&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="k"&gt;static_cast&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="k"&gt;template&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;typename&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="n"&gt;__attribute__&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="n"&gt;always_inline&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
    &lt;span class="k"&gt;constexpr&lt;/span&gt; &lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;forward&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;remove_reference_t&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;noexcept&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;static_assert&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;is_lvalue_reference_v&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="k"&gt;static_cast&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;the implementation might make absolutely no sense to you right now, but it will make sense soon.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reference Collapsing
&lt;/h2&gt;

&lt;p&gt;In C++, you are not allowed to explicitly write a reference to a reference (e.g., &lt;code&gt;int&amp;amp; &amp;amp;&lt;/code&gt; will result in a compilation error). However, the compiler can generate references to references behind the scenes during template argument deduction, &lt;code&gt;typedef&lt;/code&gt;/ &lt;code&gt;using type aliases&lt;/code&gt;, &lt;code&gt;decltype&lt;/code&gt;, and &lt;code&gt;auto type deduction&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;To handle these scenarios gracefully, C++11 introduce reference collapsing, a strict set of rules that simplifies a "reference to a reference" down to a single valid reference.&lt;/p&gt;

&lt;p&gt;The easiest way to understand this is to think &lt;code&gt;lvalue reference&lt;/code&gt; is infectious. If an &lt;code&gt;lvalue reference&lt;/code&gt; is in anywhere in the combination, the result will collapse to a &lt;code&gt;lvalue reference&lt;/code&gt;. The only way to get an rvalue reference (&amp;amp;&amp;amp;) is if both references are rvalue references.&lt;/p&gt;

&lt;p&gt;Let look at the following table to understand what does it actually mean:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Existing / Target Type&lt;/th&gt;
&lt;th&gt;Applied Reference&lt;/th&gt;
&lt;th&gt;Resulting Collapsed Type&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;T&amp;amp;&lt;/code&gt; (lvalue ref)&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;&amp;amp;&lt;/code&gt; (lvalue ref)&lt;/td&gt;
&lt;td&gt;&lt;code&gt;T&amp;amp;&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;T&amp;amp;&lt;/code&gt; (lvalue ref)&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt; (rvalue ref)&lt;/td&gt;
&lt;td&gt;&lt;code&gt;T&amp;amp;&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;T&amp;amp;&amp;amp;&lt;/code&gt; (rvalue ref)&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;&amp;amp;&lt;/code&gt; (lvalue ref)&lt;/td&gt;
&lt;td&gt;&lt;code&gt;T&amp;amp;&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;T&amp;amp;&amp;amp;&lt;/code&gt; (rvalue ref)&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt; (rvalue ref)&lt;/td&gt;
&lt;td&gt;&lt;code&gt;T&amp;amp;&amp;amp;&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Let's look at an example to understand what it means in practice:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="n"&gt;LRef&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="n"&gt;RRef&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="n"&gt;LRef&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;  &lt;span class="n"&gt;r1&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// int&amp;amp; &amp;amp;   collapses to int&amp;amp;&lt;/span&gt;
&lt;span class="n"&gt;LRef&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;r2&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// int&amp;amp; &amp;amp;&amp;amp;  collapses to int&amp;amp;&lt;/span&gt;
&lt;span class="n"&gt;RRef&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;  &lt;span class="n"&gt;r3&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// int&amp;amp;&amp;amp; &amp;amp;  collapses to int&amp;amp;&lt;/span&gt;
&lt;span class="n"&gt;RRef&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;r4&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;20&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// int&amp;amp;&amp;amp; &amp;amp;&amp;amp; collapses to int&amp;amp;&amp;amp;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is a very important rule that make sure your template argument deduction work as expected!&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;code&gt;std::forward&lt;/code&gt;
&lt;/h2&gt;

&lt;p&gt;Now let us get back to the main topic of today: What is &lt;code&gt;std::forward&lt;/code&gt;? Based on the reference collapsing rule, we can finally demystify the magic behind perfect forwarding.&lt;/p&gt;

&lt;h3&gt;
  
  
  The Problem: Named Rvalue References Are Actually Lvalues
&lt;/h3&gt;

&lt;p&gt;Before we dissect &lt;code&gt;std::forward&lt;/code&gt;, consider this classic forwarding dilemma:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;process&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;const&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;cout&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class="s"&gt;"lvalue&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;process&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;      &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;cout&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class="s"&gt;"rvalue&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;template&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;typename&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;wrapper&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;arg&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c1"&gt;// What happens if we call process(arg)?&lt;/span&gt;
    &lt;span class="n"&gt;process&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;arg&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; 
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If we pass a temporary rvalue to &lt;code&gt;wrapper&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="n"&gt;wrapper&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"hello"&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You might expect &lt;code&gt;process(std::string&amp;amp;&amp;amp;)&lt;/code&gt; to be called. But &lt;strong&gt;&lt;code&gt;process(const std::string&amp;amp;)&lt;/code&gt;&lt;/strong&gt; is called instead!&lt;/p&gt;

&lt;p&gt;Why? Because &lt;strong&gt;even though &lt;code&gt;arg&lt;/code&gt; might bind to an rvalue, the variable &lt;code&gt;arg&lt;/code&gt; itself has a name.&lt;/strong&gt;&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Crucial Rule:&lt;/strong&gt; In C++, if an expression has a name, it is an &lt;strong&gt;lvalue&lt;/strong&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Inside &lt;code&gt;wrapper&lt;/code&gt;, &lt;code&gt;arg&lt;/code&gt; is an lvalue. If you pass it directly to another function, you will always pass an lvalue—losing the original temporary/moveable nature of the caller's argument.&lt;/p&gt;




&lt;h3&gt;
  
  
  Universal References (Forwarding References)
&lt;/h3&gt;

&lt;p&gt;In the template signature &lt;code&gt;template &amp;lt;typename T&amp;gt; void wrapper(T&amp;amp;&amp;amp; arg)&lt;/code&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;If you pass an &lt;strong&gt;lvalue&lt;/strong&gt; of type &lt;code&gt;Widget&lt;/code&gt; (e.g., &lt;code&gt;Widget w; wrapper(w);&lt;/code&gt;):&lt;/li&gt;
&lt;li&gt;The compiler deduces &lt;code&gt;T&lt;/code&gt; as &lt;code&gt;Widget&amp;amp;&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;p&gt;The parameter type becomes &lt;code&gt;Widget&amp;amp; &amp;amp;&amp;amp;&lt;/code&gt;, which collapses to &lt;strong&gt;&lt;code&gt;Widget&amp;amp;&lt;/code&gt;&lt;/strong&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;If you pass an &lt;strong&gt;rvalue&lt;/strong&gt; of type &lt;code&gt;Widget&lt;/code&gt; (e.g., &lt;code&gt;wrapper(Widget{});&lt;/code&gt;):&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;The compiler deduces &lt;code&gt;T&lt;/code&gt; as &lt;code&gt;Widget&lt;/code&gt; (or non-referenccepted as an lvalue reference, and forces the developer to explicitly provide template parameter T (disabling automatic template argument deduction).&lt;br&gt;
The return type is a static cast to &lt;code&gt;static_cast&amp;lt;T&amp;amp;&amp;amp;&amp;gt;(t)&lt;/code&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;The parameter type remains &lt;strong&gt;&lt;code&gt;Widget&amp;amp;&amp;amp;&lt;/code&gt;&lt;/strong&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Notice what happened: &lt;strong&gt;&lt;code&gt;T&lt;/code&gt; encodes whether the argument was originally an lvalue (&lt;code&gt;T = Widget&amp;amp;&lt;/code&gt;) or an rvalue (&lt;code&gt;T = Widget&lt;/code&gt;)!&lt;/strong&gt;&lt;/p&gt;




&lt;h3&gt;
  
  
  How &lt;code&gt;std::forward&amp;lt;T&amp;gt;&lt;/code&gt; Uses Reference Collapsing
&lt;/h3&gt;

&lt;p&gt;Now re-examine the primary implementation of &lt;code&gt;std::forward&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;template&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;typename&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="k"&gt;constexpr&lt;/span&gt; &lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;forward&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;remove_reference_t&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;noexcept&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="k"&gt;static_cast&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Notice two critical details:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;The parameter is &lt;code&gt;std::remove_reference_t&amp;lt;T&amp;gt;&amp;amp; t&lt;/code&gt;. This ensures &lt;code&gt;t&lt;/code&gt; is always accepted as an lvalue reference, and forces the developer to explicitly provide template parameter &lt;code&gt;T&lt;/code&gt; (disabling automatic template argument deduction).&lt;/li&gt;
&lt;li&gt;The return type is a static cast to &lt;code&gt;static_cast&amp;lt;T&amp;amp;&amp;amp;&amp;gt;(t)&lt;/code&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Let’s trace the two cases when we write &lt;code&gt;std::forward&amp;lt;T&amp;gt;(arg)&lt;/code&gt;:&lt;/p&gt;

&lt;h4&gt;
  
  
  Case 1: Caller passed an Lvalue
&lt;/h4&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;T&lt;/code&gt; was deduced as &lt;code&gt;Widget&amp;amp;&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;We call &lt;code&gt;std::forward&amp;lt;Widget&amp;amp;&amp;gt;(arg)&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Inside &lt;code&gt;forward&lt;/code&gt;:&lt;/li&gt;
&lt;li&gt;Return type is &lt;code&gt;T&amp;amp;&amp;amp;&lt;/code&gt; → &lt;code&gt;Widget&amp;amp; &amp;amp;&amp;amp;&lt;/code&gt;, which &lt;strong&gt;collapses to `Widget&amp;amp;&lt;/strong&gt;`.&lt;/li&gt;
&lt;li&gt;&lt;p&gt;The cast evaluates to &lt;code&gt;static_cast&amp;lt;Widget&amp;amp;&amp;gt;(t)&lt;/code&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Result:&lt;/strong&gt; An &lt;strong&gt;lvalue reference&lt;/strong&gt; is returned. No move occurs.&lt;/p&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h4&gt;
  
  
  Case 2: Caller passed an Rvalue
&lt;/h4&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;T&lt;/code&gt; was deduced as &lt;code&gt;Widget&lt;/code&gt; (non-reference).&lt;/li&gt;
&lt;li&gt;We call &lt;code&gt;std::forward&amp;lt;Widget&amp;gt;(arg)&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Inside &lt;code&gt;forward&lt;/code&gt;:&lt;/li&gt;
&lt;li&gt;Return type is &lt;code&gt;T&amp;amp;&amp;amp;&lt;/code&gt; → &lt;code&gt;Widget&amp;amp;&amp;amp;&lt;/code&gt; (no collapse needed).&lt;/li&gt;
&lt;li&gt;&lt;p&gt;The cast evaluates to &lt;code&gt;static_cast&amp;lt;Widget&amp;amp;&amp;amp;&amp;gt;(t)&lt;/code&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Result:&lt;/strong&gt; An &lt;strong&gt;rvalue reference&lt;/strong&gt; is returned. The caller's temporary is restored as a moveable rvalue!&lt;/p&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is why people say &lt;code&gt;std::forward&lt;/code&gt; is a &lt;strong&gt;conditional cast&lt;/strong&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;std::move&amp;lt;T&amp;gt;(x)&lt;/code&gt; unconditionally casts &lt;code&gt;x&lt;/code&gt; to &lt;code&gt;T&amp;amp;&amp;amp;&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;std::forward&amp;lt;T&amp;gt;(x)&lt;/code&gt; only casts to &lt;code&gt;T&amp;amp;&amp;amp;&lt;/code&gt; if &lt;code&gt;T&lt;/code&gt; is &lt;strong&gt;not&lt;/strong&gt; an lvalue reference type.&lt;/li&gt;
&lt;/ul&gt;




&lt;h3&gt;
  
  
  What About the Second Overload?
&lt;/h3&gt;

&lt;p&gt;Recall the second overload in the definition:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;template&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;typename&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="k"&gt;constexpr&lt;/span&gt; &lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;forward&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;remove_reference_t&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;noexcept&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;static_assert&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;is_lvalue_reference_v&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; 
                  &lt;span class="s"&gt;"std::forward cannot convert an rvalue to an lvalue."&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="k"&gt;static_cast&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Why is this needed?&lt;/p&gt;

&lt;p&gt;This overload accepts an rvalue argument (&lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt;). It exists primarily as a safety net:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Perfect forwarding of expressions / temporaries directly:&lt;/strong&gt; e.g., forwarding return values like &lt;code&gt;std::forward&amp;lt;T&amp;gt;(make_widget())&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Preventing dangerous dangling references:&lt;/strong&gt; If someone accidentally writes:
&lt;/li&gt;
&lt;/ol&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;forward&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;{});&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;They are trying to bind a temporary rvalue to an lvalue reference. The &lt;code&gt;static_assert(!std::is_lvalue_reference_v&amp;lt;T&amp;gt;)&lt;/code&gt; triggers a clear compile-time error instead of silently binding to a destroyed temporary.&lt;/p&gt;




&lt;h3&gt;
  
  
  Putting It All Together
&lt;/h3&gt;

&lt;p&gt;With &lt;code&gt;std::forward&lt;/code&gt;, our &lt;code&gt;wrapper&lt;/code&gt; function preserves value categories perfectly:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;template&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;typename&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;wrapper&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;arg&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c1"&gt;// Restores original value category:&lt;/span&gt;
    &lt;span class="n"&gt;process&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;forward&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;arg&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt; 
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;"Alice"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="n"&gt;wrapper&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;                 &lt;span class="c1"&gt;// Calls process(const std::string&amp;amp;) -&amp;gt; preserved as lvalue&lt;/span&gt;
&lt;span class="n"&gt;wrapper&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"Bob"&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;   &lt;span class="c1"&gt;// Calls process(std::string&amp;amp;&amp;amp;)      -&amp;gt; preserved as rvalue&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Key Takeaways
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Names mean lvalues:&lt;/strong&gt; An rvalue reference parameter is itself an lvalue because it has an identifier.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;T&lt;/code&gt; remembers:&lt;/strong&gt; Universal references capture the original category inside template parameter &lt;code&gt;T&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Collapsing makes it work:&lt;/strong&gt; &lt;code&gt;static_cast&amp;lt;T&amp;amp;&amp;amp;&amp;gt;&lt;/code&gt; collapses to &lt;code&gt;&amp;amp;&lt;/code&gt; when &lt;code&gt;T = U&amp;amp;&lt;/code&gt;, and remains &lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt; when &lt;code&gt;T = U&lt;/code&gt;.&lt;/li&gt;
&lt;/ol&gt;

</description>
      <category>programming</category>
      <category>cpp</category>
    </item>
    <item>
      <title>Everything about std::move()</title>
      <dc:creator>llzzz</dc:creator>
      <pubDate>Sat, 31 Oct 2026 13:42:16 +0000</pubDate>
      <link>https://dev.to/z6123/everything-about-stdmove-2de3</link>
      <guid>https://dev.to/z6123/everything-about-stdmove-2de3</guid>
      <description>&lt;h2&gt;
  
  
  Introduction
&lt;/h2&gt;

&lt;p&gt;When someone tell you they use modern C++, &lt;code&gt;std::move()&lt;/code&gt; should be the first thing that come to your mind as it is so important that almost every codebase after C++11 use it. But do you actually understand how it works?&lt;/p&gt;

&lt;p&gt;&lt;code&gt;std::move&lt;/code&gt; is one of the most misunderstood tools in modern C++. The most important thing to know upfront: &lt;code&gt;std::move&lt;/code&gt; does not actually move anything. It is simply a cast that converts an expression into an rvalue, signaling to the compiler that the object's resources may be "stolen" by a move constructor or move assignment operator.&lt;/p&gt;

&lt;h2&gt;
  
  
  How it is implemented?
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;std::move()&lt;/code&gt; defined in the &lt;code&gt;&amp;lt;utility&amp;gt;&lt;/code&gt; header, its implementation is roughly equivalent to a &lt;code&gt;static_cast&lt;/code&gt; to an &lt;code&gt;rvalue reference&lt;/code&gt;.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;namespace&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;template&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;typename&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="k"&gt;constexpr&lt;/span&gt; &lt;span class="k"&gt;decltype&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;auto&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;move&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;noexcept&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="k"&gt;static_cast&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;remove_reference_t&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&amp;amp;&amp;amp;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;So based on the implementation, it doesn't really move anything, you are basically telling the compiler that you no longer need the current value; just treat it as a temporary so that a move operation can be selected via overload resolution. The actual moving happen if the target type has a move constructor/move assignment defined.&lt;/p&gt;

&lt;h2&gt;
  
  
  When do you need to use move?
&lt;/h2&gt;

&lt;p&gt;The primary legitimate use case is transferring ownership of resources from a named object that will not be used again.&lt;/p&gt;

&lt;h3&gt;
  
  
  Moving into the container
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt; &lt;span class="n"&gt;str&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;"Hello, World!"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;vector&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;push_back&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;move&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;str&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt; &lt;span class="c1"&gt;// str is now valid but unspecified (likely empty)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Here, &lt;code&gt;std::move&lt;/code&gt; enables the &lt;code&gt;push_back(T&amp;amp;&amp;amp;)&lt;/code&gt; overload, avoiding a deep copy of the string's buffer (but you may want to use emplace_back if you can directly construct the string in the container).&lt;/p&gt;

&lt;h3&gt;
  
  
  Implement move semantics in your class
&lt;/h3&gt;

&lt;p&gt;Inside a move constructor or move assignment operator, parameters (like other) are lvalues even though their type is &lt;code&gt;T&amp;amp;&amp;amp;&lt;/code&gt;. You must use &lt;code&gt;std::move&lt;/code&gt; on their members to propagate the move. Here is an example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="cp"&gt;#include&lt;/span&gt; &lt;span class="cpf"&gt;&amp;lt;print&amp;gt;&lt;/span&gt;&lt;span class="cp"&gt;
&lt;/span&gt;
&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="nc"&gt;A&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;A&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

    &lt;span class="n"&gt;A&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;A&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;println&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"move ctor"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="n"&gt;A&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="k"&gt;operator&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;A&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;println&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"move assignment"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="k"&gt;this&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;A&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;{};&lt;/span&gt; &lt;span class="c1"&gt;// default init&lt;/span&gt;
    &lt;span class="n"&gt;A&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;move&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)};&lt;/span&gt; &lt;span class="c1"&gt;// move ctor&lt;/span&gt;
    &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;move&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// move assignment&lt;/span&gt;

&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If you run the program, you will see the following get printed:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;move ctor
move assignment
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;However, there are something we must consider before using it:&lt;/p&gt;

&lt;h2&gt;
  
  
  Misconceptions and Pitfalls
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;"It Doesn't Guarantee a Move"&lt;/strong&gt;&lt;br&gt;
Using &lt;code&gt;std::move&lt;/code&gt; does not guarantee that a move will occur. If the type does not have a move constructor (or if the move constructor is not &lt;code&gt;noexcept&lt;/code&gt; in certain contexts like &lt;code&gt;vector&lt;/code&gt; reallocation), the compiler will fall back to copying. A common trap is calling &lt;code&gt;std::move&lt;/code&gt; on a &lt;code&gt;const&lt;/code&gt; object; since a move constructor typically requires a non-const rvalue reference, the operation will silently degrade to a copy.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;"The Moved-From Object is Unusable"&lt;/strong&gt;&lt;br&gt;
The C++ standard guarantees that a moved-from standard library object is in a &lt;strong&gt;"valid but unspecified state"&lt;/strong&gt;. This means you can safely destroy it or assign a new value to it. However, you cannot rely on its contents (e.g., a moved-from &lt;code&gt;std::string&lt;/code&gt; is often empty, but this is not guaranteed).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;"Don't Use It on Return Values"&lt;/strong&gt;&lt;br&gt;
Writing &lt;code&gt;return std::move(local_variable);&lt;/code&gt; is usually a pessimization. The compiler is already allowed (and often required) to perform Return Value Optimization (RVO) or implicitly treat the local variable as an rvalue. Adding &lt;code&gt;std::move&lt;/code&gt; can actually &lt;strong&gt;prevent&lt;/strong&gt; copy elision, forcing an unnecessary move (or even a copy).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;"Don't Use It on Universal References"&lt;/strong&gt;&lt;br&gt;
In a template function with a forwarding reference &lt;code&gt;T&amp;amp;&amp;amp;&lt;/code&gt;, using &lt;code&gt;std::move(t)&lt;/code&gt; is dangerous. It will unconditionally cast to an rvalue, even if the caller passed an lvalue, potentially "stealing" resources from an object the caller still intends to use. Use &lt;code&gt;std::forward&amp;lt;T&amp;gt;(t)&lt;/code&gt; instead.&lt;/p&gt;

&lt;p&gt;Then, what is &lt;code&gt;std::forward&amp;lt;T&amp;gt;(t)&lt;/code&gt;, you might ask, this will be the discussion of another article!&lt;/p&gt;

&lt;p&gt;So &lt;code&gt;std::move&lt;/code&gt; is a tool for expressing intent. You are telling the compiler and other devs that you want to transfer the ownership of the object. Usually on the object that is inside a function and you are certain that it will not be access again. But remember that never use it on a const object as it only make your code messier and silently failed!&lt;/p&gt;

</description>
      <category>code</category>
      <category>cpp</category>
      <category>programming</category>
      <category>architecture</category>
    </item>
    <item>
      <title>Deep dive into C++ value categories</title>
      <dc:creator>llzzz</dc:creator>
      <pubDate>Wed, 28 Oct 2026 13:37:51 +0000</pubDate>
      <link>https://dev.to/z6123/deep-dive-into-c-value-categories-156o</link>
      <guid>https://dev.to/z6123/deep-dive-into-c-value-categories-156o</guid>
      <description>&lt;p&gt;Knowing value categories in modern C++ is essential. Only when you know value categories, you can truly understand move semantics, and then you know how to write program efficiently.&lt;/p&gt;

&lt;p&gt;Let get straight into it!&lt;/p&gt;

&lt;p&gt;There are three primary categories. They are lvalue, xvalue and prvalue respectively, and two mixed categories (rvalue and glvalue). The relationship can be expressed in the following diagram:&lt;br&gt;
&lt;/p&gt;

&lt;pre data-lang="mermaid"&gt;&lt;code&gt;graph TD
    E["Expression"] --&amp;gt; G["glvalue (Generalized lvalue)"]
    E --&amp;gt; R["rvalue"]

    G --&amp;gt; L["lvalue"]
    G --&amp;gt; X["xvalue (eXpiring value)"]

    R --&amp;gt; X
    R --&amp;gt; P["prvalue (Pure rvalue)"]&lt;/code&gt;&lt;/pre&gt;



&lt;p&gt;any expression in C++ can be categorized into one of the primary category. Here is the detail explanation&lt;/p&gt;

&lt;h2&gt;
  
  
  1. lvalue expression
&lt;/h2&gt;

&lt;p&gt;Roughly speaking, an lvalue expression is an expression that &lt;strong&gt;has an identity&lt;/strong&gt; — it refers to a specific object, function, or bit-field that lives at a stable location in memory, and that persists beyond the expression that names it.&lt;/p&gt;

&lt;p&gt;The name "lvalue" is historical: it comes from "&lt;strong&gt;l&lt;/strong&gt;eft value", because lvalues are what you traditionally find on the left-hand side of an assignment. Keep this as a mental heuristic, but don't trust it too far — it's only a rule of thumb, and modern C++ breaks it in both directions (see the caveats below).&lt;/p&gt;

&lt;h2&gt;
  
  
  The identity test
&lt;/h2&gt;

&lt;p&gt;The most practical way to check whether an expression is an lvalue is to ask: &lt;em&gt;can I take its address?&lt;/em&gt; If the built-in address-of operator &lt;code&gt;&amp;amp;&lt;/code&gt; accepts the expression, it is (almost certainly) an lvalue. Taking an address only makes sense if the thing has a location — and having a location is exactly what "having identity" means physically.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;i&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;      &lt;span class="c1"&gt;// OK: i is an lvalue, it has an address&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Examples of lvalue expressions
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Named variables:&lt;/strong&gt; in &lt;code&gt;int x;&lt;/code&gt;, the expression &lt;code&gt;x&lt;/code&gt; is an lvalue.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Dereferenced pointers:&lt;/strong&gt; &lt;code&gt;*p&lt;/code&gt; is an lvalue — it names the object the pointer points to.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Array subscripting&lt;/strong&gt; (for built-in types): &lt;code&gt;arr[0]&lt;/code&gt; is an lvalue.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Functions returning lvalue references:&lt;/strong&gt; given &lt;code&gt;int&amp;amp; f();&lt;/code&gt;, the call expression &lt;code&gt;f()&lt;/code&gt; is an lvalue.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;String literals:&lt;/strong&gt; &lt;code&gt;"hello"&lt;/code&gt; is an lvalue — it has an address in static storage.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The conditional operator, sometimes:&lt;/strong&gt; &lt;code&gt;(cond ? a : b)&lt;/code&gt; is an lvalue if both &lt;code&gt;a&lt;/code&gt; and &lt;code&gt;b&lt;/code&gt; are lvalues of the same type.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Modifiable vs. non-modifiable lvalues
&lt;/h2&gt;

&lt;p&gt;Not every lvalue can be assigned to. This distinction matters, because only &lt;em&gt;modifiable&lt;/em&gt; lvalues can appear on the left of &lt;code&gt;=&lt;/code&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Modifiable lvalue:&lt;/strong&gt; can be assigned to, e.g. a non-const &lt;code&gt;int&lt;/code&gt; variable.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Non-modifiable lvalue:&lt;/strong&gt; has identity but cannot be changed through that expression — e.g. a &lt;code&gt;const&lt;/code&gt; variable, or an array type.
&lt;/li&gt;
&lt;/ul&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;
&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;i&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="n"&gt;i&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;20&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;           &lt;span class="c1"&gt;// OK: i is a modifiable lvalue&lt;/span&gt;
&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// f() is lvalue (let assume f() return a valid reference)&lt;/span&gt;

&lt;span class="k"&gt;const&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;ci&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="c1"&gt;// ci = 6;        // ERROR: ci is a non-modifiable lvalue&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Two caveats on the "left-hand side" heuristic:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;A non-modifiable lvalue can never be on the left of &lt;code&gt;=&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;With class types, an &lt;em&gt;rvalue&lt;/em&gt; can appear on the left of &lt;code&gt;=&lt;/code&gt; if the assignment operator is overloaded — so "left of &lt;code&gt;=&lt;/code&gt;" alone doesn't prove lvalueness.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Also note the reverse direction: a plain literal such as &lt;code&gt;20&lt;/code&gt; is &lt;em&gt;not&lt;/em&gt; an lvalue, so it can never be assigned to:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="c1"&gt;// 20 = i;        // ERROR: 20 is a prvalue, not an lvalue&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Why this matters for move semantics
&lt;/h2&gt;

&lt;p&gt;This is the key point for everything that follows.&lt;/p&gt;

&lt;p&gt;An lvalue is &lt;strong&gt;persistent&lt;/strong&gt;: it has a name, it has an address, and it survives past the current expression. Because of that, when the compiler sees a named lvalue being used to initialize or assign to another object, it must assume you might use that lvalue &lt;strong&gt;again later&lt;/strong&gt;. It therefore cannot safely steal its resources — doing so would leave a named object in a moved-from state that you might still read.&lt;/p&gt;

&lt;p&gt;Consequently, the compiler will &lt;strong&gt;not&lt;/strong&gt; automatically invoke a move constructor or move assignment on a named lvalue; it falls back to copying:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;"hello"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;          &lt;span class="c1"&gt;// a is an lvalue -&amp;gt; copy, not move&lt;/span&gt;
&lt;span class="c1"&gt;// std::string&amp;amp;&amp;amp; r = a;     // ERROR: rvalue reference cannot bind to lvalue&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;To move from a named object you must explicitly say "I'm done with this one's identity" — which is exactly what &lt;code&gt;std::move&lt;/code&gt; does by casting the lvalue into an &lt;strong&gt;xvalue&lt;/strong&gt; (an e*&lt;em&gt;X&lt;/em&gt;*piring value). That cast is the bridge to the next section: lvalues are too "sticky" to move from automatically, and xvalues are how we opt in.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. xvalue (eXpiring value)
&lt;/h2&gt;

&lt;p&gt;If lvalues are "too sticky to move from automatically," xvalues are the mechanism that lets you opt in. An xvalue is an expression that has identity and can be moved from. It still refers to a specific object (making it a glvalue), but it carries a signal: this object is expiring—its resources may be reused.&lt;/p&gt;

&lt;h3&gt;
  
  
  Where xvalues come from
&lt;/h3&gt;

&lt;p&gt;In C++, an expression is an xvalue if it is one of the following:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;A function call or cast returning an rvalue reference to an object:&lt;/strong&gt;
&lt;code&gt;std::move(x)&lt;/code&gt; is the canonical example (which internally evaluates to &lt;code&gt;static_cast&amp;lt;T&amp;amp;&amp;amp;&amp;gt;(x)&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Member access on an rvalue object:&lt;/strong&gt;
&lt;code&gt;a.m&lt;/code&gt;, where &lt;code&gt;a&lt;/code&gt; is an rvalue (either an xvalue or a prvalue) and &lt;code&gt;m&lt;/code&gt; is a non-static data member of &lt;em&gt;non-reference&lt;/em&gt; type.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pointer-to-member operations:&lt;/strong&gt;
&lt;code&gt;a.*pm&lt;/code&gt;, where &lt;code&gt;a&lt;/code&gt; is an rvalue and &lt;code&gt;pm&lt;/code&gt; points to a data member.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Array subscripting on an rvalue array:&lt;/strong&gt;
&lt;code&gt;std::move(arr)[i]&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;move&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// xvalue (via function returning T&amp;amp;&amp;amp;)&lt;/span&gt;

&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="nc"&gt;Foo&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;Foo&lt;/span&gt;&lt;span class="p"&gt;{}.&lt;/span&gt;&lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// xvalue: member access on prvalue&lt;/span&gt;

&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="nc"&gt;RefFoo&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;val&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;42&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;RefFoo&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;val&lt;/span&gt;&lt;span class="p"&gt;}.&lt;/span&gt;&lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// lvalue: reference members never decay into xvalues&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  3. prvalue (Pure Rvalue)
&lt;/h2&gt;

&lt;p&gt;If an lvalue represents an identifiable, long-lived object and an xvalue represents an existing object marked for expiration, a &lt;strong&gt;prvalue&lt;/strong&gt; represents the computation itself.&lt;/p&gt;

&lt;p&gt;A prvalue does not have an identity. Instead of referring to an object sitting somewhere in memory, it is an expression whose evaluation &lt;strong&gt;initializes an object&lt;/strong&gt; or &lt;strong&gt;computes a value&lt;/strong&gt;. Because it has no identity, nobody else can refer to it, making it inherently safe to move from or consume.&lt;/p&gt;

&lt;h3&gt;
  
  
  The C++17 Paradigm Shift: Deferred Materialization
&lt;/h3&gt;

&lt;p&gt;Prior to C++17, prvalues were often thought of as "temporary objects." Since C++17, that definition is obsolete:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;A prvalue is not an object; it is a recipe to initialize an object.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;An actual temporary object is only created when the language has no choice but to give the prvalue a physical location in memory (such as binding it to a reference or accessing a member). This process is called &lt;strong&gt;temporary materialization&lt;/strong&gt;, and it turns a prvalue into an xvalue on demand.&lt;/p&gt;

&lt;p&gt;Because prvalues are recipes rather than objects, returning a prvalue by value or passing one as an argument does not invoke a copy or move constructor—not even as an optimization. It is guaranteed by the language standard (&lt;strong&gt;Guaranteed Copy Elision&lt;/strong&gt;).&lt;/p&gt;

&lt;h3&gt;
  
  
  Where prvalues come from
&lt;/h3&gt;

&lt;p&gt;The majority of everyday expressions produce prvalues:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Literals:&lt;/strong&gt; Numeric, boolean, and character literals like &lt;code&gt;42&lt;/code&gt;, &lt;code&gt;3.14&lt;/code&gt;, &lt;code&gt;true&lt;/code&gt;, and &lt;code&gt;'a'&lt;/code&gt; (note: string literals like &lt;code&gt;"hello"&lt;/code&gt; are an exception; they are &lt;strong&gt;lvalues&lt;/strong&gt; pointing to static memory).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Function calls returning non-references:&lt;/strong&gt; Any call or overloaded operator returning a value type (e.g., &lt;code&gt;std::string("hello")&lt;/code&gt;, &lt;code&gt;make_widget()&lt;/code&gt;, &lt;code&gt;a + b&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Arithmetic, logical, and relational expressions:&lt;/strong&gt; Built-in operations like &lt;code&gt;x + y&lt;/code&gt;, &lt;code&gt;!flag&lt;/code&gt;, &lt;code&gt;a &amp;lt; b&lt;/code&gt;, or bitwise operations.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The address-of operator:&lt;/strong&gt; &lt;code&gt;&amp;amp;x&lt;/code&gt; is a prvalue representing the pointer value itself.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Lambda expressions:&lt;/strong&gt; &lt;code&gt;[](int a) { return a * 2; }&lt;/code&gt; evaluates to a prvalue closure object.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Explicit conversions/casts to non-reference types:&lt;/strong&gt; &lt;code&gt;static_cast&amp;lt;double&amp;gt;(my_int)&lt;/code&gt; or functional forms like &lt;code&gt;Foo{}&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Built-in post-increment and post-decrement:&lt;/strong&gt; &lt;code&gt;x++&lt;/code&gt; and &lt;code&gt;x--&lt;/code&gt; (they compute and return the old value as a prvalue, unlike &lt;code&gt;++x&lt;/code&gt; which returns an lvalue reference).&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Practical Example
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="nc"&gt;LargeBuffer&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;LargeBuffer&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="n"&gt;LargeBuffer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;const&lt;/span&gt; &lt;span class="n"&gt;LargeBuffer&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;delete&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// Non-copyable&lt;/span&gt;
    &lt;span class="n"&gt;LargeBuffer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;LargeBuffer&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;delete&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;      &lt;span class="c1"&gt;// Non-movable&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="n"&gt;LargeBuffer&lt;/span&gt; &lt;span class="nf"&gt;create_buffer&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;LargeBuffer&lt;/span&gt;&lt;span class="p"&gt;{};&lt;/span&gt; &lt;span class="c1"&gt;// prvalue: no temporary object created here yet&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c1"&gt;// 1. Guaranteed Copy Elision (C++17)&lt;/span&gt;
    &lt;span class="c1"&gt;// Works even though LargeBuffer is neither copyable nor movable!&lt;/span&gt;
    &lt;span class="c1"&gt;// The prvalue directly initializes `buf` in-place.&lt;/span&gt;
    &lt;span class="n"&gt;LargeBuffer&lt;/span&gt; &lt;span class="n"&gt;buf&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;create_buffer&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt; 

    &lt;span class="c1"&gt;// 2. Literals and computation&lt;/span&gt;
    &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// `5`, `3`, and `5 + 3` are prvalues&lt;/span&gt;

    &lt;span class="c1"&gt;// 3. Temporary Materialization&lt;/span&gt;
    &lt;span class="c1"&gt;// `create_buffer()` is a prvalue. Binding it to an rvalue reference forces &lt;/span&gt;
    &lt;span class="c1"&gt;// a temporary object to materialize in memory, converting it into an xvalue.&lt;/span&gt;
    &lt;span class="c1"&gt;// const LargeBuffer&amp;amp; ref = create_buffer(); &lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;






&lt;h3&gt;
  
  
  The Big Picture (Taxonomy Recap)
&lt;/h3&gt;

&lt;p&gt;To see how all three fit together:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Category&lt;/th&gt;
&lt;th&gt;Has Identity? (glvalue)&lt;/th&gt;
&lt;th&gt;Can be moved from? (rvalue)&lt;/th&gt;
&lt;th&gt;What it represents&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;lvalue&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Yes&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;Persistent entity/location in memory&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;xvalue&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Yes&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Yes&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Existing entity expiring or marked for reuse&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;prvalue&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Yes&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Pure computation / blueprint for initialization&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;glvalue&lt;/strong&gt; (generalized lvalue) = &lt;code&gt;lvalue&lt;/code&gt; + &lt;code&gt;xvalue&lt;/code&gt; (anything with an identity)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;rvalue&lt;/strong&gt; = &lt;code&gt;xvalue&lt;/code&gt; + &lt;code&gt;prvalue&lt;/code&gt; (anything safe to move from or consume)&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  One thing worth mentioning:
&lt;/h3&gt;

&lt;p&gt;The most common trap in C++ is conflating the &lt;strong&gt;type of a variable&lt;/strong&gt; (&lt;code&gt;T&amp;amp;&amp;amp;&lt;/code&gt;) with the &lt;strong&gt;value category of the expression naming it&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;A named rvalue reference is itself an &lt;strong&gt;lvalue&lt;/strong&gt;.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="nf"&gt;process&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c1"&gt;// `r` is a variable of type rvalue reference (std::string&amp;amp;&amp;amp;).&lt;/span&gt;
    &lt;span class="c1"&gt;// BUT the expression `r` is an lvalue!&lt;/span&gt;
    &lt;span class="c1"&gt;// It has a name, identity, and persists throughout this function scope.&lt;/span&gt;

    &lt;span class="c1"&gt;// std::string target = r;             // ERROR/Surprise: invokes copy constructor!&lt;/span&gt;
    &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt; &lt;span class="n"&gt;target&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;move&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;     &lt;span class="c1"&gt;// OK: casts the lvalue `r` back into an xvalue&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Rule of thumb:&lt;/strong&gt; "If it has a name, it's an lvalue." It doesn't matter if its type was declared as &lt;code&gt;T&amp;amp;&amp;amp;&lt;/code&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;After reading this article, I hope you understand that value categories aren't trivia. They are the underlying grammar that makes modern move semantics and zero-cost abstractions possible. Master the grammar, and writing expressive, high-performance C++ becomes second nature.&lt;/p&gt;

</description>
      <category>cpp</category>
      <category>programming</category>
      <category>code</category>
      <category>coding</category>
    </item>
    <item>
      <title>Deep dive into the C++ Passkey idiom</title>
      <dc:creator>llzzz</dc:creator>
      <pubDate>Sun, 25 Oct 2026 09:36:52 +0000</pubDate>
      <link>https://dev.to/z6123/deep-dive-into-the-c-passkey-idiom-f3d</link>
      <guid>https://dev.to/z6123/deep-dive-into-the-c-passkey-idiom-f3d</guid>
      <description>&lt;h3&gt;
  
  
  1. Motivation: The Problem with &lt;code&gt;friend&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;In C++, &lt;code&gt;friend&lt;/code&gt; is a double-edged sword. If you allow your friend to touch you inappropriately, that would be hurt. If class &lt;code&gt;A&lt;/code&gt; befriends another class &lt;code&gt;B&lt;/code&gt;, then everything in &lt;code&gt;A&lt;/code&gt; becomes visible to &lt;code&gt;B&lt;/code&gt;. &lt;code&gt;friend&lt;/code&gt; grants all-or-nothing access — which is rarely what you actually want. You usually want your friend to only able to touch a portion of you.&lt;/p&gt;

&lt;p&gt;Consider the following scenario. You have a &lt;code&gt;Widget&lt;/code&gt; class that must be created through a factory, because the constructor needs to perform some privileged setup (registering with a resource manager, validating invariants, logging, and so on). But the constructor itself has to be &lt;code&gt;public&lt;/code&gt; for &lt;code&gt;std::make_unique&lt;/code&gt; or for the factory to reach it. The moment it is &lt;code&gt;public&lt;/code&gt;, anyone can construct a &lt;code&gt;Widget&lt;/code&gt; — and that is a correctness bug waiting to happen.&lt;/p&gt;

&lt;p&gt;You might reach for &lt;code&gt;friend&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;WidgetFactory&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Widget&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;friend&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;WidgetFactory&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;   &lt;span class="c1"&gt;// grants access to EVERYTHING&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="n"&gt;x_&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="p"&gt;{}&lt;/span&gt;
&lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;
    &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x_&lt;/span&gt;&lt;span class="p"&gt;{};&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;WidgetFactory&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="k"&gt;static&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;WidgetFactory&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;42&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;   &lt;span class="c1"&gt;// ok&lt;/span&gt;
    &lt;span class="c1"&gt;// auto bad = std::make_unique&amp;lt;Widget&amp;gt;(42); // also ok! constructor is public, but you dont want this...&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This "works," but it is a blunt instrument. &lt;code&gt;WidgetFactory&lt;/code&gt; now has access to every private member of &lt;code&gt;Widget&lt;/code&gt;, not just the constructor. As &lt;code&gt;Widget&lt;/code&gt; grows, so does the accidental attack surface. And if you later need to grant the same narrow access to a &lt;code&gt;Debugger&lt;/code&gt; class, you add another &lt;code&gt;friend&lt;/code&gt;, and the surface widens again.&lt;/p&gt;

&lt;p&gt;The question this idiom answers is:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;How can I let a specific class touch only a specific portion of my class — and nothing else?&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;And then now let me introduce the PassKey Idiom.&lt;/p&gt;




&lt;h3&gt;
  
  
  2. The Classic Solution: A Nested PassKey
&lt;/h3&gt;

&lt;p&gt;The core idea is to make a public function that requires an argument nobody else can construct. That argument is the &lt;em&gt;passkey&lt;/em&gt;.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Widget&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;PassKey&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;friend&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="n"&gt;PassKey&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// this constructor is private&lt;/span&gt;
    &lt;span class="p"&gt;};&lt;/span&gt;

    &lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;PassKey&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="n"&gt;x_&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;{}&lt;/span&gt;

    &lt;span class="k"&gt;static&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;PassKey&lt;/span&gt;&lt;span class="p"&gt;{},&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;
    &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x_&lt;/span&gt;&lt;span class="p"&gt;{};&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c1"&gt;// auto w1 = Widget{Widget::PassKey{}, 42}; // compile error! cannot access private constructor&lt;/span&gt;
    &lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;w2&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;42&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// ok&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A few things are worth calling out:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The constructor &lt;code&gt;PassKey() = default;&lt;/code&gt; is implicitly private (it is a member of a class whose default access is private), and &lt;code&gt;Widget&lt;/code&gt; is its only friend.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;Widget&lt;/code&gt;'s constructor is &lt;code&gt;public&lt;/code&gt;, so it satisfies the syntactic requirements of &lt;code&gt;std::make_unique&lt;/code&gt;. But it is only &lt;em&gt;callable&lt;/em&gt; by code that can produce a &lt;code&gt;PassKey&lt;/code&gt; — which, in practice, means only &lt;code&gt;Widget&lt;/code&gt; itself (or whatever &lt;code&gt;Widget&lt;/code&gt; chooses to befriend).&lt;/li&gt;
&lt;li&gt;In &lt;code&gt;main&lt;/code&gt;, the direct construction fails to compile because &lt;code&gt;Widget::PassKey&lt;/code&gt; is private. The only way in is through &lt;code&gt;create&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is a clean, zero-boilerplate solution &lt;strong&gt;for a single class&lt;/strong&gt;. But it does not scale. If you have &lt;code&gt;Widget&lt;/code&gt;, &lt;code&gt;Gadget&lt;/code&gt;, and &lt;code&gt;Sprocket&lt;/code&gt;, you must replicate this nested-class boilerplate in every one of them. Worse, the authorized "friend" is baked into the nested definition, so if you want &lt;code&gt;Widget&lt;/code&gt;'s constructor callable by both a &lt;code&gt;Factory&lt;/code&gt; and a &lt;code&gt;Debugger&lt;/code&gt;, you either befriend both inside &lt;code&gt;PassKey&lt;/code&gt; or duplicate the pattern. How to solve this? we can use a template!&lt;/p&gt;




&lt;h3&gt;
  
  
  3. Scaling Up: The Templated PassKey
&lt;/h3&gt;

&lt;p&gt;The templated PassKey decouples the mechanism from the class it protects. You define it once, and any class can use it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;template&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;typename&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Passkey&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;friend&lt;/span&gt; &lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;             &lt;span class="c1"&gt;// only T can construct a Passkey&amp;lt;T&amp;gt;&lt;/span&gt;
    &lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// private: no one else can create one&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Now the authorized class can create a passkey, and unauthorized code cannot:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;WidgetFactory&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;WidgetDebugger&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Widget&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="c1"&gt;// Public constructor, but only callable by whoever can make a Passkey&amp;lt;WidgetFactory&amp;gt;&lt;/span&gt;
    &lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;WidgetFactory&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="n"&gt;x_&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;{}&lt;/span&gt;

    &lt;span class="c1"&gt;// A separate, narrower door for the debugger&lt;/span&gt;
    &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="n"&gt;dump&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;WidgetDebugger&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;const&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="cm"&gt;/* ... */&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;
    &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x_&lt;/span&gt;&lt;span class="p"&gt;{};&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;WidgetFactory&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="k"&gt;static&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;WidgetFactory&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{},&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;WidgetDebugger&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="n"&gt;inspect&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;const&lt;/span&gt; &lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;dump&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;WidgetDebugger&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{});&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;WidgetFactory&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;42&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;   &lt;span class="c1"&gt;// ok&lt;/span&gt;
    &lt;span class="n"&gt;WidgetDebugger&lt;/span&gt;&lt;span class="p"&gt;{}.&lt;/span&gt;&lt;span class="n"&gt;inspect&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;          &lt;span class="c1"&gt;// ok&lt;/span&gt;

    &lt;span class="c1"&gt;// auto bad = std::make_unique&amp;lt;Widget&amp;gt;(Passkey&amp;lt;WidgetFactory&amp;gt;{}, 1); // error&lt;/span&gt;
    &lt;span class="c1"&gt;// WidgetDebugger{}.inspect(...) can't call Widget's ctor; Factory can't call dump()&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The design now has two key properties:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Per-function granularity.&lt;/strong&gt; &lt;code&gt;Widget&lt;/code&gt;'s constructor admits only &lt;code&gt;WidgetFactory&lt;/code&gt;. &lt;code&gt;Widget::dump&lt;/code&gt; admits only &lt;code&gt;WidgetDebugger&lt;/code&gt;. Neither can use the other's door. No &lt;code&gt;friend&lt;/code&gt; grants blanket access.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reusable mechanism.&lt;/strong&gt; &lt;code&gt;Passkey&amp;lt;T&amp;gt;&lt;/code&gt; is written once and works for any number of classes. There is no nested-class boilerplate to copy.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;A subtle but important point: &lt;code&gt;std::make_unique&lt;/code&gt; cannot construct the &lt;code&gt;Passkey&lt;/code&gt; for you. The authorized class must explicitly pass &lt;code&gt;Passkey&amp;lt;WidgetFactory&amp;gt;{}&lt;/code&gt; into the constructor call. That is by design — &lt;code&gt;make_unique&lt;/code&gt; is not the privileged party; the caller is.&lt;/p&gt;

&lt;h4&gt;
  
  
  Improvement you can made if you are using C++20
&lt;/h4&gt;

&lt;p&gt;C++20 does not fundamentally change the PassKey mechanism. There is no concept that replaces it, because concepts constrain types, whereas PassKey constrains &lt;em&gt;who can produce a token&lt;/em&gt;. The two compose nicely, though: if you are building a generic system where the set of authorized callers is itself parameterized, you can write&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="cp"&gt;#include&lt;/span&gt; &lt;span class="cpf"&gt;&amp;lt;type_traits&amp;gt;&lt;/span&gt;&lt;span class="cp"&gt;
&lt;/span&gt;
&lt;span class="c1"&gt;// Marker: only types deriving from this may be a Caller.&lt;/span&gt;
&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="nc"&gt;Privileged&lt;/span&gt; &lt;span class="p"&gt;{};&lt;/span&gt;

&lt;span class="c1"&gt;// Passkey&amp;lt;T&amp;gt; only exists if T is privileged.&lt;/span&gt;
&lt;span class="k"&gt;template&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;typename&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="k"&gt;requires&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;is_base_of_v&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Privileged&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Passkey&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;friend&lt;/span&gt; &lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Widget&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Factory&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="n"&gt;x_&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="p"&gt;{}&lt;/span&gt;
&lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;
    &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x_&lt;/span&gt;&lt;span class="p"&gt;{};&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="c1"&gt;// Factory opts in — so it can make a Passkey&amp;lt;Factory&amp;gt;.&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Factory&lt;/span&gt; &lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="n"&gt;Privileged&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="k"&gt;static&lt;/span&gt; &lt;span class="n"&gt;Widget&lt;/span&gt; &lt;span class="n"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Factory&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{},&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="c1"&gt;// Sneaky does NOT opt in — so Passkey&amp;lt;Sneaky&amp;gt; won't compile.&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Sneaky&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="c1"&gt;// Widget w{Passkey&amp;lt;Sneaky&amp;gt;{}, 1};  // error: constraint not satisfied&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That's the whole idea. Widget's constructor is public, but the only way to call it is to hand it a &lt;code&gt;Passkey&amp;lt;Factory&amp;gt;&lt;/code&gt; — and only Factory can construct one, because Factory is the friend. The requires clause adds one extra guarantee: you can't even write &lt;code&gt;Passkey&amp;lt;X&amp;gt;&lt;/code&gt; unless &lt;code&gt;X&lt;/code&gt; derives from Privileged, so unauthorized types fail at the template level instead of at the friend level.&lt;/p&gt;




&lt;h3&gt;
  
  
  4. Group Permissions: Variadic Friends (C++26)
&lt;/h3&gt;

&lt;p&gt;The templated PassKey has one remaining friction point. Suppose a single function should be callable by &lt;em&gt;several&lt;/em&gt; authorized classes — say a &lt;code&gt;Factory&lt;/code&gt;, a &lt;code&gt;Debugger&lt;/code&gt;, and a &lt;code&gt;Serializer&lt;/code&gt;. Before C++26, you cannot write &lt;code&gt;friend Ts...&lt;/code&gt;; expanding a parameter pack in a friend declaration is ill-formed. The workarounds are ugly: manual overloads, a combined passkey type, or a chain of nested friends.&lt;/p&gt;

&lt;p&gt;C++26 fixes this with &lt;strong&gt;variadic friends&lt;/strong&gt; (P2893R3). You can now expand a pack directly:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="cp"&gt;#include&lt;/span&gt; &lt;span class="cpf"&gt;&amp;lt;iostream&amp;gt;&lt;/span&gt;&lt;span class="cp"&gt;
&lt;/span&gt;
&lt;span class="c1"&gt;// C++26: variadic friends — one passkey authorizes a whole pack of types.&lt;/span&gt;
&lt;span class="k"&gt;template&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;typename&lt;/span&gt;&lt;span class="o"&gt;...&lt;/span&gt; &lt;span class="nc"&gt;Ts&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Passkey&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;friend&lt;/span&gt; &lt;span class="n"&gt;Ts&lt;/span&gt;&lt;span class="p"&gt;...;&lt;/span&gt;
    &lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Factory&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Debugger&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Serializer&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Widget&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="c1"&gt;// Only Factory, Debugger, and Serializer can call this.&lt;/span&gt;
    &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="n"&gt;secretInit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Factory&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Debugger&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Serializer&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;cout&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class="s"&gt;"Widget initialized&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="c1"&gt;// Each authorized type can build the passkey — and thus call secretInit.&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Factory&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="n"&gt;make&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;secretInit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Factory&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Debugger&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Serializer&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{});&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Debugger&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="n"&gt;poke&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;secretInit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Factory&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Debugger&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Serializer&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{});&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Serializer&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="n"&gt;save&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;secretInit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Passkey&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Factory&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Debugger&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Serializer&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{});&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="c1"&gt;// Not in the pack — cannot construct the passkey.&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Intruder&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="c1"&gt;// void tryIt(Widget&amp;amp; w) { w.secretInit(Passkey&amp;lt;Factory, Debugger, Serializer&amp;gt;{}); }&lt;/span&gt;
    &lt;span class="c1"&gt;//   ^ error: Passkey ctor is private; Intruder is not a friend.&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;Widget&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="n"&gt;Factory&lt;/span&gt;&lt;span class="p"&gt;{}.&lt;/span&gt;&lt;span class="n"&gt;make&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;        &lt;span class="c1"&gt;// ok&lt;/span&gt;
    &lt;span class="n"&gt;Debugger&lt;/span&gt;&lt;span class="p"&gt;{}.&lt;/span&gt;&lt;span class="n"&gt;poke&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;       &lt;span class="c1"&gt;// ok&lt;/span&gt;
    &lt;span class="n"&gt;Serializer&lt;/span&gt;&lt;span class="p"&gt;{}.&lt;/span&gt;&lt;span class="n"&gt;save&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;     &lt;span class="c1"&gt;// ok&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This makes the "group permission" case a one-liner and removes the need for the combined-type hack. It is a small language feature, but for the PassKey idiom it is a meaningful ergonomic win: the passkey now expresses &lt;em&gt;"these N types, and no others"&lt;/em&gt; directly in the type system.&lt;/p&gt;




&lt;h3&gt;
  
  
  5. Performance and Trade-offs
&lt;/h3&gt;

&lt;h4&gt;
  
  
  Runtime cost
&lt;/h4&gt;

&lt;p&gt;&lt;strong&gt;In theory&lt;/strong&gt;, passing an empty object by value could cost a register or a stack slot. &lt;strong&gt;In practice&lt;/strong&gt;, in optimized builds, it is a &lt;strong&gt;zero-cost abstraction&lt;/strong&gt;. Because &lt;code&gt;Passkey&lt;/code&gt; has no data members and the parameter is unnamed, the optimizer elides it entirely at &lt;code&gt;-O1&lt;/code&gt; and above. There is no runtime check, no branch, no token comparison — the entire mechanism lives in the type system and disappears in the emitted code.&lt;/p&gt;

&lt;h4&gt;
  
  
  The one caveat
&lt;/h4&gt;

&lt;p&gt;If the protected function is not inlined (defined in a separate translation unit, and LTO is disabled), the calling convention may still require passing a byte for the empty class to satisfy the ABI. This is a minor, usually irrelevant cost. For header-only or inlined usage — which is the common case — there is no overhead at all.&lt;/p&gt;

&lt;h4&gt;
  
  
  Compile-time cost
&lt;/h4&gt;

&lt;p&gt;Slightly more template instantiation (one specialization per authorized type), and slightly longer function signatures. This is the real price, but it is  usually trivial.&lt;/p&gt;

&lt;h4&gt;
  
  
  Readability trade-offs
&lt;/h4&gt;

&lt;ul&gt;
&lt;li&gt;Signatures get noisier: &lt;code&gt;Widget(Passkey&amp;lt;Factory&amp;gt;, int)&lt;/code&gt; is visually heavier than &lt;code&gt;Widget(int)&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;The unnamed parameter convention (see below) is what keeps it readable; without it, reviewers wonder what the argument is for.&lt;/li&gt;
&lt;li&gt;The mechanism is &lt;em&gt;compile-time enforced&lt;/em&gt;, so the compiler error when someone tries to bypass it is clear — but the &lt;em&gt;reason&lt;/em&gt; the parameter exists is not obvious to a reader seeing the class for the first time. A brief comment on the constructor is worth the cost.&lt;/li&gt;
&lt;/ul&gt;




&lt;h3&gt;
  
  
  6. Idiomatic Usage and Best Practices
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Leave the parameter unnamed.&lt;/strong&gt; Write &lt;code&gt;void foo(Passkey&amp;lt;T&amp;gt;)&lt;/code&gt;, not &lt;code&gt;void foo(Passkey&amp;lt;T&amp;gt; key)&lt;/code&gt;. The unnamed parameter signals "this is a token, not data — it carries no information and is never used in the body."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Mark the constructor &lt;code&gt;explicit&lt;/code&gt; if you are being defensive.&lt;/strong&gt; &lt;code&gt;explicit Passkey() = default;&lt;/code&gt; is not strictly required — the private access already blocks unauthorized construction — but it guards against brace-initialization surprises and makes intent explicit. It is harmless and recommended for older-standard compatibility (C++17 or earlier).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Prefer the templated form.&lt;/strong&gt; The nested form is fine as a teaching example, but the templated form is the one to use in production.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Document the contract.&lt;/strong&gt; A one-line comment — &lt;code&gt;// only Factory may construct Widget&lt;/code&gt; — saves future readers from reverse-engineering the idiom.&lt;/li&gt;
&lt;/ul&gt;




&lt;h3&gt;
  
  
  8. Summary
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;friend&lt;/code&gt; is all-or-nothing; the PassKey idiom gives you &lt;strong&gt;per-function, per-caller&lt;/strong&gt; access control.&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;nested&lt;/strong&gt; PassKey is the minimal teaching form; the &lt;strong&gt;templated&lt;/strong&gt; &lt;code&gt;Passkey&amp;lt;T&amp;gt;&lt;/code&gt; is the idiomatic production form.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;C++26 variadic friends&lt;/strong&gt; (&lt;code&gt;friend Ts...&lt;/code&gt;) turns "group permissions" into a one-liner, removing the last piece of friction.&lt;/li&gt;
&lt;li&gt;It is a &lt;strong&gt;zero-cost abstraction&lt;/strong&gt; in optimized builds; the cost is compile-time and readability, not runtime.&lt;/li&gt;
&lt;li&gt;Use it for restricted constructors and sensitive methods; use &lt;strong&gt;Attorney-Client&lt;/strong&gt; when you need to expose members instead.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Happy coding!&lt;/p&gt;

</description>
      <category>code</category>
      <category>cpp</category>
      <category>programming</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>Why prefer std::make_unique over new in std::unique_ptr?</title>
      <dc:creator>llzzz</dc:creator>
      <pubDate>Sat, 24 Oct 2026 03:20:58 +0000</pubDate>
      <link>https://dev.to/z6123/why-prefer-stdmakeunique-over-new-in-stduniqueptr-3h9d</link>
      <guid>https://dev.to/z6123/why-prefer-stdmakeunique-over-new-in-stduniqueptr-3h9d</guid>
      <description>&lt;p&gt;In modern C++, when you need a &lt;code&gt;std::unique_ptr&lt;/code&gt;, the idiomatic way to create it is:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;ptr&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;MyClass&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;rather than manually &lt;code&gt;new&lt;/code&gt;-ing the object inside the &lt;code&gt;unique_ptr&lt;/code&gt; constructor:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;MyClass&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;ptr&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="n"&gt;MyClass&lt;/span&gt;&lt;span class="p"&gt;()};&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;std::make_unique&lt;/code&gt; was introduced in C++14 to fill a gap that &lt;code&gt;std::make_shared&lt;/code&gt; had already covered for shared ownership. It is a small function template, but it carries several important advantages. This article walks through every reason to prefer it, notes what changed in C++17 and C++20, and covers the cases where you still need the raw &lt;code&gt;new&lt;/code&gt; form.&lt;/p&gt;

&lt;p&gt;the implementation of &lt;code&gt;std::make_unique&lt;/code&gt; is roughly the following:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;namespace&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;template&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;typename&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="k"&gt;typename&lt;/span&gt;&lt;span class="o"&gt;...&lt;/span&gt; &lt;span class="nc"&gt;Args&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Args&lt;/span&gt;&lt;span class="p"&gt;...&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;noexcept&lt;/span&gt;
    &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;forward&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Args&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;)...});&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  1. Exception Safety
&lt;/h3&gt;

&lt;p&gt;This is traditionally cited as the main reason for &lt;code&gt;make_unique&lt;/code&gt;. Before C++17, the order in which function arguments are evaluated was unspecified. If you constructed a &lt;code&gt;unique_ptr&lt;/code&gt; with &lt;code&gt;new&lt;/code&gt; as one argument among several, a leak could occur if another argument threw &lt;strong&gt;after&lt;/strong&gt; the &lt;code&gt;new&lt;/code&gt; expression completed but &lt;strong&gt;before&lt;/strong&gt; the &lt;code&gt;unique_ptr&lt;/code&gt; constructor took ownership of the raw pointer.&lt;/p&gt;

&lt;p&gt;Here is an example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt; &lt;span class="p"&gt;{};&lt;/span&gt;

&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="nc"&gt;U&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;U&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
    &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;throw&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;runtime_error&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"boom"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;foo&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="p"&gt;{}},&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;U&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="n"&gt;U&lt;/span&gt;&lt;span class="p"&gt;{}});&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Before C++17, a compiler was permitted to evaluate &lt;code&gt;new T{}&lt;/code&gt; first, then evaluate &lt;code&gt;new U{}&lt;/code&gt;, and only then call the &lt;code&gt;unique_ptr&lt;/code&gt; constructors. If &lt;code&gt;new U{}&lt;/code&gt; threw, the memory allocated for &lt;code&gt;T&lt;/code&gt; had not yet been handed to a &lt;code&gt;unique_ptr&lt;/code&gt;, so it leaked.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;std::make_unique&lt;/code&gt; closes this hole because the allocation and the ownership transfer happen inside a single function call. The temporary &lt;code&gt;unique_ptr&lt;/code&gt; is fully constructed before the surrounding expression continues, so if a later argument throws, stack unwinding destroys the already-constructed &lt;code&gt;unique_ptr&lt;/code&gt; and frees the memory.&lt;/p&gt;

&lt;h4&gt;
  
  
  What changed in C++17
&lt;/h4&gt;

&lt;p&gt;C++17 tightened the evaluation-order rules. In a function call, each argument expression is now fully evaluated before the next argument is evaluated, although the order in which the arguments are evaluated relative to each other is still unspecified. Because of this, the manual &lt;code&gt;new&lt;/code&gt; form is no longer leak-prone in the exact multi-argument scenario above: once &lt;code&gt;new T{}&lt;/code&gt; completes and its &lt;code&gt;unique_ptr&lt;/code&gt; temporary is constructed, that temporary is a fully formed object, and an exception from another argument will destroy it correctly.&lt;/p&gt;

&lt;p&gt;So if you are compiling as C++17 or later, the exception-safety motivation for &lt;code&gt;make_unique&lt;/code&gt; is largely historical. The remaining reasons below are still valid.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Reduced Redundancy and &lt;code&gt;auto&lt;/code&gt; Type Deduction
&lt;/h3&gt;

&lt;p&gt;Using &lt;code&gt;make_unique&lt;/code&gt; lets you write the type name once and rely on &lt;code&gt;auto&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;MyClass&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nf"&gt;MyClass&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt; &lt;span class="c1"&gt;// MyClass written twice&lt;/span&gt;
&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;ptr&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;MyClass&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;  &lt;span class="c1"&gt;// written once&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Beyond brevity, this eliminates a class of bugs where the two type names drift apart during refactoring: one is changed but the other is not, producing a mismatched or ill-formed expression. The C++ Core Guidelines encode this as &lt;strong&gt;R.23: Use &lt;code&gt;make_unique()&lt;/code&gt; to make &lt;code&gt;unique_ptr&lt;/code&gt;s&lt;/strong&gt;, citing both conciseness and exception safety.&lt;/p&gt;

&lt;h4&gt;
  
  
  Polymorphism caveat
&lt;/h4&gt;

&lt;p&gt;&lt;code&gt;make_unique&lt;/code&gt; does not perform polymorphic type erasure automatically. With &lt;code&gt;auto&lt;/code&gt;, you get exactly the &lt;code&gt;unique_ptr&amp;lt;T&amp;gt;&lt;/code&gt; corresponding to the template argument:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="nc"&gt;Base&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;virtual&lt;/span&gt; &lt;span class="o"&gt;~&lt;/span&gt;&lt;span class="n"&gt;Base&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="nc"&gt;Derived&lt;/span&gt; &lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="n"&gt;Base&lt;/span&gt; &lt;span class="p"&gt;{};&lt;/span&gt;

&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;p1&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Base&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;    &lt;span class="c1"&gt;// std::unique_ptr&amp;lt;Base&amp;gt;&lt;/span&gt;
&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;p2&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Derived&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt; &lt;span class="c1"&gt;// std::unique_ptr&amp;lt;Derived&amp;gt;, not unique_ptr&amp;lt;Base&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If you want a base-class handle, you must state the target type explicitly:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Base&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Derived&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This works because &lt;code&gt;unique_ptr&amp;lt;Derived&amp;gt;&lt;/code&gt; converts to &lt;code&gt;unique_ptr&amp;lt;Base&amp;gt;&lt;/code&gt; when &lt;code&gt;Derived*&lt;/code&gt; converts to &lt;code&gt;Base*&lt;/code&gt;. Also note the virtual destructor on &lt;code&gt;Base&lt;/code&gt;: without it, deleting a &lt;code&gt;Derived&lt;/code&gt; through a &lt;code&gt;Base*&lt;/code&gt; is undefined behavior.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Enforcing a "No Raw &lt;code&gt;new&lt;/code&gt;" Discipline
&lt;/h3&gt;

&lt;p&gt;Every occurrence of &lt;code&gt;new&lt;/code&gt; in application code must be audited for lifetime correctness: is it deleted exactly once, through the correct type, with the correct &lt;code&gt;delete&lt;/code&gt; form? &lt;code&gt;make_unique&lt;/code&gt; removes that audit burden from the call site. If the owning object has a correct lifetime, the &lt;code&gt;unique_ptr&lt;/code&gt; it produces has a correct lifetime.&lt;/p&gt;

&lt;p&gt;This lets you adopt a simple, mechanically checkable rule: &lt;strong&gt;do not write &lt;code&gt;new&lt;/code&gt; in your codebase except inside the implementation of a factory or a low-level container&lt;/strong&gt;. As Scott Meyers and others have put it, &lt;code&gt;make_unique&lt;/code&gt; teaches “never say &lt;code&gt;new&lt;/code&gt;/&lt;code&gt;delete&lt;/code&gt;” without disclaimers.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Array Safety
&lt;/h3&gt;

&lt;p&gt;&lt;code&gt;make_unique&lt;/code&gt; distinguishes scalar and array types and returns the appropriate &lt;code&gt;unique_ptr&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="p"&gt;[]&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// std::unique_ptr&amp;lt;int[]&amp;gt;&lt;/span&gt;
&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;42&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;   &lt;span class="c1"&gt;// std::unique_ptr&amp;lt;int&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;With the manual constructor, nothing prevents you from writing a mismatched pair such as &lt;code&gt;std::unique_ptr&amp;lt;int&amp;gt;(new int[10])&lt;/code&gt; or &lt;code&gt;std::unique_ptr&amp;lt;int[]&amp;gt;(new int(42))&lt;/code&gt;, both of which lead to undefined behavior when the default deleter uses the wrong &lt;code&gt;delete&lt;/code&gt; form.&lt;/p&gt;

&lt;p&gt;(&lt;code&gt;make_unique&amp;lt;T[N]&amp;gt;&lt;/code&gt; for a fixed bound &lt;code&gt;N&lt;/code&gt; is also permitted, but it is almost always a mistake because &lt;code&gt;unique_ptr&amp;lt;T[N]&amp;gt;&lt;/code&gt; does not have array-covariant behavior in the way you might expect.)&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Consistency with &lt;code&gt;make_shared&lt;/code&gt; and Easy Switching
&lt;/h3&gt;

&lt;p&gt;You should already be using &lt;code&gt;std::make_shared&lt;/code&gt; for shared ownership (it performs a single combined allocation, unlike &lt;code&gt;shared_ptr&amp;lt;T&amp;gt;(new T)&lt;/code&gt;). Using &lt;code&gt;make_unique&lt;/code&gt; gives your codebase a uniform creation syntax:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;u&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_shared&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This consistency pays off when requirements change. Switching between exclusive and shared ownership becomes a one-token edit:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// change to std::make_shared&amp;lt;T&amp;gt;(args)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;With the manual form, that switch requires rewriting the declaration, removing &lt;code&gt;new&lt;/code&gt;, and reconciling the deleter.&lt;/p&gt;

&lt;h3&gt;
  
  
  6. &lt;code&gt;std::make_unique_for_overwrite&lt;/code&gt; (C++20)
&lt;/h3&gt;

&lt;p&gt;C++20 added &lt;code&gt;std::make_unique_for_overwrite&lt;/code&gt; for the case where you want to allocate an object &lt;strong&gt;without value-initializing it&lt;/strong&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;buffer&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique_for_overwrite&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="kt"&gt;char&lt;/span&gt;&lt;span class="p"&gt;[]&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;size&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="k"&gt;auto&lt;/span&gt; &lt;span class="n"&gt;obj&lt;/span&gt;    &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;make_unique_for_overwrite&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;MyPod&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;For scalar types, &lt;code&gt;make_unique&amp;lt;T&amp;gt;()&lt;/code&gt; value-initializes (&lt;code&gt;T()&lt;/code&gt;), which zero-initializes fundamental types. For large buffers this can be an unnecessary cost. &lt;code&gt;make_unique_for_overwrite&lt;/code&gt; performs default-initialization instead, matching what &lt;code&gt;new T&lt;/code&gt; does for fundamental types, while preserving all the ownership and exception-safety benefits of the factory function.&lt;/p&gt;

&lt;h3&gt;
  
  
  When &lt;em&gt;Not&lt;/em&gt; to Use &lt;code&gt;std::make_unique&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;There are two well-defined cases where the manual constructor is still required.&lt;/p&gt;

&lt;h4&gt;
  
  
  Custom deleters
&lt;/h4&gt;

&lt;p&gt;&lt;code&gt;make_unique&lt;/code&gt; always uses &lt;code&gt;std::default_delete&amp;lt;T&amp;gt;&lt;/code&gt;, which calls &lt;code&gt;delete&lt;/code&gt; (or &lt;code&gt;delete[]&lt;/code&gt;). It cannot accept a custom deleter, because its variadic template parameters are forwarded to the &lt;strong&gt;object constructor&lt;/strong&gt;, not to the &lt;code&gt;unique_ptr&lt;/code&gt; constructor. If you are wrapping a C API handle or a resource that is not released with &lt;code&gt;delete&lt;/code&gt;, construct the &lt;code&gt;unique_ptr&lt;/code&gt; directly:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="kt"&gt;FILE&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="k"&gt;decltype&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;fclose&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;file&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;fopen&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"data.bin"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;"rb"&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;fclose&lt;/span&gt;&lt;span class="p"&gt;};&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A common workaround is to define your own &lt;code&gt;make_unique&lt;/code&gt; overload for the resource type in your own namespace.&lt;/p&gt;

&lt;h4&gt;
  
  
  Private or protected constructors
&lt;/h4&gt;

&lt;p&gt;&lt;code&gt;std::make_unique&lt;/code&gt; is not a friend of your class, so it cannot invoke a private or protected constructor. If a class restricts construction to factory member functions, the factory must construct the raw pointer internally and pass it to a &lt;code&gt;unique_ptr&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Widget&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;private:&lt;/span&gt;
    &lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="k"&gt;static&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;create&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;());&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;or you can use the PassKey idiom if you really want to use &lt;code&gt;std::make_unique&lt;/code&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Widget&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nl"&gt;public:&lt;/span&gt;
    &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Key&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;private:&lt;/span&gt;
        &lt;span class="c1"&gt;// this constructor is private&lt;/span&gt;
        &lt;span class="n"&gt;Key&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
        &lt;span class="k"&gt;friend&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;   &lt;span class="c1"&gt;// only this class can make a Key&lt;/span&gt;
    &lt;span class="p"&gt;};&lt;/span&gt;

    &lt;span class="c1"&gt;// "Public" constructor, but requires a Key you can't forge.&lt;/span&gt;
    &lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Key&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;size&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="n"&gt;size_&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;size&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{}&lt;/span&gt;

    &lt;span class="k"&gt;static&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;size&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;unique_ptr&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Key&lt;/span&gt;&lt;span class="p"&gt;{},&lt;/span&gt; &lt;span class="n"&gt;size&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;
    &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;size_&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;Widget&lt;/span&gt; &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Widget&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Key&lt;/span&gt;&lt;span class="p"&gt;{},&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;   &lt;span class="c1"&gt;// error: Key's constructor is private&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;but the passkey idiom is a topic for a separate post, so we won't expand on it here. See &lt;a href="https://dev.to/z6123/deep-dive-into-the-c-passkey-idiom-f3d"&gt;here&lt;/a&gt; if you are interested.&lt;/p&gt;

&lt;h3&gt;
  
  
  Summary
&lt;/h3&gt;

&lt;p&gt;Default to &lt;code&gt;std::make_unique&lt;/code&gt;. Its headline selling point — exception safety — has lost some of its bite since C++17 tightened the evaluation-order rules, so consider the famous leak example a historical artifact rather than a live threat. The other arguments, though, are still pulling their weight: it writes the type once instead of twice, it plays nicely with &lt;code&gt;auto&lt;/code&gt;, it keeps your arrays and scalars from getting their &lt;code&gt;delete&lt;/code&gt;s crossed, and it lets you adopt a clean "no raw &lt;code&gt;new&lt;/code&gt;" policy without asterisks.&lt;/p&gt;

&lt;p&gt;Reach for the manual &lt;code&gt;unique_ptr&lt;/code&gt; constructor only when &lt;code&gt;make_unique&lt;/code&gt; genuinely can't help you: custom deleters (it always uses &lt;code&gt;default_delete&lt;/code&gt;) and constructors that are private or protected. Everywhere else, let &lt;code&gt;make_unique&lt;/code&gt; do the &lt;code&gt;new&lt;/code&gt;-ing so you don't have to.&lt;/p&gt;

</description>
      <category>cpp</category>
      <category>programming</category>
      <category>system</category>
    </item>
  </channel>
</rss>
