title: Why is `make_unique<T[N]>` disallowed?
body: <p><sup>Assume namespace <code>std</code> throughout.</sup></p>
  
  <p>The C++14 committee draft N3690 defines <code>std::make_unique</code> thus:</p>
  
  <blockquote>
    <p><code>[n3690: 20.9.1.4]:</code> <strong><code>unique_ptr</code> creation</strong> &nbsp;&nbsp;&nbsp;<em>[unique.ptr.create]</em></p>
    
    <p><code>template &lt;class T, class... Args&gt; unique_ptr&lt;T&gt; make_unique(Args&amp;&amp;... args);</code></p>
    
    <p><strong>1</strong> Remarks: This function shall not participate in overload resolution unless <code>T</code> is not an array.<br>
    <strong>2</strong> Returns: <code>unique_ptr&lt;T&gt;(new T(std::forward&lt;Args&gt;(args)...)).</code></p>
    
    <p><code>template &lt;class T&gt; unique_ptr&lt;T&gt; make_unique(size_t n);</code></p>
    
    <p><strong>3</strong> Remarks: This function shall not participate in overload resolution unless <code>T</code> is an array of unknown bound.<br>
    <strong>4</strong> Returns: <code>unique_ptr&lt;T&gt;(new typename remove_extent&lt;T&gt;::type[n]()).</code></p>
    
    <p><code>template &lt;class T, class... Args&gt; unspecified make_unique(Args&amp;&amp;...) = delete;</code></p>
    
    <p><strong>5</strong> Remarks: This function shall not participate in overload resolution unless <code>T</code> is an array of known bound.</p>
  </blockquote>
  
  <p>Now, this seems to me to be about as clear as mud, and I think it needs more exposition. But, this editorial comment aside, I believe I've decoded the meanings of each variant:</p>
  
  <ol>
  <li><p><code>template &lt;class T, class... Args&gt; unique_ptr&lt;T&gt; make_unique(Args&amp;&amp;... args);</code></p>
  
  <p>Your bog-standard <code>make_unique</code> for non-array types. Presumably the "remark" indicates that some form of static assertion or SFINAE trick is to prevent the template from being successfully instantiated when <code>T</code> is an array type.</p>
  
  <p>At a high-level, see it as the smart-pointer equivalent to <code>T* ptr = new T(args);</code>.</p></li>
  <li><p><code>template &lt;class T&gt; unique_ptr&lt;T&gt; make_unique(size_t n);</code></p>
  
  <p>A variant for array types. Creates a dynamically-allocated array of <code>n</code> &times; <code>Ts</code>, and returns it wrapped in a <code>unique_ptr&lt;T[]&gt;</code>.</p>
  
  <p>At a high-level, see it as the smart-pointer equivalent to <code>T* ptr = new T[n];</code>.</p></li>
  <li><p><code>template &lt;class T, class... Args&gt; unspecified make_unique(Args&amp;&amp;...)</code></p>
  
  <p>Disallowed. "<em>unspecified</em>" would probably be <code>unique_ptr&lt;T[N]&gt;</code>.</p>
  
  <p>Would otherwise be the smart-pointer equivalent to something like the invalid <code>T[N]* ptr = new (keep_the_dimension_please) (the_dimension_is_constexpr) T[N];</code>.</p></li>
  </ol>
  
  <p>First of all, am I correct? And, if so, what's going on with the third function?</p>
  
  <ul>
  <li><p>If it's there to disallow programmers from attempting to dynamically-allocate an array while providing constructor arguments for each element (just as <code>new int[5](args)</code> is impossible), then that's already covered by the fact that the first function cannot be instantiated for array types, isn't it?</p></li>
  <li><p>If it's there to prevent the addition to the language of a construct like <code>T[N]* ptr = new T[N]</code> (where <code>N</code> is some <code>constexpr</code>) then, well, why? Wouldn't it be completely possible for a <code>unique_ptr&lt;T[N]&gt;</code> to exist that wraps a dynamically-allocated block of <code>N</code> &times; <code>T</code>s? Would this be such a bad thing, to the extent that the committee has gone out of its way to disallow its creation using <code>make_unique</code>?</p></li>
  </ul>
  
  <p><strong>Why is <code>make_unique&lt;T[N]&gt;</code> disallowed?</strong></p>