title: direct-initialization vs direct-list-initialization (C++)
body: <p><b>DIRECT- &nbsp;VS&nbsp; COPY-INITIALIZATION</b><br>
  Through this question (<a href="https://stackoverflow.com/questions/46634869/is-it-direct-initialization-or-copy-initialization">Is it direct-initialization or copy-initialization?</a>) I learned the differences between <b>direct-initialization</b> and <b>copy-initialization</b>:</p>
  
  <blockquote>
  <pre><code>direct-initialization                   copy-initialization
  -----------------------                 ---------------------
  
  obj s("value");                         obj s = obj("value");
                                          obj s = "value";
  
  obj s{"value"};                         obj s = {"value"};
                                          obj s = obj{"value"};
  </code></pre>
  </blockquote>
  
  <p>I mention it here for the sake of completeness. My actual questions for this page are listed in the next paragraph >></p>
  
  <p>&nbsp;<br>
  <b>DIRECT-INITIALIZATION &nbsp;VS&nbsp; DIRECT-LIST-INITIALIZATION</b><br>
  The answers revealed that within the category of direct-initialization, one can make a difference between <b>direct-initialization</b> and <b>direct-list-initialization</b>.:</p>
  
  <blockquote>
  <pre><code>obj s("value");   // direct-initialization
  
  obj s{"value"};   // direct-list-initialization
  </code></pre>
  </blockquote>
  
  <p>I know that list-initialization doesn't allow narrowing, such that an initialization like <code>int x{3.5};</code> won't compile. But besides this, I got a couple of questions:</p>
  
  <p>&nbsp;<br>
  (1) Is there any difference in compiler output between<br>
  <code>obj s("value");</code> and <code>obj s{"value"};</code>?<br>
  Let's consider a compiler without any optimizations. I would like to know any possible technical difference :-)</p>
  
  <p>&nbsp;<br>
  (2) Perhaps I should ask the exact same question for a multi-variable initialization, like:<br>
  <code>obj s("val1", "val2");</code> and <code>obj s{"val1", "val2"};</code><br></p>
  
  <p>&nbsp;<br>
  (3) I have noticed that the list-initialization can sometimes call a different constructor, like in:<br></p>
  
  <pre><code>vector&lt;int&gt; a{10,20};   //Curly braces -&gt; fills the vector with the arguments
  vector&lt;int&gt; b(10,20);   //Parentesis -&gt; uses arguments to parameterize some functionality
  </code></pre>
  
  <p>How is that possible?
  &nbsp;<br>
  &nbsp;<br></p>
  
  <p><b>DID WE COVER ALL POSSIBLE INITIALIZATIONS HERE?</b><br>
  From my limited knowledge on C++, I believe that all possible initializations of objects (either native-typed or user-defined-typed objects) have been covered in the examples above. Is that correct? Did I overlook something?
  &nbsp;<br>
  &nbsp;<br></p>
  
  <hr>
  
  <p>PS: I am learning C++ (I do know C, but not yet C++), so please don't be too hard on me ;-)</p>